Skip to main content
Bêta Privée - 12+ Générateurs Disponibles

Personne n'aime écrire du
Code Sans Valeur

Générer du code Symfony prêt pour la production à partir de simples schémas YAML. Entités, formulaires, APIs, et plus — en quelques secondes, pas en heures.

12+
Générateurs Prêts
100%
Open Source
Q4 2025
Date de Lancement
Le Problème

Le Boilerplate Symfony est Répétitif

Vous passez des heures à écrire et transposer le code pour chaque projet. Entités, formulaires, contrôleurs, validations... Ça vous dit quelque chose ?

Chronophage

Des heures passées sur des tâches répétitives

🔄

Code Répétitif

Mêmes patterns, projets différents

Source d'Erreurs

L'humain est faillible

😤

Frustration

Focus sur la logique métier, pas le setup

Fonctionnalités

Tout ce qu'il Faut pour Livrer Plus Vite

Embrex gère l'amorcage pour que vous puissiez vous concentrer sur ce qui rend votre application unique.

Ultra Rapide

Générez des applications Symfony complètes en secondes, pas en heures. Une commande, tout est prêt.

12+ Générateurs Inclus

Entités, repositories, formulaires, contrôleurs, ressources API, validation, services, sécurité, et plus.

Architecture Flexible

Support pour MVC standard, architecture hexagonale, et DDD. Votre projet, vos règles.

Mises à Jour Sécurisées

Mettez à jour votre schéma et régénérez le code sans perdre vos personnalisations. Fusion intelligente avec Git.

Bonnes Pratiques Symfony

Le code généré suit les standards Symfony et les meilleures pratiques de la communauté.

Prêt pour la Production

Sécurité, validation, gestion d'erreurs - tout est inclus. Déployez en toute confiance.

Et Bien Plus Encore...

Règles de Validation
Ressources API Platform
Classes de Service
Voters de Sécurité
Handlers Messenger
Composants Twig
Ressources & Grilles Sylius
Et bien d'autres à venir...
Processus Simple

Du Schéma à l'Application en 3 Étapes

Pas de configuration complexe. Pas de courbe d'apprentissage abrupte. Décrire simplement ce qui est souhaité et laisser Embrex faire le travail.

1

Définir le schéma

Écrire un simple fichier YAML décrivant les entités et leurs relations.

entities:
  Product:
    properties:
      sku: string(50)
      name: string(255)
      price: decimal(10,2)
      stock: integer
      isActive: boolean
    relations:
      category: manyToOne(Category)
      
  Category:
    properties:
      name: string(100)
      slug: string(100)
2

Exécuter Embrex Build

Une seule commande pour générer tout le code instantanément.

$ php bin/console embrex:build

✓ Génération des entités...
✓ Création des repositories...
✓ Construction des formulaires...
✓ Configuration des contrôleurs...
3

Commencer à construire

L'application est prête ! Se concentrer sur la logique métier, pas le boilerplate.

Entités créées
Formulaires prêts
APIs configurées

Exemple Concret : Plateforme E-commerce

Votre Schéma (schema.yaml)

entities:
  Product:
    properties:
      sku: string(50)
      name: string(255)
      price: decimal(10,2)
      stock: integer
      isActive: boolean
    relations:
      category: manyToOne(Category)
      
  Category:
    properties:
      name: string(100)
      slug: string(100)
    relations:
      products: oneToMany(Product)
      
  Order:
    properties:
      orderNumber: string(50)
      totalAmount: decimal(10,2)
      status: string(20)
    relations:
      items: oneToMany(OrderItem)
      
forms:
  ProductType:
    entity: Product
    fields:
      sku: text
      name: text
      price: money
      category: entity
    
controllers:
  ProductController:
    actions:
      index: /products
      show: /products/{id}
      
api_resources:
  ProductResource:
    entity: Product
    operations: [Get, GetCollection, Post, Put, Delete]

Fichiers Générés

src/Entity/Product.php ✓ Créé
src/Repository/ProductRepository.php ✓ Créé
src/Form/ProductType.php ✓ Créé
src/Controller/ProductController.php ✓ Créé
src/ApiResource/ProductResource.php ✓ Créé
+ 15 fichiers supplémentaires...
Voir la différence

Des Heures de Travail vs Quelques Secondes avec Embrex

Comparer l'approche traditionnelle avec Embrex. Voir combien de temps et d'efforts peuvent être économisés.

Sans Embrex (45+ min)
// src/Entity/Product.php
<?php

namespace App\Entity;

use App\Repository\ProductRepository;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
use DOctrine\DBAL\Types\Types;

