@forinda/kickjs-cli 1.1.3 → 1.2.0

package/dist/index.js

@@ -3,6 +3,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/generators/module.ts
 import { join } from "path";
+import { createInterface } from "readline";
 
 // src/utils/fs.ts
 import { writeFile, mkdir, access, readFile } from "fs/promises";
@@ -59,9 +60,25 @@ __name(pluralizePascal, "pluralizePascal");
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 
 // src/generators/templates/module-index.ts
+function repoMaps(pascal, kebab, repo) {
+  const repoClassMap = {
+    inmemory: `InMemory${pascal}Repository`,
+    drizzle: `Drizzle${pascal}Repository`,
+    prisma: `Prisma${pascal}Repository`
+  };
+  const repoFileMap = {
+    inmemory: `in-memory-${kebab}`,
+    drizzle: `drizzle-${kebab}`,
+    prisma: `prisma-${kebab}`
+  };
+  return {
+    repoClass: repoClassMap[repo] ?? repoClassMap.inmemory,
+    repoFile: repoFileMap[repo] ?? repoFileMap.inmemory
+  };
+}
+__name(repoMaps, "repoMaps");
 function generateModuleIndex(pascal, kebab, plural, repo) {
-  const repoClass = repo === "inmemory" ? `InMemory${pascal}Repository` : `Drizzle${pascal}Repository`;
-  const repoFile = repo === "inmemory" ? `in-memory-${kebab}` : `drizzle-${kebab}`;
+  const { repoClass, repoFile } = repoMaps(pascal, kebab, repo);
   return `/**
  * ${pascal} Module
  *
@@ -114,6 +131,65 @@ export class ${pascal}Module implements AppModule {
 `;
 }
 __name(generateModuleIndex, "generateModuleIndex");
