cad-workflow 1.1.0

package/src/stacks/backend-only/skills/clean-hexa-backend/templates/adapter.template.ts

@@ -0,0 +1,75 @@
+// Template: TypeORM Repository Adapter (Backend)
+// Location: src/infrastructure/persistence/repositories/typeorm-[name].repository.ts
+
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+// TODO: Import port interface from domain
+// TODO: Import domain entity
+// TODO: Import ORM entity
+// TODO: Import persistence mapper
+
+/**
+ * TypeORM Repository Adapter Template
+ *
+ * Rules:
+ * - Implements domain port interface
+ * - Uses TypeORM for persistence
+ * - Maps between ORM entities and domain entities
+ * - Handles database-specific concerns
+ */
+
+@Injectable()
+export class TypeOrm[Name]Repository implements I[Name]Repository {
+  constructor(
+    @InjectRepository([Name]OrmEntity)
+    private readonly repository: Repository<[Name]OrmEntity>,
+  ) {}
+
+  async findById(id: string): Promise<[DomainEntity] | null> {
+    const ormEntity = await this.repository.findOne({ where: { id } });
+
+    if (!ormEntity) {
+      return null;
+    }
+
+    return [Name]PersistenceMapper.toDomain(ormEntity);
+  }
+
+  async findAll(options?: { skip?: number; take?: number }): Promise<[DomainEntity][]> {
+    const ormEntities = await this.repository.find({
+      skip: options?.skip,
+      take: options?.take,
+      order: { createdAt: 'DESC' },
+    });
+
+    return ormEntities.map([Name]PersistenceMapper.toDomain);
+  }
+
+  async findBy(criteria: Partial<[DomainEntity]>): Promise<[DomainEntity][]> {
+    const ormEntities = await this.repository.find({
+      where: this.mapCriteriaToOrm(criteria),
+    });
+
+    return ormEntities.map([Name]PersistenceMapper.toDomain);
+  }
+
+  async save(entity: [DomainEntity]): Promise<void> {
+    const ormEntity = [Name]PersistenceMapper.toOrm(entity);
+    await this.repository.save(ormEntity);
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.repository.delete(id);
+  }
+
+  async exists(id: string): Promise<boolean> {
+    const count = await this.repository.count({ where: { id } });
+    return count > 0;
+  }
+
+  private mapCriteriaToOrm(criteria: Partial<[DomainEntity]>): Partial<[Name]OrmEntity> {
+    // TODO: Map domain criteria to ORM criteria
+    return {};
+  }
+}

package/src/stacks/backend-only/skills/clean-hexa-backend/templates/controller.template.ts

