DEV Community: neothone

Fastfony is officially out!

neothone — Tue, 22 Jul 2025 14:31:11 +0000

Fastfony v0.3.1: First Stable Release 🚀

I'm excited to share the release of Fastfony v0.3.1—the very first stable version of this modern web app starter kit!

What is Fastfony?

Fastfony helps you launch web projects, with PHP and the Symfony framework, faster by combining a robust tech stack (PHP 8.2, Symfony 7.3, Webpack Encore, Vue 3, Tailwind CSS 4, API Platform, EasyAdmin) with essential features out-of-the-box.

Key Features:

Content Management: SEO pages, collections, taxonomies, inline editing
Authentication: Magic link login, user management, permissions, password reset, avatars
E-Commerce: Product management, Stripe integration, contact form
Admin Tools: Scheduler, logs, settings panel, CRUD generator
Modern UI: Responsive Tailwind + DaisyUI, toast notifications, i18n
APIs: OAuth2 ready, REST & GraphQL, flexible endpoints

Release Cycle:

Fastfony syncs with Symfony’s release schedule (with a 2-month delay). Expect releases in January and July, with LTS versions for long-term stability (v0.4 in January 2026 will be the first LTS).

Get Started:

Check out the documentation (still growing!) and explore the showroom.

I hope Fastfony will thrive and evolve with the help of the community. Interested in contributing or collaborating? Reach out—everyone is welcome!

Happy coding!

Fastfony : Symfony boilerplate and starter-kit for professionnals

neothone — Sun, 22 Jun 2025 16:06:26 +0000

Announcing Fastfony RC1: A New Symfony Starter-Kit for Professionals

Hey folks! 👋

After months of hard work, sleepless nights, and way too much coffee, I’m thrilled (and a little relieved!) to announce the first release candidate of Fastfony, my very own starter-kit for Symfony projects.

Why Fastfony?

I realized something was missing: a true, ready-to-go starter-kit that covers both the boilerplate and the essential features that almost every Symfony project needs. There were some attempts out there, but none really hit the mark for me. So, what do you do when you can’t find the tool you need? You build it yourself! 🚀

Fastfony is the result of about 200 hours of work, and I can say without hesitation: it’s been a labor of love. My goal is simple—save you those 200 hours (or more!) by providing a solid, customizable foundation for your next Symfony project.

What’s Inside?

Fastfony is more than just a boilerplate. It’s a complete, production-ready stack designed to get you up and running quickly. Here’s what you get:

A functional, opinionated boilerplate: All the boring setup is already done for you!
Essential features, simplified: Authentication, user management, basic CRUD, and more—implemented in their simplest, most customizable form.
A base you can truly make your own: The code is easy to adapt, extend, or strip down to fit your needs.

Whether you’re launching a SaaS, building an internal tool, or just want a strong starting point for your next client project, Fastfony gives you the boost you need.

For Pros, By a Pro

I built Fastfony for my own professional use, and I’ve already used it on real-world projects. That means I’m committed to keeping it battle-tested, up-to-date, and aligned with the needs of people who build real apps for real clients.

Licensing and the Road Ahead

Fastfony will be available via a license subscription. I believe this is the fairest way to ensure ongoing development and support, especially for professional and commercial use. I know putting a price tag on open tooling can be divisive, but my hope is that the time you save and the quality you get will make it a no-brainer for serious Symfony devs. And... it's free for personal usage!

Feedback: The Good, The Bad, and the Honest

I’m well aware that not everyone will love every decision I’ve made—and that’s okay! I’m expecting a range of feedback, both positive and critical, and I genuinely welcome it. Your input will help me improve Fastfony and make it even more useful for the community.

Release Plan: In Sync with Symfony

No matter how widely Fastfony is adopted, I’m in this for the long haul. I plan to follow the official Symfony release calendar, ensuring that Fastfony stays compatible and up-to-date. After all, I’m the first and main user—I depend on it for my own work!

Try Fastfony Today

If you’re a Symfony developer looking for a fast, reliable, and professional-grade starter-kit, I’d love for you to give Fastfony a try. Check out the RC1, let me know what you think, and help shape the future of this project.