+function generateRestModuleIndex(pascal, kebab, plural, repo) {
+  const { repoClass, repoFile } = repoMaps(pascal, kebab, repo);
+  return `/**
+ * ${pascal} Module
+ *
+ * REST module with a flat folder structure.
+ * Controller delegates to service, service wraps the repository.
+ *
+ * Structure:
+ *   ${kebab}.controller.ts  \u2014 HTTP routes (CRUD)
+ *   ${kebab}.service.ts     \u2014 Business logic
+ *   ${kebab}.repository.ts  \u2014 Repository interface
+ *   ${repoFile}.repository.ts \u2014 Repository implementation
+ *   dtos/                   \u2014 Request/response schemas
+ */
+import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs-core'
+import { buildRoutes } from '@forinda/kickjs-http'
+import { ${pascal.toUpperCase()}_REPOSITORY } from './${kebab}.repository'
+import { ${repoClass} } from './${repoFile}.repository'
+import { ${pascal}Controller } from './${kebab}.controller'
+
+// Eagerly load decorated classes so @Service()/@Repository() decorators register in the DI container
+import.meta.glob(['./**/*.service.ts', './**/*.repository.ts', '!./**/*.test.ts'], { eager: true })
+
+export class ${pascal}Module implements AppModule {
+  register(container: Container): void {
+    container.registerFactory(${pascal.toUpperCase()}_REPOSITORY, () =>
+      container.resolve(${repoClass}),
+    )
+  }
+
+  routes(): ModuleRoutes {
+    return {
+      path: '/${plural}',
+      router: buildRoutes(${pascal}Controller),
+      controller: ${pascal}Controller,
+    }
+  }
+}
+`;
+}
+__name(generateRestModuleIndex, "generateRestModuleIndex");
+function generateMinimalModuleIndex(pascal, kebab, plural) {
+  return `import { type AppModule, type ModuleRoutes } from '@forinda/kickjs-core'
+import { buildRoutes } from '@forinda/kickjs-http'
+import { ${pascal}Controller } from './${kebab}.controller'
+
+export class ${pascal}Module implements AppModule {
+  routes(): ModuleRoutes {
+    return {
+      path: '/${plural}',
+      router: buildRoutes(${pascal}Controller),
+      controller: ${pascal}Controller,
+    }
+  }
+}
+`;
+}
+__name(generateMinimalModuleIndex, "generateMinimalModuleIndex");
 
 // src/generators/templates/controller.ts
 function generateController(pascal, kebab, plural, pluralPascal) {
@@ -179,6 +255,62 @@ export class ${pascal}Controller {
 `;
 }
 __name(generateController, "generateController");
+function generateRestController(pascal, kebab, plural, pluralPascal) {
+  const camel = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  return `import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams } from '@forinda/kickjs-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+import { ApiTags } from '@forinda/kickjs-swagger'
+import { ${pascal}Service } from './${kebab}.service'
+import { create${pascal}Schema } from './dtos/create-${kebab}.dto'
+import { update${pascal}Schema } from './dtos/update-${kebab}.dto'
+import { ${pascal.toUpperCase()}_QUERY_CONFIG } from './${kebab}.constants'
+
+@Controller()
+export class ${pascal}Controller {
+  @Autowired() private ${camel}Service!: ${pascal}Service
+
+  @Get('/')
+  @ApiTags('${pascal}')
+  @ApiQueryParams(${pascal.toUpperCase()}_QUERY_CONFIG)
+  async list(ctx: RequestContext) {
+    return ctx.paginate(
+      (parsed) => this.${camel}Service.findPaginated(parsed),
+      ${pascal.toUpperCase()}_QUERY_CONFIG,
+    )
+  }
+
+  @Get('/:id')
+  @ApiTags('${pascal}')
+  async getById(ctx: RequestContext) {
+    const result = await this.${camel}Service.findById(ctx.params.id)
+    if (!result) return ctx.notFound('${pascal} not found')
+    ctx.json(result)
+  }
+
+  @Post('/', { body: create${pascal}Schema, name: 'Create${pascal}' })
+  @ApiTags('${pascal}')
+  async create(ctx: RequestContext) {
+    const result = await this.${camel}Service.create(ctx.body)
+    ctx.created(result)
+  }
+
+  @Put('/:id', { body: update${pascal}Schema, name: 'Update${pascal}' })
+  @ApiTags('${pascal}')
+  async update(ctx: RequestContext) {
+    const result = await this.${camel}Service.update(ctx.params.id, ctx.body)
+    ctx.json(result)
+  }
+
+  @Delete('/:id')
+  @ApiTags('${pascal}')
+  async remove(ctx: RequestContext) {
+    await this.${camel}Service.delete(ctx.params.id)
+    ctx.noContent()
+  }
+}
+`;
+}
+__name(generateRestController, "generateRestController");
 
 // src/generators/templates/constants.ts
 function generateConstants(pascal) {
@@ -342,20 +474,19 @@ export class Delete${pascal}UseCase {
 __name(generateUseCases, "generateUseCases");
 
 // src/generators/templates/repository.ts
-function generateRepositoryInterface(pascal, kebab) {
+function generateRepositoryInterface(pascal, kebab, dtoPrefix = "../../application/dtos") {
   return `/**
  * ${pascal} Repository Interface
  *
- * Domain layer \u2014 defines the contract for data access.
- * The interface lives in the domain layer; implementations live in infrastructure.
- * This inversion of dependencies keeps the domain pure and testable.
+ * Defines the contract for data access.
+ * The interface declares what operations are available;
+ * implementations (in-memory, Drizzle, Prisma) fulfill the contract.
  *
- * To swap implementations (e.g. in-memory -> Drizzle -> Prisma),
- * change the factory in the module's register() method.
+ * To swap implementations, change the factory in the module's register() method.
  */
-import type { ${pascal}ResponseDTO } from '../../application/dtos/${kebab}-response.dto'
-import type { Create${pascal}DTO } from '../../application/dtos/create-${kebab}.dto'
-import type { Update${pascal}DTO } from '../../application/dtos/update-${kebab}.dto'
+import type { ${pascal}ResponseDTO } from '${dtoPrefix}/${kebab}-response.dto'
+import type { Create${pascal}DTO } from '${dtoPrefix}/create-${kebab}.dto'
+import type { Update${pascal}DTO } from '${dtoPrefix}/update-${kebab}.dto'
 import type { ParsedQuery } from '@forinda/kickjs-http'
 
 export interface I${pascal}Repository {
@@ -371,11 +502,11 @@ export const ${pascal.toUpperCase()}_REPOSITORY = Symbol('I${pascal}Repository')
 `;
 }
 __name(generateRepositoryInterface, "generateRepositoryInterface");
-function generateInMemoryRepository(pascal, kebab) {
+function generateInMemoryRepository(pascal, kebab, repoPrefix = "../../domain/repositories", dtoPrefix = "../../application/dtos") {
   return `/**
  * In-Memory ${pascal} Repository
  *
- * Infrastructure layer \u2014 implements the repository interface using a Map.
+ * Implements the repository interface using a Map.
  * Useful for prototyping and testing. Replace with a database implementation
  * (Drizzle, Prisma, etc.) for production use.
  *
@@ -384,10 +515,10 @@ function generateInMemoryRepository(pascal, kebab) {
 import { randomUUID } from 'node:crypto'
 import { Repository, HttpException } from '@forinda/kickjs-core'
 import type { ParsedQuery } from '@forinda/kickjs-http'
-import type { I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
-import type { ${pascal}ResponseDTO } from '../../application/dtos/${kebab}-response.dto'
-import type { Create${pascal}DTO } from '../../application/dtos/create-${kebab}.dto'
-import type { Update${pascal}DTO } from '../../application/dtos/update-${kebab}.dto'
+import type { I${pascal}Repository } from '${repoPrefix}/${kebab}.repository'
+import type { ${pascal}ResponseDTO } from '${dtoPrefix}/${kebab}-response.dto'
+import type { Create${pascal}DTO } from '${dtoPrefix}/create-${kebab}.dto'
+import type { Update${pascal}DTO } from '${dtoPrefix}/update-${kebab}.dto'
 
 @Repository()
 export class InMemory${pascal}Repository implements I${pascal}Repository {
@@ -435,6 +566,162 @@ export class InMemory${pascal}Repository implements I${pascal}Repository {
 `;
 }
 __name(generateInMemoryRepository, "generateInMemoryRepository");
+function generateDrizzleRepository(pascal, kebab, repoPrefix = "../../domain/repositories", dtoPrefix = "../../application/dtos") {
+  return `/**
+ * Drizzle ${pascal} Repository
+ *
+ * Implements the repository interface using Drizzle ORM.
+ * Requires a Drizzle database instance injected via the DI container.
+ *
+ * TODO: Update the schema import to match your Drizzle schema file.
+ * TODO: Replace 'db' injection token with your actual database token.
+ *
+ * @Repository() registers this class in the DI container as a singleton.
+ */
+import { eq, sql } from 'drizzle-orm'
+import { Repository, HttpException, Autowired } from '@forinda/kickjs-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+import type { I${pascal}Repository } from '${repoPrefix}/${kebab}.repository'
+import type { ${pascal}ResponseDTO } from '${dtoPrefix}/${kebab}-response.dto'
+import type { Create${pascal}DTO } from '${dtoPrefix}/create-${kebab}.dto'
+import type { Update${pascal}DTO } from '${dtoPrefix}/update-${kebab}.dto'
+
+// TODO: Import your Drizzle schema table \u2014 e.g.:
+// import { ${kebab}s } from '@/db/schema'
+
+// TODO: Import your Drizzle DB injection token \u2014 e.g.:
+// import { DRIZZLE_DB } from '@/db/drizzle.provider'
+
+@Repository()
+export class Drizzle${pascal}Repository implements I${pascal}Repository {
+  // TODO: Uncomment and configure your Drizzle DB injection:
+  // @Autowired(DRIZZLE_DB) private db!: DrizzleDB
+
+  async findById(id: string): Promise<${pascal}ResponseDTO | null> {
+    // TODO: Implement with Drizzle
+    // const [row] = await this.db.select().from(${kebab}s).where(eq(${kebab}s.id, id))
+    // return row ?? null
+    throw new Error('Drizzle ${pascal} repository not yet implemented \u2014 update schema imports and queries')
+  }
+
+  async findAll(): Promise<${pascal}ResponseDTO[]> {
+    // TODO: Implement with Drizzle
+    // return this.db.select().from(${kebab}s)
+    throw new Error('Drizzle ${pascal} repository not yet implemented')
+  }
+
+  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${pascal}ResponseDTO[]; total: number }> {
+    // TODO: Implement with Drizzle
+    // const data = await this.db.select().from(${kebab}s)
+    //   .limit(parsed.pagination.limit)
+    //   .offset(parsed.pagination.offset)
+    // const [{ count }] = await this.db.select({ count: sql\`count(*)\` }).from(${kebab}s)
+    // return { data, total: Number(count) }
+    throw new Error('Drizzle ${pascal} repository not yet implemented')
+  }
+
+  async create(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    // TODO: Implement with Drizzle
+    // const [row] = await this.db.insert(${kebab}s).values(dto).returning()
+    // return row
+    throw new Error('Drizzle ${pascal} repository not yet implemented')
+  }
+
+  async update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    // TODO: Implement with Drizzle
+    // const [row] = await this.db.update(${kebab}s).set(dto).where(eq(${kebab}s.id, id)).returning()
+    // if (!row) throw HttpException.notFound('${pascal} not found')
+    // return row
+    throw new Error('Drizzle ${pascal} repository not yet implemented')
+  }
+
+  async delete(id: string): Promise<void> {
+    // TODO: Implement with Drizzle
+    // const result = await this.db.delete(${kebab}s).where(eq(${kebab}s.id, id))
+    // if (!result.rowCount) throw HttpException.notFound('${pascal} not found')
+    throw new Error('Drizzle ${pascal} repository not yet implemented')
+  }
+}
+`;
+}
+__name(generateDrizzleRepository, "generateDrizzleRepository");
+function generatePrismaRepository(pascal, kebab, repoPrefix = "../../domain/repositories", dtoPrefix = "../../application/dtos") {
+  const camel = kebab.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+  return `/**
+ * Prisma ${pascal} Repository
+ *
+ * Implements the repository interface using Prisma Client.
+ * Requires a PrismaClient instance injected via the DI container.
+ *
+ * TODO: Ensure your Prisma schema has a '${pascal}' model defined.
+ * TODO: Replace 'PRISMA_CLIENT' with your actual Prisma injection token.
+ *
+ * @Repository() registers this class in the DI container as a singleton.
+ */
+import { Repository, HttpException, Autowired } from '@forinda/kickjs-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+import type { I${pascal}Repository } from '${repoPrefix}/${kebab}.repository'
+import type { ${pascal}ResponseDTO } from '${dtoPrefix}/${kebab}-response.dto'
+import type { Create${pascal}DTO } from '${dtoPrefix}/create-${kebab}.dto'
+import type { Update${pascal}DTO } from '${dtoPrefix}/update-${kebab}.dto'
+
+// TODO: Import your Prisma injection token \u2014 e.g.:
+// import { PRISMA_CLIENT } from '@/db/prisma.provider'
+// import type { PrismaClient } from '@prisma/client'
+
+@Repository()
+export class Prisma${pascal}Repository implements I${pascal}Repository {
+  // TODO: Uncomment and configure your Prisma injection:
+  // @Autowired(PRISMA_CLIENT) private prisma!: PrismaClient
+
+  async findById(id: string): Promise<${pascal}ResponseDTO | null> {
+    // TODO: Implement with Prisma
+    // return this.prisma.${camel}.findUnique({ where: { id } })
+    throw new Error('Prisma ${pascal} repository not yet implemented \u2014 update Prisma imports and queries')
+  }
+
+  async findAll(): Promise<${pascal}ResponseDTO[]> {
+    // TODO: Implement with Prisma
+    // return this.prisma.${camel}.findMany()
+    throw new Error('Prisma ${pascal} repository not yet implemented')
+  }
+
+  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${pascal}ResponseDTO[]; total: number }> {
+    // TODO: Implement with Prisma
+    // const [data, total] = await Promise.all([
+    //   this.prisma.${camel}.findMany({
+    //     skip: parsed.pagination.offset,
+    //     take: parsed.pagination.limit,
+    //   }),
+    //   this.prisma.${camel}.count(),
+    // ])
+    // return { data, total }
+    throw new Error('Prisma ${pascal} repository not yet implemented')
+  }
+
+  async create(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    // TODO: Implement with Prisma
+    // return this.prisma.${camel}.create({ data: dto })
+    throw new Error('Prisma ${pascal} repository not yet implemented')
+  }
+
+  async update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    // TODO: Implement with Prisma
+    // const row = await this.prisma.${camel}.update({ where: { id }, data: dto })
+    // if (!row) throw HttpException.notFound('${pascal} not found')
+    // return row
+    throw new Error('Prisma ${pascal} repository not yet implemented')
+  }
+
+  async delete(id: string): Promise<void> {
+    // TODO: Implement with Prisma
+    // await this.prisma.${camel}.delete({ where: { id } })
+    throw new Error('Prisma ${pascal} repository not yet implemented')
+  }
+}
+`;
+}
+__name(generatePrismaRepository, "generatePrismaRepository");
 
 // src/generators/templates/domain.ts
 function generateDomainService(pascal, kebab) {
@@ -633,9 +920,9 @@ describe('${pascal}Controller', () => {
 `;
 }
 __name(generateControllerTest, "generateControllerTest");
