Plugin pour atournayre/framework avec skills et intégrations

GitHub stars
9

Install

/plugin install framework@atournayre-claude-plugin-marketplace

Run it inside Claude Code after adding the marketplace with /plugin marketplace add atournayre/claude-marketplace.

Contents

Discovered from source

Skills 9

Framework Make All Skill

Instructions à Exécuter

IMPORTANT : Exécute ce workflow étape par étape :

Description

Orchestrateur générant une stack complète Elegant Objects + DDD pour une entité.

Usage

Use skill framework:make:all

Variables requises

  • {EntityName} - Nom de l'entité en PascalCase (ex: Product)
  • {properties} - Liste des propriétés avec types (optionnel)

Skills orchestrées

  1. framework:make:contracts (si absent)
  2. framework:make:entity
  3. framework:make:out
  4. framework:make:invalide
  5. framework:make:urls
  6. framework:make:collection
  7. framework:make:factory
  8. framework:make:story

Outputs

PhaseFichiers
CoreEntity, Repository, RepositoryInterface
PatternsOut, Invalide
AvancéUrls, UrlsMessage, UrlsMessageHandler, Collection
TestsFactory, Story, AppStory

Workflow

Initialisation

Créer les tâches du workflow :

Utiliser TaskCreate pour chaque phase :

TaskCreate #1: Demander EntityName et propriétés
TaskCreate #2: Vérifier/créer Contracts
TaskCreate #3: Générer Entity (framework:make:entity)
TaskCreate #4: Générer Out (framework:make:out)
TaskCreate #5: Générer Invalide (framework:make:invalide)
TaskCreate #6: Générer Urls (framework:make:urls)
TaskCreate #7: Générer Collection (framework:make:collection)
TaskCreate #8: Générer Factory (framework:make:factory)
TaskCreate #9: Générer Story (framework:make:story)
TaskCreate #10: Afficher résumé + prochaines étapes

Important :

  • Utiliser activeForm (ex: "Demandant EntityName", "Générant Entity")
  • Respecter l'ordre d'exécution (dépendances entre skills)
  • Chaque tâche doit être marquée in_progress puis completed

Pattern d'exécution pour chaque étape :

  1. TaskUpdate → tâche en in_progress
  2. Exécuter l'étape
  3. TaskUpdate → tâche en completed

Étapes

  1. Demander EntityName et propriétés
  2. Vérifier/créer Contracts
  3. Exécuter séquentiellement les 8 skills
  4. Afficher résumé + prochaines étapes

Ordre d'exécution

contracts → entity → out/invalide → urls/collection → factory → story

Task Management