@@ -0,0 +1,131 @@
+// Template: Controller (Backend)
+// Location: src/presentation/controllers/[name].controller.ts
+
+import {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Delete,
+  Body,
+  Param,
+  Query,
+  HttpCode,
+  HttpStatus,
+  UseGuards,
+  ParseUUIDPipe,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';
+// TODO: Import use cases
+// TODO: Import DTOs
+// TODO: Import guards if needed
+
+/**
+ * Controller Template
+ *
+ * Rules:
+ * - Thin controller (no business logic)
+ * - Delegate to use cases
+ * - Handle HTTP concerns (status codes, validation)
+ * - Document with Swagger decorators
+ */
+
+// Request DTOs
+export class Create[Name]RequestDto {
+  // TODO: Add properties with class-validator decorators
+  // @IsString()
+  // @IsNotEmpty()
+  // name: string;
+}
+
+export class Update[Name]RequestDto {
+  // TODO: Add properties
+}
+
+// Response DTOs
+export class [Name]ResponseDto {
+  id: string;
+  // TODO: Add properties
+  createdAt: Date;
+}
+
+@ApiTags('[names]')
+@Controller('[names]')
+export class [Name]Controller {
+  constructor(
+    private readonly create[Name]UseCase: Create[Name]UseCase,
+    private readonly get[Name]UseCase: Get[Name]UseCase,
+    private readonly update[Name]UseCase: Update[Name]UseCase,
+    private readonly delete[Name]UseCase: Delete[Name]UseCase,
+  ) {}
+
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  @ApiOperation({ summary: 'Create a new [name]' })
+  @ApiResponse({ status: 201, type: [Name]ResponseDto })
+  async create(@Body() dto: Create[Name]RequestDto): Promise<[Name]ResponseDto> {
+    const result = await this.create[Name]UseCase.execute({
+      // Map DTO to command
+    });
+
+    return this.toResponseDto(result);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get [name] by ID' })
+  @ApiResponse({ status: 200, type: [Name]ResponseDto })
+  @ApiResponse({ status: 404, description: '[Name] not found' })
+  async findOne(
+    @Param('id', ParseUUIDPipe) id: string,
+  ): Promise<[Name]ResponseDto> {
+    const result = await this.get[Name]UseCase.execute({ id });
+
+    if (!result) {
+      // Throw NotFoundException or let exception filter handle
+    }
+
+    return this.toResponseDto(result);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'List all [names]' })
+  @ApiResponse({ status: 200, type: [Name]ResponseDto, isArray: true })
+  async findAll(
+    @Query('skip') skip?: number,
+    @Query('take') take?: number,
+  ): Promise<[Name]ResponseDto[]> {
+    const results = await this.list[Names]UseCase.execute({ skip, take });
+    return results.map(this.toResponseDto);
+  }
+
+  @Put(':id')
+  @ApiOperation({ summary: 'Update [name]' })
+  @ApiResponse({ status: 200, type: [Name]ResponseDto })
+  async update(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: Update[Name]RequestDto,
+  ): Promise<[Name]ResponseDto> {
+    const result = await this.update[Name]UseCase.execute({
+      id,
+      // Map DTO to command
+    });
+
+    return this.toResponseDto(result);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: 'Delete [name]' })
+  @ApiResponse({ status: 204 })
+  async delete(@Param('id', ParseUUIDPipe) id: string): Promise<void> {
+    await this.delete[Name]UseCase.execute({ id });
+  }
+
+  private toResponseDto(entity: any): [Name]ResponseDto {
+    // TODO: Map entity to response DTO
+    return {
+      id: entity.id,
+      createdAt: entity.createdAt,
+    };
+  }
+}

package/src/stacks/backend-only/skills/clean-hexa-backend/templates/entity.template.ts

@@ -0,0 +1,87 @@
+// Template: Domain Entity (Backend)
+// Location: src/domain/entities/[name].entity.ts
+
+/**
+ * Domain Entity Template
+ *
+ * Rules:
+ * - Immutable where possible
+ * - No NestJS/TypeORM imports
+ * - Private constructor + static factory methods
+ * - Business logic encapsulated
+ * - Separate from ORM entities
+ */
+
+// TODO: Import value objects
+// TODO: Import domain errors
+
+export class [EntityName] {
+  private constructor(
+    public readonly id: string,
+    public readonly createdAt: Date,
+    public readonly updatedAt: Date,
+    // TODO: Add entity properties
+  ) {}
+
+  /**
+   * Factory method for creating new entities
+   */
+  static create(/* params */): [EntityName] {
+    // TODO: Add validation logic
+    const now = new Date();
+    return new [EntityName](
+      this.generateId(),
+      now,
+      now,
+      // ... properties
+    );
+  }
+
+  /**
+   * Factory method for reconstituting from persistence
+   */
+  static reconstitute(props: {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    // TODO: Add properties
+  }): [EntityName] {
+    return new [EntityName](
+      props.id,
+      props.createdAt,
+      props.updatedAt,
+      // ... properties
+    );
+  }
+
+  /**
+   * Business methods that return new instances (immutability)
+   */
+  // TODO: Add domain behavior methods
+  // Example:
+  // confirm(): [EntityName] {
+  //   if (this.status !== Status.PENDING) {
+  //     throw new InvalidStateError('Can only confirm pending orders');
+  //   }
+  //   return new [EntityName](
+  //     this.id,
+  //     this.createdAt,
+  //     new Date(),
+  //     Status.CONFIRMED,
+  //   );
+  // }
+
+  /**
+   * Domain validation
+   */
+  // private validate(): void {
+  //   if (!this.someProperty) {
+  //     throw new ValidationError('Property is required');
+  //   }
+  // }
+
+  private static generateId(): string {
+    // Use UUID v4 or similar
+    return require('crypto').randomUUID();
+  }
+}