-function generateRepositoryTest(pascal, kebab, plural) {
+function generateRepositoryTest(pascal, kebab, plural, repoImport = `../infrastructure/repositories/in-memory-${kebab}.repository`) {
   return `import { describe, it, expect, beforeEach } from 'vitest'
-import { InMemory${pascal}Repository } from '../infrastructure/repositories/in-memory-${kebab}.repository'
+import { InMemory${pascal}Repository } from '${repoImport}'
 
 describe('InMemory${pascal}Repository', () => {
   let repo: InMemory${pascal}Repository
@@ -700,21 +987,553 @@ describe('InMemory${pascal}Repository', () => {
 }
 __name(generateRepositoryTest, "generateRepositoryTest");
 
+// src/generators/templates/rest-service.ts
+function generateRestService(pascal, kebab) {
+  return `import { Service, Inject, HttpException } from '@forinda/kickjs-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from './${kebab}.repository'
+import type { ${pascal}ResponseDTO } from './dtos/${kebab}-response.dto'
+import type { Create${pascal}DTO } from './dtos/create-${kebab}.dto'
+import type { Update${pascal}DTO } from './dtos/update-${kebab}.dto'
+
+@Service()
+export class ${pascal}Service {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+  ) {}
+
+  async findById(id: string): Promise<${pascal}ResponseDTO | null> {
+    return this.repo.findById(id)
+  }
+
+  async findAll(): Promise<${pascal}ResponseDTO[]> {
+    return this.repo.findAll()
+  }
+
+  async findPaginated(parsed: ParsedQuery) {
+    return this.repo.findPaginated(parsed)
+  }
+
+  async create(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    return this.repo.create(dto)
+  }
+
+  async update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    return this.repo.update(id, dto)
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.repo.delete(id)
+  }
+}
+`;
+}
+__name(generateRestService, "generateRestService");
+function generateRestConstants(pascal) {
+  return `import type { QueryFieldConfig } from '@forinda/kickjs-http'
+
+export const ${pascal.toUpperCase()}_QUERY_CONFIG: QueryFieldConfig = {
+  filterable: ['name'],
+  sortable: ['name', 'createdAt'],
+  searchable: ['name'],
+}
+`;
+}
+__name(generateRestConstants, "generateRestConstants");
+
+// src/generators/templates/cqrs.ts
+function generateCqrsModuleIndex(pascal, kebab, plural, repo) {
+  const repoClassMap = {
+    inmemory: `InMemory${pascal}Repository`,
+    drizzle: `Drizzle${pascal}Repository`,
+    prisma: `Prisma${pascal}Repository`
+  };
+  const repoFileMap = {
+    inmemory: `in-memory-${kebab}`,
+    drizzle: `drizzle-${kebab}`,
+    prisma: `prisma-${kebab}`
+  };
+  const repoClass = repoClassMap[repo] ?? repoClassMap.inmemory;
+  const repoFile = repoFileMap[repo] ?? repoFileMap.inmemory;
+  return `/**
+ * ${pascal} Module \u2014 CQRS Pattern
+ *
+ * Separates read (queries) and write (commands) operations.
+ * Events are emitted after state changes and can be handled via
+ * WebSocket broadcasts, queue jobs, or ETL pipelines.
+ *
+ * Structure:
+ *   commands/       \u2014 Write operations (create, update, delete)
+ *   queries/        \u2014 Read operations (get, list)
+ *   events/         \u2014 Domain events + handlers (WS broadcast, queue dispatch)
+ *   dtos/           \u2014 Request/response schemas
+ */
+import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs-core'
+import { buildRoutes } from '@forinda/kickjs-http'
+import { ${pascal.toUpperCase()}_REPOSITORY } from './${kebab}.repository'
+import { ${repoClass} } from './${repoFile}.repository'
+import { ${pascal}Controller } from './${kebab}.controller'
+
+// Eagerly load decorated classes
+import.meta.glob(
+  [
+    './commands/**/*.ts',
+    './queries/**/*.ts',
+    './events/**/*.ts',
+    '!./**/*.test.ts',
+  ],
+  { eager: true },
+)
+
+export class ${pascal}Module implements AppModule {
+  register(container: Container): void {
+    container.registerFactory(${pascal.toUpperCase()}_REPOSITORY, () =>
+      container.resolve(${repoClass}),
+    )
+  }
+
+  routes(): ModuleRoutes {
+    return {
+      path: '/${plural}',
+      router: buildRoutes(${pascal}Controller),
+      controller: ${pascal}Controller,
+    }
+  }
+}
+`;
+}
+__name(generateCqrsModuleIndex, "generateCqrsModuleIndex");
+function generateCqrsController(pascal, kebab, plural, pluralPascal) {
+  const camel = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  return `import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams } from '@forinda/kickjs-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+import { ApiTags } from '@forinda/kickjs-swagger'
+import { Create${pascal}Command } from './commands/create-${kebab}.command'
+import { Update${pascal}Command } from './commands/update-${kebab}.command'
+import { Delete${pascal}Command } from './commands/delete-${kebab}.command'
+import { Get${pascal}Query } from './queries/get-${kebab}.query'
+import { List${pluralPascal}Query } from './queries/list-${plural}.query'
+import { create${pascal}Schema } from './dtos/create-${kebab}.dto'
+import { update${pascal}Schema } from './dtos/update-${kebab}.dto'
+import { ${pascal.toUpperCase()}_QUERY_CONFIG } from './${kebab}.constants'
+
+@Controller()
+export class ${pascal}Controller {
+  @Autowired() private create${pascal}Command!: Create${pascal}Command
+  @Autowired() private update${pascal}Command!: Update${pascal}Command
+  @Autowired() private delete${pascal}Command!: Delete${pascal}Command
+  @Autowired() private get${pascal}Query!: Get${pascal}Query
+  @Autowired() private list${pluralPascal}Query!: List${pluralPascal}Query
+
+  @Get('/')
+  @ApiTags('${pascal}')
+  @ApiQueryParams(${pascal.toUpperCase()}_QUERY_CONFIG)
+  async list(ctx: RequestContext) {
+    return ctx.paginate(
+      (parsed) => this.list${pluralPascal}Query.execute(parsed),
+      ${pascal.toUpperCase()}_QUERY_CONFIG,
+    )
+  }
+
+  @Get('/:id')
+  @ApiTags('${pascal}')
+  async getById(ctx: RequestContext) {
+    const result = await this.get${pascal}Query.execute(ctx.params.id)
+    if (!result) return ctx.notFound('${pascal} not found')
+    ctx.json(result)
+  }
+
+  @Post('/', { body: create${pascal}Schema, name: 'Create${pascal}' })
+  @ApiTags('${pascal}')
+  async create(ctx: RequestContext) {
+    const result = await this.create${pascal}Command.execute(ctx.body)
+    ctx.created(result)
+  }
+
+  @Put('/:id', { body: update${pascal}Schema, name: 'Update${pascal}' })
+  @ApiTags('${pascal}')
+  async update(ctx: RequestContext) {
+    const result = await this.update${pascal}Command.execute(ctx.params.id, ctx.body)
+    ctx.json(result)
+  }
+
+  @Delete('/:id')
+  @ApiTags('${pascal}')
+  async remove(ctx: RequestContext) {
+    await this.delete${pascal}Command.execute(ctx.params.id)
+    ctx.noContent()
+  }
+}
+`;
+}
+__name(generateCqrsController, "generateCqrsController");
+function generateCqrsCommands(pascal, kebab) {
+  return [
+    {
+      file: `create-${kebab}.command.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../${kebab}.repository'
+import type { Create${pascal}DTO } from '../dtos/create-${kebab}.dto'
+import type { ${pascal}ResponseDTO } from '../dtos/${kebab}-response.dto'
+import { ${pascal}Events } from '../events/${kebab}.events'
+
+@Service()
+export class Create${pascal}Command {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+    @Inject(${pascal}Events) private readonly events: ${pascal}Events,
+  ) {}
+
+  async execute(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    const result = await this.repo.create(dto)
+    this.events.emit('${kebab}.created', result)
+    return result
+  }
+}
+`
+    },
+    {
+      file: `update-${kebab}.command.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../${kebab}.repository'
+import type { Update${pascal}DTO } from '../dtos/update-${kebab}.dto'
+import type { ${pascal}ResponseDTO } from '../dtos/${kebab}-response.dto'
+import { ${pascal}Events } from '../events/${kebab}.events'
+
+@Service()
+export class Update${pascal}Command {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+    @Inject(${pascal}Events) private readonly events: ${pascal}Events,
+  ) {}
+
+  async execute(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    const result = await this.repo.update(id, dto)
+    this.events.emit('${kebab}.updated', result)
+    return result
+  }
+}
+`
+    },
+    {
+      file: `delete-${kebab}.command.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../${kebab}.repository'
+import { ${pascal}Events } from '../events/${kebab}.events'
+
+@Service()
+export class Delete${pascal}Command {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+    @Inject(${pascal}Events) private readonly events: ${pascal}Events,
+  ) {}
+
+  async execute(id: string): Promise<void> {
+    await this.repo.delete(id)
+    this.events.emit('${kebab}.deleted', { id })
+  }
+}
+`
+    }
+  ];
+}
+__name(generateCqrsCommands, "generateCqrsCommands");
+function generateCqrsQueries(pascal, kebab, plural, pluralPascal) {
+  return [
+    {
+      file: `get-${kebab}.query.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../${kebab}.repository'
+import type { ${pascal}ResponseDTO } from '../dtos/${kebab}-response.dto'
+
+@Service()
+export class Get${pascal}Query {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+  ) {}
+
+  async execute(id: string): Promise<${pascal}ResponseDTO | null> {
+    return this.repo.findById(id)
+  }
+}
+`
+    },
+    {
+      file: `list-${plural}.query.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../${kebab}.repository'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+
+@Service()
+export class List${pluralPascal}Query {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+  ) {}
+
+  async execute(parsed: ParsedQuery) {
+    return this.repo.findPaginated(parsed)
+  }
+}
+`
+    }
+  ];
+}
+__name(generateCqrsQueries, "generateCqrsQueries");
+function generateCqrsEvents(pascal, kebab) {
+  return [
+    {
+      file: `${kebab}.events.ts`,
+      content: `import { Service } from '@forinda/kickjs-core'
+import { EventEmitter } from 'node:events'
+import type { ${pascal}ResponseDTO } from '../dtos/${kebab}-response.dto'
+
+/**
+ * ${pascal} domain event types.
+ *
+ * These events are emitted by commands after state changes.
+ * Subscribe to them in event handlers for side effects:
+ *   - WebSocket broadcasts (real-time UI updates)
+ *   - Queue jobs (async processing, ETL pipelines)
+ *   - Audit logging
+ *   - Cache invalidation
+ */
+export interface ${pascal}EventMap {
+  '${kebab}.created': ${pascal}ResponseDTO
+  '${kebab}.updated': ${pascal}ResponseDTO
+  '${kebab}.deleted': { id: string }
+}
+
+@Service()
+export class ${pascal}Events {
+  private emitter = new EventEmitter()
+
+  emit<K extends keyof ${pascal}EventMap>(event: K, data: ${pascal}EventMap[K]): void {
+    this.emitter.emit(event, data)
+  }
+
+  on<K extends keyof ${pascal}EventMap>(event: K, handler: (data: ${pascal}EventMap[K]) => void): void {
+    this.emitter.on(event, handler)
+  }
+
+  off<K extends keyof ${pascal}EventMap>(event: K, handler: (data: ${pascal}EventMap[K]) => void): void {
+    this.emitter.off(event, handler)
+  }
+}
+`
+    },
+    {
+      file: `on-${kebab}-change.handler.ts`,
+      content: `import { Service, Autowired } from '@forinda/kickjs-core'
+import { ${pascal}Events } from './${kebab}.events'
+
+/**
+ * ${pascal} Change Event Handler
+ *
+ * Reacts to domain events emitted by commands.
+ * Wire up side effects here:
+ *
+ * 1. WebSocket broadcast \u2014 notify connected clients in real-time
+ *    import { WsGateway } from '@forinda/kickjs-ws'
+ *    this.ws.broadcast('${kebab}-channel', { event, data })
+ *
+ * 2. Queue dispatch \u2014 offload heavy processing to background workers
+ *    import { QueueService } from '@forinda/kickjs-queue'
+ *    this.queue.add('${kebab}-etl', { action: event, payload: data })
+ *
+ * 3. ETL pipeline \u2014 transform and load data to external systems
+ *    await this.etlPipeline.process(data)
+ */
+@Service()
+export class On${pascal}ChangeHandler {
+  @Autowired() private events!: ${pascal}Events
+
+  // Uncomment to inject WebSocket and Queue services:
+  // @Autowired() private ws!: WsGateway
+  // @Autowired() private queue!: QueueService
+
+  onInit(): void {
+    this.events.on('${kebab}.created', (data) => {
+      console.log('[${pascal}] Created:', data.id)
+      // TODO: Broadcast via WebSocket
+      // this.ws.broadcast('${kebab}-channel', { event: '${kebab}.created', data })
+      // TODO: Dispatch to queue for async processing / ETL
+      // this.queue.add('${kebab}-etl', { action: 'create', payload: data })
+    })
+
+    this.events.on('${kebab}.updated', (data) => {
+      console.log('[${pascal}] Updated:', data.id)
+      // TODO: Broadcast via WebSocket
+      // this.ws.broadcast('${kebab}-channel', { event: '${kebab}.updated', data })
+    })
+
+    this.events.on('${kebab}.deleted', (data) => {
+      console.log('[${pascal}] Deleted:', data.id)
+      // TODO: Broadcast via WebSocket
+      // this.ws.broadcast('${kebab}-channel', { event: '${kebab}.deleted', data })
+    })
+  }
+}
+`
+    }
+  ];
+}
+__name(generateCqrsEvents, "generateCqrsEvents");
+
 // src/generators/module.ts
+function promptUser(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim().toLowerCase());
+    });
+  });
+}
+__name(promptUser, "promptUser");
 async function generateModule(options) {
-  const { name, modulesDir, noEntity, noTests, repo = "inmemory", minimal } = options;
+  const { name, modulesDir, noEntity, noTests, repo = "inmemory", force } = options;
+  let pattern = options.pattern ?? "ddd";
+  if (options.minimal) pattern = "minimal";
   const kebab = toKebabCase(name);
   const pascal = toPascalCase(name);
-  const camel = toCamelCase(name);
   const plural = pluralize(kebab);
   const pluralPascal = pluralizePascal(pascal);
   const moduleDir = join(modulesDir, plural);
   const files = [];
+  let overwriteAll = force ?? false;
   const write = /* @__PURE__ */ __name(async (relativePath, content) => {
     const fullPath = join(moduleDir, relativePath);
+    if (!overwriteAll && await fileExists(fullPath)) {
+      const answer = await promptUser(`  File already exists: ${relativePath}
+  Overwrite? (y/n/a = yes/no/all) `);
+      if (answer === "a") {
+        overwriteAll = true;
+      } else if (answer !== "y") {
+        console.log(`  Skipped: ${relativePath}`);
+        return;
+      }
+    }
     await writeFileSafe(fullPath, content);
     files.push(fullPath);
   }, "write");
+  const ctx = {
+    kebab,
+    pascal,
+    plural,
+    pluralPascal,
+    moduleDir,
+    repo,
+    noEntity: noEntity ?? false,
+    noTests: noTests ?? false,
+    write,
+    files
+  };
+  switch (pattern) {
+    case "minimal":
+      await generateMinimalFiles(ctx);
+      break;
+    case "rest":
+      await generateRestFiles(ctx);
+      break;
+    case "cqrs":
+      await generateCqrsFiles(ctx);
+      break;
+    case "graphql":
+    case "ddd":
+    default:
+      await generateDddFiles(ctx);
+      break;
+  }
+  await autoRegisterModule(modulesDir, pascal, plural);
+  return files;
+}
+__name(generateModule, "generateModule");
+async function generateMinimalFiles(ctx) {
+  const { pascal, kebab, plural, write } = ctx;
+  await write("index.ts", generateMinimalModuleIndex(pascal, kebab, plural));
+  await write(`${kebab}.controller.ts`, `import { Controller, Get } from '@forinda/kickjs-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+
+@Controller()
+export class ${pascal}Controller {
+  @Get('/')
+  async list(ctx: RequestContext) {
+    ctx.json({ message: '${pascal} list' })
+  }
+}
+`);
+}
+__name(generateMinimalFiles, "generateMinimalFiles");
+async function generateRestFiles(ctx) {
+  const { pascal, kebab, plural, pluralPascal, repo, noTests, write } = ctx;
+  await write("index.ts", generateRestModuleIndex(pascal, kebab, plural, repo));
+  await write(`${kebab}.constants.ts`, generateRestConstants(pascal));
+  await write(`${kebab}.controller.ts`, generateRestController(pascal, kebab, plural, pluralPascal));
+  await write(`${kebab}.service.ts`, generateRestService(pascal, kebab));
+  await write(`dtos/create-${kebab}.dto.ts`, generateCreateDTO(pascal, kebab));
+  await write(`dtos/update-${kebab}.dto.ts`, generateUpdateDTO(pascal, kebab));
+  await write(`dtos/${kebab}-response.dto.ts`, generateResponseDTO(pascal, kebab));
+  await write(`${kebab}.repository.ts`, generateRepositoryInterface(pascal, kebab, "./dtos"));
+  const repoFileMap = {
+    inmemory: `in-memory-${kebab}`,
+    drizzle: `drizzle-${kebab}`,
+    prisma: `prisma-${kebab}`
+  };
+  const repoGeneratorMap = {
+    inmemory: /* @__PURE__ */ __name(() => generateInMemoryRepository(pascal, kebab, ".", "./dtos"), "inmemory"),
+    drizzle: /* @__PURE__ */ __name(() => generateDrizzleRepository(pascal, kebab, ".", "./dtos"), "drizzle"),
+    prisma: /* @__PURE__ */ __name(() => generatePrismaRepository(pascal, kebab, ".", "./dtos"), "prisma")
+  };
+  await write(`${repoFileMap[repo]}.repository.ts`, repoGeneratorMap[repo]());
+  if (!noTests) {
+    await write(`__tests__/${kebab}.controller.test.ts`, generateControllerTest(pascal, kebab, plural));
+    await write(`__tests__/${kebab}.repository.test.ts`, generateRepositoryTest(pascal, kebab, plural, `../${repoFileMap.inmemory}.repository`));
+  }
+}
+__name(generateRestFiles, "generateRestFiles");
+async function generateCqrsFiles(ctx) {
+  const { pascal, kebab, plural, pluralPascal, repo, noTests, write } = ctx;
+  await write("index.ts", generateCqrsModuleIndex(pascal, kebab, plural, repo));
+  await write(`${kebab}.constants.ts`, generateRestConstants(pascal));
+  await write(`${kebab}.controller.ts`, generateCqrsController(pascal, kebab, plural, pluralPascal));
+  await write(`dtos/create-${kebab}.dto.ts`, generateCreateDTO(pascal, kebab));
+  await write(`dtos/update-${kebab}.dto.ts`, generateUpdateDTO(pascal, kebab));
+  await write(`dtos/${kebab}-response.dto.ts`, generateResponseDTO(pascal, kebab));
+  const commands = generateCqrsCommands(pascal, kebab);
+  for (const cmd of commands) {
+    await write(`commands/${cmd.file}`, cmd.content);
+  }
+  const queries = generateCqrsQueries(pascal, kebab, plural, pluralPascal);
+  for (const q of queries) {
+    await write(`queries/${q.file}`, q.content);
+  }
+  const events = generateCqrsEvents(pascal, kebab);
+  for (const e of events) {
+    await write(`events/${e.file}`, e.content);
+  }
+  await write(`${kebab}.repository.ts`, generateRepositoryInterface(pascal, kebab, "./dtos"));
+  const repoFileMap = {
+    inmemory: `in-memory-${kebab}`,
+    drizzle: `drizzle-${kebab}`,
+    prisma: `prisma-${kebab}`
+  };
+  const repoGeneratorMap = {
+    inmemory: /* @__PURE__ */ __name(() => generateInMemoryRepository(pascal, kebab, ".", "./dtos"), "inmemory"),
+    drizzle: /* @__PURE__ */ __name(() => generateDrizzleRepository(pascal, kebab, ".", "./dtos"), "drizzle"),
+    prisma: /* @__PURE__ */ __name(() => generatePrismaRepository(pascal, kebab, ".", "./dtos"), "prisma")
+  };
+  await write(`${repoFileMap[repo]}.repository.ts`, repoGeneratorMap[repo]());
+  if (!noTests) {
+    await write(`__tests__/${kebab}.controller.test.ts`, generateControllerTest(pascal, kebab, plural));
+    await write(`__tests__/${kebab}.repository.test.ts`, generateRepositoryTest(pascal, kebab, plural, `../${repoFileMap.inmemory}.repository`));
+  }
+}
+__name(generateCqrsFiles, "generateCqrsFiles");
+async function generateDddFiles(ctx) {
+  const { pascal, kebab, plural, pluralPascal, repo, noEntity, noTests, write } = ctx;
   await write("index.ts", generateModuleIndex(pascal, kebab, plural, repo));
   await write("constants.ts", generateConstants(pascal));
   await write(`presentation/${kebab}.controller.ts`, generateController(pascal, kebab, plural, pluralPascal));
@@ -727,10 +1546,18 @@ async function generateModule(options) {
   }
   await write(`domain/repositories/${kebab}.repository.ts`, generateRepositoryInterface(pascal, kebab));
   await write(`domain/services/${kebab}-domain.service.ts`, generateDomainService(pascal, kebab));
-  if (repo === "inmemory") {
-    await write(`infrastructure/repositories/in-memory-${kebab}.repository.ts`, generateInMemoryRepository(pascal, kebab));
-  }
-  if (!noEntity && !minimal) {
+  const repoFileMap = {
+    inmemory: `in-memory-${kebab}`,
+    drizzle: `drizzle-${kebab}`,
+    prisma: `prisma-${kebab}`
+  };
+  const repoGeneratorMap = {
+    inmemory: /* @__PURE__ */ __name(() => generateInMemoryRepository(pascal, kebab), "inmemory"),
+    drizzle: /* @__PURE__ */ __name(() => generateDrizzleRepository(pascal, kebab), "drizzle"),
+    prisma: /* @__PURE__ */ __name(() => generatePrismaRepository(pascal, kebab), "prisma")
+  };
+  await write(`infrastructure/repositories/${repoFileMap[repo]}.repository.ts`, repoGeneratorMap[repo]());
+  if (!noEntity) {
     await write(`domain/entities/${kebab}.entity.ts`, generateEntity(pascal, kebab));
     await write(`domain/value-objects/${kebab}-id.vo.ts`, generateValueObject(pascal, kebab));
   }
@@ -738,10 +1565,8 @@ async function generateModule(options) {
     await write(`__tests__/${kebab}.controller.test.ts`, generateControllerTest(pascal, kebab, plural));
     await write(`__tests__/${kebab}.repository.test.ts`, generateRepositoryTest(pascal, kebab, plural));
   }
-  await autoRegisterModule(modulesDir, pascal, plural);
-  return files;
 }
-__name(generateModule, "generateModule");
+__name(generateDddFiles, "generateDddFiles");
 async function autoRegisterModule(modulesDir, pascal, plural) {
   const indexPath = join(modulesDir, "index.ts");
   const exists = await fileExists(indexPath);
@@ -877,13 +1702,64 @@ export class ${pascal}Adapter implements AppAdapter {
 __name(generateAdapter, "generateAdapter");
 
 // src/generators/middleware.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
+
+// src/utils/resolve-out-dir.ts
+import { resolve, join as join3 } from "path";
+var DDD_FOLDER_MAP = {
+  controller: "presentation",
+  service: "domain/services",
+  dto: "application/dtos",
+  guard: "presentation/guards",
+  middleware: "middleware"
+};
+var FLAT_FOLDER_MAP = {
+  controller: "",
+  service: "",
+  dto: "dtos",
+  guard: "guards",
+  middleware: "middleware"
+};
+var CQRS_FOLDER_MAP = {
+  controller: "",
+  service: "",
+  dto: "dtos",
+  guard: "guards",
+  middleware: "middleware",
+  command: "commands",
+  query: "queries",
+  event: "events"
+};
+function resolveOutDir(options) {
+  const { type, outDir, moduleName, modulesDir = "src/modules", defaultDir, pattern = "ddd" } = options;
+  if (outDir) return resolve(outDir);
+  if (moduleName) {
+    const folderMap = pattern === "ddd" ? DDD_FOLDER_MAP : pattern === "cqrs" ? CQRS_FOLDER_MAP : FLAT_FOLDER_MAP;
+    const kebab = toKebabCase(moduleName);
+    const plural = pluralize(kebab);
+    const subfolder = folderMap[type] ?? "";
+    const base = join3(modulesDir, plural);
+    return resolve(subfolder ? join3(base, subfolder) : base);
+  }
+  return resolve(defaultDir);
+}
+__name(resolveOutDir, "resolveOutDir");
+
+// src/generators/middleware.ts
 async function generateMiddleware(options) {
-  const { name, outDir } = options;
+  const { name, moduleName, modulesDir, pattern } = options;
+  const outDir = resolveOutDir({
+    type: "middleware",
+    outDir: options.outDir,
+    moduleName,
+    modulesDir,
+    defaultDir: "src/middleware",
+    pattern
+  });
   const kebab = toKebabCase(name);
   const camel = toCamelCase(name);
   const files = [];
-  const filePath = join3(outDir, `${kebab}.middleware.ts`);
+  const filePath = join4(outDir, `${kebab}.middleware.ts`);
   await writeFileSafe(filePath, `import type { Request, Response, NextFunction } from 'express'
 
 export interface ${toPascalCase(name)}Options {
@@ -915,14 +1791,22 @@ export function ${camel}(options: ${toPascalCase(name)}Options = {}) {
 __name(generateMiddleware, "generateMiddleware");
 
 // src/generators/guard.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 async function generateGuard(options) {
-  const { name, outDir } = options;
+  const { name, moduleName, modulesDir, pattern } = options;
+  const outDir = resolveOutDir({
+    type: "guard",
+    outDir: options.outDir,
+    moduleName,
+    modulesDir,
+    defaultDir: "src/guards",
+    pattern
+  });
   const kebab = toKebabCase(name);
   const camel = toCamelCase(name);
   const pascal = toPascalCase(name);
   const files = [];
-  const filePath = join4(outDir, `${kebab}.guard.ts`);
+  const filePath = join5(outDir, `${kebab}.guard.ts`);
   await writeFileSafe(filePath, `import { Container, HttpException } from '@forinda/kickjs-core'
 import type { RequestContext } from '@forinda/kickjs-http'
 
@@ -966,13 +1850,21 @@ export async function ${camel}Guard(ctx: RequestContext, next: () => void): Prom
 __name(generateGuard, "generateGuard");
 
 // src/generators/service.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 async function generateService(options) {
-  const { name, outDir } = options;
+  const { name, moduleName, modulesDir, pattern } = options;
+  const outDir = resolveOutDir({
+    type: "service",
+    outDir: options.outDir,
+    moduleName,
+    modulesDir,
+    defaultDir: "src/services",
+    pattern
+  });
   const kebab = toKebabCase(name);
   const pascal = toPascalCase(name);
   const files = [];
-  const filePath = join5(outDir, `${kebab}.service.ts`);
+  const filePath = join6(outDir, `${kebab}.service.ts`);
   await writeFileSafe(filePath, `import { Service } from '@forinda/kickjs-core'
 
 @Service()
@@ -989,13 +1881,21 @@ export class ${pascal}Service {
 __name(generateService, "generateService");
 
 // src/generators/controller.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 async function generateController2(options) {
-  const { name, outDir } = options;
+  const { name, moduleName, modulesDir, pattern } = options;
+  const outDir = resolveOutDir({
+    type: "controller",
+    outDir: options.outDir,
+    moduleName,
+    modulesDir,
+    defaultDir: "src/controllers",
+    pattern
+  });
   const kebab = toKebabCase(name);
   const pascal = toPascalCase(name);
   const files = [];
-  const filePath = join6(outDir, `${kebab}.controller.ts`);
+  const filePath = join7(outDir, `${kebab}.controller.ts`);
   await writeFileSafe(filePath, `import { Controller, Get, Post, Autowired } from '@forinda/kickjs-core'
 import type { RequestContext } from '@forinda/kickjs-http'
 
@@ -1020,14 +1920,22 @@ export class ${pascal}Controller {
 __name(generateController2, "generateController");
 
 // src/generators/dto.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 async function generateDto(options) {
-  const { name, outDir } = options;
+  const { name, moduleName, modulesDir, pattern } = options;
+  const outDir = resolveOutDir({
+    type: "dto",
+    outDir: options.outDir,
+    moduleName,
+    modulesDir,
+    defaultDir: "src/dtos",
+    pattern
+  });
   const kebab = toKebabCase(name);
   const pascal = toPascalCase(name);
   const camel = toCamelCase(name);
   const files = [];
-  const filePath = join7(outDir, `${kebab}.dto.ts`);
+  const filePath = join8(outDir, `${kebab}.dto.ts`);
   await writeFileSafe(filePath, `import { z } from 'zod'
 
 export const ${camel}Schema = z.object({
@@ -1043,12 +1951,12 @@ export type ${pascal}DTO = z.infer<typeof ${camel}Schema>
 __name(generateDto, "generateDto");
 
 // src/generators/project.ts
-import { join as join8, dirname as dirname2 } from "path";
+import { join as join9, dirname as dirname2 } from "path";
 import { execSync } from "child_process";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 var __dirname = dirname2(fileURLToPath(import.meta.url));
-var cliPkg = JSON.parse(readFileSync(join8(__dirname, "..", "package.json"), "utf-8"));
+var cliPkg = JSON.parse(readFileSync(join9(__dirname, "..", "package.json"), "utf-8"));
 var KICKJS_VERSION = `^${cliPkg.version}`;
 async function initProject(options) {
   const { name, directory, packageManager = "pnpm", template = "rest" } = options;
@@ -1068,19 +1976,21 @@ async function initProject(options) {
   };
   if (template !== "minimal") {
     baseDeps["@forinda/kickjs-swagger"] = KICKJS_VERSION;
+    baseDeps["@forinda/kickjs-devtools"] = KICKJS_VERSION;
   }
   if (template === "graphql") {
     baseDeps["@forinda/kickjs-graphql"] = KICKJS_VERSION;
     baseDeps["graphql"] = "^16.11.0";
   }
-  if (template === "microservice") {
+  if (template === "cqrs") {
     baseDeps["@forinda/kickjs-queue"] = KICKJS_VERSION;
+    baseDeps["@forinda/kickjs-ws"] = KICKJS_VERSION;
     baseDeps["@forinda/kickjs-otel"] = KICKJS_VERSION;
   }
   if (template === "ddd") {
     baseDeps["@forinda/kickjs-swagger"] = KICKJS_VERSION;
   }
-  await writeFileSafe(join8(dir, "package.json"), JSON.stringify({
+  await writeFileSafe(join9(dir, "package.json"), JSON.stringify({
     name,
     version: cliPkg.version,
     type: "module",
@@ -1109,7 +2019,7 @@ async function initProject(options) {
       prettier: "^3.8.1"
     }
   }, null, 2));
-  await writeFileSafe(join8(dir, "vite.config.ts"), `import { defineConfig } from 'vite'
+  await writeFileSafe(join9(dir, "vite.config.ts"), `import { defineConfig } from 'vite'
 import { resolve } from 'path'
 import swc from 'unplugin-swc'
 
@@ -1136,7 +2046,7 @@ export default defineConfig({
   },
 })
 `);
-  await writeFileSafe(join8(dir, "tsconfig.json"), JSON.stringify({
+  await writeFileSafe(join9(dir, "tsconfig.json"), JSON.stringify({
     compilerOptions: {
       target: "ES2022",
       module: "ESNext",
@@ -1166,35 +2076,68 @@ export default defineConfig({
       "src"
     ]
   }, null, 2));
-  await writeFileSafe(join8(dir, ".prettierrc"), JSON.stringify({
+  await writeFileSafe(join9(dir, ".prettierrc"), JSON.stringify({
     semi: false,
     singleQuote: true,
     trailingComma: "all",
     printWidth: 100,
     tabWidth: 2
   }, null, 2));
-  await writeFileSafe(join8(dir, ".gitignore"), `node_modules/
+  await writeFileSafe(join9(dir, ".editorconfig"), `# https://editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+`);
+  await writeFileSafe(join9(dir, ".gitignore"), `node_modules/
 dist/
 .env
 coverage/
 .DS_Store
 *.tsbuildinfo
 `);
-  await writeFileSafe(join8(dir, ".env"), `PORT=3000
+  await writeFileSafe(join9(dir, ".gitattributes"), `# Auto-detect text files and normalise line endings to LF
+* text=auto eol=lf
+
+# Explicitly mark generated / binary files
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.woff binary
+*.woff2 binary
+*.ttf binary
+*.eot binary
+
+# Lock files \u2014 treat as generated
+pnpm-lock.yaml -diff linguist-generated
+yarn.lock -diff linguist-generated
+package-lock.json -diff linguist-generated
+`);
+  await writeFileSafe(join9(dir, ".env"), `PORT=3000
 NODE_ENV=development
 `);
-  await writeFileSafe(join8(dir, ".env.example"), `PORT=3000
+  await writeFileSafe(join9(dir, ".env.example"), `PORT=3000
 NODE_ENV=development
 `);
-  await writeFileSafe(join8(dir, "src/index.ts"), getEntryFile(name, template));
-  await writeFileSafe(join8(dir, "src/modules/index.ts"), `import type { AppModuleClass } from '@forinda/kickjs-core'
+  await writeFileSafe(join9(dir, "src/index.ts"), getEntryFile(name, template));
+  await writeFileSafe(join9(dir, "src/modules/index.ts"), `import type { AppModuleClass } from '@forinda/kickjs-core'
 
 export const modules: AppModuleClass[] = []
 `);
   if (template === "graphql") {
-    await writeFileSafe(join8(dir, "src/resolvers/.gitkeep"), "");
+    await writeFileSafe(join9(dir, "src/resolvers/.gitkeep"), "");
   }
-  await writeFileSafe(join8(dir, "kick.config.ts"), `import { defineConfig } from '@forinda/kickjs-cli'
+  await writeFileSafe(join9(dir, "kick.config.ts"), `import { defineConfig } from '@forinda/kickjs-cli'
 
 export default defineConfig({
   pattern: '${template}',
@@ -1226,7 +2169,7 @@ export default defineConfig({
   ],
 })
 `);
-  await writeFileSafe(join8(dir, "vitest.config.ts"), `import { defineConfig } from 'vitest/config'
+  await writeFileSafe(join9(dir, "vitest.config.ts"), `import { defineConfig } from 'vitest/config'
 import swc from 'unplugin-swc'
 
 export default defineConfig({
@@ -1282,19 +2225,36 @@ export default defineConfig({
     rest: "kick g module user",
     graphql: "kick g resolver user",
     ddd: "kick g module user --repo drizzle",
-    microservice: "kick g module user && kick g job email",
+    cqrs: "kick g module user --pattern cqrs",
     minimal: "# add your routes to src/index.ts"
   };
   console.log(`    ${genHint[template] ?? genHint.rest}`);
   console.log("    kick dev");
   console.log();
   console.log("  Commands:");
-  console.log("    kick dev         Start dev server with Vite HMR");
-  console.log("    kick build       Production build via Vite");
-  console.log("    kick start       Run production build");
-  console.log(`    kick g module X  Generate a DDD module`);
-  if (template === "graphql") console.log("    kick g resolver X  Generate a GraphQL resolver");
-  if (template === "microservice") console.log("    kick g job X       Generate a queue job processor");
+  console.log("    kick dev                  Start dev server with Vite HMR");
+  console.log("    kick build                Production build via Vite");
+  console.log("    kick start                Run production build");
+  console.log();
+  console.log("  Generators:");
+  console.log("    kick g module <name>      Full DDD module (controller, DTOs, use-cases, repo)");
+  console.log("    kick g scaffold <n> <f..> CRUD module from field definitions");
+  console.log("    kick g controller <name>  Standalone controller");
+  console.log("    kick g service <name>     @Service() class");
+  console.log("    kick g middleware <name>   Express middleware");
+  console.log("    kick g guard <name>       Route guard (auth, roles, etc.)");
+  console.log("    kick g adapter <name>     AppAdapter with lifecycle hooks");
+  console.log("    kick g dto <name>         Zod DTO schema");
+  if (template === "graphql") console.log("    kick g resolver <name>    GraphQL resolver");
+  if (template === "cqrs") console.log("    kick g job <name>         Queue job processor");
+  console.log("    kick g config             Generate kick.config.ts");
+  console.log();
+  console.log("  Add packages:");
+  console.log("    kick add <pkg>            Install a KickJS package + peers");
+  console.log("    kick add --list           Show all available packages");
+  console.log();
+  console.log("  Available: auth, swagger, graphql, drizzle, prisma, ws,");
+  console.log("             cron, queue, mailer, otel, multi-tenant, notifications, testing");
   console.log();
 }
 __name(initProject, "initProject");
@@ -1322,12 +2282,13 @@ bootstrap({
   ],
 })
 `;
-    case "microservice":
+    case "cqrs":
       return `import 'reflect-metadata'
 import { bootstrap } from '@forinda/kickjs-http'
 import { DevToolsAdapter } from '@forinda/kickjs-devtools'
 import { SwaggerAdapter } from '@forinda/kickjs-swagger'
 import { OtelAdapter } from '@forinda/kickjs-otel'
+// import { WsAdapter } from '@forinda/kickjs-ws'
 // import { QueueAdapter, BullMQProvider } from '@forinda/kickjs-queue'
 import { modules } from './modules'
 
@@ -1339,6 +2300,8 @@ bootstrap({
     new SwaggerAdapter({
       info: { title: '${name}', version: '${cliPkg.version}' },
     }),
+    // Uncomment for WebSocket support:
+    // new WsAdapter(),
     // Uncomment when Redis is available:
     // new QueueAdapter({
     //   provider: new BullMQProvider({ host: 'localhost', port: 6379 }),
@@ -1378,7 +2341,7 @@ __name(getEntryFile, "getEntryFile");
 
 // src/config.ts
 import { readFile as readFile3, access as access2 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function defineConfig(config) {
   return config;
 }
@@ -1391,7 +2354,7 @@ var CONFIG_FILES = [
 ];
 async function loadKickConfig(cwd) {
   for (const filename of CONFIG_FILES) {
-    const filepath = join9(cwd, filename);
+    const filepath = join10(cwd, filename);
     try {
       await access2(filepath);
     } catch {