Thanks for reading—and happy coding! ✨

More info on https://fastfony.com

My first published project!

neothone — Wed, 18 Jun 2025 14:26:28 +0000

neothone for Fastfony

Jun 18 '25

v0.3.0-RC1 is out and available for testing

#php #symfony #webdev #tooling

Comments 1

2 min read

v0.3.0-RC1 is out and available for testing

neothone — Wed, 18 Jun 2025 14:25:12 +0000

🚀 Introducing Fastfony: The Pragmatic Symfony Starter-Kit You’ve Been Waiting For (if you are Symfony PHP Developers) !

Hey devs!

I’m super excited (and, let’s be honest, a little nervous 😅) to announce the very first Release Candidate of Fastfony — a pragmatic starter-kit for Symfony that I’ve poured around 200 hours of work into, so you don’t have to.

Why Fastfony?

If you’ve ever kicked off a new Symfony project, you know the drill:

You start by setting up the same stack, the same basic features, and the same best practices — over and over. There are some “boilerplate” projects out there, but nothing truly opinionated and flexible that covers the professional needs and patterns I (and, I bet, you) use in the real world.

That’s where Fastfony comes in. Think of it as a complete, production-ready boilerplate and a customizable starter-kit rolled into one. It provides you with a solid, functional technical stack, plus all those essential features you end up building in every Symfony project — in their simplest, most customizable form.

What’s Inside?

A full-featured Symfony base with modern best practices baked in.
Ready-to-customize features that you’ll want in every project, but stripped to their essentials so you can make them your own.
Pragmatic defaults: sensible, flexible, and designed for commercial/pro use.
A release plan tied to the official Symfony release calendar — because I’m the first user of Fastfony, and I’ll be maintaining it for real projects.

Launching Today on Product Hunt!

I’ve just dropped Fastfony on Product Hunt — and, well, it only has 5 upvotes as I write this! If you like what you see, I’d love your support, but more importantly, your feedback. 😍

Open for Feedback (Positive and Negative!)

This is just the beginning. I’m sure there are things to improve — and I’m counting on the dev community to help me make Fastfony even better. Whether you’re excited, skeptical, or have suggestions, I want to hear from you! Every bit of criticism will help shape Fastfony’s future.

Sustainable & Professional

To make ongoing development sustainable (and because this is a pro-grade tool), Fastfony will be offered as a subscription license for commercial use. But regardless of its commercial success or mass adoption, I will keep it updated and evolving — because I rely on it for my own projects, too.

Thanks for reading, and thanks even more if you give Fastfony a try!

Let’s build better Symfony projects, faster, together.

Feel free to check it out, give feedback, or just come say hi! 🚀

👉 Support Fastfony now on Product Hunt

👉 Discover Fastfony.com and Github repository

Happy coding!

neothone

Fastfony : première Release Candidate 🚀

neothone — Tue, 17 Jun 2025 13:37:52 +0000

Hello à tous,

Aujourd’hui, j’ai le plaisir (et une pointe de fierté, je l’avoue) de vous annoncer la toute première Release Candidate de Fastfony, mon starter-kit pour Symfony ! 🎉

Pourquoi Fastfony ?

Parce que je ne trouvais aucun acteur solide sur ce segment, j’ai décidé de créer Fastfony : un starter-kit pensé pour les développeurs qui veulent aller vite, bien, et avec une stack moderne, sans repartir d’une feuille blanche à chaque nouveau projet.

Fastfony, c’est deux choses :

Un boilerplate Symfony complet et fonctionnel : tout est prêt à l’emploi pour démarrer un projet pro, sans perdre de temps sur l’initialisation de la stack.
Un starter-kit personnalisable : toutes les fonctionnalités de base (authentification, gestion des utilisateurs, configuration des outils courants, etc.) sont intégrées dans leur version la plus simple, pour que chacun puisse les adapter à son contexte.

200 heures de boulot… pour vous en faire gagner autant !