package/src/stacks/backend-only/skills/clean-hexa-backend/templates/port.template.ts

@@ -0,0 +1,62 @@
+// Template: Port Interface (Backend)
+// Location: src/domain/ports/repositories/[name].repository.port.ts
+
+// TODO: Import entity from domain
+
+/**
+ * Port Interface Template
+ *
+ * Rules:
+ * - Define contract, not implementation
+ * - Use domain types only (no TypeORM, no Prisma)
+ * - Export Symbol for NestJS DI
+ * - Async methods return Promise
+ */
+
+// Injection token for NestJS DI
+export const [NAME]_REPOSITORY = Symbol('[NAME]_REPOSITORY');
+
+/**
+ * Repository port for [Name] aggregate
+ */
+export interface I[Name]Repository {
+  /**
+   * Find entity by ID
+   * @returns Promise resolving to entity or null if not found
+   */
+  findById(id: string): Promise<[Entity] | null>;
+
+  /**
+   * Find all entities with optional pagination
+   */
+  findAll(options?: {
+    skip?: number;
+    take?: number;
+  }): Promise<[Entity][]>;
+
+  /**
+   * Find entities matching criteria
+   */
+  findBy(criteria: Partial<[Entity]>): Promise<[Entity][]>;
+
+  /**
+   * Save entity (create or update)
+   */
+  save(entity: [Entity]): Promise<void>;
+
+  /**
+   * Delete entity by ID
+   */
+  delete(id: string): Promise<void>;
+
+  /**
+   * Check if entity exists
+   */
+  exists(id: string): Promise<boolean>;
+
+  // TODO: Add domain-specific query methods
+  // Example:
+  // findByStatus(status: EntityStatus): Promise<[Entity][]>;
+  // findByUserId(userId: string): Promise<[Entity][]>;
+  // countByStatus(status: EntityStatus): Promise<number>;
+}

package/src/stacks/backend-only/skills/clean-hexa-backend/templates/use-case.template.ts

@@ -0,0 +1,77 @@
+// Template: Use Case (Backend)
+// Location: src/application/use-cases/[name]/[name].use-case.ts
+
+import { Injectable, Inject } from '@nestjs/common';
+// TODO: Import port symbol and interface from domain
+// TODO: Import entity from domain
+// TODO: Import domain errors
+
+/**
+ * Use Case Template
+ *
+ * Rules:
+ * - One class = One business action
+ * - Single execute() method
+ * - Inject ports via Symbol tokens
+ * - Return Result<T> or throw domain errors
+ */
+
+// Command/Input DTO
+export class [Name]Command {
+  constructor(
+    // TODO: Define command properties
+    public readonly userId: string,
+  ) {}
+}
+
+// Result DTO
+export interface [Name]Result {
+  // TODO: Define result properties
+  id: string;
+  success: boolean;
+}
+
+@Injectable()
+export class [Name]UseCase {
+  constructor(
+    @Inject([REPOSITORY]_REPOSITORY)
+    private readonly repository: I[Repository]Repository,
+    // TODO: Inject other ports if needed
+    // @Inject(PAYMENT_SERVICE)
+    // private readonly paymentService: IPaymentService,
+  ) {}
+
+  /**
+   * Execute the use case
+   * @throws DomainError on business rule violation
+   */
+  async execute(command: [Name]Command): Promise<[Name]Result> {
+    // 1. Validate command
+    this.validateCommand(command);
+
+    // 2. Load required aggregates
+    // const entity = await this.repository.findById(command.entityId);
+    // if (!entity) {
+    //   throw new EntityNotFoundError(command.entityId);
+    // }
+
+    // 3. Execute domain logic
+    // const updatedEntity = entity.doSomething();
+
+    // 4. Persist changes
+    // await this.repository.save(updatedEntity);
+
+    // 5. Return result
+    return {
+      id: 'generated-id',
+      success: true,
+    };
+  }
+
+  private validateCommand(command: [Name]Command): void {
+    // TODO: Add validation logic
+    // if (!command.userId) {
+    //   throw new ValidationError('userId is required');
+    // }
+  }
+}