#[ORM\Entity(repositoryClass: ProductRepository::class)]
#[ORM\Table(name: 'products')]
class Product
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255, type: Types::TEXT)]
    #[Assert\NotBlank]
    #[Assert\Length(min: 3, max: 255)]
    private ?string $name = null;

    #[ORM\Column(type: Types::INTEGER]
    #[Assert\NotNull]
    #[Assert\PositiveOrZero]
    private ?int $price = null;

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getName(): ?string
    {
        return $this->name;
    }

    public function setName(string $name): static
    {
        $this->name = $name;
        return $this;
    }

    // ... more getters and setters ...
}

// src/Repository/ProductRepository.php
// src/Form/ProductType.php
// src/Controller/ProductController.php
// ... and many more files to write manually ...
Avec Embrex (30 sec)
# schema.yaml
entities:
  Product:
    properties:
      sku: string(50)
      name: string(255)
      price: decimal(10,2)
      stock: integer
      isActive: boolean
    relations:
      category: manyToOne(Category)

forms:
  ProductType:
    entity: Product
    fields:
      sku: text
      name: text
      price: money
      category: entity

controllers:
  ProductController:
    actions:
      index: /products
      show: /products/{id}

validation:
  Product:
    properties:
      name:
        - NotBlank
        - Length: { min: 3, max: 255 }
      price:
        - NotNull
        - PositiveOrZero
$ Lancer la commande:
php bin/console embrex:build
Généré automatiquement:
Entité avec toutes les propriétés, getters/setters
Repository avec méthodes de requête personnalisées
Type de formulaire avec validation
Contrôleur CRUD avec toutes les actions
Templates pour les vues

C'est 44,5 minutes économisées sur une seule entité !

Imaginez les économies de temps sur l'ensemble de votre projet avec des dizaines d'entités, de formulaires et de contrôleurs.

10+
Heures par projet
100%
Cohérence
0
Bugs de boilerplate
Architecture Flexible

Construisez à Votre Façon : N'importe Quelle Architecture

Que vous préfériez le MVC traditionnel ou l'architecture hexagonale moderne, Embrex s'adapte aux besoins de votre projet.

Architecture Standard

Structure Symfony traditionnelle

Parfait pour le développement rapide et les petits projets. Suivez les conventions Symfony avec les entités dans src/Entity/ et les repositories dans src/Repository/.

src/
├── Entity/
│ ├── Product.php
│ └── Category.php
├── Repository/
│ ├── ProductRepository.php
│ └── CategoryRepository.php
├── Controller/
└── Form/
Démarrage rapide
Suit les conventions Symfony
Facile à comprendre

Hexagonale / DDD

Design dirigé par le domaine avec contextes

Idéal pour les applications complexes avec plusieurs contextes délimités. Organisez le code par domaines métier avec une séparation claire des responsabilités.

src/
├── Catalog/
│ ├── Domain/
│ │ ├── Entity/Product.php
│ │ └── ValueObject/Money.php
│ ├── Application/
│ └── Infrastructure/
└── Ordering/
├── Domain/
└── Application/
Frontières claires
Évolutif pour les équipes
Design pérenne

Configuration Standard

namespaces:
  entity: 'App\Entity'
  repository: 'App\Repository'
  form: 'App\Form'

paths:
  entity: 'src/Entity'
  repository: 'src/Repository'
  form: 'src/Form'

entities:
  Product:
    properties:
      sku: 'string(50)'
      name: 'string(255)'
      price: 'decimal(10,2)'
      stock: 'integer'
      isActive: 'boolean'
    relations:
      category: 'manyToOne(Category)'

  Category:
    properties:
      name: 'string(100)'
      slug: 'string(100)'
    relations:
      products: 'oneToMany(Product)'

Configuration Hexagonale

# Use the hexagonal convention
convention: hexagonal

contexts:
  Catalog:
    entities:
      Product:
        properties:
          sku: string(50)
          name: string(255)
          price: decimal(10,2)
        relations:
          category: manyToOne(Category)

      Category:
        properties:
          name: string(100)
          slug: string(100)
        relations:
          products: oneToMany(Product)

  User:
    entities:
      User:
        properties:
          email: string(180)
          username: string(100)

Commencer simple, évoluer selon les besoins

Commencer avec l'architecture standard et migrer vers l'hexagonale au fur et à mesure que le projet grandit. Embrex supporte la migration progressive sans tout réécrire.

En savoir plus - Rejoindre la liste d'attente
Prêt pour l'Écosystème

Fonctionne avec Vos Outils Préférés

Embrex s'intègre parfaitement avec l'écosystème Symfony. Utiliser les outils préférés, améliorés par la génération automatique de code.

