@forinda/kickjs-cli 2.0.1 → 2.2.0

package/dist/config-D9faxBLQ.js

@@ -1,3108 +0,0 @@
-import { dirname as Q, join as p, resolve as P } from "node:path";
-import { createInterface as ee } from "node:readline";
-import { access as F, mkdir as te, readFile as L, writeFile as N } from "node:fs/promises";
-import { execSync as R } from "node:child_process";
-import { readFileSync as re } from "node:fs";
-import { fileURLToPath as oe } from "node:url";
-var W = !1;
-function st(r) {
-  W = r;
-}
-async function l(r, e) {
-  W || (await te(Q(r), { recursive: !0 }), await N(r, e, "utf-8"));
-}
-async function B(r) {
-  try {
-    return await F(r), !0;
-  } catch {
-    return !1;
-  }
-}
-function g(r) {
-  return r.replace(/[-_\s]+(.)?/g, (e, t) => t ? t.toUpperCase() : "").replace(/^(.)/, (e) => e.toUpperCase());
-}
-function T(r) {
-  const e = g(r);
-  return e.charAt(0).toLowerCase() + e.slice(1);
-}
-function y(r) {
-  return r.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
-}
-function Y(r) {
-  return r.endsWith("s") ? r : r.endsWith("x") || r.endsWith("z") || r.endsWith("sh") || r.endsWith("ch") ? r + "es" : r.endsWith("y") && !/[aeiou]y$/.test(r) ? r.slice(0, -1) + "ies" : r + "s";
-}
-function se(r) {
-  return r.endsWith("s") ? r : r.endsWith("x") || r.endsWith("z") || r.endsWith("sh") || r.endsWith("ch") ? r + "es" : r.endsWith("y") && !/[aeiou]y$/i.test(r) ? r.slice(0, -1) + "ies" : r + "s";
-}
-var ie = {
-  inmemory: "in-memory",
-  drizzle: "Drizzle",
-  prisma: "Prisma"
-};
-function H(r) {
-  return r.charAt(0).toUpperCase() + r.slice(1).replace(/-([a-z])/g, (e, t) => t.toUpperCase());
-}
-function ae(r) {
-  return r.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-}
-function _(r) {
-  return ie[r] ?? H(r);
-}
-function K(r, e, t) {
-  const o = {
-    inmemory: `InMemory${r}Repository`,
-    drizzle: `Drizzle${r}Repository`,
-    prisma: `Prisma${r}Repository`
-  }, s = {
-    inmemory: `in-memory-${e}`,
-    drizzle: `drizzle-${e}`,
-    prisma: `prisma-${e}`
-  };
-  return {
-    repoClass: o[t] ?? `${H(t)}${r}Repository`,
-    repoFile: s[t] ?? `${ae(t)}-${e}`
-  };
-}
-function ne(r) {
-  const { pascal: e, kebab: t, plural: o = "", repo: s } = r, { repoClass: i, repoFile: n } = K(e, t, s);
-  return `/**
- * ${e} Module
- *
- * Self-contained feature module following Domain-Driven Design (DDD).
- * Registers dependencies in the DI container and declares HTTP routes.
- *
- * Structure:
- *   presentation/    — HTTP controllers (entry points)
- *   application/     — Use cases (orchestration) and DTOs (validation)
- *   domain/          — Entities, value objects, repository interfaces, domain services
- *   infrastructure/  — Repository implementations (currently ${_(s)})
- */
-import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-import { buildRoutes } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY } from './domain/repositories/${t}.repository'
-import { ${i} } from './infrastructure/repositories/${n}.repository'
-import { ${e}Controller } from './presentation/${t}.controller'
-
-// Eagerly load decorated classes so @Service()/@Repository() decorators register in the DI container
-import.meta.glob(
-  ['./domain/services/**/*.ts', './application/use-cases/**/*.ts', '!./**/*.test.ts'],
-  { eager: true },
-)
-
-export class ${e}Module implements AppModule {
-  /**
-   * Register module dependencies in the DI container.
-   * Bind repository interface tokens to their implementations here.
-   * Currently wired to ${_(s)}. To swap implementations, change the factory target.
-   */
-  register(container: Container): void {
-    container.registerFactory(${e.toUpperCase()}_REPOSITORY, () =>
-      container.resolve(${i}),
-    )
-  }
-
-  /**
-   * Declare HTTP routes for this module.
-   * The path is prefixed with the global apiPrefix and version (e.g. /api/v1/${o}).
-   * Passing 'controller' enables automatic OpenAPI spec generation via SwaggerAdapter.
-   */
-  routes(): ModuleRoutes {
-    return {
-      path: '/${o}',
-      router: buildRoutes(${e}Controller),
-      controller: ${e}Controller,
-    }
-  }
-}
-`;
-}
-function ce(r) {
-  const { pascal: e, kebab: t, plural: o = "", repo: s } = r, { repoClass: i, repoFile: n } = K(e, t, s);
-  return `/**
- * ${e} Module
- *
- * REST module with a flat folder structure.
- * Controller delegates to service, service wraps the repository.
- *
- * Structure:
- *   ${t}.controller.ts  — HTTP routes (CRUD)
- *   ${t}.service.ts     — Business logic
- *   ${t}.repository.ts  — Repository interface
- *   ${n}.repository.ts — Repository implementation
- *   dtos/                   — Request/response schemas
- */
-import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-import { buildRoutes } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY } from './${t}.repository'
-import { ${i} } from './${n}.repository'
-import { ${e}Controller } from './${t}.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 ${e}Module implements AppModule {
-  register(container: Container): void {
-    container.registerFactory(${e.toUpperCase()}_REPOSITORY, () =>
-      container.resolve(${i}),
-    )
-  }
-
-  routes(): ModuleRoutes {
-    return {
-      path: '/${o}',
-      router: buildRoutes(${e}Controller),
-      controller: ${e}Controller,
-    }
-  }
-}
-`;
-}
-function de(r) {
-  const { pascal: e, kebab: t, plural: o = "" } = r;
-  return `import { type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-import { buildRoutes } from '@forinda/kickjs'
-import { ${e}Controller } from './${t}.controller'
-
-export class ${e}Module implements AppModule {
-  routes(): ModuleRoutes {
-    return {
-      path: '/${o}',
-      router: buildRoutes(${e}Controller),
-      controller: ${e}Controller,
-    }
-  }
-}
-`;
-}
-function pe(r) {
-  const { pascal: e, kebab: t, plural: o = "", pluralPascal: s = "" } = r;
-  return `import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams } from '@forinda/kickjs'
-import type { RequestContext } from '@forinda/kickjs'
-import { ApiTags } from '@forinda/kickjs-swagger'
-import { Create${e}UseCase } from '../application/use-cases/create-${t}.use-case'
-import { Get${e}UseCase } from '../application/use-cases/get-${t}.use-case'
-import { List${s}UseCase } from '../application/use-cases/list-${o}.use-case'
-import { Update${e}UseCase } from '../application/use-cases/update-${t}.use-case'
-import { Delete${e}UseCase } from '../application/use-cases/delete-${t}.use-case'
-import { create${e}Schema } from '../application/dtos/create-${t}.dto'
-import { update${e}Schema } from '../application/dtos/update-${t}.dto'
-import { ${e.toUpperCase()}_QUERY_CONFIG } from '../constants'
-
-@Controller()
-export class ${e}Controller {
-  @Autowired() private create${e}UseCase!: Create${e}UseCase
-  @Autowired() private get${e}UseCase!: Get${e}UseCase
-  @Autowired() private list${s}UseCase!: List${s}UseCase
-  @Autowired() private update${e}UseCase!: Update${e}UseCase
-  @Autowired() private delete${e}UseCase!: Delete${e}UseCase
-
-  @Get('/')
-  @ApiTags('${e}')
-  @ApiQueryParams(${e.toUpperCase()}_QUERY_CONFIG)
-  async list(ctx: RequestContext) {
-    return ctx.paginate(
-      (parsed) => this.list${s}UseCase.execute(parsed),
-      ${e.toUpperCase()}_QUERY_CONFIG,
-    )
-  }
-
-  @Get('/:id')
-  @ApiTags('${e}')
-  async getById(ctx: RequestContext) {
-    const result = await this.get${e}UseCase.execute(ctx.params.id)
-    if (!result) return ctx.notFound('${e} not found')
-    ctx.json(result)
-  }
-
-  @Post('/', { body: create${e}Schema, name: 'Create${e}' })
-  @ApiTags('${e}')
-  async create(ctx: RequestContext) {
-    const result = await this.create${e}UseCase.execute(ctx.body)
-    ctx.created(result)
-  }
-
-  @Put('/:id', { body: update${e}Schema, name: 'Update${e}' })
-  @ApiTags('${e}')
-  async update(ctx: RequestContext) {
-    const result = await this.update${e}UseCase.execute(ctx.params.id, ctx.body)
-    ctx.json(result)
-  }
-
-  @Delete('/:id')
-  @ApiTags('${e}')
-  async remove(ctx: RequestContext) {
-    await this.delete${e}UseCase.execute(ctx.params.id)
-    ctx.noContent()
-  }
-}
-`;
-}
-function le(r) {
-  const { pascal: e, kebab: t, plural: o = "", pluralPascal: s = "" } = r, i = e.charAt(0).toLowerCase() + e.slice(1);
-  return `import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams } from '@forinda/kickjs'
-import type { RequestContext } from '@forinda/kickjs'
-import { ApiTags } from '@forinda/kickjs-swagger'
-import { ${e}Service } from './${t}.service'
-import { create${e}Schema } from './dtos/create-${t}.dto'
-import { update${e}Schema } from './dtos/update-${t}.dto'
-import { ${e.toUpperCase()}_QUERY_CONFIG } from './${t}.constants'
-
-@Controller()
-export class ${e}Controller {
-  @Autowired() private ${i}Service!: ${e}Service
-
-  @Get('/')
-  @ApiTags('${e}')
-  @ApiQueryParams(${e.toUpperCase()}_QUERY_CONFIG)
-  async list(ctx: RequestContext) {
-    return ctx.paginate(
-      (parsed) => this.${i}Service.findPaginated(parsed),
-      ${e.toUpperCase()}_QUERY_CONFIG,
-    )
-  }
-
-  @Get('/:id')
-  @ApiTags('${e}')
-  async getById(ctx: RequestContext) {
-    const result = await this.${i}Service.findById(ctx.params.id)
-    if (!result) return ctx.notFound('${e} not found')
-    ctx.json(result)
-  }
-
-  @Post('/', { body: create${e}Schema, name: 'Create${e}' })
-  @ApiTags('${e}')
-  async create(ctx: RequestContext) {
-    const result = await this.${i}Service.create(ctx.body)
-    ctx.created(result)
-  }
-
-  @Put('/:id', { body: update${e}Schema, name: 'Update${e}' })
-  @ApiTags('${e}')
-  async update(ctx: RequestContext) {
-    const result = await this.${i}Service.update(ctx.params.id, ctx.body)
-    ctx.json(result)
-  }
-
-  @Delete('/:id')
-  @ApiTags('${e}')
-  async remove(ctx: RequestContext) {
-    await this.${i}Service.delete(ctx.params.id)
-    ctx.noContent()
-  }
-}
-`;
-}
-function ue(r) {
-  const { pascal: e } = r;
-  return `import type { QueryParamsConfig } from '@forinda/kickjs'
-
-export const ${e.toUpperCase()}_QUERY_CONFIG: QueryParamsConfig = {
-  filterable: ['name'],
-  sortable: ['name', 'createdAt'],
-  searchable: ['name'],
-}
-`;
-}
-function O(r) {
-  const { pascal: e, kebab: t } = r;
-  return `import { z } from 'zod'
-
-/**
- * Create ${e} DTO — Zod schema for validating POST request bodies.
- * This schema is passed to @Post('/', { body: create${e}Schema }) for automatic validation.
- * It also generates OpenAPI request body docs when SwaggerAdapter is used.
- *
- * Add more fields as needed. Supported Zod types:
- *   z.string(), z.number(), z.boolean(), z.enum([...]),
- *   z.array(), z.object(), .optional(), .default(), .transform()
- */
-export const create${e}Schema = z.object({
-  name: z.string().min(1, 'Name is required').max(200),
-})
-
-export type Create${e}DTO = z.infer<typeof create${e}Schema>
-`;
-}
-function I(r) {
-  const { pascal: e, kebab: t } = r;
-  return `import { z } from 'zod'
-
-export const update${e}Schema = z.object({
-  name: z.string().min(1).max(200).optional(),
-})
-
-export type Update${e}DTO = z.infer<typeof update${e}Schema>
-`;
-}
-function S(r) {
-  const { pascal: e, kebab: t } = r;
-  return `export interface ${e}ResponseDTO {
-  id: string
-  name: string
-  createdAt: string
-  updatedAt: string
-}
-`;
-}
-function me(r) {
-  const { pascal: e, kebab: t, plural: o = "", pluralPascal: s = "" } = r;
-  return [
-    {
-      file: `create-${t}.use-case.ts`,
-      content: `/**
- * Create ${e} Use Case
- *
- * Application layer — orchestrates a single business operation.
- * Use cases are thin: validate input (via DTO), call domain/repo, return response.
- * Keep business rules in the domain service, not here.
- */
-import { Service, Inject } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../../domain/repositories/${t}.repository'
-import type { Create${e}DTO } from '../dtos/create-${t}.dto'
-import type { ${e}ResponseDTO } from '../dtos/${t}-response.dto'
-
-@Service()
-export class Create${e}UseCase {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-  ) {}
-
-  async execute(dto: Create${e}DTO): Promise<${e}ResponseDTO> {
-    return this.repo.create(dto)
-  }
-}
-`
-    },
-    {
-      file: `get-${t}.use-case.ts`,
-      content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../../domain/repositories/${t}.repository'
-import type { ${e}ResponseDTO } from '../dtos/${t}-response.dto'
-
-@Service()
-export class Get${e}UseCase {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-  ) {}
-
-  async execute(id: string): Promise<${e}ResponseDTO | null> {
-    return this.repo.findById(id)
-  }
-}
-`
-    },
-    {
-      file: `list-${o}.use-case.ts`,
-      content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../../domain/repositories/${t}.repository'
-import type { ParsedQuery } from '@forinda/kickjs'
-
-@Service()
-export class List${s}UseCase {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-  ) {}
-
-  async execute(parsed: ParsedQuery) {
-    return this.repo.findPaginated(parsed)
-  }
-}
-`
-    },
-    {
-      file: `update-${t}.use-case.ts`,
-      content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../../domain/repositories/${t}.repository'
-import type { Update${e}DTO } from '../dtos/update-${t}.dto'
-import type { ${e}ResponseDTO } from '../dtos/${t}-response.dto'
-
-@Service()
-export class Update${e}UseCase {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-  ) {}
-
-  async execute(id: string, dto: Update${e}DTO): Promise<${e}ResponseDTO> {
-    return this.repo.update(id, dto)
-  }
-}
-`
-    },
-    {
-      file: `delete-${t}.use-case.ts`,
-      content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../../domain/repositories/${t}.repository'
-
-@Service()
-export class Delete${e}UseCase {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-  ) {}
-
-  async execute(id: string): Promise<void> {
-    await this.repo.delete(id)
-  }
-}
-`
-    }
-  ];
-}
-function A(r) {
-  const { pascal: e, kebab: t, dtoPrefix: o = "../../application/dtos" } = r;
-  return `/**
- * ${e} Repository Interface
- *
- * Defines the contract for data access.
- * The interface declares what operations are available;
- * implementations (in-memory, Drizzle, Prisma) fulfill the contract.
- *
- * To swap implementations, change the factory in the module's register() method.
- */
-import type { ${e}ResponseDTO } from '${o}/${t}-response.dto'
-import type { Create${e}DTO } from '${o}/create-${t}.dto'
-import type { Update${e}DTO } from '${o}/update-${t}.dto'
-import type { ParsedQuery } from '@forinda/kickjs'
-
-export interface I${e}Repository {
-  findById(id: string): Promise<${e}ResponseDTO | null>
-  findAll(): Promise<${e}ResponseDTO[]>
-  findPaginated(parsed: ParsedQuery): Promise<{ data: ${e}ResponseDTO[]; total: number }>
-  create(dto: Create${e}DTO): Promise<${e}ResponseDTO>
-  update(id: string, dto: Update${e}DTO): Promise<${e}ResponseDTO>
-  delete(id: string): Promise<void>
-}
-
-export const ${e.toUpperCase()}_REPOSITORY = Symbol('I${e}Repository')
-`;
-}
-function v(r) {
-  const { pascal: e, kebab: t, repoPrefix: o = "../../domain/repositories", dtoPrefix: s = "../../application/dtos" } = r;
-  return `/**
- * In-Memory ${e} Repository
- *
- * Implements the repository interface using a Map.
- * Useful for prototyping and testing. Replace with a database implementation
- * (Drizzle, Prisma, etc.) for production use.
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { randomUUID } from 'node:crypto'
-import { Repository, HttpException } from '@forinda/kickjs'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${e}Repository } from '${o}/${t}.repository'
-import type { ${e}ResponseDTO } from '${s}/${t}-response.dto'
-import type { Create${e}DTO } from '${s}/create-${t}.dto'
-import type { Update${e}DTO } from '${s}/update-${t}.dto'
-
-@Repository()
-export class InMemory${e}Repository implements I${e}Repository {
-  private store = new Map<string, ${e}ResponseDTO>()
-
-  async findById(id: string): Promise<${e}ResponseDTO | null> {
-    return this.store.get(id) ?? null
-  }
-
-  async findAll(): Promise<${e}ResponseDTO[]> {
-    return Array.from(this.store.values())
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${e}ResponseDTO[]; total: number }> {
-    const all = Array.from(this.store.values())
-    const data = all.slice(parsed.pagination.offset, parsed.pagination.offset + parsed.pagination.limit)
-    return { data, total: all.length }
-  }
-
-  async create(dto: Create${e}DTO): Promise<${e}ResponseDTO> {
-    const now = new Date().toISOString()
-    const entity: ${e}ResponseDTO = {
-      id: randomUUID(),
-      name: dto.name,
-      createdAt: now,
-      updatedAt: now,
-    }
-    this.store.set(entity.id, entity)
-    return entity
-  }
-
-  async update(id: string, dto: Update${e}DTO): Promise<${e}ResponseDTO> {
-    const existing = this.store.get(id)
-    if (!existing) throw HttpException.notFound('${e} not found')
-    const updated = { ...existing, ...dto, updatedAt: new Date().toISOString() }
-    this.store.set(id, updated)
-    return updated
-  }
-
-  async delete(id: string): Promise<void> {
-    if (!this.store.has(id)) throw HttpException.notFound('${e} not found')
-    this.store.delete(id)
-  }
-}
-`;
-}
-function j(r) {
-  const { pascal: e, kebab: t, repoType: o = "", repoPrefix: s = "../../domain/repositories", dtoPrefix: i = "../../application/dtos" } = r, n = o.charAt(0).toUpperCase() + o.slice(1).replace(/-([a-z])/g, (a, c) => c.toUpperCase());
-  return `/**
- * ${n} ${e} Repository
- *
- * Stub implementation for a custom '${o}' repository.
- * Implements the repository interface using an in-memory Map as a placeholder.
- *
- * TODO: Replace the in-memory Map with your ${o} data-access logic.
- * See I${e}Repository for the interface contract.
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { randomUUID } from 'node:crypto'
-import { Repository, HttpException } from '@forinda/kickjs'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${e}Repository } from '${s}/${t}.repository'
-import type { ${e}ResponseDTO } from '${i}/${t}-response.dto'
-import type { Create${e}DTO } from '${i}/create-${t}.dto'
-import type { Update${e}DTO } from '${i}/update-${t}.dto'
-
-@Repository()
-export class ${n}${e}Repository implements I${e}Repository {
-  // TODO: Replace with your ${o} client/connection
-  private store = new Map<string, ${e}ResponseDTO>()
-
-  async findById(id: string): Promise<${e}ResponseDTO | null> {
-    // TODO: Implement with ${o}
-    return this.store.get(id) ?? null
-  }
-
-  async findAll(): Promise<${e}ResponseDTO[]> {
-    // TODO: Implement with ${o}
-    return Array.from(this.store.values())
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${e}ResponseDTO[]; total: number }> {
-    // TODO: Implement with ${o}
-    const all = Array.from(this.store.values())
-    const data = all.slice(parsed.pagination.offset, parsed.pagination.offset + parsed.pagination.limit)
-    return { data, total: all.length }
-  }
-
-  async create(dto: Create${e}DTO): Promise<${e}ResponseDTO> {
-    // TODO: Implement with ${o}
-    const now = new Date().toISOString()
-    const entity: ${e}ResponseDTO = {
-      id: randomUUID(),
-      name: dto.name,
-      createdAt: now,
-      updatedAt: now,
-    }
-    this.store.set(entity.id, entity)
-    return entity
-  }
-
-  async update(id: string, dto: Update${e}DTO): Promise<${e}ResponseDTO> {
-    // TODO: Implement with ${o}
-    const existing = this.store.get(id)
-    if (!existing) throw HttpException.notFound('${e} not found')
-    const updated = { ...existing, ...dto, updatedAt: new Date().toISOString() }
-    this.store.set(id, updated)
-    return updated
-  }
-
-  async delete(id: string): Promise<void> {
-    // TODO: Implement with ${o}
-    if (!this.store.has(id)) throw HttpException.notFound('${e} not found')
-    this.store.delete(id)
-  }
-}
-`;
-}
-function fe(r) {
-  const { pascal: e, kebab: t } = r;
-  return `/**
- * ${e} Domain Service
- *
- * Domain layer — contains business rules that don't belong to a single entity.
- * Use this for cross-entity logic, validation rules, and domain invariants.
- * Keep it free of HTTP/framework concerns.
- */
-import { Service, Inject, HttpException } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../repositories/${t}.repository'
-
-@Service()
-export class ${e}DomainService {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-  ) {}
-
-  async ensureExists(id: string): Promise<void> {
-    const entity = await this.repo.findById(id)
-    if (!entity) {
-      throw HttpException.notFound('${e} not found')
-    }
-  }
-}
-`;
-}
-function $e(r) {
-  const { pascal: e, kebab: t } = r;
-  return `/**
- * ${e} Entity
- *
- * Domain layer — the core business object.
- * Uses a private constructor with static factory methods (create, reconstitute)
- * to enforce invariants. Properties are accessed via getters to maintain encapsulation.
- *
- * Patterns used:
- *   - Private constructor: prevents direct instantiation
- *   - create(): factory for new entities (generates ID, sets timestamps)
- *   - reconstitute(): factory for rebuilding from persistence (no side effects)
- *   - changeName(): mutation method that enforces business rules
- */
-import { ${e}Id } from '../value-objects/${t}-id.vo'
-
-interface ${e}Props {
-  id: ${e}Id
-  name: string
-  createdAt: Date
-  updatedAt: Date
-}
-
-export class ${e} {
-  private constructor(private props: ${e}Props) {}
-
-  static create(params: { name: string }): ${e} {
-    const now = new Date()
-    return new ${e}({
-      id: ${e}Id.create(),
-      name: params.name,
-      createdAt: now,
-      updatedAt: now,
-    })
-  }
-
-  static reconstitute(props: ${e}Props): ${e} {
-    return new ${e}(props)
-  }
-
-  get id(): ${e}Id {
-    return this.props.id
-  }
-  get name(): string {
-    return this.props.name
-  }
-  get createdAt(): Date {
-    return this.props.createdAt
-  }
-  get updatedAt(): Date {
-    return this.props.updatedAt
-  }
-
-  changeName(name: string): void {
-    if (!name || name.trim().length === 0) {
-      throw new Error('Name cannot be empty')
-    }
-    this.props.name = name.trim()
-    this.props.updatedAt = new Date()
-  }
-
-  toJSON() {
-    return {
-      id: this.props.id.toString(),
-      name: this.props.name,
-      createdAt: this.props.createdAt.toISOString(),
-      updatedAt: this.props.updatedAt.toISOString(),
-    }
-  }
-}
-`;
-}
-function ye(r) {
-  const { pascal: e, kebab: t } = r;
-  return `/**
- * ${e} ID Value Object
- *
- * Domain layer — wraps a primitive ID with type safety and validation.
- * Value objects are immutable and compared by value, not reference.
- *
- *   ${e}Id.create()    — generate a new UUID
- *   ${e}Id.from(id)    — wrap an existing ID string (validates non-empty)
- *   id.equals(other)  — compare two IDs by value
- */
-import { randomUUID } from 'node:crypto'
-
-export class ${e}Id {
-  private constructor(private readonly value: string) {}
-
-  static create(): ${e}Id {
-    return new ${e}Id(randomUUID())
-  }
-
-  static from(id: string): ${e}Id {
-    if (!id || id.trim().length === 0) {
-      throw new Error('${e}Id cannot be empty')
-    }
-    return new ${e}Id(id)
-  }
-
-  toString(): string {
-    return this.value
-  }
-
-  equals(other: ${e}Id): boolean {
-    return this.value === other.value
-  }
-}
-`;
-}
-function E(r) {
-  const { pascal: e, kebab: t, plural: o = "" } = r;
-  return `import { describe, it, expect, beforeEach } from 'vitest'
-import { Container } from '@forinda/kickjs'
-
-describe('${e}Controller', () => {
-  beforeEach(() => {
-    Container.reset()
-  })
-
-  it('should be defined', () => {
-    expect(true).toBe(true)
-  })
-
-  describe('POST /${o}', () => {
-    it('should create a new ${t}', async () => {
-      // TODO: Set up test module, call create endpoint, assert 201
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('GET /${o}', () => {
-    it('should return paginated ${o}', async () => {
-      // TODO: Set up test module, call list endpoint, assert { data, meta }
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('GET /${o}/:id', () => {
-    it('should return a ${t} by id', async () => {
-      // TODO: Create a ${t}, then fetch by id, assert match
-      expect(true).toBe(true)
-    })
-
-    it('should return 404 for non-existent ${t}', async () => {
-      // TODO: Fetch non-existent id, assert 404
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('PUT /${o}/:id', () => {
-    it('should update an existing ${t}', async () => {
-      // TODO: Create, update, assert changes
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('DELETE /${o}/:id', () => {
-    it('should delete a ${t}', async () => {
-      // TODO: Create, delete, assert gone
-      expect(true).toBe(true)
-    })
-  })
-})
-`;
-}
-function U(r) {
-  const { pascal: e, kebab: t, plural: o = "", repoPrefix: s = `../infrastructure/repositories/in-memory-${t}.repository` } = r;
-  return `import { describe, it, expect, beforeEach } from 'vitest'
-import { InMemory${e}Repository } from '${s}'
-
-describe('InMemory${e}Repository', () => {
-  let repo: InMemory${e}Repository
-
-  beforeEach(() => {
-    repo = new InMemory${e}Repository()
-  })
-
-  it('should create and retrieve a ${t}', async () => {
-    const created = await repo.create({ name: 'Test ${e}' })
-    expect(created).toBeDefined()
-    expect(created.name).toBe('Test ${e}')
-    expect(created.id).toBeDefined()
-
-    const found = await repo.findById(created.id)
-    expect(found).toEqual(created)
-  })
-
-  it('should return null for non-existent id', async () => {
-    const found = await repo.findById('non-existent')
-    expect(found).toBeNull()
-  })
-
-  it('should list all ${o}', async () => {
-    await repo.create({ name: '${e} 1' })
-    await repo.create({ name: '${e} 2' })
-
-    const all = await repo.findAll()
-    expect(all).toHaveLength(2)
-  })
-
-  it('should return paginated results', async () => {
-    await repo.create({ name: '${e} 1' })
-    await repo.create({ name: '${e} 2' })
-    await repo.create({ name: '${e} 3' })
-
-    const result = await repo.findPaginated({
-      filters: [],
-      sort: [],
-      search: '',
-      pagination: { page: 1, limit: 2, offset: 0 },
-    })
-
-    expect(result.data).toHaveLength(2)
-    expect(result.total).toBe(3)
-  })
-
-  it('should update a ${t}', async () => {
-    const created = await repo.create({ name: 'Original' })
-    const updated = await repo.update(created.id, { name: 'Updated' })
-    expect(updated.name).toBe('Updated')
-  })
-
-  it('should delete a ${t}', async () => {
-    const created = await repo.create({ name: 'To Delete' })
-    await repo.delete(created.id)
-    const found = await repo.findById(created.id)
-    expect(found).toBeNull()
-  })
-})
-`;
-}
-function ge(r) {
-  const { pascal: e, kebab: t } = r;
-  return `import { Service, Inject, HttpException } from '@forinda/kickjs'
-import type { ParsedQuery } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from './${t}.repository'
-import type { ${e}ResponseDTO } from './dtos/${t}-response.dto'
-import type { Create${e}DTO } from './dtos/create-${t}.dto'
-import type { Update${e}DTO } from './dtos/update-${t}.dto'
-
-@Service()
-export class ${e}Service {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-  ) {}
-
-  async findById(id: string): Promise<${e}ResponseDTO | null> {
-    return this.repo.findById(id)
-  }
-
-  async findAll(): Promise<${e}ResponseDTO[]> {
-    return this.repo.findAll()
-  }
-
-  async findPaginated(parsed: ParsedQuery) {
-    return this.repo.findPaginated(parsed)
-  }
-
-  async create(dto: Create${e}DTO): Promise<${e}ResponseDTO> {
-    return this.repo.create(dto)
-  }
-
-  async update(id: string, dto: Update${e}DTO): Promise<${e}ResponseDTO> {
-    return this.repo.update(id, dto)
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.repo.delete(id)
-  }
-}
-`;
-}
-function J(r) {
-  const { pascal: e } = r;
-  return `import type { QueryFieldConfig } from '@forinda/kickjs'
-
-export const ${e.toUpperCase()}_QUERY_CONFIG: QueryFieldConfig = {
-  filterable: ['name'],
-  sortable: ['name', 'createdAt'],
-  searchable: ['name'],
-}
-`;
-}
-function he(r) {
-  const { pascal: e, kebab: t, plural: o = "", repo: s } = r, i = {
-    inmemory: `InMemory${e}Repository`,
-    drizzle: `Drizzle${e}Repository`,
-    prisma: `Prisma${e}Repository`
-  }, n = {
-    inmemory: `in-memory-${t}`,
-    drizzle: `drizzle-${t}`,
-    prisma: `prisma-${t}`
-  }, a = i[s] ?? i.inmemory, c = n[s] ?? n.inmemory;
-  return `/**
- * ${e} Module — 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/       — Write operations (create, update, delete)
- *   queries/        — Read operations (get, list)
- *   events/         — Domain events + handlers (WS broadcast, queue dispatch)
- *   dtos/           — Request/response schemas
- */
-import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-import { buildRoutes } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY } from './${t}.repository'
-import { ${a} } from './${c}.repository'
-import { ${e}Controller } from './${t}.controller'
-
-// Eagerly load decorated classes
-import.meta.glob(
-  [
-    './commands/**/*.ts',
-    './queries/**/*.ts',
-    './events/**/*.ts',
-    '!./**/*.test.ts',
-  ],
-  { eager: true },
-)
-
-export class ${e}Module implements AppModule {
-  register(container: Container): void {
-    container.registerFactory(${e.toUpperCase()}_REPOSITORY, () =>
-      container.resolve(${a}),
-    )
-  }
-
-  routes(): ModuleRoutes {
-    return {
-      path: '/${o}',
-      router: buildRoutes(${e}Controller),
-      controller: ${e}Controller,
-    }
-  }
-}
-`;
-}
-function ke(r) {
-  const { pascal: e, kebab: t, plural: o = "", pluralPascal: s = "" } = r;
-  return `import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams } from '@forinda/kickjs'
-import type { RequestContext } from '@forinda/kickjs'
-import { ApiTags } from '@forinda/kickjs-swagger'
-import { Create${e}Command } from './commands/create-${t}.command'
-import { Update${e}Command } from './commands/update-${t}.command'
-import { Delete${e}Command } from './commands/delete-${t}.command'
-import { Get${e}Query } from './queries/get-${t}.query'
-import { List${s}Query } from './queries/list-${o}.query'
-import { create${e}Schema } from './dtos/create-${t}.dto'
-import { update${e}Schema } from './dtos/update-${t}.dto'
-import { ${e.toUpperCase()}_QUERY_CONFIG } from './${t}.constants'
-
-@Controller()
-export class ${e}Controller {
-  @Autowired() private create${e}Command!: Create${e}Command
-  @Autowired() private update${e}Command!: Update${e}Command
-  @Autowired() private delete${e}Command!: Delete${e}Command
-  @Autowired() private get${e}Query!: Get${e}Query
-  @Autowired() private list${s}Query!: List${s}Query
-
-  @Get('/')
-  @ApiTags('${e}')
-  @ApiQueryParams(${e.toUpperCase()}_QUERY_CONFIG)
-  async list(ctx: RequestContext) {
-    return ctx.paginate(
-      (parsed) => this.list${s}Query.execute(parsed),
-      ${e.toUpperCase()}_QUERY_CONFIG,
-    )
-  }
-
-  @Get('/:id')
-  @ApiTags('${e}')
-  async getById(ctx: RequestContext) {
-    const result = await this.get${e}Query.execute(ctx.params.id)
-    if (!result) return ctx.notFound('${e} not found')
-    ctx.json(result)
-  }
-
-  @Post('/', { body: create${e}Schema, name: 'Create${e}' })
-  @ApiTags('${e}')
-  async create(ctx: RequestContext) {
-    const result = await this.create${e}Command.execute(ctx.body)
-    ctx.created(result)
-  }
-
-  @Put('/:id', { body: update${e}Schema, name: 'Update${e}' })
-  @ApiTags('${e}')
-  async update(ctx: RequestContext) {
-    const result = await this.update${e}Command.execute(ctx.params.id, ctx.body)
-    ctx.json(result)
-  }
-
-  @Delete('/:id')
-  @ApiTags('${e}')
-  async remove(ctx: RequestContext) {
-    await this.delete${e}Command.execute(ctx.params.id)
-    ctx.noContent()
-  }
-}
-`;
-}
-function ve(r) {
-  const { pascal: e, kebab: t } = r;
-  return [
-    {
-      file: `create-${t}.command.ts`,
-      content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../${t}.repository'
-import type { Create${e}DTO } from '../dtos/create-${t}.dto'
-import type { ${e}ResponseDTO } from '../dtos/${t}-response.dto'
-import { ${e}Events } from '../events/${t}.events'
-
-@Service()
-export class Create${e}Command {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-    @Inject(${e}Events) private readonly events: ${e}Events,
-  ) {}
-
-  async execute(dto: Create${e}DTO): Promise<${e}ResponseDTO> {
-    const result = await this.repo.create(dto)
-    this.events.emit('${t}.created', result)
-    return result
-  }
-}
-`
-    },
-    {
-      file: `update-${t}.command.ts`,
-      content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../${t}.repository'
-import type { Update${e}DTO } from '../dtos/update-${t}.dto'
-import type { ${e}ResponseDTO } from '../dtos/${t}-response.dto'
-import { ${e}Events } from '../events/${t}.events'
-
-@Service()
-export class Update${e}Command {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-    @Inject(${e}Events) private readonly events: ${e}Events,
-  ) {}
-
-  async execute(id: string, dto: Update${e}DTO): Promise<${e}ResponseDTO> {
-    const result = await this.repo.update(id, dto)
-    this.events.emit('${t}.updated', result)
-    return result
-  }
-}
-`
-    },
-    {
-      file: `delete-${t}.command.ts`,
-      content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../${t}.repository'
-import { ${e}Events } from '../events/${t}.events'
-
-@Service()
-export class Delete${e}Command {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-    @Inject(${e}Events) private readonly events: ${e}Events,
-  ) {}
-
-  async execute(id: string): Promise<void> {
-    await this.repo.delete(id)
-    this.events.emit('${t}.deleted', { id })
-  }
-}
-`
-    }
-  ];
-}
-function we(r) {
-  const { pascal: e, kebab: t, plural: o = "", pluralPascal: s = "" } = r;
-  return [{
-    file: `get-${t}.query.ts`,
-    content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../${t}.repository'
-import type { ${e}ResponseDTO } from '../dtos/${t}-response.dto'
-
-@Service()
-export class Get${e}Query {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-  ) {}
-
-  async execute(id: string): Promise<${e}ResponseDTO | null> {
-    return this.repo.findById(id)
-  }
-}
-`
-  }, {
-    file: `list-${o}.query.ts`,
-    content: `import { Service, Inject } from '@forinda/kickjs'
-import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../${t}.repository'
-import type { ParsedQuery } from '@forinda/kickjs'
-
-@Service()
-export class List${s}Query {
-  constructor(
-    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
-  ) {}
-
-  async execute(parsed: ParsedQuery) {
-    return this.repo.findPaginated(parsed)
-  }
-}
-`
-  }];
-}
-function Re(r) {
-  const { pascal: e, kebab: t } = r;
-  return [{
-    file: `${t}.events.ts`,
-    content: `import { Service } from '@forinda/kickjs'
-import { EventEmitter } from 'node:events'
-import type { ${e}ResponseDTO } from '../dtos/${t}-response.dto'
-
-/**
- * ${e} 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 ${e}EventMap {
-  '${t}.created': ${e}ResponseDTO
-  '${t}.updated': ${e}ResponseDTO
-  '${t}.deleted': { id: string }
-}
-
-@Service()
-export class ${e}Events {
-  private emitter = new EventEmitter()
-
-  emit<K extends keyof ${e}EventMap>(event: K, data: ${e}EventMap[K]): void {
-    this.emitter.emit(event, data)
-  }
-
-  on<K extends keyof ${e}EventMap>(event: K, handler: (data: ${e}EventMap[K]) => void): void {
-    this.emitter.on(event, handler)
-  }
-
-  off<K extends keyof ${e}EventMap>(event: K, handler: (data: ${e}EventMap[K]) => void): void {
-    this.emitter.off(event, handler)
-  }
-}
-`
-  }, {
-    file: `on-${t}-change.handler.ts`,
-    content: `import { Service, Autowired } from '@forinda/kickjs'
-import { ${e}Events } from './${t}.events'
-
-/**
- * ${e} Change Event Handler
- *
- * Reacts to domain events emitted by commands.
- * Wire up side effects here:
- *
- * 1. WebSocket broadcast — notify connected clients in real-time
- *    import { WsGateway } from '@forinda/kickjs-ws'
- *    this.ws.broadcast('${t}-channel', { event, data })
- *
- * 2. Queue dispatch — offload heavy processing to background workers
- *    import { QueueService } from '@forinda/kickjs-queue'
- *    this.queue.add('${t}-etl', { action: event, payload: data })
- *
- * 3. ETL pipeline — transform and load data to external systems
- *    await this.etlPipeline.process(data)
- */
-@Service()
-export class On${e}ChangeHandler {
-  @Autowired() private events!: ${e}Events
-
-  // Uncomment to inject WebSocket and Queue services:
-  // @Autowired() private ws!: WsGateway
-  // @Autowired() private queue!: QueueService
-
-  onInit(): void {
-    this.events.on('${t}.created', (data) => {
-      console.log('[${e}] Created:', data.id)
-      // TODO: Broadcast via WebSocket
-      // this.ws.broadcast('${t}-channel', { event: '${t}.created', data })
-      // TODO: Dispatch to queue for async processing / ETL
-      // this.queue.add('${t}-etl', { action: 'create', payload: data })
-    })
-
-    this.events.on('${t}.updated', (data) => {
-      console.log('[${e}] Updated:', data.id)
-      // TODO: Broadcast via WebSocket
-      // this.ws.broadcast('${t}-channel', { event: '${t}.updated', data })
-    })
-
-    this.events.on('${t}.deleted', (data) => {
-      console.log('[${e}] Deleted:', data.id)
-      // TODO: Broadcast via WebSocket
-      // this.ws.broadcast('${t}-channel', { event: '${t}.deleted', data })
-    })
-  }
-}
-`
-  }];
-}
-function M(r) {
-  const { pascal: e, kebab: t, repoPrefix: o = "../../domain/repositories", dtoPrefix: s = "../../application/dtos" } = r;
-  return `/**
- * Drizzle ${e} Repository
- *
- * Implements the repository interface using Drizzle ORM.
- * Uses buildFromColumns() with Column objects for type-safe query building.
- *
- * TODO: Update the schema import to match your Drizzle schema file.
- * TODO: Replace DRIZZLE_DB injection token with your actual database token.
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc, count, sql } from 'drizzle-orm'
-import { Repository, HttpException, Inject } from '@forinda/kickjs'
-import { DRIZZLE_DB, DrizzleQueryAdapter } from '@forinda/kickjs-drizzle'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${e}Repository } from '${o}/${t}.repository'
-import type { ${e}ResponseDTO } from '${s}/${t}-response.dto'
-import type { Create${e}DTO } from '${s}/create-${t}.dto'
-import type { Update${e}DTO } from '${s}/update-${t}.dto'
-import { ${e.toUpperCase()}_QUERY_CONFIG } from '../../constants'
-
-// TODO: Import your Drizzle schema table — e.g.:
-// import { ${t}s } from '@/db/schema'
-
-const queryAdapter = new DrizzleQueryAdapter({
-  eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc,
-})
-
-@Repository()
-export class Drizzle${e}Repository implements I${e}Repository {
-  constructor(@Inject(DRIZZLE_DB) private db: any) {}
-
-  async findById(id: string): Promise<${e}ResponseDTO | null> {
-    // TODO: Implement with Drizzle
-    // const row = this.db.select().from(${t}s).where(eq(${t}s.id, id)).get()
-    // return row ?? null
-    throw new Error('Drizzle ${e} repository not yet implemented — update schema imports and queries')
-  }
-
-  async findAll(): Promise<${e}ResponseDTO[]> {
-    // TODO: Implement with Drizzle
-    // return this.db.select().from(${t}s).all()
-    throw new Error('Drizzle ${e} repository not yet implemented')
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${e}ResponseDTO[]; total: number }> {
-    // TODO: Use buildFromColumns() with your query config for type-safe filtering
-    // const query = queryAdapter.buildFromColumns(parsed, ${e.toUpperCase()}_QUERY_CONFIG)
-    //
-    // const data = this.db
-    //   .select().from(${t}s).$dynamic()
-    //   .where(query.where).orderBy(...query.orderBy)
-    //   .limit(query.limit).offset(query.offset).all()
-    //
-    // const totalResult = this.db
-    //   .select({ count: count() }).from(${t}s)
-    //   .$dynamic().where(query.where).get()
-    //
-    // return { data, total: totalResult?.count ?? 0 }
-    throw new Error('Drizzle ${e} repository not yet implemented')
-  }
-
-  async create(dto: Create${e}DTO): Promise<${e}ResponseDTO> {
-    // TODO: Implement with Drizzle
-    // return this.db.insert(${t}s).values(dto).returning().get()
-    throw new Error('Drizzle ${e} repository not yet implemented')
-  }
-
-  async update(id: string, dto: Update${e}DTO): Promise<${e}ResponseDTO> {
-    // TODO: Implement with Drizzle
-    // const row = this.db.update(${t}s).set(dto).where(eq(${t}s.id, id)).returning().get()
-    // if (!row) throw HttpException.notFound('${e} not found')
-    // return row
-    throw new Error('Drizzle ${e} repository not yet implemented')
-  }
-
-  async delete(id: string): Promise<void> {
-    // TODO: Implement with Drizzle
-    // this.db.delete(${t}s).where(eq(${t}s.id, id)).run()
-    throw new Error('Drizzle ${e} repository not yet implemented')
-  }
-}
-`;
-}
-function Ce(r) {
-  const { pascal: e, kebab: t } = r;
-  return `import type { DrizzleQueryParamsConfig } from '@forinda/kickjs-drizzle'
-// TODO: Import your schema table and reference actual columns for type safety
-// import { ${t}s } from '@/db/schema'
-
-export const ${e.toUpperCase()}_QUERY_CONFIG: DrizzleQueryParamsConfig = {
-  columns: {
-    // Replace with actual Drizzle Column references for type-safe filtering:
-    // name: ${t}s.name,
-    // status: ${t}s.status,
-  },
-  sortable: {
-    // name: ${t}s.name,
-    // createdAt: ${t}s.createdAt,
-  },
-  searchColumns: [
-    // ${t}s.name,
-  ],
-}
-`;
-}
-function q(r) {
-  const { pascal: e, kebab: t, repoPrefix: o = "../../domain/repositories", dtoPrefix: s = "../../application/dtos" } = r, i = t.replace(/-([a-z])/g, (n, a) => a.toUpperCase());
-  return `/**
- * Prisma ${e} Repository
- *
- * Implements the repository interface using Prisma Client.
- * Requires a PrismaClient instance injected via the DI container.
- *
- * Ensure your Prisma schema has a '${e}' model defined.
- *
- * For full Prisma field-level type safety, replace PrismaModelDelegate with your PrismaClient:
- *   @Inject(PRISMA_CLIENT) private prisma!: PrismaClient
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { Repository, HttpException, Inject } from '@forinda/kickjs'
-import { PRISMA_CLIENT, type PrismaModelDelegate } from '@forinda/kickjs-prisma'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${e}Repository } from '${o}/${t}.repository'
-import type { ${e}ResponseDTO } from '${s}/${t}-response.dto'
-import type { Create${e}DTO } from '${s}/create-${t}.dto'
-import type { Update${e}DTO } from '${s}/update-${t}.dto'
-
-@Repository()
-export class Prisma${e}Repository implements I${e}Repository {
-  @Inject(PRISMA_CLIENT) private prisma!: { ${i}: PrismaModelDelegate }
-
-  async findById(id: string): Promise<${e}ResponseDTO | null> {
-    return this.prisma.${i}.findUnique({ where: { id } }) as Promise<${e}ResponseDTO | null>
-  }
-
-  async findAll(): Promise<${e}ResponseDTO[]> {
-    return this.prisma.${i}.findMany() as Promise<${e}ResponseDTO[]>
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${e}ResponseDTO[]; total: number }> {
-    const [data, total] = await Promise.all([
-      this.prisma.${i}.findMany({
-        skip: parsed.pagination.offset,
-        take: parsed.pagination.limit,
-      }) as Promise<${e}ResponseDTO[]>,
-      this.prisma.${i}.count(),
-    ])
-    return { data, total }
-  }
-
-  async create(dto: Create${e}DTO): Promise<${e}ResponseDTO> {
-    return this.prisma.${i}.create({ data: dto as Record<string, unknown> }) as Promise<${e}ResponseDTO>
-  }
-
-  async update(id: string, dto: Update${e}DTO): Promise<${e}ResponseDTO> {
-    const existing = await this.prisma.${i}.findUnique({ where: { id } })
-    if (!existing) throw HttpException.notFound('${e} not found')
-    return this.prisma.${i}.update({ where: { id }, data: dto as Record<string, unknown> }) as Promise<${e}ResponseDTO>
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.prisma.${i}.deleteMany({ where: { id } })
-  }
-}
-`;
-}
-async function be(r) {
-  const { pascal: e, kebab: t, plural: o, write: s } = r;
-  await s("index.ts", de({
-    pascal: e,
-    kebab: t,
-    plural: o
-  })), await s(`${t}.controller.ts`, `import { Controller, Get } from '@forinda/kickjs'
-import type { RequestContext } from '@forinda/kickjs'
-
-@Controller()
-export class ${e}Controller {
-  @Get('/')
-  async list(ctx: RequestContext) {
-    ctx.json({ message: '${e} list' })
-  }
-}
-`);
-}
-async function xe(r) {
-  const { pascal: e, kebab: t, plural: o, pluralPascal: s, repo: i, noTests: n, prismaClientPath: a, write: c } = r;
-  await c("index.ts", ce({
-    pascal: e,
-    kebab: t,
-    plural: o,
-    repo: i
-  })), await c(`${t}.constants.ts`, J({
-    pascal: e,
-    kebab: t
-  })), await c(`${t}.controller.ts`, le({
-    pascal: e,
-    kebab: t,
-    plural: o,
-    pluralPascal: s
-  })), await c(`${t}.service.ts`, ge({
-    pascal: e,
-    kebab: t
-  })), await c(`dtos/create-${t}.dto.ts`, O({
-    pascal: e,
-    kebab: t
-  })), await c(`dtos/update-${t}.dto.ts`, I({
-    pascal: e,
-    kebab: t
-  })), await c(`dtos/${t}-response.dto.ts`, S({
-    pascal: e,
-    kebab: t
-  })), await c(`${t}.repository.ts`, A({
-    pascal: e,
-    kebab: t,
-    dtoPrefix: "./dtos"
-  }));
-  const d = {
-    inmemory: `in-memory-${t}`,
-    drizzle: `drizzle-${t}`,
-    prisma: `prisma-${t}`
-  }, u = {
-    inmemory: () => v({
-      pascal: e,
-      kebab: t,
-      repoPrefix: ".",
-      dtoPrefix: "./dtos"
-    }),
-    drizzle: () => M({
-      pascal: e,
-      kebab: t,
-      repoPrefix: ".",
-      dtoPrefix: "./dtos"
-    }),
-    prisma: () => q({
-      pascal: e,
-      kebab: t,
-      repoPrefix: ".",
-      dtoPrefix: "./dtos",
-      prismaClientPath: a
-    })
-  }, m = d[i] ?? `${y(i)}-${t}`, f = u[i] ?? (() => j({
-    pascal: e,
-    kebab: t,
-    repoType: i,
-    repoPrefix: ".",
-    dtoPrefix: "./dtos"
-  }));
-  await c(`${m}.repository.ts`, f()), n || (i !== "inmemory" && await c(`in-memory-${t}.repository.ts`, v({
-    pascal: e,
-    kebab: t,
-    repoPrefix: ".",
-    dtoPrefix: "./dtos"
-  })), await c(`__tests__/${t}.controller.test.ts`, E({
-    pascal: e,
-    kebab: t,
-    plural: o
-  })), await c(`__tests__/${t}.repository.test.ts`, U({
-    pascal: e,
-    kebab: t,
-    plural: o,
-    repoPrefix: `../${d.inmemory ?? `in-memory-${t}`}.repository`
-  })));
-}
-async function De(r) {
-  const { pascal: e, kebab: t, plural: o, pluralPascal: s, repo: i, noTests: n, prismaClientPath: a, write: c } = r;
-  await c("index.ts", he({
-    pascal: e,
-    kebab: t,
-    plural: o,
-    repo: i
-  })), await c(`${t}.constants.ts`, J({
-    pascal: e,
-    kebab: t
-  })), await c(`${t}.controller.ts`, ke({
-    pascal: e,
-    kebab: t,
-    plural: o,
-    pluralPascal: s
-  })), await c(`dtos/create-${t}.dto.ts`, O({
-    pascal: e,
-    kebab: t
-  })), await c(`dtos/update-${t}.dto.ts`, I({
-    pascal: e,
-    kebab: t
-  })), await c(`dtos/${t}-response.dto.ts`, S({
-    pascal: e,
-    kebab: t
-  }));
-  const d = ve({
-    pascal: e,
-    kebab: t
-  });
-  for (const $ of d) await c(`commands/${$.file}`, $.content);
-  const u = we({
-    pascal: e,
-    kebab: t,
-    plural: o,
-    pluralPascal: s
-  });
-  for (const $ of u) await c(`queries/${$.file}`, $.content);
-  const m = Re({
-    pascal: e,
-    kebab: t
-  });
-  for (const $ of m) await c(`events/${$.file}`, $.content);
-  await c(`${t}.repository.ts`, A({
-    pascal: e,
-    kebab: t,
-    dtoPrefix: "./dtos"
-  }));
-  const f = {
-    inmemory: `in-memory-${t}`,
-    drizzle: `drizzle-${t}`,
-    prisma: `prisma-${t}`
-  }, w = {
-    inmemory: () => v({
-      pascal: e,
-      kebab: t,
-      repoPrefix: ".",
-      dtoPrefix: "./dtos"
-    }),
-    drizzle: () => M({
-      pascal: e,
-      kebab: t,
-      repoPrefix: ".",
-      dtoPrefix: "./dtos"
-    }),
-    prisma: () => q({
-      pascal: e,
-      kebab: t,
-      repoPrefix: ".",
-      dtoPrefix: "./dtos",
-      prismaClientPath: a
-    })
-  }, k = f[i] ?? `${y(i)}-${t}`, h = w[i] ?? (() => j({
-    pascal: e,
-    kebab: t,
-    repoType: i,
-    repoPrefix: ".",
-    dtoPrefix: "./dtos"
-  }));
-  await c(`${k}.repository.ts`, h()), n || (i !== "inmemory" && await c(`in-memory-${t}.repository.ts`, v({
-    pascal: e,
-    kebab: t,
-    repoPrefix: ".",
-    dtoPrefix: "./dtos"
-  })), await c(`__tests__/${t}.controller.test.ts`, E({
-    pascal: e,
-    kebab: t,
-    plural: o
-  })), await c(`__tests__/${t}.repository.test.ts`, U({
-    pascal: e,
-    kebab: t,
-    plural: o,
-    repoPrefix: `../${f.inmemory ?? `in-memory-${t}`}.repository`
-  })));
-}
-async function Pe(r) {
-  const { pascal: e, kebab: t, plural: o, pluralPascal: s, repo: i, noEntity: n, noTests: a, prismaClientPath: c, write: d } = r;
-  await d("index.ts", ne({
-    pascal: e,
-    kebab: t,
-    plural: o,
-    repo: i
-  })), await d("constants.ts", i === "drizzle" ? Ce({
-    pascal: e,
-    kebab: t
-  }) : ue({
-    pascal: e,
-    kebab: t
-  })), await d(`presentation/${t}.controller.ts`, pe({
-    pascal: e,
-    kebab: t,
-    plural: o,
-    pluralPascal: s
-  })), await d(`application/dtos/create-${t}.dto.ts`, O({
-    pascal: e,
-    kebab: t
-  })), await d(`application/dtos/update-${t}.dto.ts`, I({
-    pascal: e,
-    kebab: t
-  })), await d(`application/dtos/${t}-response.dto.ts`, S({
-    pascal: e,
-    kebab: t
-  }));
-  const u = me({
-    pascal: e,
-    kebab: t,
-    plural: o,
-    pluralPascal: s
-  });
-  for (const h of u) await d(`application/use-cases/${h.file}`, h.content);
-  await d(`domain/repositories/${t}.repository.ts`, A({
-    pascal: e,
-    kebab: t
-  })), await d(`domain/services/${t}-domain.service.ts`, fe({
-    pascal: e,
-    kebab: t
-  }));
-  const m = {
-    inmemory: `in-memory-${t}`,
-    drizzle: `drizzle-${t}`,
-    prisma: `prisma-${t}`
-  }, f = {
-    inmemory: () => v({
-      pascal: e,
-      kebab: t
-    }),
-    drizzle: () => M({
-      pascal: e,
-      kebab: t
-    }),
-    prisma: () => q({
-      pascal: e,
-      kebab: t,
-      prismaClientPath: c
-    })
-  }, w = m[i] ?? `${y(i)}-${t}`, k = f[i] ?? (() => j({
-    pascal: e,
-    kebab: t,
-    repoType: i
-  }));
-  await d(`infrastructure/repositories/${w}.repository.ts`, k()), n || (await d(`domain/entities/${t}.entity.ts`, $e({
-    pascal: e,
-    kebab: t
-  })), await d(`domain/value-objects/${t}-id.vo.ts`, ye({
-    pascal: e,
-    kebab: t
-  }))), a || (i !== "inmemory" && await d(`infrastructure/repositories/in-memory-${t}.repository.ts`, v({
-    pascal: e,
-    kebab: t
-  })), await d(`__tests__/${t}.controller.test.ts`, E({
-    pascal: e,
-    kebab: t,
-    plural: o
-  })), await d(`__tests__/${t}.repository.test.ts`, U({
-    pascal: e,
-    kebab: t,
-    plural: o
-  })));
-}
-function it(r) {
-  return r ? typeof r == "string" ? r : r.name : "inmemory";
-}
-function Te(r) {
-  const e = ee({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((t) => {
-    e.question(r, (o) => {
-      e.close(), t(o.trim().toLowerCase());
-    });
-  });
-}
-async function at(r) {
-  const { name: e, modulesDir: t, noEntity: o, noTests: s, repo: i = "inmemory", force: n, dryRun: a } = r, c = r.pluralize !== !1;
-  let d = r.pattern ?? "ddd";
-  r.minimal && (d = "minimal");
-  const u = y(e), m = g(e), f = c ? Y(u) : u, w = c ? se(m) : m, k = p(t, f), h = [];
-  let $ = n ?? !1;
-  const Z = async (D, X) => {
-    const x = p(k, D);
-    if (a) {
-      h.push(x);
-      return;
-    }
-    if (!$ && await B(x)) {
-      const z = await Te(`  File already exists: ${D}
-  Overwrite? (y/n/a = yes/no/all) `);
-      if (z === "a") $ = !0;
-      else if (z !== "y") {
-        console.log(`  Skipped: ${D}`);
-        return;
-      }
-    }
-    await l(x, X), h.push(x);
-  }, b = {
-    kebab: u,
-    pascal: m,
-    plural: f,
-    pluralPascal: w,
-    moduleDir: k,
-    repo: i,
-    noEntity: o ?? !1,
-    noTests: s ?? !1,
-    prismaClientPath: r.prismaClientPath ?? "@prisma/client",
-    write: Z,
-    files: h
-  };
-  switch (d) {
-    case "minimal":
-      await be(b);
-      break;
-    case "rest":
-      await xe(b);
-      break;
-    case "cqrs":
-      await De(b);
-      break;
-    default:
-      await Pe(b);
-      break;
-  }
-  return a || await Oe(t, m, f), h;
-}
-async function Oe(r, e, t) {
-  const o = p(r, "index.ts");
-  if (!await B(o)) {
-    await l(o, `import type { AppModuleClass } from '@forinda/kickjs'
-import { ${e}Module } from './${t}'
-
-export const modules: AppModuleClass[] = [${e}Module]
-`);
-    return;
-  }
-  let s = await L(o, "utf-8");
-  const i = `import { ${e}Module } from './${t}'`;
-  if (!s.includes(`${e}Module`)) {
-    const n = s.lastIndexOf("import ");
-    if (n !== -1) {
-      const a = s.indexOf(`
-`, n);
-      s = s.slice(0, a + 1) + i + `
-` + s.slice(a + 1);
-    } else s = i + `
-` + s;
-    s = s.replace(/(=\s*\[)([\s\S]*?)(])/, (a, c, d, u) => {
-      const m = d.trim();
-      if (!m) return `${c}${e}Module${u}`;
-      const f = m.endsWith(",") ? "" : ",";
-      return `${c}${d.trimEnd()}${f} ${e}Module${u}`;
-    });
-  }
-  await N(o, s, "utf-8");
-}
-async function nt(r) {
-  const { name: e, outDir: t } = r, o = y(e), s = g(e), i = [], n = p(t, `${o}.adapter.ts`);
-  return await l(n, `import type { AppAdapter, AdapterContext, AdapterMiddleware } from '@forinda/kickjs'
-
-export interface ${s}AdapterOptions {
-  // Add your adapter configuration here
-}
-
-/**
- * ${s} adapter.
- *
- * Hooks into the Application lifecycle to add middleware, routes,
- * or external service connections.
- *
- * Usage:
- *   bootstrap({
- *     adapters: [new ${s}Adapter({ ... })],
- *   })
- */
-export class ${s}Adapter implements AppAdapter {
-  name = '${s}Adapter'
-
-  constructor(private options: ${s}AdapterOptions = {}) {}
-
-  /**
-   * Return middleware entries that the Application will mount.
-   * Use \`phase\` to control where in the pipeline they run:
-   *   'beforeGlobal' | 'afterGlobal' | 'beforeRoutes' | 'afterRoutes'
-   */
-  middleware(): AdapterMiddleware[] {
-    return [
-      // Example: add a custom header to all responses
-      // {
-      //   phase: 'beforeGlobal',
-      //   handler: (_req: any, res: any, next: any) => {
-      //     res.setHeader('X-${s}', 'true')
-      //     next()
-      //   },
-      // },
-      // Example: scope middleware to a specific path
-      // {
-      //   phase: 'beforeRoutes',
-      //   path: '/api/v1/admin',
-      //   handler: myAdminMiddleware(),
-      // },
-    ]
-  }
-
-  /**
-   * Called before global middleware.
-   * Use this to mount routes that bypass the middleware stack
-   * (health checks, docs UI, static assets).
-   */
-  beforeMount({ app }: AdapterContext): void {
-    // Example: mount a status route
-    // app.get('/${o}/status', (_req, res) => {
-    //   res.json({ status: 'ok' })
-    // })
-  }
-
-  /**
-   * Called after modules and routes are registered, before the server starts.
-   * Use this for late-stage DI registrations or config validation.
-   */
-  beforeStart({ container }: AdapterContext): void {
-    // Example: register a service in the DI container
-    // container.registerInstance(MY_TOKEN, new MyService(this.options))
-  }
-
-  /**
-   * Called after the HTTP server is listening.
-   * Use this to attach to the raw http.Server (Socket.IO, gRPC, etc).
-   */
-  afterStart({ server, container }: AdapterContext): void {
-    // Example: attach Socket.IO
-    // const io = new Server(server)
-    // container.registerInstance(SOCKET_IO, io)
-  }
-
-  /**
-   * Called on graceful shutdown. Clean up connections.
-   */
-  async shutdown(): Promise<void> {
-    // Example: close a connection pool
-    // await this.pool.end()
-  }
-}
-`), i.push(n), i;
-}
-var Ie = {
-  controller: "presentation",
-  service: "domain/services",
-  dto: "application/dtos",
-  guard: "presentation/guards",
-  middleware: "middleware"
-}, Se = {
-  controller: "",
-  service: "",
-  dto: "dtos",
-  guard: "guards",
-  middleware: "middleware"
-}, Ae = {
-  controller: "",
-  service: "",
-  dto: "dtos",
-  guard: "guards",
-  middleware: "middleware",
-  command: "commands",
-  query: "queries",
-  event: "events"
-};
-function C(r) {
-  const { type: e, outDir: t, moduleName: o, modulesDir: s = "src/modules", defaultDir: i, pattern: n = "ddd" } = r;
-  if (t) return P(t);
-  if (o) {
-    const a = n === "ddd" ? Ie : n === "cqrs" ? Ae : Se, c = Y(y(o)), d = a[e] ?? "", u = p(s, c);
-    return P(d ? p(u, d) : u);
-  }
-  return P(i);
-}
-async function ct(r) {
-  const { name: e, moduleName: t, modulesDir: o, pattern: s } = r, i = C({
-    type: "middleware",
-    outDir: r.outDir,
-    moduleName: t,
-    modulesDir: o,
-    defaultDir: "src/middleware",
-    pattern: s
-  }), n = y(e), a = T(e), c = [], d = p(i, `${n}.middleware.ts`);
-  return await l(d, `import type { Request, Response, NextFunction } from 'express'
-
-export interface ${g(e)}Options {
-  // Add configuration options here
-}
-
-/**
- * ${g(e)} middleware.
- *
- * Usage in bootstrap:
- *   middleware: [${a}()]
- *
- * Usage with adapter:
- *   middleware() { return [{ handler: ${a}(), phase: 'afterGlobal' }] }
- *
- * Usage with @Middleware decorator:
- *   @Middleware(${a}())
- */
-export function ${a}(options: ${g(e)}Options = {}) {
-  return (req: Request, res: Response, next: NextFunction) => {
-    // Implement your middleware logic here
-    next()
-  }
-}
-`), c.push(d), c;
-}
-async function dt(r) {
-  const { name: e, moduleName: t, modulesDir: o, pattern: s } = r, i = C({
-    type: "guard",
-    outDir: r.outDir,
-    moduleName: t,
-    modulesDir: o,
-    defaultDir: "src/guards",
-    pattern: s
-  }), n = y(e), a = T(e), c = g(e), d = [], u = p(i, `${n}.guard.ts`);
-  return await l(u, `import { Container, HttpException } from '@forinda/kickjs'
-import type { RequestContext } from '@forinda/kickjs'
-
-/**
- * ${c} guard.
- *
- * Guards protect routes by checking conditions before the handler runs.
- * Return early with an error response to block access.
- *
- * Usage:
- *   @Middleware(${a}Guard)
- *   @Get('/protected')
- *   async handler(ctx: RequestContext) { ... }
- */
-export async function ${a}Guard(ctx: RequestContext, next: () => void): Promise<void> {
-  // Example: check for an authorization header
-  const header = ctx.headers.authorization
-  if (!header?.startsWith('Bearer ')) {
-    ctx.res.status(401).json({ message: 'Missing or invalid authorization header' })
-    return
-  }
-
-  const token = header.slice(7)
-
-  try {
-    // Verify the token using a service from the DI container
-    // const container = Container.getInstance()
-    // const authService = container.resolve(AuthService)
-    // const payload = authService.verifyToken(token)
-    // ctx.set('auth', payload)
-
-    next()
-  } catch {
-    ctx.res.status(401).json({ message: 'Invalid or expired token' })
-  }
-}
-`), d.push(u), d;
-}
-async function pt(r) {
-  const { name: e, moduleName: t, modulesDir: o, pattern: s } = r, i = C({
-    type: "service",
-    outDir: r.outDir,
-    moduleName: t,
-    modulesDir: o,
-    defaultDir: "src/services",
-    pattern: s
-  }), n = y(e), a = g(e), c = [], d = p(i, `${n}.service.ts`);
-  return await l(d, `import { Service } from '@forinda/kickjs'
-
-@Service()
-export class ${a}Service {
-  // Inject dependencies via constructor
-  // constructor(
-  //   @Inject(MY_REPO) private readonly repo: IMyRepository,
-  // ) {}
-}
-`), c.push(d), c;
-}
-async function lt(r) {
-  const { name: e, moduleName: t, modulesDir: o, pattern: s } = r, i = C({
-    type: "controller",
-    outDir: r.outDir,
-    moduleName: t,
-    modulesDir: o,
-    defaultDir: "src/controllers",
-    pattern: s
-  }), n = y(e), a = g(e), c = [], d = p(i, `${n}.controller.ts`);
-  return await l(d, `import { Controller, Get, Post, Autowired } from '@forinda/kickjs'
-import type { RequestContext } from '@forinda/kickjs'
-
-@Controller()
-export class ${a}Controller {
-  // @Autowired() private myService!: MyService
-
-  @Get('/')
-  async list(ctx: RequestContext) {
-    ctx.json({ message: '${a} list' })
-  }
-
-  @Post('/')
-  async create(ctx: RequestContext) {
-    ctx.created({ message: '${a} created', data: ctx.body })
-  }
-}
-`), c.push(d), c;
-}
-async function ut(r) {
-  const { name: e, moduleName: t, modulesDir: o, pattern: s } = r, i = C({
-    type: "dto",
-    outDir: r.outDir,
-    moduleName: t,
-    modulesDir: o,
-    defaultDir: "src/dtos",
-    pattern: s
-  }), n = y(e), a = g(e), c = T(e), d = [], u = p(i, `${n}.dto.ts`);
-  return await l(u, `import { z } from 'zod'
-
-export const ${c}Schema = z.object({
-  // Define your schema fields here
-  name: z.string().min(1).max(200),
-})
-
-export type ${a}DTO = z.infer<typeof ${c}Schema>
-`), d.push(u), d;
-}
-function je(r, e, t) {
-  const o = {
-    "@forinda/kickjs": t,
-    "@forinda/kickjs-config": t,
-    express: "^5.1.0",
-    "reflect-metadata": "^0.2.2",
-    zod: "^4.3.6",
-    pino: "^10.3.1",
-    "pino-pretty": "^13.1.3"
-  };
-  return e !== "minimal" && (o["@forinda/kickjs-swagger"] = t, o["@forinda/kickjs-devtools"] = t), e === "graphql" && (o["@forinda/kickjs-graphql"] = t, o.graphql = "^16.11.0"), e === "cqrs" && (o["@forinda/kickjs-queue"] = t, o["@forinda/kickjs-ws"] = t, o["@forinda/kickjs-otel"] = t), e === "ddd" && (o["@forinda/kickjs-swagger"] = t), JSON.stringify({
-    name: r,
-    version: t.replace("^", ""),
-    type: "module",
-    scripts: {
-      dev: "kick dev",
-      "dev:debug": "kick dev:debug",
-      build: "kick build",
-      start: "kick start",
-      test: "vitest run",
-      "test:watch": "vitest",
-      typecheck: "tsc --noEmit",
-      lint: "eslint src/",
-      format: "prettier --write src/"
-    },
-    dependencies: o,
-    devDependencies: {
-      "@forinda/kickjs-cli": t,
-      "@swc/core": "^1.7.28",
-      "@types/express": "^5.0.6",
-      "@types/node": "^25.0.0",
-      "unplugin-swc": "^1.5.9",
-      vite: "^8.0.2",
-      vitest: "^4.1.1",
-      typescript: "^5.9.2",
-      prettier: "^3.8.1"
-    }
-  }, null, 2);
-}
-function Ee() {
-  return `import { defineConfig } from 'vite'
-import { resolve } from 'path'
-import swc from 'unplugin-swc'
-
-export default defineConfig({
-  oxc: false,
-  plugins: [swc.vite()],
-  resolve: {
-    alias: {
-      '@': resolve(__dirname, 'src'),
-    },
-  },
-  ssr: {
-    // Don't bundle pino — its worker-thread transport needs Node.js resolution
-    // to find pino-pretty at runtime for colored log output
-    external: ['pino', 'pino-pretty'],
-  },
-  server: {
-    watch: { usePolling: false },
-    hmr: true,
-  },
-  build: {
-    target: 'node20',
-    ssr: true,
-    outDir: 'dist',
-    sourcemap: true,
-    rollupOptions: {
-      input: resolve(__dirname, 'src/index.ts'),
-      output: { format: 'esm' },
-    },
-  },
-})
-`;
-}
-function Ue() {
-  return JSON.stringify({
-    compilerOptions: {
-      target: "ES2022",
-      module: "ESNext",
-      moduleResolution: "bundler",
-      lib: ["ES2022"],
-      types: ["node", "vite/client"],
-      strict: !0,
-      esModuleInterop: !0,
-      skipLibCheck: !0,
-      sourceMap: !0,
-      declaration: !0,
-      experimentalDecorators: !0,
-      emitDecoratorMetadata: !0,
-      outDir: "dist",
-      rootDir: "src",
-      paths: { "@/*": ["./src/*"] }
-    },
-    include: ["src"]
-  }, null, 2);
-}
-function Me() {
-  return JSON.stringify({
-    semi: !1,
-    singleQuote: !0,
-    trailingComma: "all",
-    printWidth: 100,
-    tabWidth: 2
-  }, null, 2);
-}
-function qe() {
-  return `# 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
-`;
-}
-function ze() {
-  return `node_modules/
-dist/
-.env
-coverage/
-.DS_Store
-*.tsbuildinfo
-`;
-}
-function _e() {
-  return `# 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 — treat as generated
-pnpm-lock.yaml -diff linguist-generated
-yarn.lock -diff linguist-generated
-package-lock.json -diff linguist-generated
-`;
-}
-function Ge() {
-  return `PORT=3000
-NODE_ENV=development
-`;
-}
-function Qe() {
-  return `PORT=3000
-NODE_ENV=development
-`;
-}
-function Fe() {
-  return `import { defineConfig } from 'vitest/config'
-import swc from 'unplugin-swc'
-
-export default defineConfig({
-  plugins: [swc.vite()],
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-  },
-})
-`;
-}
-function Le(r, e, t) {
-  switch (e) {
-    case "graphql":
-      return `import 'reflect-metadata'
-import { bootstrap } from '@forinda/kickjs'
-import { DevToolsAdapter } from '@forinda/kickjs-devtools'
-import { GraphQLAdapter } from '@forinda/kickjs-graphql'
-import { modules } from './modules'
-
-// Import your resolvers here
-// import { UserResolver } from './resolvers/user.resolver'
-
-bootstrap({
-  modules,
-  adapters: [
-    new DevToolsAdapter(),
-    new GraphQLAdapter({
-      resolvers: [/* UserResolver */],
-      // Add custom type definitions here:
-      // typeDefs: userTypeDefs,
-    }),
-  ],
-})
-`;
-    case "cqrs":
-      return `import 'reflect-metadata'
-import { bootstrap } from '@forinda/kickjs'
-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'
-
-bootstrap({
-  modules,
-  adapters: [
-    new OtelAdapter({ serviceName: '${r}' }),
-    new DevToolsAdapter(),
-    new SwaggerAdapter({
-      info: { title: '${r}', version: '${t}' },
-    }),
-    // Uncomment for WebSocket support:
-    // new WsAdapter(),
-    // Uncomment when Redis is available:
-    // new QueueAdapter({
-    //   provider: new BullMQProvider({ host: 'localhost', port: 6379 }),
-    // }),
-  ],
-})
-`;
-    case "minimal":
-      return `import 'reflect-metadata'
-import { bootstrap } from '@forinda/kickjs'
-import { modules } from './modules'
-
-bootstrap({ modules })
-`;
-    default:
-      return `import 'reflect-metadata'
-import { bootstrap } from '@forinda/kickjs'
-import { DevToolsAdapter } from '@forinda/kickjs-devtools'
-import { SwaggerAdapter } from '@forinda/kickjs-swagger'
-import { modules } from './modules'
-
-bootstrap({
-  modules,
-  adapters: [
-    new DevToolsAdapter(),
-    new SwaggerAdapter({
-      info: { title: '${r}', version: '${t}' },
-    }),
-  ],
-})
-`;
-  }
-}
-function Ne() {
-  return `import type { AppModuleClass } from '@forinda/kickjs'
-
-export const modules: AppModuleClass[] = []
-`;
-}
-function We(r, e = "inmemory") {
-  return `import { defineConfig } from '@forinda/kickjs-cli'
-
-export default defineConfig({
-  pattern: '${r}',
-  modules: {
-    dir: 'src/modules',
-    repo: '${e}',
-    pluralize: true,
-  },
-
-  commands: [
-    {
-      name: 'test',
-      description: 'Run tests with Vitest',
-      steps: 'npx vitest run',
-    },
-    {
-      name: 'format',
-      description: 'Format code with Prettier',
-      steps: 'npx prettier --write src/',
-    },
-    {
-      name: 'format:check',
-      description: 'Check formatting without writing',
-      steps: 'npx prettier --check src/',
-    },
-    {
-      name: 'check',
-      description: 'Run typecheck + format check',
-      steps: ['npx tsc --noEmit', 'npx prettier --check src/'],
-      aliases: ['verify', 'ci'],
-    },
-  ],
-})
-`;
-}
-function Be(r, e, t) {
-  const o = {
-    rest: "REST API",
-    graphql: "GraphQL API",
-    ddd: "Domain-Driven Design",
-    cqrs: "CQRS + Event-Driven",
-    minimal: "Minimal"
-  }, s = [
-    "@forinda/kickjs-core",
-    "@forinda/kickjs-http",
-    "@forinda/kickjs-config"
-  ];
-  return e !== "minimal" && s.push("@forinda/kickjs-swagger", "@forinda/kickjs-devtools"), e === "graphql" && s.push("@forinda/kickjs-graphql"), e === "cqrs" && s.push("@forinda/kickjs-queue", "@forinda/kickjs-ws", "@forinda/kickjs-otel"), `# ${r}
-
-A **${o[e] ?? "REST API"}** built with [KickJS](https://forinda.github.io/kick-js/) — a decorator-driven Node.js framework on Express 5 and TypeScript.
-
-## Getting Started
-
-\`\`\`bash
-${t} install
-kick dev
-\`\`\`
-
-## Scripts
-
-| Command | Description |
-|---|---|
-| \`kick dev\` | Start dev server with Vite HMR |
-| \`kick build\` | Production build |
-| \`kick start\` | Run production build |
-| \`${t} run test\` | Run tests with Vitest |
-| \`kick g module <name>\` | Generate a DDD module |
-| \`kick g scaffold <name> <fields...>\` | Generate CRUD from field definitions |
-| \`kick add <package>\` | Add a KickJS package |
-
-## Project Structure
-
-\`\`\`
-src/
-├── index.ts           # Application entry point
-├── modules/           # Feature modules (controllers, services, repos)
-│   └── index.ts       # Module registry
-└── ...
-\`\`\`
-
-## Packages
-
-${s.map((i) => `- \`${i}\``).join(`
-`)}
-
-## Adding Features
-
-\`\`\`bash
-kick add auth          # Authentication (JWT, API key, OAuth)
-kick add swagger       # OpenAPI documentation
-kick add ws            # WebSocket support
-kick add queue         # Background job processing
-kick add mailer        # Email sending
-kick add cron          # Scheduled tasks
-kick add --list        # Show all available packages
-\`\`\`
-
-## Environment Variables
-
-Copy \`.env.example\` to \`.env\` and configure:
-
-| Variable | Default | Description |
-|---|---|---|
-| \`PORT\` | \`3000\` | Server port |
-| \`NODE_ENV\` | \`development\` | Environment |
-
-## Learn More
-
-- [KickJS Documentation](https://forinda.github.io/kick-js/)
-- [CLI Reference](https://forinda.github.io/kick-js/api/cli.html)
-`;
-}
-function Ye(r, e, t) {
-  return `# CLAUDE.md — ${r} Development Guide
-
-## Project Overview
-
-This is a **${{
-    rest: "REST API",
-    graphql: "GraphQL API",
-    ddd: "Domain-Driven Design",
-    cqrs: "CQRS + Event-Driven",
-    minimal: "Minimal Express"
-  }[e] ?? "REST API"}** application built with [KickJS](https://forinda.github.io/kick-js/) — a decorator-driven Node.js framework on Express 5 and TypeScript.
-
-## Quick Commands
-
-\`\`\`bash
-${t} install           # Install dependencies
-kick dev                # Start dev server with HMR
-kick build              # Production build via Vite
-kick start              # Run production build
-${t} run test          # Run tests with Vitest
-${t} run typecheck     # TypeScript type checking
-${t} run format        # Format code with Prettier
-\`\`\`
-
-## Project Structure
-
-\`\`\`
-src/
-├── index.ts           # Application bootstrap
-├── modules/           # Feature modules (DDD/CQRS pattern)
-│   └── index.ts       # Module registry
-${e === "graphql" ? `├── resolvers/         # GraphQL resolvers
-` : ""}└── ...
-\`\`\`
-
-## Package Manager
-
-- Always use **${t}** for this project
-- Run \`${t} install\` to sync dependencies
-- Never mix package managers (npm/yarn/pnpm)
-
-## Code Style
-
-- **Prettier** — no semicolons, single quotes, trailing commas, 100 char width
-- **TypeScript strict mode** — all types required
-- Format before committing: \`${t} run format\`
-- Type check with: \`${t} run typecheck\`
-
-## Key Patterns
-
-### Controllers
-
-Use decorators to define routes:
-
-\`\`\`ts
-import { Controller, Get, Post, RequestContext } from '@forinda/kickjs'
-
-@Controller('/users')
-export class UserController {
-  @Get('/')
-  async findAll(ctx: RequestContext) {
-    return ctx.json({ users: [] })
-  }
-
-  @Post('/')
-  async create(ctx: RequestContext) {
-    const data = ctx.body
-    return ctx.created({ user: data })
-  }
-}
-\`\`\`
-
-### Services
-
-Inject dependencies with \`@Service()\` and \`@Autowired()\`:
-
-\`\`\`ts
-import { Service, Autowired } from '@forinda/kickjs'
-
-@Service()
-export class UserService {
-  @Autowired()
-  private userRepository!: UserRepository
-
-  async findAll() {
-    return this.userRepository.findAll()
-  }
-}
-\`\`\`
-
-### Modules
-
-Register controllers and providers in modules:
-
-\`\`\`ts
-import { Module } from '@forinda/kickjs'
-import { UserController } from './user.controller'
-import { UserService } from './user.service'
-
-@Module({
-  controllers: [UserController],
-  providers: [UserService],
-})
-export class UserModule {}
-\`\`\`
-
-### RequestContext
-
-Every controller method receives \`ctx: RequestContext\`:
-
-\`\`\`ts
-ctx.body           // Request body (parsed JSON)
-ctx.params         // Route params
-ctx.query          // Query string
-ctx.headers        // Request headers
-ctx.requestId      // Auto-generated request ID
-ctx.session        // Session data (if session middleware enabled)
-ctx.file           // Uploaded file (single)
-ctx.files          // Uploaded files (multiple)
-
-// Pagination helpers
-ctx.qs(config)           // Parse query with filters/sort/pagination
-ctx.paginate(handler)     // Auto-paginated response
-
-// Response helpers
-ctx.json(data)            // 200 OK with JSON
-ctx.created(data)         // 201 Created
-ctx.noContent()           // 204 No Content
-ctx.notFound()            // 404 Not Found
-ctx.badRequest(msg)       // 400 Bad Request
-\`\`\`
-
-## CLI Generators
-
-Generate code with the \`kick\` CLI:
-
-\`\`\`bash
-kick g module <name>              # Full module (controller, service, DTOs, repo)
-kick g scaffold <name> <fields>   # CRUD module from field definitions
-kick g controller <name>          # Standalone controller
-kick g service <name>             # Service class
-kick g middleware <name>          # Express middleware
-kick g guard <name>               # Route guard (auth, roles)
-kick g adapter <name>             # AppAdapter with lifecycle hooks
-kick g dto <name>                 # Zod DTO schema
-${e === "graphql" ? `kick g resolver <name>           # GraphQL resolver
-` : ""}${e === "cqrs" ? `kick g job <name>                # Queue job processor
-` : ""}\`\`\`
-
-## Adding Packages
-
-\`\`\`bash
-kick add auth          # JWT, API key, OAuth strategies
-kick add swagger       # OpenAPI docs from decorators
-kick add ws            # WebSocket support
-kick add queue         # Background jobs (BullMQ/RabbitMQ/Kafka)
-kick add mailer        # Email (SMTP, Resend, SES)
-kick add cron          # Scheduled tasks
-kick add prisma        # Prisma ORM adapter
-kick add drizzle       # Drizzle ORM adapter
-kick add otel          # OpenTelemetry tracing
-kick add --list        # Show all available packages
-\`\`\`
-
-## Environment Configuration
-
-Edit \`.env\` for environment variables. Access them with \`@Value()\` decorator:
-
-\`\`\`ts
-import { Value } from '@forinda/kickjs-config'
-
-@Service()
-export class ApiService {
-  @Value('API_KEY')
-  private apiKey!: string
-
-  @Value('PORT', 3000)  // With default
-  private port!: number
-}
-\`\`\`
-
-Or use \`ConfigService\`:
-
-\`\`\`ts
-import { ConfigService } from '@forinda/kickjs-config'
-
-@Service()
-export class AppService {
-  @Autowired()
-  private config!: ConfigService
-
-  getPort() {
-    return this.config.get('PORT', 3000)
-  }
-}
-\`\`\`
-
-## Testing
-
-Tests live in \`src/**/*.test.ts\`:
-
-\`\`\`ts
-import { describe, it, expect, beforeEach } from 'vitest'
-import { Container } from '@forinda/kickjs'
-import { createTestApp } from '@forinda/kickjs-testing'
-
-describe('UserController', () => {
-  beforeEach(() => Container.reset())
-
-  it('should return users', async () => {
-    const app = await createTestApp([UserModule])
-    const res = await app.get('/users')
-    expect(res.status).toBe(200)
-  })
-})
-\`\`\`
-
-Run tests:
-- \`${t} run test\` — run all tests
-- \`${t} run test:watch\` — watch mode
-
-## Decorators Reference
-
-### Route Decorators
-- \`@Controller('/path')\` — define controller prefix
-- \`@Get('/'), @Post('/'), @Put('/'), @Delete('/'), @Patch('/')\` — HTTP methods
-- \`@Middleware(fn)\` — attach middleware
-- \`@Public()\` — skip authentication (requires @forinda/kickjs-auth)
-- \`@Roles('admin', 'user')\` — role-based access control
-
-### DI Decorators
-- \`@Module({ controllers, providers, imports })\` — define module
-- \`@Service()\` — singleton service (DI-registered)
-- \`@Repository()\` — repository (semantic alias for @Service)
-- \`@Autowired()\` — property injection
-- \`@Inject('token')\` — token-based injection
-- \`@Value('ENV_VAR')\` — inject config value
-
-${e === "cqrs" ? "### CQRS/Event Decorators\n- `@Job('job-name')` — queue job handler\n- `@Process('queue-name')` — queue processor\n- `@Cron('0 * * * *')` — cron schedule\n- `@WsController('/path')` — WebSocket controller\n- `@Subscribe('event')` — WebSocket event handler\n\n" : ""}${e === "graphql" ? "### GraphQL Decorators\n- `@Resolver()` — GraphQL resolver\n- `@Query()` — GraphQL query\n- `@Mutation()` — GraphQL mutation\n- `@Arg('name')` — resolver argument\n\n" : ""}## Common Pitfalls
-
-1. **Decorators fire at import time** — make sure to import module classes in \`src/modules/index.ts\`
-2. **Tests need \`Container.reset()\`** — call in \`beforeEach\` to isolate DI state
-3. **Always use \`ctx.body\`** — never \`req.body\` directly
-4. **DI requires \`reflect-metadata\`** — already imported in \`src/index.ts\`
-5. **Vite HMR requires proper cleanup** — adapters should implement \`shutdown()\`
-
-## Learn More
-
-- [KickJS Documentation](https://forinda.github.io/kick-js/)
-- [API Reference](https://forinda.github.io/kick-js/api/)
-- [CLI Commands](https://forinda.github.io/kick-js/guide/cli-commands.html)
-- [Decorators Guide](https://forinda.github.io/kick-js/guide/decorators.html)
-`;
-}
-function He(r, e, t) {
-  return `# AGENTS.md — AI Agent Guide for ${r}
-
-This guide helps AI agents (Claude, Copilot, etc.) work effectively on this KickJS application.
-
-## Before You Start
-
-1. Read \`CLAUDE.md\` for project conventions and commands
-2. Run \`${t} install\` to install dependencies
-3. Run \`kick dev\` to verify the app starts
-4. Read the [KickJS documentation](https://forinda.github.io/kick-js/) for framework details
-
-## Where to Find Things
-
-### Application Structure
-
-| What | Where |
-|------|-------|
-| Entry point | \`src/index.ts\` |
-| Module registry | \`src/modules/index.ts\` |
-| Feature modules | \`src/modules/<module-name>/\` |
-${e === "graphql" ? "| GraphQL resolvers | `src/resolvers/` |\n" : ""}| Environment config | \`.env\` |
-| TypeScript config | \`tsconfig.json\` |
-| Vite config (HMR) | \`vite.config.ts\` |
-| Vitest config | \`vitest.config.ts\` |
-| Prettier config | \`.prettierrc\` |
-| CLI config | \`kick.config.ts\` |
-
-### Module Pattern (${e.toUpperCase()})
-
-Each module in \`src/modules/<name>/\` typically contains:
-
-${e === "ddd" ? `\`\`\`
-<name>/
-├── <name>.controller.ts     # HTTP routes (@Controller)
-├── <name>.service.ts        # Business logic (@Service)
-├── <name>.repository.ts     # Data access (@Repository)
-├── <name>.dto.ts            # Request/response schemas (Zod)
-├── <name>.entity.ts         # Domain entity (optional)
-└── <name>.module.ts         # Module definition (@Module)
-\`\`\`
-` : e === "cqrs" ? `\`\`\`
-<name>/
-├── commands/                # Write operations
-│   ├── create-<name>.command.ts
-│   └── create-<name>.handler.ts
-├── queries/                 # Read operations
-│   ├── get-<name>.query.ts
-│   └── get-<name>.handler.ts
-├── events/                  # Domain events
-│   └── <name>-created.event.ts
-├── <name>.controller.ts     # HTTP routes
-├── <name>.repository.ts     # Data access
-└── <name>.module.ts         # Module definition
-\`\`\`
-` : e === "graphql" ? "```\nresolvers/\n├── <name>.resolver.ts       # @Resolver, @Query, @Mutation\n├── <name>.types.ts          # GraphQL type definitions\n└── <name>.service.ts        # Business logic\n```\n" : e === "rest" ? `\`\`\`
-<name>/
-├── <name>.controller.ts     # HTTP routes (@Controller)
-├── <name>.service.ts        # Business logic (@Service)
-├── <name>.dto.ts            # Request/response schemas (Zod)
-└── <name>.module.ts         # Module definition (@Module)
-\`\`\`
-` : "```\nsrc/\n├── index.ts                 # Add routes here\n└── ...                      # Custom structure\n```\n"}
-
-## Checklist: Adding a Feature
-
-### New Module (Recommended)
-
-Use the CLI generator for consistency:
-
-\`\`\`bash
-kick g module <name>              # Generate full module
-# or
-kick g scaffold <name> <fields>   # Generate CRUD from fields
-\`\`\`
-
-Then:
-- [ ] Review generated files in \`src/modules/<name>/\`
-- [ ] Verify module is registered in \`src/modules/index.ts\`
-- [ ] Update DTOs in \`<name>.dto.ts\` if needed
-- [ ] Implement business logic in \`<name>.service.ts\`
-- [ ] Run \`kick dev\` to test with HMR
-- [ ] Write tests in \`<name>.test.ts\`
-
-### Manual Controller
-
-If not using generators:
-
-- [ ] Create \`src/modules/<name>/<name>.controller.ts\`
-- [ ] Add \`@Controller('/path')\` decorator
-- [ ] Add route handlers with \`@Get()\`, \`@Post()\`, etc.
-- [ ] Create module file with \`@Module({ controllers: [NameController] })\`
-- [ ] Register module in \`src/modules/index.ts\`
-- [ ] Test with \`kick dev\`
-
-### Manual Service
-
-- [ ] Create \`src/modules/<name>/<name>.service.ts\`
-- [ ] Add \`@Service()\` decorator
-- [ ] Inject dependencies with \`@Autowired()\`
-- [ ] Register in module \`providers\` array
-- [ ] Write unit tests
-
-### New Middleware
-
-- [ ] Create \`src/middleware/<name>.middleware.ts\`
-- [ ] Export middleware function (Express format)
-- [ ] Register in \`src/index.ts\` or attach to routes with \`@Middleware()\`
-- [ ] Test with sample requests
-
-### Adding a Package
-
-Use \`kick add\` to install KickJS packages with correct peer dependencies:
-
-- [ ] Run \`kick add <package>\` (e.g., \`kick add auth\`)
-- [ ] Follow package-specific setup in terminal output
-- [ ] Update \`src/index.ts\` to register adapter (if needed)
-- [ ] Configure environment variables in \`.env\`
-- [ ] Test integration with \`kick dev\`
-
-## Common Tasks
-
-### Generate CRUD Module
-
-\`\`\`bash
-kick g scaffold user name:string email:string age:number
-\`\`\`
-
-This creates a full CRUD module with:
-- Controller with GET, POST, PUT, DELETE routes
-- Service with business logic
-- Repository with data access
-- DTOs with Zod validation
-
-### Add Authentication
-
-\`\`\`bash
-kick add auth
-\`\`\`
-
-Then configure in \`src/index.ts\`:
-
-\`\`\`ts
-import { AuthAdapter, JwtStrategy } from '@forinda/kickjs-auth'
-
-bootstrap({
-  modules,
-  adapters: [
-    new AuthAdapter({
-      strategies: [new JwtStrategy({ secret: process.env.JWT_SECRET! })],
-    }),
-  ],
-})
-\`\`\`
-
-### Add Database (Prisma)
-
-\`\`\`bash
-kick add prisma
-${t} install prisma @prisma/client
-npx prisma init
-# Edit prisma/schema.prisma
-npx prisma migrate dev --name init
-kick g module user --repo prisma
-\`\`\`
-
-### Add WebSocket Support
-
-\`\`\`bash
-kick add ws
-\`\`\`
-
-Then add adapter in \`src/index.ts\`:
-
-\`\`\`ts
-import { WsAdapter } from '@forinda/kickjs-ws'
-
-bootstrap({
-  modules,
-  adapters: [new WsAdapter()],
-})
-\`\`\`
-
-Create WebSocket controller:
-
-\`\`\`bash
-kick g controller chat --ws
-\`\`\`
-
-## Testing Guidelines
-
-All tests use Vitest:
-
-\`\`\`ts
-import { describe, it, expect, beforeEach } from 'vitest'
-import { Container } from '@forinda/kickjs'
-import { createTestApp } from '@forinda/kickjs-testing'
-
-describe('UserController', () => {
-  beforeEach(() => {
-    Container.reset()  // Important: isolate DI state
-  })
-
-  it('should return users', async () => {
-    const app = await createTestApp([UserModule])
-    const res = await app.get('/users')
-    
-    expect(res.status).toBe(200)
-    expect(res.body).toHaveProperty('users')
-  })
-})
-\`\`\`
-
-Run tests:
-- \`${t} run test\` — run all tests once
-- \`${t} run test:watch\` — watch mode
-- Individual file: \`${t} run test src/modules/user/user.test.ts\`
-
-## Environment Variables
-
-Managed via \`.env\` file. Access with:
-
-1. **@Value() decorator** (recommended):
-\`\`\`ts
-@Value('DATABASE_URL')
-private dbUrl!: string
-\`\`\`
-
-2. **ConfigService** (for dynamic access):
-\`\`\`ts
-@Autowired()
-private config!: ConfigService
-
-const port = this.config.get('PORT', 3000)
-\`\`\`
-
-3. **Direct access** (avoid in app code):
-\`\`\`ts
-process.env.PORT
-\`\`\`
-
-## Key Decorators
-
-### HTTP Routes
-| Decorator | Purpose |
-|-----------|---------|
-| \`@Controller('/path')\` | Define route prefix |
-| \`@Get('/'), @Post('/')\` | HTTP method handlers |
-| \`@Middleware(fn)\` | Attach middleware |
-| \`@Public()\` | Skip auth (requires auth adapter) |
-| \`@Roles('admin')\` | Role-based access |
-
-### Dependency Injection
-| Decorator | Purpose |
-|-----------|---------|
-| \`@Module({})\` | Define feature module |
-| \`@Service()\` | Register singleton service |
-| \`@Repository()\` | Register repository |
-| \`@Autowired()\` | Property injection |
-| \`@Inject('token')\` | Token-based injection |
-| \`@Value('VAR')\` | Inject env variable |
-
-${e === "graphql" ? "### GraphQL\n| Decorator | Purpose |\n|-----------|---------|\n| `@Resolver()` | GraphQL resolver class |\n| `@Query()` | Query handler |\n| `@Mutation()` | Mutation handler |\n| `@Arg('name')` | Resolver argument |\n\n" : ""}${e === "cqrs" ? "### Background Jobs\n| Decorator | Purpose |\n|-----------|---------|\n| `@Job('name')` | Queue job handler |\n| `@Process('queue')` | Queue processor |\n| `@Cron('0 * * * *')` | Cron schedule |\n| `@WsController()` | WebSocket controller |\n\n" : ""}## Common Pitfalls
-
-1. **Forgot to register module** — Add to \`src/modules/index.ts\` exports array
-2. **DI not working** — Ensure \`reflect-metadata\` is imported in \`src/index.ts\`
-3. **Tests failing randomly** — Missing \`Container.reset()\` in \`beforeEach\`
-4. **Routes not found** — Check controller path and module registration
-5. **HMR not working** — Verify \`vite.config.ts\` has \`hmr: true\`
-6. **Decorators not working** — Check \`tsconfig.json\` has \`experimentalDecorators: true\`
-
-## CLI Commands Reference
-
-| Command | Description |
-|---------|-------------|
-| \`kick dev\` | Dev server with HMR |
-| \`kick dev:debug\` | Dev server with debugger |
-| \`kick build\` | Production build |
-| \`kick start\` | Run production build |
-| \`kick g module <names...>\` | Generate one or more modules |
-| \`kick g scaffold <name> <fields>\` | Generate CRUD |
-| \`kick g controller <name>\` | Generate controller |
-| \`kick g service <name>\` | Generate service |
-| \`kick g middleware <name>\` | Generate middleware |
-| \`kick add <package>\` | Add KickJS package |
-| \`kick add --list\` | List available packages |
-| \`kick rm module <names...>\` | Remove one or more modules |
-
-> **Note:** When using \`kick new\` in scripts or CI, pass \`-t\` (or \`--template\`) and \`-r\` (or \`--repo\`) flags to bypass interactive prompts:
-> \`\`\`bash
-> kick new my-api -t ddd -r prisma --pm ${t} --no-git --no-install -f
-> \`\`\`
-
-## Learn More
-
-- [KickJS Docs](https://forinda.github.io/kick-js/)
-- [CLI Reference](https://forinda.github.io/kick-js/api/cli.html)
-- [Decorators Guide](https://forinda.github.io/kick-js/guide/decorators.html)
-- [DI System](https://forinda.github.io/kick-js/guide/dependency-injection.html)
-- [Testing](https://forinda.github.io/kick-js/api/testing.html)
-`;
-}
-var Ke = Q(oe(import.meta.url)), V = JSON.parse(re(p(Ke, "..", "package.json"), "utf-8")), Je = `^${V.version}`;
-async function mt(r) {
-  const { name: e, directory: t, packageManager: o = "pnpm", template: s = "rest", defaultRepo: i = "inmemory" } = r, n = t, a = (u) => console.log(`  ${u}`);
-  if (console.log(`
-  Creating KickJS project: ${e}
-`), await l(p(n, "package.json"), je(e, s, Je)), await l(p(n, "vite.config.ts"), Ee()), await l(p(n, "tsconfig.json"), Ue()), await l(p(n, ".prettierrc"), Me()), await l(p(n, ".editorconfig"), qe()), await l(p(n, ".gitignore"), ze()), await l(p(n, ".gitattributes"), _e()), await l(p(n, ".env"), Ge()), await l(p(n, ".env.example"), Qe()), await l(p(n, "src/index.ts"), Le(e, s, V.version)), await l(p(n, "src/modules/index.ts"), Ne()), s === "graphql" && await l(p(n, "src/resolvers/.gitkeep"), ""), await l(p(n, "kick.config.ts"), We(s, i)), await l(p(n, "vitest.config.ts"), Fe()), await l(p(n, "README.md"), Be(e, s, o)), await l(p(n, "CLAUDE.md"), Ye(e, s, o)), await l(p(n, "AGENTS.md"), He(e, s, o)), r.initGit) try {
-    R("git init", {
-      cwd: n,
-      stdio: "pipe"
-    }), R("git branch -M main", {
-      cwd: n,
-      stdio: "pipe"
-    }), R("git add -A", {
-      cwd: n,
-      stdio: "pipe"
-    }), R('git commit -m "chore: initial commit from kick new"', {
-      cwd: n,
-      stdio: "pipe"
-    }), a("Git repository initialized");
-  } catch {
-    a("Warning: git init failed (git may not be installed)");
-  }
-  if (r.installDeps) {
-    console.log(`
-  Installing dependencies with ${o}...
-`);
-    try {
-      R(`${o} install`, {
-        cwd: n,
-        stdio: "inherit"
-      }), console.log(`
-  Dependencies installed successfully!`);
-    } catch {
-      console.log(`
-  Warning: ${o} install failed. Run it manually.`);
-    }
-  }
-  console.log(`
-  Project scaffolded successfully!`), console.log();
-  const c = n !== process.cwd();
-  a("Next steps:"), c && a(`  cd ${e}`), r.installDeps || a(`  ${o} install`);
-  const d = {
-    rest: "kick g module user",
-    graphql: "kick g resolver user",
-    ddd: "kick g module user --repo drizzle",
-    cqrs: "kick g module user --pattern cqrs",
-    minimal: "# add your routes to src/index.ts"
-  };
-  a(`  ${d[s] ?? d.rest}`), a("  kick dev"), a(""), a("Commands:"), a("  kick dev                  Start dev server with Vite HMR"), a("  kick build                Production build via Vite"), a("  kick start                Run production build"), a(""), a("Generators:"), a("  kick g module <name>      Full DDD module (controller, DTOs, use-cases, repo)"), a("  kick g scaffold <n> <f..> CRUD module from field definitions"), a("  kick g controller <name>  Standalone controller"), a("  kick g service <name>     @Service() class"), a("  kick g middleware <name>   Express middleware"), a("  kick g guard <name>       Route guard (auth, roles, etc.)"), a("  kick g adapter <name>     AppAdapter with lifecycle hooks"), a("  kick g dto <name>         Zod DTO schema"), s === "graphql" && a("  kick g resolver <name>    GraphQL resolver"), s === "cqrs" && a("  kick g job <name>         Queue job processor"), a("  kick g config             Generate kick.config.ts"), a(""), a("Add packages:"), a("  kick add <pkg>            Install a KickJS package + peers"), a("  kick add --list           Show all available packages"), a(""), a("Available: auth, swagger, graphql, drizzle, prisma, ws,"), a("           cron, queue, mailer, otel, multi-tenant, notifications, testing"), a("");
-}
-var G = [
-  "drizzle",
-  "inmemory",
-  "prisma"
-];
-function ft(r) {
-  return r;
-}
-function $t(r) {
-  if (!r) return {};
-  const e = {
-    dir: r.modules?.dir ?? r.modulesDir,
-    repo: r.modules?.repo ?? r.defaultRepo,
-    schemaDir: r.modules?.schemaDir ?? r.schemaDir,
-    pluralize: r.modules?.pluralize ?? r.pluralize,
-    prismaClientPath: r.modules?.prismaClientPath
-  };
-  return e.repo && typeof e.repo == "string" && !G.includes(e.repo) && console.warn(`  Warning: modules.repo '${e.repo}' is not a built-in type (${G.join(", ")}). It will generate a stub repository. Use { name: '${e.repo}' } to silence this warning.`), e;
-}
-var Ve = [
-  "kick.config.ts",
-  "kick.config.js",
-  "kick.config.mjs",
-  "kick.config.json"
-];
-async function yt(r) {
-  for (const e of Ve) {
-    const t = p(r, e);
-    try {
-      await F(t);
-    } catch {
-      continue;
-    }
-    if (e.endsWith(".json")) {
-      const o = await L(t, "utf-8");
-      return JSON.parse(o);
-    }
-    try {
-      const { pathToFileURL: o } = await import("node:url"), s = await import(o(t).href);
-      return s.default ?? s;
-    } catch {
-      e.endsWith(".ts") && console.warn(`Warning: Failed to load ${e}. TypeScript config files require a runtime loader (e.g. tsx, ts-node) or use kick.config.js/.mjs instead.`);
-      continue;
-    }
-  }
-  return null;
-}
-export {
-  g as _,
-  ut as a,
-  l as b,
-  dt as c,
-  at as d,
-  it as f,
-  y as g,
-  T as h,
-  mt as i,
-  ct as l,
-  se as m,
-  yt as n,
-  lt as o,
-  Y as p,
-  $t as r,
-  pt as s,
-  ft as t,
-  nt as u,
-  B as v,
-  st as y
-};