package/src/stacks/backend-only/skills/mutation-testing/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: mutation-testing
+description: Mutation testing avec Stryker pour valider la qualite des tests.
+---
+
+# Skill Mutation Testing
+
+Le mutation testing valide que vos tests detectent vraiment les bugs.
+
+## Principe
+
+1. Stryker modifie (mute) votre code de production
+2. Execute vos tests sur le code mute
+3. Si les tests passent = mutant survit = test insuffisant
+4. Si les tests echouent = mutant tue = test efficace
+
+## Types de mutations
+
+### Mutations arithmetiques
+```typescript
+// Original
+const total = price * quantity;
+
+// Mutant
+const total = price / quantity;  // * -> /
+const total = price + quantity;  // * -> +
+```
+
+### Mutations conditionnelles
+```typescript
+// Original
+if (age >= 18)
+
+// Mutants
+if (age > 18)   // >= -> >
+if (age <= 18)  // >= -> <=
+if (true)       // condition -> true
+if (false)      // condition -> false
+```
+
+### Mutations de blocs
+```typescript
+// Original
+if (condition) {
+  doSomething();
+}
+
+// Mutant
+if (condition) {
+  // Block removed
+}
+```
+
+## Configuration Stryker
+
+```json
+// stryker.conf.json
+{
+  "mutate": [
+    "src/**/*.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/*.module.ts"
+  ],
+  "testRunner": "jest",
+  "reporters": ["html", "clear-text", "progress"],
+  "thresholds": {
+    "high": 80,
+    "low": 60,
+    "break": 75
+  }
+}
+```
+
+## Interpretation du score
+
+- **Score > 80%** : Excellent, tests robustes
+- **Score 60-80%** : Acceptable, ameliorations possibles
+- **Score < 60%** : Tests insuffisants
+
+## Mutants survivants
+
+Quand un mutant survit, analyser :
+
+1. **Test manquant** : Ajouter un test pour ce cas
+2. **Code mort** : Le code n'est pas necessaire
+3. **Test trop general** : Affiner les assertions
+
+### Exemple
+```typescript
+// Code
+function calculateDiscount(price: number, isPremium: boolean): number {
+  if (isPremium) {
+    return price * 0.9;  // 10% discount
+  }
+  return price;
+}
+
+// Test insuffisant
+it('should apply discount for premium', () => {
+  expect(calculateDiscount(100, true)).toBeLessThan(100);
+  // Mutant survit: price * 0.8 passe aussi!
+});
+
+// Test robuste
+it('should apply 10% discount for premium', () => {
+  expect(calculateDiscount(100, true)).toBe(90);
+  // Mutant tue: seul 0.9 donne 90
+});
+```
+
+## Commandes
+
+```bash
+# Lancer mutation testing complet
+npm run stryker
+
+# Sur fichiers specifiques
+npx stryker run --mutate "src/application/use-cases/**/*.ts"
+
+# Rapport HTML
+open reports/mutation/html/index.html
+```
+
+## Integration workflow
+
+Phase 4 (Review) inclut obligatoirement :
+1. Score mutation >= 75%
+2. Analyse des mutants survivants
+3. Ajout de tests si necessaire