Je ne vais pas vous mentir : ce projet, c’est environ 200 heures de travail (soirées, week-ends, cafés, refactors et “tiens, si je faisais mieux”). Mais c’est du temps que j’ai investi pour que vous n’ayez pas à le faire ! Mon objectif, c’est que Fastfony vous fasse gagner des jours, voire des semaines, sur vos prochains projets Symfony.

Un modèle pro & commercial

Fastfony s’adresse aux développeurs, aux agences, aux startups… à tous ceux qui veulent une base sérieuse pour leurs projets Symfony. Pour garantir un vrai suivi, des mises à jour régulières et un support de qualité, la licence sera proposée sous forme d’abonnement.

Je sais que ce choix peut susciter des débats (et sûrement des critiques, bonnes ou mauvaises), mais il me paraît juste pour garantir la pérennité du projet. Les retours, même négatifs, seront précieux pour faire grandir Fastfony !

Release Plan et roadmap

Que Fastfony devienne un standard ou reste un outil de niche, je vais maintenir le projet. En tant que premier utilisateur (je l’ai déjà utilisé sur mes propres projets), je vais suivre le release calendar officiel de Symfony pour garantir une compatibilité optimale et des évolutions continues.

Et maintenant ?

Je vous invite à tester cette Release Candidate, à me faire vos retours (bons ou mauvais, tout est bon à prendre !), et à suivre l’aventure. Fastfony, c’est un projet passion, mais aussi une vraie volonté de faire avancer la communauté Symfony.

Merci à tous ceux qui suivront, testeront, critiqueront, ou encourageront ce projet !

Le point d'entrée : fastfony.com

À très vite,
neothone

Bash script for install php on naked Ubuntu 24.04

neothone — Sun, 23 Mar 2025 14:18:40 +0000

This script works:

#!/bin/bash
sudo DEBIAN_FRONTEND=noninteractive
sudo apt update -y
sudo apt upgrade -y
sudo apt install nginx wget build-essential curl lsb-release ca-certificates apt-transport-https software-properties-common -y
sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo add-apt-repository ppa:ondrej/php -y
sudo apt update
sudo apt install php8.4 php8.4-fpm php8.4-common php8.4-pgsql php8.4-xml php8.4-xmlrpc php8.4-curl php8.4-gd php8.4-imagick php8.4-cli php8.4-dev php8.4-imap php8.4-mbstring php8.4-opcache php8.4-soap php8.4-zip php8.4-intl php8.4-bcmath unzip -y
curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/bin --filename=composer
sudo snap install core; sudo snap refresh core
sudo apt-get remove certbot
sudo snap install --classic certbot
sudo ln -s /snap/bin/certbot /usr/bin/certbot

Install php 8.4, composer, nginx & certbot!

Directory structure of a PHP Symfony project

neothone — Wed, 19 Mar 2025 22:01:49 +0000

The src folder of a Symfony project contains your business classes and forms the heart of your application.

Symfony Best Practices recommends a structure for this src/ folder and a few subfolders.

Here I offer you the results of recent years and PHP projects carried out with the Symfony framework: this is a tree structure that I was able to find in the src folders.

The list is not here to set things in stone and is not official.

The purpose of this list is to create a reference for:

defining what types of classes and services should be found in each namespace corresponding to a subfolder of the src folder
"finding inspiration" when you don't have a design pattern that spontaneously comes to mind.

Some come from the Symfony documentation or its best practices, others from entirely personal habits.

A