Progression du workflow :

  • 10 tâches créées à l'initialisation
  • Chaque skill orchestré correspond à une tâche (tâches #3 à #9)
  • Respecter l'ordre séquentiel (dépendances entre skills)
  • Chaque tâche suit le pattern : in_progress → exécution → completed
  • Utiliser TaskList pour voir la progression globale

Notes

  • Orchestrateur sans templates propres
  • Ordre critique (respecte dépendances)
  • Idéal pour démarrer rapidement

Framework Make Collection Skill

Instructions à Exécuter

IMPORTANT : Exécute ce workflow étape par étape :

Description

Génère une classe Collection typée pour gérer des ensembles d'entités avec les traits et interfaces Atournayre.

Usage

Use skill framework:make:collection

Variables requises

  • {EntityName} - Nom de l'entité en PascalCase (ex: Product)
  • {entityName} - Nom de l'entité en camelCase (ex: product)
  • {namespace} - Namespace du projet (défaut: App)

Dépendances

  • Entité dans src/Entity/{EntityName}.php
  • Framework atournayre/framework

Outputs

  • src/Collection/{EntityName}Collection.php

Workflow

  1. Demander le nom de l'entité (EntityName)
  2. Vérifier que l'entité existe dans src/Entity/{EntityName}.php
    • Si non : arrêter et demander de créer l'entité d'abord
  3. Générer la classe Collection depuis le template templates/Collection/
  4. Afficher le fichier créé

Patterns appliqués

  • Classe final
  • Interfaces : AsListInterface, ToArrayInterface, CountInterface, CountByInterface, AtLeastOneElementInterface, HasSeveralElementsInterface, HasNoElementInterface, HasOneElementInterface, HasXElementsInterface, LoggableInterface
  • Traits : Collection, Collection\ToArray, Collection\Countable
  • Méthode statique asList(array $collection)

References

  • Usage - Exemples d'utilisation et méthodes métier

Notes

  • Respect du principe YAGNI : pas de méthodes génériques anticipées
  • Seules les méthodes explicitement demandées doivent être ajoutées
  • Les traits fournissent déjà les fonctionnalités de base

Framework Make Contracts Skill

Instructions à Exécuter

IMPORTANT : Exécute ce workflow étape par étape :

Description

Génère l'ensemble des interfaces de contrats nécessaires pour une architecture respectant les principes Elegant Objects et DDD.

Ces interfaces servent de fondation pour toutes les autres skills du framework.

Usage

Use skill framework:make:contracts

Templates

  • OutInterface.php - Interface pour objets de sortie (DTO)
  • InvalideInterface.php - Interface pour exceptions métier
  • HasUrlsInterface.php - Interface pour objets ayant des URLs
  • OutDataInterface.php - Interface pour data classes de sortie
  • InvalideDataInterface.php - Interface pour data classes d'invalidation
  • UrlsDataInterface.php - Interface pour data classes d'URLs
  • Story/StoryInterface.php - Interface pour stories de tests
  • Doctrine/DoctrineMigrationInterface.php - Interface pour migrations Doctrine

Variables requises

Aucune - Ces interfaces sont génériques et ne nécessitent pas de paramètres.

Dépendances

Aucune - C'est la première skill à exécuter (Niveau 0 - Fondation).

Outputs

  • src/Contracts/OutInterface.php
  • src/Contracts/InvalideInterface.php
  • src/Contracts/HasUrlsInterface.php
  • src/Contracts/OutDataInterface.php
  • src/Contracts/InvalideDataInterface.php
  • src/Contracts/UrlsDataInterface.php
  • src/Contracts/Story/StoryInterface.php
  • src/Contracts/Doctrine/DoctrineMigrationInterface.php

Workflow

  1. Vérifier si le répertoire src/Contracts/ existe
  2. Créer la structure de répertoires si nécessaire :
    • src/Contracts/
    • src/Contracts/Story/
    • src/Contracts/Doctrine/
  3. Copier tous les templates d'interfaces depuis framework/skills/make-contracts/templates/Contracts/ vers src/Contracts/
  4. Afficher la liste des fichiers créés

Notes

  • Ces interfaces n'ont pas besoin d'être modifiées pour chaque projet
  • Elles doivent être créées une seule fois par projet
  • Toutes les autres skills du framework dépendent de ces interfaces

Framework Make Entity Skill

Génère une entité Doctrine complète avec son repository selon les principes Elegant Objects.

Variables

  • {EntityName} - Nom de l'entité en PascalCase (ex: Product)
  • {entityName} - Nom de l'entité en camelCase (ex: product)
  • {namespace} - Namespace du projet (défaut: App)
  • {properties} - Liste des propriétés avec types (name:string, price:float)

Outputs

  • src/Entity/{EntityName}.php
  • src/Repository/{EntityName}Repository.php
  • src/Repository/{EntityName}RepositoryInterface.php

Instructions à Exécuter

IMPORTANT : Exécute ce workflow étape par étape :

1. Demander le nom de l'entité

  • Utilise AskUserQuestion pour demander :
    Question: "Quel est le nom de l'entité à créer ?"
    Header: "Entité"
    
  • Valide que le nom est en PascalCase (première lettre majuscule)
  • Stocke dans EntityName
  • Génère entityName = EntityName en camelCase (première lettre minuscule)

2. Demander les propriétés de l'entité

  • Utilise AskUserQuestion pour demander :
    Question: "Quelles sont les propriétés de l'entité ? Format: name:type,email:string,age:int"
    Header: "Propriétés"
    
  • Parse la liste des propriétés
  • Pour chaque propriété, extrais le nom et le type

3. Vérifier les contracts

  • Exécute ls src/Contracts/ avec Bash
  • Si le répertoire n'existe pas :
    • Affiche : ⚠️ Contracts manquants - Génération automatique
    • Utilise Skill pour appeler framework:make:contracts

4. Détecter le namespace du projet

  • Lis composer.json avec Read
  • Extrais le namespace depuis autoload.psr-4
  • Si non trouvé, utilise App par défaut

5. Générer l'entité

  • Créé le fichier src/Entity/{EntityName}.php avec Write
  • Structure de classe :
    namespace {namespace}\Entity;
    
    use Doctrine\ORM\Mapping as ORM;
    use {namespace}\Repository\{EntityName}Repository;
    
    #[ORM\Entity(repositoryClass: {EntityName}Repository::class)]
    final class {EntityName}
    {
        #[ORM\Id]
        #[ORM\Column(type: 'uuid', unique: true)]
        private string $id;
    
        // Propriétés générées depuis la liste
    
        private function __construct() {}
    
        public static function create({params}): self
        {
            $self = new self();
            $self->id = Uuid::v7();
            // Affectations des propriétés
            return $self;
        }
    
        // Getters pour chaque propriété
    }
    

6. Générer l'interface du repository

  • Créé le fichier src/Repository/{EntityName}RepositoryInterface.php avec Write
  • Contenu :
    namespace {namespace}\Repository;
    
    interface {EntityName}RepositoryInterface
    {
        public function find(string $id): ?{EntityName};
        public function findAll(): array;
    }
    

7. Générer le repository

  • Créé le fichier src/Repository/{EntityName}Repository.php avec Write
  • Contenu :
    namespace {namespace}\Repository;
    
    use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
    use Doctrine\Persistence\ManagerRegistry;
    use {namespace}\Entity\{EntityName};
    
    final class {EntityName}Repository extends ServiceEntityRepository implements {EntityName}RepositoryInterface
    {
        public function __construct(ManagerRegistry $registry)
        {
            parent::__construct($registry, {EntityName}::class);
        }
    }
    

8. Afficher le résumé

Affiche :

✅ Entité {EntityName} générée avec succès

Fichiers créés :
- src/Entity/{EntityName}.php
- src/Repository/{EntityName}Repository.php
- src/Repository/{EntityName}RepositoryInterface.php

Propriétés :
{liste des propriétés}

Prochaines étapes :
- Créer la migration : php bin/console make:migration
- Générer la factory : /framework:make:factory {EntityName}
- Générer la collection : /framework:make:collection {EntityName}

Patterns appliqués

Entité

  • Classe final, constructeur privé, factory statique create()
  • Traits : DatabaseTrait, NullTrait, DependencyInjectionTrait
  • Interfaces : LoggableInterface, DatabaseEntityInterface, NullableInterface, DependencyInjectionAwareInterface, OutInterface, HasUrlsInterface, InvalideInterface

Repository

  • Classe final, extends ServiceEntityRepository
  • Implémente interface du repository

References

  • Usage - Exemples et détails de génération

Notes

  • ID Uuid ajouté automatiquement
  • Propriétés privées avec getters (pas de setters)
  • Méthode toLog() inclut toutes les propriétés

Framework Make Factory Skill

Instructions à Exécuter

IMPORTANT : Exécute ce workflow étape par étape :

Description

Génère une Factory Foundry pour créer des instances d'entités dans les tests.

Usage

Use skill framework:make:factory

Variables requises

  • {EntityName} - Nom de l'entité en PascalCase (ex: Product)
  • {entityName} - Nom de l'entité en camelCase (ex: product)
  • {namespace} - Namespace du projet (défaut: App)
  • {properties} - Liste des propriétés pour defaults()

Dépendances

  • Entité dans src/Entity/{EntityName}.php
  • Zenstruck Foundry installé

Outputs

  • src/Factory/{EntityName}Factory.php

Workflow

  1. Demander le nom de l'entité (EntityName)
  2. Vérifier que l'entité existe
  3. Lire l'entité pour détecter les propriétés du constructeur create()
  4. Générer la factory depuis le template templates/Factory/
  5. Afficher le fichier créé

Patterns appliqués

  • Extends PersistentObjectFactory, classe final
  • Méthode class() retournant FQCN
  • Méthode defaults() avec valeurs Faker
  • Méthode initialize() avec instantiateWith() appelant Entity::create()
  • Méthodes custom (ex: withSpecificId(), inactive())

References

  • Usage - Exemples de tests et valeurs Faker recommandées

Notes

  • Utilise instantiateWith() pour respecter Elegant Objects (pas de new Entity())
  • Faker via self::faker()
  • Méthodes custom uniquement si demandées (YAGNI)
  • Persiste par défaut, withoutPersisting() si besoin

Framework Make Invalide Skill

Instructions à Exécuter

IMPORTANT : Exécute ce workflow étape par étape :

Description

Génère une classe Invalide pour gérer les exceptions métier d'une entité avec factory methods.

Usage

Use skill framework:make:invalide

Variables requises

  • {EntityName} - Nom de l'entité en PascalCase (ex: Product)
  • {entityName} - Nom de l'entité en camelCase (ex: product)
  • {namespace} - Namespace du projet (défaut: App)

Dépendances

  • Entité dans src/Entity/{EntityName}.php

Outputs

  • src/Invalide/{EntityName}Invalide.php

Workflow

  1. Demander le nom de l'entité (EntityName)
  2. Vérifier que l'entité existe dans src/Entity/{EntityName}.php
    • Si non : arrêter et demander de créer l'entité d'abord
  3. Générer la classe Invalide depuis le template templates/Invalide/
  4. Afficher le fichier créé

Patterns appliqués

  • Classe final
  • Constructeur privé
  • Factory statique new() pour instanciation
  • Propriété privée de type entité
  • Méthodes factory statiques pour exceptions (préfixe car)

References

  • Usage - Exemples d'implémentation et enrichissement

Notes

  • Les méthodes factory d'exceptions commencent par car (convention)
  • Messages d'exception sans point final
  • Messages avec maximum de contexte
  • Exceptions standard PHP (\InvalidArgumentException, \DomainException)
  • Principe "fail fast"

Framework Make Out Skill

Instructions à Exécuter

IMPORTANT : Exécute ce workflow étape par étape :

Description

Génère une classe Out (DTO readonly) pour représenter les données de sortie d'une entité.

Usage

Use skill framework:make:out

Variables requises

  • {EntityName} - Nom de l'entité en PascalCase (ex: Product)
  • {entityName} - Nom de l'entité en camelCase (ex: product)
  • {namespace} - Namespace du projet (défaut: App)

Dépendances

  • Entité dans src/Entity/{EntityName}.php

Outputs

  • src/Out/{EntityName}Out.php

Workflow

  1. Demander le nom de l'entité (EntityName)
  2. Vérifier que l'entité existe dans src/Entity/{EntityName}.php
    • Si non : arrêter et demander de créer l'entité d'abord
  3. Générer la classe Out depuis le template templates/Out/
  4. Afficher le fichier créé

Patterns appliqués

  • Classe final readonly
  • Constructeur privé
  • Factory statique new() pour instanciation
  • Propriété privée de type entité

References

  • Usage - Exemples et usage dans l'entité

Notes

  • Couche anti-corruption entre domaine et extérieur
  • Peut être enrichie avec méthodes pour propriétés calculées
  • Respecte le principe d'immutabilité

Framework Make Story Skill

Instructions à Exécuter

IMPORTANT : Exécute ce workflow étape par étape :

Description

Génère une Story Foundry pour créer des fixtures de tests avec scénarios prédéfinis.

Usage

Use skill framework:make:story

Variables requises

  • {EntityName} - Nom de l'entité en PascalCase (ex: Product)
  • {entityName} - Nom de l'entité en camelCase (ex: product)
  • {namespace} - Namespace du projet (défaut: App)

Dépendances

  • Entité dans src/Entity/{EntityName}.php
  • Factory (appelle framework:make:factory si absente)
  • Contracts (StoryInterface)

Outputs

  • src/Story/{EntityName}Story.php
  • src/Story/AppStory.php (créé ou mis à jour)

Workflow

  1. Demander le nom de l'entité (EntityName)
  2. Vérifier que l'entité existe
  3. Vérifier/créer la Factory
  4. Générer la Story depuis le template templates/Story/
  5. Créer ou mettre à jour AppStory
  6. Afficher les fichiers créés

Patterns appliqués

Story

  • Extends Story, Implements StoryInterface
  • Classe final
  • Méthode build() créant les fixtures via Factory

AppStory

  • Extends Story, Implements StoryInterface
  • Attribut #[AsFixture(name: 'main')]
  • Point d'entrée unique pour toutes les fixtures

References

  • Usage - Scénarios complexes, relations et états nommés

Notes

  • AppStory est le point d'entrée pour charger toutes les fixtures
  • Stories peuvent avoir des dépendances (charger d'autres Stories)
  • addState() pour nommer des instances réutilisables dans les tests

Framework Make Urls Skill

Instructions à Exécuter

IMPORTANT : Exécute ce workflow étape par étape :

Description

Génère une classe Urls pour la génération d'URLs d'une entité avec pattern CQRS (Message + Handler).

Usage

Use skill framework:make:urls

Variables requises

  • {EntityName} - Nom de l'entité en PascalCase (ex: Product)
  • {entityName} - Nom de l'entité en camelCase (ex: product)
  • {namespace} - Namespace du projet (défaut: App)

Dépendances

  • Entité dans src/Entity/{EntityName}.php
  • Repository dans src/Repository/{EntityName}Repository.php
  • Interface repository dans src/Repository/{EntityName}RepositoryInterface.php

Outputs

  • src/Urls/{EntityName}Urls.php
  • src/MessageHandler/{EntityName}UrlsMessage.php
  • src/MessageHandler/{EntityName}UrlsMessageHandler.php

Workflow

  1. Demander le nom de l'entité (EntityName)
  2. Vérifier que l'entité et le repository existent
  3. Générer les 3 classes depuis les templates templates/
  4. Afficher les fichiers créés

Patterns appliqués

Classe Urls

  • final readonly, constructeur privé, factory new()
  • Propriétés : UrlGeneratorInterface + entité

Message CQRS

  • Extends AbstractQueryEvent, Implements QueryInterface
  • final, constructeur privé, factory new()

MessageHandler

  • final readonly, attribut #[AsMessageHandler]
  • Injection : repository + UrlGeneratorInterface

References

  • Usage - Architecture CQRS et exemples d'enrichissement

Notes

  • Pattern CQRS : séparation query (Message) / handler
  • Classe Urls enrichissable avec méthodes spécifiques (show, edit, delete)
  • Immutabilité (readonly)

Sponsors

Details

Marketplace
atournayre/claude-marketplace
Source
framework
Category
Community

More from atournayre/claude-marketplace

All 18