@forinda/kickjs-cli 1.3.1 → 1.4.0

package/dist/config-11ag0rJc.js

@@ -0,0 +1,3097 @@
+import { dirname as Q, join as p, resolve as x } 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 w } 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 h(r) {
+  return r.replace(/[-_\s]+(.)?/g, (e, t) => t ? t.toUpperCase() : "").replace(/^(.)/, (e) => e.toUpperCase());
+}
+function P(r) {
+  const e = h(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-core'
+import { buildRoutes } from '@forinda/kickjs-http'
+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-core'
+import { buildRoutes } from '@forinda/kickjs-http'
+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-core'
+import { buildRoutes } from '@forinda/kickjs-http'
+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-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+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-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+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-core'
+
+export const ${e.toUpperCase()}_QUERY_CONFIG: QueryParamsConfig = {
+  filterable: ['name'],
+  sortable: ['name', 'createdAt'],
+  searchable: ['name'],
+}
+`;
+}
+function T(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 O(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 I(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-core'
+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-core'
+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-core'
+import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../../domain/repositories/${t}.repository'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+
+@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-core'
+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-core'
+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 S(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-http'
+
+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 A(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-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+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-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+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-core'
+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-core'
+
+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 he(r) {
+  const { pascal: e, kebab: t } = r;
+  return `import { Service, Inject, HttpException } from '@forinda/kickjs-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+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-http'
+
+export const ${e.toUpperCase()}_QUERY_CONFIG: QueryFieldConfig = {
+  filterable: ['name'],
+  sortable: ['name', 'createdAt'],
+  searchable: ['name'],
+}
+`;
+}
+function ge(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-core'
+import { buildRoutes } from '@forinda/kickjs-http'
+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-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+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-core'
+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-core'
+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-core'
+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-core'
+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-core'
+import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../${t}.repository'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+
+@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-core'
+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-core'
+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-core'
+import { DRIZZLE_DB, DrizzleQueryAdapter } from '@forinda/kickjs-drizzle'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+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-core'
+import { PRISMA_CLIENT, type PrismaModelDelegate } from '@forinda/kickjs-prisma'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+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-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+
+@Controller()
+export class ${e}Controller {
+  @Get('/')
+  async list(ctx: RequestContext) {
+    ctx.json({ message: '${e} list' })
+  }
+}
+`);
+}
+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", 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`, he({
+    pascal: e,
+    kebab: t
+  })), await c(`dtos/create-${t}.dto.ts`, T({
+    pascal: e,
+    kebab: t
+  })), await c(`dtos/update-${t}.dto.ts`, O({
+    pascal: e,
+    kebab: t
+  })), await c(`dtos/${t}-response.dto.ts`, I({
+    pascal: e,
+    kebab: t
+  })), await c(`${t}.repository.ts`, S({
+    pascal: e,
+    kebab: t,
+    dtoPrefix: "./dtos"
+  }));
+  const d = {
+    inmemory: `in-memory-${t}`,
+    drizzle: `drizzle-${t}`,
+    prisma: `prisma-${t}`
+  }, u = {
+    inmemory: () => A({
+      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 || (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 xe(r) {
+  const { pascal: e, kebab: t, plural: o, pluralPascal: s, repo: i, noTests: n, prismaClientPath: a, write: c } = r;
+  await c("index.ts", ge({
+    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`, T({
+    pascal: e,
+    kebab: t
+  })), await c(`dtos/update-${t}.dto.ts`, O({
+    pascal: e,
+    kebab: t
+  })), await c(`dtos/${t}-response.dto.ts`, I({
+    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`, S({
+    pascal: e,
+    kebab: t,
+    dtoPrefix: "./dtos"
+  }));
+  const f = {
+    inmemory: `in-memory-${t}`,
+    drizzle: `drizzle-${t}`,
+    prisma: `prisma-${t}`
+  }, v = {
+    inmemory: () => A({
+      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}`, g = v[i] ?? (() => j({
+    pascal: e,
+    kebab: t,
+    repoType: i,
+    repoPrefix: ".",
+    dtoPrefix: "./dtos"
+  }));
+  await c(`${k}.repository.ts`, g()), n || (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`, T({
+    pascal: e,
+    kebab: t
+  })), await d(`application/dtos/update-${t}.dto.ts`, O({
+    pascal: e,
+    kebab: t
+  })), await d(`application/dtos/${t}-response.dto.ts`, I({
+    pascal: e,
+    kebab: t
+  }));
+  const u = me({
+    pascal: e,
+    kebab: t,
+    plural: o,
+    pluralPascal: s
+  });
+  for (const g of u) await d(`application/use-cases/${g.file}`, g.content);
+  await d(`domain/repositories/${t}.repository.ts`, S({
+    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: () => A({
+      pascal: e,
+      kebab: t
+    }),
+    drizzle: () => M({
+      pascal: e,
+      kebab: t
+    }),
+    prisma: () => q({
+      pascal: e,
+      kebab: t,
+      prismaClientPath: c
+    })
+  }, v = m[i] ?? `${y(i)}-${t}`, k = f[i] ?? (() => j({
+    pascal: e,
+    kebab: t,
+    repoType: i
+  }));
+  await d(`infrastructure/repositories/${v}.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 || (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 = h(e), f = c ? Y(u) : u, v = c ? se(m) : m, k = p(t, f), g = [];
+  let $ = n ?? !1;
+  const Z = async (D, X) => {
+    const b = p(k, D);
+    if (a) {
+      g.push(b);
+      return;
+    }
+    if (!$ && await B(b)) {
+      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(b, X), g.push(b);
+  }, C = {
+    kebab: u,
+    pascal: m,
+    plural: f,
+    pluralPascal: v,
+    moduleDir: k,
+    repo: i,
+    noEntity: o ?? !1,
+    noTests: s ?? !1,
+    prismaClientPath: r.prismaClientPath ?? "@prisma/client",
+    write: Z,
+    files: g
+  };
+  switch (d) {
+    case "minimal":
+      await be(C);
+      break;
+    case "rest":
+      await De(C);
+      break;
+    case "cqrs":
+      await xe(C);
+      break;
+    default:
+      await Pe(C);
+      break;
+  }
+  return a || await Oe(t, m, f), g;
+}
+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-core'
+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 = h(e), i = [], n = p(t, `${o}.adapter.ts`);
+  return await l(n, `import type { Express } from 'express'
+import type { AppAdapter, AdapterMiddleware, Container } from '@forinda/kickjs-core'
+
+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: Express, container: Container): 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(app: Express, container: Container): 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: any, container: Container): 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 R(r) {
+  const { type: e, outDir: t, moduleName: o, modulesDir: s = "src/modules", defaultDir: i, pattern: n = "ddd" } = r;
+  if (t) return x(t);
+  if (o) {
+    const a = n === "ddd" ? Ie : n === "cqrs" ? Ae : Se, c = Y(y(o)), d = a[e] ?? "", u = p(s, c);
+    return x(d ? p(u, d) : u);
+  }
+  return x(i);
+}
+async function ct(r) {
+  const { name: e, moduleName: t, modulesDir: o, pattern: s } = r, i = R({
+    type: "middleware",
+    outDir: r.outDir,
+    moduleName: t,
+    modulesDir: o,
+    defaultDir: "src/middleware",
+    pattern: s
+  }), n = y(e), a = P(e), c = [], d = p(i, `${n}.middleware.ts`);
+  return await l(d, `import type { Request, Response, NextFunction } from 'express'
+
+export interface ${h(e)}Options {
+  // Add configuration options here
+}
+
+/**
+ * ${h(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: ${h(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 = R({
+    type: "guard",
+    outDir: r.outDir,
+    moduleName: t,
+    modulesDir: o,
+    defaultDir: "src/guards",
+    pattern: s
+  }), n = y(e), a = P(e), c = h(e), d = [], u = p(i, `${n}.guard.ts`);
+  return await l(u, `import { Container, HttpException } from '@forinda/kickjs-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+
+/**
+ * ${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 = R({
+    type: "service",
+    outDir: r.outDir,
+    moduleName: t,
+    modulesDir: o,
+    defaultDir: "src/services",
+    pattern: s
+  }), n = y(e), a = h(e), c = [], d = p(i, `${n}.service.ts`);
+  return await l(d, `import { Service } from '@forinda/kickjs-core'
+
+@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 = R({
+    type: "controller",
+    outDir: r.outDir,
+    moduleName: t,
+    modulesDir: o,
+    defaultDir: "src/controllers",
+    pattern: s
+  }), n = y(e), a = h(e), c = [], d = p(i, `${n}.controller.ts`);
+  return await l(d, `import { Controller, Get, Post, Autowired } from '@forinda/kickjs-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+
+@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 = R({
+    type: "dto",
+    outDir: r.outDir,
+    moduleName: t,
+    modulesDir: o,
+    defaultDir: "src/dtos",
+    pattern: s
+  }), n = y(e), a = h(e), c = P(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-core": t,
+    "@forinda/kickjs-http": 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": "^24.5.2",
+      "unplugin-swc": "^1.5.9",
+      vite: "^8.0.2",
+      vitest: "^3.2.4",
+      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-http'
+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-http'
+import { DevToolsAdapter } from '@forinda/kickjs-devtools'
+import { SwaggerAdapter } from '@forinda/kickjs-swagger'
+import { OtelAdapter } from '@forinda/kickjs-otel'
+// import { WsAdapter } from '@forinda/kickjs-ws'
+// import { QueueAdapter, BullMQProvider } from '@forinda/kickjs-queue'
+import { modules } from './modules'
+
+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-http'
+import { modules } from './modules'
+
+bootstrap({ modules })
+`;
+    default:
+      return `import 'reflect-metadata'
+import { bootstrap } from '@forinda/kickjs-http'
+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-core'
+
+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-http'
+
+@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-core'
+
+@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-core'
+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-core'
+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-core'
+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 {
+    w("git init", {
+      cwd: n,
+      stdio: "pipe"
+    }), w("git branch -M main", {
+      cwd: n,
+      stdio: "pipe"
+    }), w("git add -A", {
+      cwd: n,
+      stdio: "pipe"
+    }), w('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 {
+      w(`${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 {
+  h as _,
+  ut as a,
+  l as b,
+  dt as c,
+  at as d,
+  it as f,
+  y as g,
+  P 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
+};