Adapter: A service that converts one object into another (see Transformer if it's data and not an object)
Aggregator: A service that gathers data from different sources
ApiResource: A folder created by API Platform that contains the models used to build APIs "automatically" with API Platform and that are not Doctrine entities

B

Builder: A service that constructs a service with its required elements or default values (see Factory for building objects)

C

Client: A service that allows you to connect to a third-party service (an API, a web service, etc.)
Command: A service that executes scripts/command-line processes
Controller: A service that handles an HTTP request and provides an HTTP response

D

DataFixtures: A folder created by the Doctrine Fixtures bundle in which you create your "Entity1Fixture", "Entity2Fixture", etc. classes
DataManager: A service that organizes, sorts, filters, and/or enriches data from from a third-party source (similar to the concept of DAO)

E

Enricher: Service that enriches data or an object with data from another source
Entity: Doctrine object that makes up the data model
EnvProcessor: Contains classes that define custom Environment Variable Processors
EventListener: Service that sets up processes to be executed when a listened event is triggered
EventSubscriber: Service that sets up processes to be executed when an event to which it subscribes is triggered
Exception

F

Factory: Service that constructs objects with required and/or default values (quite similar to Builder for services)

G

H

Handler: Service that orchestrates business logic, organizes, sorts, and filters objects/entities (like a "manager")
Helper: Service that provides useful "all over the place" and simple (often static) functions

I

IndexManager: Service that organizes, sorts, filters, and enriches documents from an index Elasticsearch

J

K

L

M

Message: Data structure that forms an envelope for transmitting information in message queues
MessageHandler: Service that organizes the business logic associated with message reception
Model: Business Objects (DAO)

N

Naming: this directory can contain the Namer class for your custom file namer (see also https://github.com/dustin10/VichUploaderBundle/blob/master/docs/file_namer/howto/create_a_custom_file_namer.md)

O

P

Paginator: Service that allows you to set up pagination

Q

R

Repository: Service associated with Doctrine entities and that contains DQL or SQL queries, or dynamic query constructions (using query builders, for example) and that allows you to retrieve objects or arrays of objects that respond to these queries (these services do not contain business logic, which should instead be found in the "Handlers")

S

Security: This folder contains services specific to and related to the Symfony Security component (e.g., Authenticator, Provider, etc.)
Serializer: Service that serializes or deserializes data objects
Service: Since Symfony 2 this folder was often used to store everything that wasn't a controller or repository, but it's imprecise. On large projects, it became a catch-all and dense resource. I'm trying as hard as possible to stop using it and eliminate it in favor of all the others mentioned in this article.

T

Transformer: service that converts data of a certain type into another type
Twig: custom Twig extensions (filters or functions)

U

V

Validator: service that checks validation rules

W

X

Y

Z

Today, I also tend to add "business" sub-namespaces to each of these namespaces. For example, src/Entity/User/ can contain:

src/Entity/User/User.php
src/Entity/User/Group.php
src/Entity/User/Role.php
src/Entity/User/RequestPassword.php

This avoids having a tree structure with folders that require endless scrolling...

Help me keep this topic moving forward and alive!

I'm wondering if it's structured more or less the same way with Laravel?

This post is a translation of a first post in French, available here: https://dev.to/neothone/arborescence-dun-projet-php-symfony-34go

AssociationField with entity parameter in QueryBuilder

neothone — Mon, 17 Mar 2025 11:20:14 +0000

If you need to restrict the results displayed in an AssociationField in Easyadmin with a condition on the current entity which you are editing, you can do this:

<?php

class ProductCrud extends AbstractCrudController
{
    public function __construct(
        private readonly ProductRepository $productRepository,
        private readonly RequestStack $requestStack,
    ) {
    }

    public static function getEntityFqcn(): string
    {
        return Product::class;
    }

    /**
     * @return iterable<FieldInterface>
     */
    public function configureFields(string $pageName): iterable
    {
        $entityId = $this->requestStack->getCurrentRequest()->attributes->get('entityId');
        $currentProduct = null;
        if (null != $entityId) {
            $currentProduct = $this->productRepository->find($entityId);
        }

        return [
            AssociationField::new('defaultPrice')
                ->setQueryBuilder(
                    fn (QueryBuilder $queryBuilder) => $queryBuilder
                        ->andWhere('entity.product = :product')
                        ->setParameter('product', $currentProduct)
                ),
        ];
    }
}

In this example, I want only displayed prices link to the current product (ManyToOne relation defaultPrice on Product, ManyToOne relation product on Price, OneToMany relation prices on Product).

This is a solution for this issues :

Arborescence d’un projet PHP Symfony

neothone — Sun, 16 Mar 2025 09:17:08 +0000

Le dossier src d’un projet Symfony contient vos classes métiers et compose le coeur de votre application.

Les Best Practices de Symfony préconise une structure de base avec ce dossier src/ et quelques sous-dossiers.

Je vous propose ici le fruit de ces dernières années et des projets PHP réalisés avec le framework Symfony : il s’agit d’une arborescence des dossiers que j'ai pu trouvé dans les dossiers src.

Cette liste n’est pas là pour figer les choses et n’a rien d’officielle.

Le but de cette liste est de faire un référentiel pour :

définir quels types de classe et services nous devrions trouvés dans chaque namespace correspondant à un sous-dossier du dossier src
“trouver l’inspiration” quand vous n’avez pas de modèle de conception qui vous vienne spontanément à l’esprit.

Certains proviennent de la documentation Symfony ou de ses best-practices, d’autres d’habitudes tout à fait personnelles.

A

Adapter : service qui converti un objet en un autre (c.f. Transformer s’il s’agit de donnée et non d’objet)
Aggregator : service qui rassemble de la donnée depuis différentes sources
ApiResource : dossier créé par API Platform qui vise à contenir les modèles utilisés pour construire des APIs “automatiquement” avec API Platform et qui ne sont pas des entités Doctrine

B

Builder : service qui construit un service avec ses éléments requis ou des valeurs par défaut (c.f. Factory pour construire des objets)

C

Client : service qui permet de se connecter à un service tiers (une API, un webservice…)
Command : service qui exécute des scripts / des processus en ligne de commande
Controller : service qui prend en charge une requête HTTP et fourni une réponse HTTP

D

DataFixtures : dossier créé par le bundle Doctrine Fixtures dans lequel on vient créer ses classes “Entity1Fixture”, “Entity2Fixture” etc…
DataManager : service qui organise, tri, filtre et/ou enrichi des données provenant d’une source tierce (similaire à la notion de DAO)

E

Enricher : service qui enrichi une donnée ou un objet avec la donnée d’une autre source
Entity : objet Doctrine composant le modèle de données
EnvProcessor : contient les classes qui définissent des Environment Variable Processor custom
EventListener : service qui met en place les processus à exécuter quand un événement écouté est déclenché
EventSubscriber : service qui met en place les processsus à exécuter quand un évènement auquel il souscrit se déclenche
Exception

F

Factory : service qui construit des objets avec les requis et/ou les valeurs par défaut (assez similaire à Builder pour les services)

G

H

Handler : service qui orchestre une logique métier, organise, tri, filtre des objets/entités (en français : “gestionnaire”)
Helper : service qui fournie des fonctions utiles “un peu partout” et simples (souvent static)

I

IndexManager : service qui organise, tri, filtre et enrichi des documents provenant d’un index Elasticsearch

J

K

L

M

Message : structure de données qui permet de former une enveloppe pour faire des transiter des informations dans des files de messages
MessageHandler : service qui organise la logique métier associé à la réception de message
Model : objets métiers (DAO)

N

O

P

Paginator : service qui permet de mettre en place une pagination

Q

R

Repository : service associé aux entités Doctrine et qui contient des requêtes DQL ou SQL, ou des constructions dynamiques de requêtes (grâce aux “query builder” par exemple) et qui permet de récupérer les objets ou les tableaux d’objets répondant à ces requêtes (ces services ne contiennent pas de logique métier, qui doit plutôt être retrouvé dans les “Handlers”)

S

Security : ce dossier contient les services spécifiques et relatifs au composant Security de symfony (ex: Authenticator, Provider…)
Serializer : service qui procède à la sérialisation ou la dé-sérialisation d’objets données
Service : ce dossier était beaucoup utilisé depuis l’apparition de Symfony 2 pour y mettre tout ce qui n’était pas un contrôleur ou un repository, mais il est imprécis. Sur les projets importants il devenait “fourre-tout” et dense. J’essaie au maximum de ne plus l’utiliser et de le faire disparaître au profit de tous les autres cités dans cet article

T

Transformer : service qui converti une donnée d’un certain type dans un autre type
Twig : extensions twig personnalisés (filters ou functions)

U

V

Validator : service qui contrôle des règles de validation

W

X

Y

Z

Aujourd'hui je tend aussi à ajouter dans chacun de ces namespaces des sous-namespaces "métiers". Par exemple src/Entity/User/ peut contenir :

src/Entity/User/User.php
src/Entity/User/Group.php
src/Entity/User/Role.php
src/Entity/User/RequestPassword.php

Ceci permet d'éviter d'avoir une arborescence avec des dossiers dans lesquels il faut scroller vers l'infini et l'au delà...

Aidez moi à faire évoluer et vivre ce sujet !

Je me demande d'ailleurs si avec Laravel c'est plus ou moins structuré de la même manière ?

[Boost]

neothone — Wed, 12 Mar 2025 22:22:02 +0000

Add test coverage badge for PHP and Pest in your GitHub repository

Roberto B. ・ Dec 20 '21

#php #github #testing #codequality

Recent vulnerabilities in eslint impact my Symfony projects with ux-vue

neothone — Thu, 27 Feb 2025 20:00:52 +0000

Since a few days, I saw in my npm command the warning "3 moderate severity vulnerabilities".

I tried to execute npm audit fix --force but the warning is always here...

In fact, it's a library load by composer, not a library load by npm! I saw this important warn: Manual fix required in linked project at ./vendor/symfony/ux-vue/assets for @vitejs/plugin-vue@1.8.0 - 5.2.0

So, I tried with cd ./vendor/symfony/ux-vue/assets and run npm install && npm audit fix --force and the warning became **2** moderate severity vulnerabilities.

Finally, I returned to the root of my project with cd ../../../../ and I executed a npm audit fix that it fixed the last 2 vulnerabilities and update the package-lock.json file.

Editor.js in Symfony EasyAdmin

neothone — Wed, 26 Feb 2025 20:27:45 +0000

Yesterday, I spoke about Editor.js. Today, I purpose an implementation for Symfony with EasyAdmin for a properties of type json on a Doctrine entity.

If you think to an improvement, don't hesitate to comment!

First, create new Field (it's specific for EasyAdmin):

# src/admin/Field/Editorjs.php
<?php

namespace App\Admin\Field;

use App\Form\Type\EditorjsType;
use EasyCorp\Bundle\EasyAdminBundle\Contracts\Field\FieldInterface;
use EasyCorp\Bundle\EasyAdminBundle\Field\FieldTrait;

class Editorjs implements FieldInterface
{
    use FieldTrait;

    public static function new(string $propertyName, ?string $label = null): self
    {
        return (new self())
            ->setProperty($propertyName)
            ->setLabel($label)
            ->setFormType(EditorjsType::class)
            // required also the easyadmin entry in webpack.config.js
        ;
    }
}

and the form type EditorJsType mentioned:

# src/Form/Type/EditorjsType.php
<?php

declare(strict_types=1);

namespace App\Form\Type;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\CallbackTransformer;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;

class EditorjsType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            ->addModelTransformer(
                new CallbackTransformer(
                    function ($value): string {
                        // transform the array to a json string
                        return json_encode($value);
                    },
                    function ($value): array {
                        // transform the json string to a php array
                        return json_decode($value, true);
                    }
                )
            );
    }

    public function getParent(): string
    {
        return TextType::class;
    }
}

In order to have specific js and css load in EasyAdmin context, I create a specific entry in webpack.config.js:

// webpack.config.js
...

Encore
   ...
   .addEntry('easyadmin', './assets/easyadmin.js')
   ...
;

Then, create the easyadmin.js file:

import './styles/easyadmin.css';

import EditorJS from '@editorjs/editorjs';
import Header from '@editorjs/header';
import Quote from '@editorjs/quote';
import RawTool from '@editorjs/raw';
import SimpleImage from "@editorjs/simple-image";
import EditorjsList from '@editorjs/list';
import Embed from '@editorjs/embed';
import Paragraph from '@editorjs/paragraph';
import Table from '@editorjs/table';
import CodeTool from '@editorjs/code';
import Underline from '@editorjs/underline';
import Delimiter from '@editorjs/delimiter';
import InlineCode from '@editorjs/inline-code';

const wrapper = document.getElementById('editorjs');
if (wrapper) {
const input = document.getElementById(wrapper.dataset.fieldId);
const editor = new EditorJS({
  holder: wrapper.id,
  tools: {
    header: {
      class: Header,
      shortcut: 'CMD+SHIFT+H',
      config: {
        levels: [2, 3, 4, 5, 6],
        defaultLevel: 3
      }
    },
    quote: {
      class: Quote,
      inlineToolbar: true,
      shortcut: 'CMD+SHIFT+O',
    },
    raw: RawTool,
    image: SimpleImage,
    list: {
      class: EditorjsList,
      inlineToolbar: true,
      config: {
        defaultStyle: 'unordered'
      },
    },
    embed: Embed,
    paragraph: {
      class: Paragraph,
      inlineToolbar: true,
    },
    table: Table,
    code: CodeTool,
    underline: Underline,
    delimiter: Delimiter,
    inlineCode: {
      class: InlineCode,
      shortcut: 'CMD+SHIFT+M',
    },
  },
  onReady: () => {
    editor.render(JSON.parse(input.value));
  },
  onChange: (api, event) => {
    editor.save().then((outputData) => {
      input.value = JSON.stringify(outputData);
    });
  }
});
}

and the easyadmin.css file:

/* Editor.js customization */
.editorjs {
    background-color: var(--form-control-bg);
    background-repeat: no-repeat;
    border: 1px solid var(--form-input-border-color);
    border-radius: var(--bs-border-radius);
    box-shadow: var(--form-input-shadow);
    color: var(--form-input-text-color);
    margin: 1rem 0;
    padding: 0.5rem 1rem 0.5rem 3rem;
    transition: box-shadow .08s ease-in, color .08s ease-in;
    white-space: nowrap;
    word-break:keep-all;

    .codex-editor__redactor {
        padding-bottom: 2rem!important;


    }
    .ce-inline-toolbar {
        .ce-popover__container, .ce-popover__items {
            overflow-y: hidden!important;
        }
    }
}

/* Dark mode */
@media (prefers-color-scheme: dark) {
    /* Editor.js customization */
    .editorjs {
        .codex-editor__redactor {
            .ce-block__content {
                background-color: transparent;
            }
        }
        .ce-toolbar {
            .ce-toolbar__plus, .ce-toolbar__settings-btn {
                color: var(--text-color)!important;
                &:hover {
                    color: #1d202b!important;
                }
            }
        }
    }
}

Run this npm install command:
npm install @editorjs/editorjs @editorjs/header @editorjs/quote @editorjs/raw @editorjs/simple-image @editorjs/list @editorjs/embed @editorjs/paragraph @editorjs/table @editorjs/code @editorjs/underline @editorjs/delimiter @editorjs/inline-code

Configure EasyAdmin for use the new Webpack entry and a custom form template, in Dashboard Controller, add this:

# src/Controller/Admin/Dashboard.php
...
    public function configureCrud(): Crud
    {
        return Crud::new()
            ->setFormThemes(['form/custom_types.html.twig', '@EasyAdmin/crud/form_theme.html.twig'])
        ;
    }

    public function configureAssets(): Assets
    {
        return Assets::new()
            ->addWebpackEncoreEntry('easyadmin')
        ;
    }
...

Create the custom form template file:

{# templates/form/custom_types.html.twig #}
{% block editorjs_row %}
    <div class="{{ ea_crud_form.ea_field.columns }}">
        {{ form_label(form) }}
        <div id="editorjs" class="editorjs" data-field-id="{{ id }}"></div>
        <input type="hidden" name="{{ full_name }}" id="{{ id }}" value="{{ value }}" />
        {{ form_errors(form) }}
    </div>
    <div class="flex-fill"></div>
{% endblock %}

Now you can use new Field type in a crud controller :

    ...
    use App\Admin\Field\Editorjs;
    ...

    public function configureFields(string $pageName): iterable
    {
        return [
            ...
            Editorjs::new('content') // content is a json (array) properties of a doctrine entity
                ->hideOnIndex(),
            ...
        ];
    }

    ...
}

Enjoy!