🔥

API Platform

Générez des APIs REST et GraphQL automatiquement

Documentation OpenAPI
Filtres & pagination
Auth JWT
🛍️

Sylius Stack

UI Admin et gestion des ressources

Système de ressources
Machines à états
Grilles & filtres
🗄️

Doctrine

Intégration ORM complète avec extensions

Migrations
Fixtures
Extensions
🎨

Symfony UX

Composants UI modernes prêts à l'emploi

Live components
Turbo
Stimulus
📬

Messenger

Gestion asynchrone des messages et queues

Command bus
Event bus
Queue workers
🔗

Webhooks

Notifications d'événements en temps réel

Callbacks HTTP
Déclencheurs d'événements
Logique de retry

Un Schéma, Plusieurs Intégrations

Définir une fois...

entities:
  Product:
    properties:
      sku: string(50)
      name: string(255)
      price: decimal(10,2)
      description: text
      isActive: boolean
    extensions:
      timestampable: ~
      
api_resources:
  ProductResource:
    entity: Product
    normalization_context:
      groups: [product:read]
    denormalization_context:
      groups: [product:write]
    filters:
      - search: [name, description]  
      - order: [name, price]
    
sylius_resources:
  Product:
    entity: Product
    driver: doctrine/orm
    
webhooks:
  stripe_payment:
    type: custom
    parser:
      request_matcher:
        path: /webhook/stripe
        methods: [POST]
        headers:
          stripe-signature: ~
    events:
      payment_intent.succeeded:
        properties:
          id: string
          amount: integer
          status: string

...Obtenez Tout !

API Platform Auto-généré
  • • Endpoints REST sur /api/products
  • • Requêtes et mutations GraphQL
  • • Documentation OpenAPI
Sylius Stack Auto-généré
  • • Gestion des ressources
  • • Grille avec filtres & tri
  • • Workflows de machine à états
Webhooks Auto-généré
  • • Configuration des listeners d'événements
  • • Configuration du client HTTP
  • • Gestion des retry & erreurs

Besoin de Plus ?

Créer ses propres intégrations personnalisées avec notre architecture extensible. Des intégrations supplémentaires pour Sylius, Sonata Admin, et plus sont disponibles dans notre offre Entreprise.

Solutions Entreprise

Embrex pour les Équipes

Services professionnels et outils avancés pour agences, ESN, startup studios, indépendants et équipes internes. Consulting disponible maintenant, fonctionnalités avancées bientôt.

Services de Consulting - Transformez Dès Maintenant

Audit d'Architecture

Auditez votre architecture Symfony existante et obtenez des recommandations pour adopter Embrex

Formation Sur Mesure

Sessions de formation personnalisées pour votre équipe sur Embrex Bundle et les bonnes pratiques Symfony

Support Migration

Accompagnement pratique pour migrer vos projets existants vers Embrex Bundle

Services de Consulting

Disponible en consulting horaire ou engagement par projet

Bientôt Disponible

Embrex Builder

Interface visuelle pour créer des schémas Embrex. Pour les entreprises.

  • Designer d'entités interactif
  • Multiples builders (Forms, API, Controllers...)
  • Export/Import schémas YAML
  • Génération YAML temps réel
  • Collaboration équipe (roadmap)
  • Templates personnalisés (roadmap)
Demander une Démo

Interface Embrex Builder

Concepteur d'Entités
Product { name: string, price: decimal }
Constructeur de Relations
Product Category
Aperçu
// Aperçu du code généré
class Product extends Entity {...}

Prêt à Transformer Votre Développement ?

Nous contacter pour discuter des besoins spécifiques et découvrir comment Embrex peut accélérer les projets.

Bêta Privée

Rejoindre des Développeurs Heureux

Nous sommes actuellement en bêta privée. S'inscrire sur la liste d'attente pour être parmi les premiers à transformer le workflow de développement Symfony.

Prêt pour le Lancement

12+
Générateurs
5+
Bêta Testeurs
100%
Open Source
2025
Année de Lancement

Rejoindre la Liste d'Attente

Optional
Optional - helps us understand your needs

En vous inscrivant, vous acceptez de recevoir des emails concernant Embrex. Vos données sont sécurisées et ne seront jamais partagées.

Prêt à Multiplier par 10 Votre
Développement Symfony ?

Transformez votre workflow de développement Symfony avec la génération de code intelligente.

Bientôt disponible via Composer :

composer require --dev embrex/embrex-bundle
Ultra Rapide
Générez en secondes
Prêt pour la Production
Bonnes pratiques incluses
100% Personnalisable
Votre code, à votre façon