@forinda/kickjs-cli 5.11.0 → 6.0.0

package/dist/doctor-Cin9GYv9.mjs

@@ -1,2076 +0,0 @@
-/**
- * @forinda/kickjs-cli v5.11.0
- *
- * Copyright (c) Felix Orinda
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @license MIT
- */
-import{b as e,c as t,d as n,g as r,l as i,o as a,s as o,v as s}from"./project-docs-CjnHf0Wd.mjs";import{i as c}from"./config-DW9HQc2u.mjs";import{t as l}from"./project-root-SRoIXPwv.mjs";import{createRequire as u}from"node:module";import{dirname as d,join as f,relative as p,resolve as m}from"node:path";import{existsSync as h,readFileSync as g,readdirSync as _,statSync as v}from"node:fs";import{readFile as y,writeFile as b}from"node:fs/promises";import x from"pluralize";import{execFileSync as S,execSync as C}from"node:child_process";import{fileURLToPath as ee,pathToFileURL as te}from"node:url";function w(e){return e.replace(/[-_\s]+(.)?/g,(e,t)=>t?t.toUpperCase():``).replace(/^(.)/,e=>e.toUpperCase())}function T(e){let t=w(e);return t.charAt(0).toLowerCase()+t.slice(1)}function E(e){return e.replace(/([a-z])([A-Z])/g,`$1-$2`).replace(/[\s_]+/g,`-`).toLowerCase()}function D(e){return x.plural(e)}function O(e){return x.plural(e)}function k(e){return e.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`)}const ne={inmemory:`in-memory`,drizzle:`Drizzle`,prisma:`Prisma`};function A(e){return e.charAt(0).toUpperCase()+e.slice(1).replace(/-([a-z])/g,(e,t)=>t.toUpperCase())}function re(e){return e.replace(/([a-z])([A-Z])/g,`$1-$2`).toLowerCase()}function j(e){return ne[e]??A(e)}function M(e,t,n){let r={inmemory:`InMemory${e}Repository`,drizzle:`Drizzle${e}Repository`,prisma:`Prisma${e}Repository`},i={inmemory:`in-memory-${t}`,drizzle:`drizzle-${t}`,prisma:`prisma-${t}`};return{repoClass:r[n]??`${A(n)}${e}Repository`,repoFile:i[n]??`${re(n)}-${t}`}}function N(e){return e??`define`}function ie(e){let{pascal:t,kebab:n,plural:r=``,repo:i,style:a}=e,{repoClass:o,repoFile:s}=M(t,n,i),c=N(a),l=`/**
- * ${t} 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 ${j(i)})
- */`,u=`import { ${t.toUpperCase()}_REPOSITORY } from './domain/repositories/${n}.repository'
-import { ${o} } from './infrastructure/repositories/${s}.repository'
-import { ${t}Controller } from './presentation/${n}.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 },
-)`,d=`    /**
-     * Declare HTTP routes for this module. Return value shape:
-     *
-     *   - \`path\`        — URL prefix for this route set, mounted under
-     *                     \`/{apiPrefix}/v{version}{path}\`.
-     *   - \`controller\`  — Controller class. Used both for the route
-     *                     handler bindings and OpenAPI spec generation.
-     *   - \`version\`     — Optional. Overrides the app-wide API version
-     *                     for this route set only.
-     *
-     * Return an **array** to mount multiple route sets under the
-     * same module (e.g. side-by-side v1 + v2 controllers):
-     *
-     *   return [
-     *     { path: '/${r}', version: 1, controller: ${t}V1Controller },
-     *     { path: '/${r}', version: 2, controller: ${t}V2Controller },
-     *   ]
-     */`;return c===`class`?`${l}
-import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-${u}
-
-export class ${t}Module implements AppModule {
-  /**
-   * Register module dependencies in the DI container.
-   * Bind repository interface tokens to their implementations here.
-   * Currently wired to ${j(i)}. To swap implementations, change the factory target.
-   */
-  register(container: Container): void {
-    container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-      container.resolve(${o}),
-    )
-  }
-
-${d.replace(/^ {4}/gm,`  `).replace(/^ {6}/gm,`    `)}
-  routes(): ModuleRoutes {
-    return {
-      path: '/${r}',
-      controller: ${t}Controller,
-    }
-  }
-}
-`:`${l}
-import { defineModule } from '@forinda/kickjs'
-${u}
-
-export const ${t}Module = defineModule({
-  name: '${t}Module',
-  build: () => ({
-    /**
-     * Register module dependencies in the DI container.
-     * Bind repository interface tokens to their implementations here.
-     * Currently wired to ${j(i)}. To swap implementations, change the factory target.
-     */
-    register(container) {
-      container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-        container.resolve(${o}),
-      )
-    },
-
-${d}
-    routes() {
-      return {
-        path: '/${r}',
-        controller: ${t}Controller,
-      }
-    },
-  }),
-})
-`}function ae(e){let{pascal:t,kebab:n,plural:r=``,repo:i,style:a}=e,{repoClass:o,repoFile:s}=M(t,n,i),c=N(a),l=`/**
- * ${t} Module
- *
- * REST module with a flat folder structure.
- * Controller delegates to service, service wraps the repository.
- *
- * Structure:
- *   ${n}.controller.ts  — HTTP routes (CRUD)
- *   ${n}.service.ts     — Business logic
- *   ${n}.repository.ts  — Repository interface
- *   ${s}.repository.ts — Repository implementation
- *   dtos/                   — Request/response schemas
- */`,u=`import { ${t.toUpperCase()}_REPOSITORY } from './${n}.repository'
-import { ${o} } from './${s}.repository'
-import { ${t}Controller } from './${n}.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 })`,d=`    /**
-     * Declare HTTP routes for this module. Return value shape:
-     *
-     *   - \`path\`        — URL prefix for this route set.
-     *   - \`controller\`  — Controller class (also drives OpenAPI).
-     *   - \`version\`     — Optional. Overrides the app-wide API version.
-     *
-     * Return an **array** to mount multiple route sets — admin
-     * surfaces, side-by-side v1 + v2 controllers, etc:
-     *
-     *   return [
-     *     { path: '/${r}', version: 1, controller: ${t}V1Controller },
-     *     { path: '/${r}', version: 2, controller: ${t}V2Controller },
-     *   ]
-     */`;return c===`class`?`${l}
-import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-${u}
-
-export class ${t}Module implements AppModule {
-  register(container: Container): void {
-    container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-      container.resolve(${o}),
-    )
-  }
-
-${d.replace(/^ {4}/gm,`  `).replace(/^ {6}/gm,`    `)}
-  routes(): ModuleRoutes {
-    return {
-      path: '/${r}',
-      controller: ${t}Controller,
-    }
-  }
-}
-`:`${l}
-import { defineModule } from '@forinda/kickjs'
-${u}
-
-export const ${t}Module = defineModule({
-  name: '${t}Module',
-  build: () => ({
-    register(container) {
-      container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-        container.resolve(${o}),
-      )
-    },
-
-${d}
-    routes() {
-      return {
-        path: '/${r}',
-        controller: ${t}Controller,
-      }
-    },
-  }),
-})
-`}function oe(e){let{pascal:t,kebab:n,plural:r=``,style:i}=e,a=N(i),o=`    /**
-     * Declare HTTP routes. Return value shape:
-     *
-     *   - \`path\`        — URL prefix for this route set.
-     *   - \`controller\`  — Controller class (also drives OpenAPI).
-     *   - \`version\`     — Optional. Overrides the app-wide API version.
-     *
-     * Return an array to mount multiple route sets:
-     *
-     *   return [
-     *     { path: '/${r}', version: 1, controller: ${t}V1Controller },
-     *     { path: '/${r}', version: 2, controller: ${t}V2Controller },
-     *   ]
-     */`;return a===`class`?`import { type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-import { ${t}Controller } from './${n}.controller'
-
-export class ${t}Module implements AppModule {
-${o.replace(/^ {4}/gm,`  `).replace(/^ {6}/gm,`    `)}
-  routes(): ModuleRoutes {
-    return {
-      path: '/${r}',
-      controller: ${t}Controller,
-    }
-  }
-}
-`:`import { defineModule } from '@forinda/kickjs'
-import { ${t}Controller } from './${n}.controller'
-
-export const ${t}Module = defineModule({
-  name: '${t}Module',
-  build: () => ({
-${o}
-    routes() {
-      return {
-        path: '/${r}',
-        controller: ${t}Controller,
-      }
-    },
-  }),
-})
-`}function se(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return`import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams, type Ctx } from '@forinda/kickjs'
-import { ApiTags } from '@forinda/kickjs-swagger'
-import { Create${t}UseCase } from '../application/use-cases/create-${n}.use-case'
-import { Get${t}UseCase } from '../application/use-cases/get-${n}.use-case'
-import { List${i}UseCase } from '../application/use-cases/list-${r}.use-case'
-import { Update${t}UseCase } from '../application/use-cases/update-${n}.use-case'
-import { Delete${t}UseCase } from '../application/use-cases/delete-${n}.use-case'
-import { create${t}Schema } from '../application/dtos/create-${n}.dto'
-import { update${t}Schema } from '../application/dtos/update-${n}.dto'
-import { ${t.toUpperCase()}_QUERY_CONFIG } from '../constants'
-
-// Each handler annotates its \`ctx\` with \`Ctx<KickRoutes.${t}Controller['<method>']>\`
-// so \`ctx.params\`, \`ctx.body\`, and \`ctx.query\` are typed end-to-end.
-// The \`KickRoutes\` namespace is generated by \`kick typegen\` (auto-run on
-// \`kick dev\`) — see https://forinda.github.io/kick-js/guide/typegen.
-
-@Controller()
-export class ${t}Controller {
-  @Autowired() private readonly create${t}UseCase!: Create${t}UseCase
-  @Autowired() private readonly get${t}UseCase!: Get${t}UseCase
-  @Autowired() private readonly list${i}UseCase!: List${i}UseCase
-  @Autowired() private readonly update${t}UseCase!: Update${t}UseCase
-  @Autowired() private readonly delete${t}UseCase!: Delete${t}UseCase
-
-  @Get('/')
-  @ApiTags('${t}')
-  @ApiQueryParams(${t.toUpperCase()}_QUERY_CONFIG)
-  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
-    return ctx.paginate(
-      (parsed) => this.list${i}UseCase.execute(parsed),
-      ${t.toUpperCase()}_QUERY_CONFIG,
-    )
-  }
-
-  @Get('/:id')
-  @ApiTags('${t}')
-  async getById(ctx: Ctx<KickRoutes.${t}Controller['getById']>) {
-    const result = await this.get${t}UseCase.execute(ctx.params.id)
-    if (!result) return ctx.notFound('${t} not found')
-    ctx.json(result)
-  }
-
-  @Post('/', { body: create${t}Schema, name: 'Create${t}' })
-  @ApiTags('${t}')
-  async create(ctx: Ctx<KickRoutes.${t}Controller['create']>) {
-    const result = await this.create${t}UseCase.execute(ctx.body)
-    ctx.created(result)
-  }
-
-  @Put('/:id', { body: update${t}Schema, name: 'Update${t}' })
-  @ApiTags('${t}')
-  async update(ctx: Ctx<KickRoutes.${t}Controller['update']>) {
-    const result = await this.update${t}UseCase.execute(ctx.params.id, ctx.body)
-    ctx.json(result)
-  }
-
-  @Delete('/:id')
-  @ApiTags('${t}')
-  async remove(ctx: Ctx<KickRoutes.${t}Controller['remove']>) {
-    await this.delete${t}UseCase.execute(ctx.params.id)
-    ctx.noContent()
-  }
-}
-`}function ce(e){let{pascal:t,kebab:n}=e,r=t.charAt(0).toLowerCase()+t.slice(1);return`import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams, type Ctx } from '@forinda/kickjs'
-import { ApiTags } from '@forinda/kickjs-swagger'
-import { ${t}Service } from './${n}.service'
-import { create${t}Schema } from './dtos/create-${n}.dto'
-import { update${t}Schema } from './dtos/update-${n}.dto'
-import { ${t.toUpperCase()}_QUERY_CONFIG } from './${n}.constants'
-
-// Each handler annotates its \`ctx\` with \`Ctx<KickRoutes.${t}Controller['<method>']>\`
-// so \`ctx.params\`, \`ctx.body\`, and \`ctx.query\` are typed end-to-end.
-// The \`KickRoutes\` namespace is generated by \`kick typegen\` (auto-run on
-// \`kick dev\`) — see https://forinda.github.io/kick-js/guide/typegen.
-
-@Controller()
-export class ${t}Controller {
-  @Autowired() private readonly ${r}Service!: ${t}Service
-
-  @Get('/')
-  @ApiTags('${t}')
-  @ApiQueryParams(${t.toUpperCase()}_QUERY_CONFIG)
-  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
-    return ctx.paginate(
-      (parsed) => this.${r}Service.findPaginated(parsed),
-      ${t.toUpperCase()}_QUERY_CONFIG,
-    )
-  }
-
-  @Get('/:id')
-  @ApiTags('${t}')
-  async getById(ctx: Ctx<KickRoutes.${t}Controller['getById']>) {
-    const result = await this.${r}Service.findById(ctx.params.id)
-    if (!result) return ctx.notFound('${t} not found')
-    ctx.json(result)
-  }
-
-  @Post('/', { body: create${t}Schema, name: 'Create${t}' })
-  @ApiTags('${t}')
-  async create(ctx: Ctx<KickRoutes.${t}Controller['create']>) {
-    const result = await this.${r}Service.create(ctx.body)
-    ctx.created(result)
-  }
-
-  @Put('/:id', { body: update${t}Schema, name: 'Update${t}' })
-  @ApiTags('${t}')
-  async update(ctx: Ctx<KickRoutes.${t}Controller['update']>) {
-    const result = await this.${r}Service.update(ctx.params.id, ctx.body)
-    ctx.json(result)
-  }
-
-  @Delete('/:id')
-  @ApiTags('${t}')
-  async remove(ctx: Ctx<KickRoutes.${t}Controller['remove']>) {
-    await this.${r}Service.delete(ctx.params.id)
-    ctx.noContent()
-  }
-}
-`}function le(e){let{pascal:t}=e;return`import type { QueryParamsConfig } from '@forinda/kickjs'
-
-export const ${t.toUpperCase()}_QUERY_CONFIG: QueryParamsConfig = {
-  filterable: ['name'],
-  sortable: ['name', 'createdAt'],
-  searchable: ['name'],
-}
-`}function P(e){let{pascal:t}=e;return`import { z } from 'zod'
-
-/**
- * Create ${t} DTO — Zod schema for validating POST request bodies.
- * This schema is passed to @Post('/', { body: create${t}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${t}Schema = z.object({
-  name: z.string().min(1, 'Name is required').max(200),
-})
-
-export type Create${t}DTO = z.infer<typeof create${t}Schema>
-`}function F(e){let{pascal:t}=e;return`import { z } from 'zod'
-
-export const update${t}Schema = z.object({
-  name: z.string().min(1).max(200).optional(),
-})
-
-export type Update${t}DTO = z.infer<typeof update${t}Schema>
-`}function I(e){let{pascal:t}=e;return`export interface ${t}ResponseDTO {
-  id: string
-  name: string
-  createdAt: string
-  updatedAt: string
-}
-`}function ue(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return[{file:`create-${n}.use-case.ts`,content:`/**
- * Create ${t} Use Case
- *
- * Application layer — orchestrates a single business operation.
- * Use cases are thin: validate input (via DTO), call domain/repo, return response.
- * Keep business rules in the domain service, not here.
- */
-import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
-import type { Create${t}DTO } from '../dtos/create-${n}.dto'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-
-@Service()
-export class Create${t}UseCase {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    return this.repo.create(dto)
-  }
-}
-`},{file:`get-${n}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-
-@Service()
-export class Get${t}UseCase {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(id: string): Promise<${t}ResponseDTO | null> {
-    return this.repo.findById(id)
-  }
-}
-`},{file:`list-${r}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
-import type { ParsedQuery } from '@forinda/kickjs'
-
-@Service()
-export class List${i}UseCase {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(parsed: ParsedQuery) {
-    return this.repo.findPaginated(parsed)
-  }
-}
-`},{file:`update-${n}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
-import type { Update${t}DTO } from '../dtos/update-${n}.dto'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-
-@Service()
-export class Update${t}UseCase {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    return this.repo.update(id, dto)
-  }
-}
-`},{file:`delete-${n}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
-
-@Service()
-export class Delete${t}UseCase {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(id: string): Promise<void> {
-    await this.repo.delete(id)
-  }
-}
-`}]}function L(e){let{pascal:t,kebab:n,dtoPrefix:r=`../../application/dtos`,tokenScope:i=`app`}=e;return`/**
- * ${t} 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 { createToken } from '@forinda/kickjs'
-import type { ${t}ResponseDTO } from '${r}/${n}-response.dto'
-import type { Create${t}DTO } from '${r}/create-${n}.dto'
-import type { Update${t}DTO } from '${r}/update-${n}.dto'
-import type { ParsedQuery } from '@forinda/kickjs'
-
-export interface I${t}Repository {
-  findById(id: string): Promise<${t}ResponseDTO | null>
-  findAll(): Promise<${t}ResponseDTO[]>
-  findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }>
-  create(dto: Create${t}DTO): Promise<${t}ResponseDTO>
-  update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO>
-  delete(id: string): Promise<void>
-}
-
-/**
- * Collision-safe DI token bound to \`I${t}Repository\`.
- * \`container.resolve(${t.toUpperCase()}_REPOSITORY)\` and
- * \`@Inject(${t.toUpperCase()}_REPOSITORY)\` both return the typed
- * interface — no manual generic, no \`any\` cast.
- *
- * The \`'${i}/'\` prefix matches the project scope so
- * \`kick-lint\`'s \`token-reserved-prefix\` rule never fires —
- * adopters must NOT use the reserved \`'kick/'\` namespace.
- */
-export const ${t.toUpperCase()}_REPOSITORY = createToken<I${t}Repository>('${i}/${t}/repository')
-`}function R(e){let{pascal:t,kebab:n,repoPrefix:r=`../../domain/repositories`,dtoPrefix:i=`../../application/dtos`}=e;return`/**
- * In-Memory ${t} Repository
- *
- * Implements the repository interface using a Map.
- * Useful for prototyping and testing. Replace with a database implementation
- * (Drizzle, Prisma, etc.) for production use.
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { randomUUID } from 'node:crypto'
-import { Repository, HttpException } from '@forinda/kickjs'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${t}Repository } from '${r}/${n}.repository'
-import type { ${t}ResponseDTO } from '${i}/${n}-response.dto'
-import type { Create${t}DTO } from '${i}/create-${n}.dto'
-import type { Update${t}DTO } from '${i}/update-${n}.dto'
-
-@Repository()
-export class InMemory${t}Repository implements I${t}Repository {
-  private store = new Map<string, ${t}ResponseDTO>()
-
-  async findById(id: string): Promise<${t}ResponseDTO | null> {
-    return this.store.get(id) ?? null
-  }
-
-  async findAll(): Promise<${t}ResponseDTO[]> {
-    return Array.from(this.store.values())
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}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${t}DTO): Promise<${t}ResponseDTO> {
-    const now = new Date().toISOString()
-    const entity: ${t}ResponseDTO = {
-      id: randomUUID(),
-      name: dto.name,
-      createdAt: now,
-      updatedAt: now,
-    }
-    this.store.set(entity.id, entity)
-    return entity
-  }
-
-  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    const existing = this.store.get(id)
-    if (!existing) throw HttpException.notFound('${t} 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('${t} not found')
-    this.store.delete(id)
-  }
-}
-`}function z(e){let{pascal:t,kebab:n,repoType:r=``,repoPrefix:i=`../../domain/repositories`,dtoPrefix:a=`../../application/dtos`}=e,o=r.charAt(0).toUpperCase()+r.slice(1).replace(/-([a-z])/g,(e,t)=>t.toUpperCase());return`/**
- * ${o} ${t} Repository
- *
- * Stub implementation for a custom '${r}' repository.
- * Implements the repository interface using an in-memory Map as a placeholder.
- *
- * TODO: Replace the in-memory Map with your ${r} data-access logic.
- * See I${t}Repository for the interface contract.
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { randomUUID } from 'node:crypto'
-import { Repository, HttpException } from '@forinda/kickjs'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${t}Repository } from '${i}/${n}.repository'
-import type { ${t}ResponseDTO } from '${a}/${n}-response.dto'
-import type { Create${t}DTO } from '${a}/create-${n}.dto'
-import type { Update${t}DTO } from '${a}/update-${n}.dto'
-
-@Repository()
-export class ${o}${t}Repository implements I${t}Repository {
-  // TODO: Replace with your ${r} client/connection
-  private store = new Map<string, ${t}ResponseDTO>()
-
-  async findById(id: string): Promise<${t}ResponseDTO | null> {
-    // TODO: Implement with ${r}
-    return this.store.get(id) ?? null
-  }
-
-  async findAll(): Promise<${t}ResponseDTO[]> {
-    // TODO: Implement with ${r}
-    return Array.from(this.store.values())
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }> {
-    // TODO: Implement with ${r}
-    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${t}DTO): Promise<${t}ResponseDTO> {
-    // TODO: Implement with ${r}
-    const now = new Date().toISOString()
-    const entity: ${t}ResponseDTO = {
-      id: randomUUID(),
-      name: dto.name,
-      createdAt: now,
-      updatedAt: now,
-    }
-    this.store.set(entity.id, entity)
-    return entity
-  }
-
-  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    // TODO: Implement with ${r}
-    const existing = this.store.get(id)
-    if (!existing) throw HttpException.notFound('${t} 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 ${r}
-    if (!this.store.has(id)) throw HttpException.notFound('${t} not found')
-    this.store.delete(id)
-  }
-}
-`}function de(e){let{pascal:t,kebab:n}=e;return`/**
- * ${t} Domain Service
- *
- * Domain layer — contains business rules that don't belong to a single entity.
- * Use this for cross-entity logic, validation rules, and domain invariants.
- * Keep it free of HTTP/framework concerns.
- */
-import { Service, Inject, HttpException } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../repositories/${n}.repository'
-
-@Service()
-export class ${t}DomainService {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async ensureExists(id: string): Promise<void> {
-    const entity = await this.repo.findById(id)
-    if (!entity) {
-      throw HttpException.notFound('${t} not found')
-    }
-  }
-}
-`}function fe(e){let{pascal:t,kebab:n}=e;return`/**
- * ${t} 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 { ${t}Id } from '../value-objects/${n}-id.vo'
-
-interface ${t}Props {
-  id: ${t}Id
-  name: string
-  createdAt: Date
-  updatedAt: Date
-}
-
-export class ${t} {
-  private constructor(private props: ${t}Props) {}
-
-  static create(params: { name: string }): ${t} {
-    const now = new Date()
-    return new ${t}({
-      id: ${t}Id.create(),
-      name: params.name,
-      createdAt: now,
-      updatedAt: now,
-    })
-  }
-
-  static reconstitute(props: ${t}Props): ${t} {
-    return new ${t}(props)
-  }
-
-  get id(): ${t}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 pe(e){let{pascal:t}=e;return`/**
- * ${t} ID Value Object
- *
- * Domain layer — wraps a primitive ID with type safety and validation.
- * Value objects are immutable and compared by value, not reference.
- *
- *   ${t}Id.create()    — generate a new UUID
- *   ${t}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 ${t}Id {
-  private constructor(private readonly value: string) {}
-
-  static create(): ${t}Id {
-    return new ${t}Id(randomUUID())
-  }
-
-  static from(id: string): ${t}Id {
-    if (!id || id.trim().length === 0) {
-      throw new Error('${t}Id cannot be empty')
-    }
-    return new ${t}Id(id)
-  }
-
-  toString(): string {
-    return this.value
-  }
-
-  equals(other: ${t}Id): boolean {
-    return this.value === other.value
-  }
-}
-`}function B(e){let{pascal:t,kebab:n,plural:r=``}=e;return`import { describe, it, expect, beforeEach } from 'vitest'
-import { Container } from '@forinda/kickjs'
-
-describe('${t}Controller', () => {
-  beforeEach(() => {
-    Container.reset()
-  })
-
-  it('should be defined', () => {
-    expect(true).toBe(true)
-  })
-
-  describe('POST /${r}', () => {
-    it('should create a new ${n}', async () => {
-      // TODO: Set up test module, call create endpoint, assert 201
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('GET /${r}', () => {
-    it('should return paginated ${r}', async () => {
-      // TODO: Set up test module, call list endpoint, assert { data, meta }
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('GET /${r}/:id', () => {
-    it('should return a ${n} by id', async () => {
-      // TODO: Create a ${n}, then fetch by id, assert match
-      expect(true).toBe(true)
-    })
-
-    it('should return 404 for non-existent ${n}', async () => {
-      // TODO: Fetch non-existent id, assert 404
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('PUT /${r}/:id', () => {
-    it('should update an existing ${n}', async () => {
-      // TODO: Create, update, assert changes
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('DELETE /${r}/:id', () => {
-    it('should delete a ${n}', async () => {
-      // TODO: Create, delete, assert gone
-      expect(true).toBe(true)
-    })
-  })
-})
-`}function V(e){let{pascal:t,kebab:n,plural:r=``,repoPrefix:i=`../infrastructure/repositories/in-memory-${n}.repository`}=e;return`import { describe, it, expect, beforeEach } from 'vitest'
-import { InMemory${t}Repository } from '${i}'
-
-describe('InMemory${t}Repository', () => {
-  let repo: InMemory${t}Repository
-
-  beforeEach(() => {
-    repo = new InMemory${t}Repository()
-  })
-
-  it('should create and retrieve a ${n}', async () => {
-    const created = await repo.create({ name: 'Test ${t}' })
-    expect(created).toBeDefined()
-    expect(created.name).toBe('Test ${t}')
-    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 ${r}', async () => {
-    await repo.create({ name: '${t} 1' })
-    await repo.create({ name: '${t} 2' })
-
-    const all = await repo.findAll()
-    expect(all).toHaveLength(2)
-  })
-
-  it('should return paginated results', async () => {
-    await repo.create({ name: '${t} 1' })
-    await repo.create({ name: '${t} 2' })
-    await repo.create({ name: '${t} 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 ${n}', 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 ${n}', 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 me(e){let{pascal:t,kebab:n}=e;return`import { Service, Inject, HttpException } from '@forinda/kickjs'
-import type { ParsedQuery } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from './${n}.repository'
-import type { ${t}ResponseDTO } from './dtos/${n}-response.dto'
-import type { Create${t}DTO } from './dtos/create-${n}.dto'
-import type { Update${t}DTO } from './dtos/update-${n}.dto'
-
-@Service()
-export class ${t}Service {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async findById(id: string): Promise<${t}ResponseDTO | null> {
-    return this.repo.findById(id)
-  }
-
-  async findAll(): Promise<${t}ResponseDTO[]> {
-    return this.repo.findAll()
-  }
-
-  async findPaginated(parsed: ParsedQuery) {
-    return this.repo.findPaginated(parsed)
-  }
-
-  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    return this.repo.create(dto)
-  }
-
-  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    return this.repo.update(id, dto)
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.repo.delete(id)
-  }
-}
-`}function H(e){let{pascal:t}=e;return`import type { QueryFieldConfig } from '@forinda/kickjs'
-
-export const ${t.toUpperCase()}_QUERY_CONFIG: QueryFieldConfig = {
-  filterable: ['name'],
-  sortable: ['name', 'createdAt'],
-  searchable: ['name'],
-}
-`}function he(e){let{pascal:t,kebab:n,plural:r=``,repo:i,style:a}=e,o={inmemory:`InMemory${t}Repository`,drizzle:`Drizzle${t}Repository`,prisma:`Prisma${t}Repository`},s={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},c=o[i]??o.inmemory,l=s[i]??s.inmemory,u=a??`define`,d=`/**
- * ${t} 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
- */`,f=`import { ${t.toUpperCase()}_REPOSITORY } from './${n}.repository'
-import { ${c} } from './${l}.repository'
-import { ${t}Controller } from './${n}.controller'
-
-// Eagerly load decorated classes
-import.meta.glob(
-  [
-    './commands/**/*.ts',
-    './queries/**/*.ts',
-    './events/**/*.ts',
-    '!./**/*.test.ts',
-  ],
-  { eager: true },
-)`,p=`    /**
-     * Declare HTTP routes for this CQRS module. Return value shape:
-     *
-     *   - \`path\`        — URL prefix for this route set.
-     *   - \`controller\`  — Controller class (also drives OpenAPI).
-     *   - \`version\`     — Optional. Overrides the app-wide API version.
-     *
-     * Return an array to mount multiple route sets:
-     *
-     *   return [
-     *     { path: '/${r}', version: 1, controller: ${t}V1Controller },
-     *     { path: '/${r}', version: 2, controller: ${t}V2Controller },
-     *   ]
-     */`;return u===`class`?`${d}
-import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-${f}
-
-export class ${t}Module implements AppModule {
-  register(container: Container): void {
-    container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-      container.resolve(${c}),
-    )
-  }
-
-${p.replace(/^ {4}/gm,`  `).replace(/^ {6}/gm,`    `)}
-  routes(): ModuleRoutes {
-    return {
-      path: '/${r}',
-      controller: ${t}Controller,
-    }
-  }
-}
-`:`${d}
-import { defineModule } from '@forinda/kickjs'
-${f}
-
-export const ${t}Module = defineModule({
-  name: '${t}Module',
-  build: () => ({
-    register(container) {
-      container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-        container.resolve(${c}),
-      )
-    },
-
-${p}
-    routes() {
-      return {
-        path: '/${r}',
-        controller: ${t}Controller,
-      }
-    },
-  }),
-})
-`}function ge(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return`import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams, type Ctx } from '@forinda/kickjs'
-import { ApiTags } from '@forinda/kickjs-swagger'
-import { Create${t}Command } from './commands/create-${n}.command'
-import { Update${t}Command } from './commands/update-${n}.command'
-import { Delete${t}Command } from './commands/delete-${n}.command'
-import { Get${t}Query } from './queries/get-${n}.query'
-import { List${i}Query } from './queries/list-${r}.query'
-import { create${t}Schema } from './dtos/create-${n}.dto'
-import { update${t}Schema } from './dtos/update-${n}.dto'
-import { ${t.toUpperCase()}_QUERY_CONFIG } from './${n}.constants'
-
-// Each handler annotates its \`ctx\` with \`Ctx<KickRoutes.${t}Controller['<method>']>\`
-// so \`ctx.params\`, \`ctx.body\`, and \`ctx.query\` are typed end-to-end.
-// The \`KickRoutes\` namespace is generated by \`kick typegen\` (auto-run on
-// \`kick dev\`) — see https://forinda.github.io/kick-js/guide/typegen.
-
-@Controller()
-export class ${t}Controller {
-  @Autowired() private readonly create${t}Command!: Create${t}Command
-  @Autowired() private readonly update${t}Command!: Update${t}Command
-  @Autowired() private readonly delete${t}Command!: Delete${t}Command
-  @Autowired() private readonly get${t}Query!: Get${t}Query
-  @Autowired() private readonly list${i}Query!: List${i}Query
-
-  @Get('/')
-  @ApiTags('${t}')
-  @ApiQueryParams(${t.toUpperCase()}_QUERY_CONFIG)
-  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
-    return ctx.paginate(
-      (parsed) => this.list${i}Query.execute(parsed),
-      ${t.toUpperCase()}_QUERY_CONFIG,
-    )
-  }
-
-  @Get('/:id')
-  @ApiTags('${t}')
-  async getById(ctx: Ctx<KickRoutes.${t}Controller['getById']>) {
-    const result = await this.get${t}Query.execute(ctx.params.id)
-    if (!result) return ctx.notFound('${t} not found')
-    ctx.json(result)
-  }
-
-  @Post('/', { body: create${t}Schema, name: 'Create${t}' })
-  @ApiTags('${t}')
-  async create(ctx: Ctx<KickRoutes.${t}Controller['create']>) {
-    const result = await this.create${t}Command.execute(ctx.body)
-    ctx.created(result)
-  }
-
-  @Put('/:id', { body: update${t}Schema, name: 'Update${t}' })
-  @ApiTags('${t}')
-  async update(ctx: Ctx<KickRoutes.${t}Controller['update']>) {
-    const result = await this.update${t}Command.execute(ctx.params.id, ctx.body)
-    ctx.json(result)
-  }
-
-  @Delete('/:id')
-  @ApiTags('${t}')
-  async remove(ctx: Ctx<KickRoutes.${t}Controller['remove']>) {
-    await this.delete${t}Command.execute(ctx.params.id)
-    ctx.noContent()
-  }
-}
-`}function _e(e){let{pascal:t,kebab:n}=e;return[{file:`create-${n}.command.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
-import type { Create${t}DTO } from '../dtos/create-${n}.dto'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-import { ${t}Events } from '../events/${n}.events'
-
-@Service()
-export class Create${t}Command {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-    @Inject(${t}Events) private readonly events: ${t}Events,
-  ) {}
-
-  async execute(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    const result = await this.repo.create(dto)
-    this.events.emit('${n}.created', result)
-    return result
-  }
-}
-`},{file:`update-${n}.command.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
-import type { Update${t}DTO } from '../dtos/update-${n}.dto'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-import { ${t}Events } from '../events/${n}.events'
-
-@Service()
-export class Update${t}Command {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-    @Inject(${t}Events) private readonly events: ${t}Events,
-  ) {}
-
-  async execute(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    const result = await this.repo.update(id, dto)
-    this.events.emit('${n}.updated', result)
-    return result
-  }
-}
-`},{file:`delete-${n}.command.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
-import { ${t}Events } from '../events/${n}.events'
-
-@Service()
-export class Delete${t}Command {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-    @Inject(${t}Events) private readonly events: ${t}Events,
-  ) {}
-
-  async execute(id: string): Promise<void> {
-    await this.repo.delete(id)
-    this.events.emit('${n}.deleted', { id })
-  }
-}
-`}]}function ve(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return[{file:`get-${n}.query.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-
-@Service()
-export class Get${t}Query {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(id: string): Promise<${t}ResponseDTO | null> {
-    return this.repo.findById(id)
-  }
-}
-`},{file:`list-${r}.query.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
-import type { ParsedQuery } from '@forinda/kickjs'
-
-@Service()
-export class List${i}Query {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(parsed: ParsedQuery) {
-    return this.repo.findPaginated(parsed)
-  }
-}
-`}]}function ye(e){let{pascal:t,kebab:n}=e;return[{file:`${n}.events.ts`,content:`import { Service } from '@forinda/kickjs'
-import { EventEmitter } from 'node:events'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-
-/**
- * ${t} 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 ${t}EventMap {
-  '${n}.created': ${t}ResponseDTO
-  '${n}.updated': ${t}ResponseDTO
-  '${n}.deleted': { id: string }
-}
-
-@Service()
-export class ${t}Events {
-  private emitter = new EventEmitter()
-
-  emit<K extends keyof ${t}EventMap>(event: K, data: ${t}EventMap[K]): void {
-    this.emitter.emit(event, data)
-  }
-
-  on<K extends keyof ${t}EventMap>(event: K, handler: (data: ${t}EventMap[K]) => void): void {
-    this.emitter.on(event, handler)
-  }
-
-  off<K extends keyof ${t}EventMap>(event: K, handler: (data: ${t}EventMap[K]) => void): void {
-    this.emitter.off(event, handler)
-  }
-}
-`},{file:`on-${n}-change.handler.ts`,content:`import { Service, Autowired } from '@forinda/kickjs'
-import { ${t}Events } from './${n}.events'
-
-/**
- * ${t} 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('${n}-channel', { event, data })
- *
- * 2. Queue dispatch — offload heavy processing to background workers
- *    import { QueueService } from '@forinda/kickjs-queue'
- *    this.queue.add('${n}-etl', { action: event, payload: data })
- *
- * 3. ETL pipeline — transform and load data to external systems
- *    await this.etlPipeline.process(data)
- */
-@Service()
-export class On${t}ChangeHandler {
-  @Autowired() private events!: ${t}Events
-
-  // Uncomment to inject WebSocket and Queue services:
-  // @Autowired() private ws!: WsGateway
-  // @Autowired() private queue!: QueueService
-
-  onInit(): void {
-    this.events.on('${n}.created', (data) => {
-      console.log('[${t}] Created:', data.id)
-      // TODO: Broadcast via WebSocket
-      // this.ws.broadcast('${n}-channel', { event: '${n}.created', data })
-      // TODO: Dispatch to queue for async processing / ETL
-      // this.queue.add('${n}-etl', { action: 'create', payload: data })
-    })
-
-    this.events.on('${n}.updated', (data) => {
-      console.log('[${t}] Updated:', data.id)
-      // TODO: Broadcast via WebSocket
-      // this.ws.broadcast('${n}-channel', { event: '${n}.updated', data })
-    })
-
-    this.events.on('${n}.deleted', (data) => {
-      console.log('[${t}] Deleted:', data.id)
-      // TODO: Broadcast via WebSocket
-      // this.ws.broadcast('${n}-channel', { event: '${n}.deleted', data })
-    })
-  }
-}
-`}]}function U(e){let{pascal:t,kebab:n,repoPrefix:r=`../../domain/repositories`,dtoPrefix:i=`../../application/dtos`}=e;return`/**
- * Drizzle ${t} Repository
- *
- * Implements the repository interface using Drizzle ORM.
- * Uses buildFromColumns() with Column objects for type-safe query building.
- *
- * TODO: Update the schema import to match your Drizzle schema file.
- * TODO: Replace DRIZZLE_DB injection token with your actual database token.
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc, count, sql } from 'drizzle-orm'
-import { Repository, HttpException, Inject } from '@forinda/kickjs'
-import { DRIZZLE_DB, DrizzleQueryAdapter } from '@forinda/kickjs-drizzle'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${t}Repository } from '${r}/${n}.repository'
-import type { ${t}ResponseDTO } from '${i}/${n}-response.dto'
-import type { Create${t}DTO } from '${i}/create-${n}.dto'
-import type { Update${t}DTO } from '${i}/update-${n}.dto'
-import { ${t.toUpperCase()}_QUERY_CONFIG } from '../../constants'
-
-// TODO: Import your Drizzle schema table — e.g.:
-// import { ${n}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${t}Repository implements I${t}Repository {
-  constructor(@Inject(DRIZZLE_DB) private db: any) {}
-
-  async findById(id: string): Promise<${t}ResponseDTO | null> {
-    // TODO: Implement with Drizzle
-    // const row = this.db.select().from(${n}s).where(eq(${n}s.id, id)).get()
-    // return row ?? null
-    throw new Error('Drizzle ${t} repository not yet implemented — update schema imports and queries')
-  }
-
-  async findAll(): Promise<${t}ResponseDTO[]> {
-    // TODO: Implement with Drizzle
-    // return this.db.select().from(${n}s).all()
-    throw new Error('Drizzle ${t} repository not yet implemented')
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }> {
-    // TODO: Use buildFromColumns() with your query config for type-safe filtering
-    // const query = queryAdapter.buildFromColumns(parsed, ${t.toUpperCase()}_QUERY_CONFIG)
-    //
-    // const data = this.db
-    //   .select().from(${n}s).$dynamic()
-    //   .where(query.where).orderBy(...query.orderBy)
-    //   .limit(query.limit).offset(query.offset).all()
-    //
-    // const totalResult = this.db
-    //   .select({ count: count() }).from(${n}s)
-    //   .$dynamic().where(query.where).get()
-    //
-    // return { data, total: totalResult?.count ?? 0 }
-    throw new Error('Drizzle ${t} repository not yet implemented')
-  }
-
-  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    // TODO: Implement with Drizzle
-    // return this.db.insert(${n}s).values(dto).returning().get()
-    throw new Error('Drizzle ${t} repository not yet implemented')
-  }
-
-  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    // TODO: Implement with Drizzle
-    // const row = this.db.update(${n}s).set(dto).where(eq(${n}s.id, id)).returning().get()
-    // if (!row) throw HttpException.notFound('${t} not found')
-    // return row
-    throw new Error('Drizzle ${t} repository not yet implemented')
-  }
-
-  async delete(id: string): Promise<void> {
-    // TODO: Implement with Drizzle
-    // this.db.delete(${n}s).where(eq(${n}s.id, id)).run()
-    throw new Error('Drizzle ${t} repository not yet implemented')
-  }
-}
-`}function be(e){let{pascal:t,kebab:n}=e;return`import type { DrizzleQueryParamsConfig } from '@forinda/kickjs-drizzle'
-// TODO: Import your schema table and reference actual columns for type safety
-// import { ${n}s } from '@/db/schema'
-
-export const ${t.toUpperCase()}_QUERY_CONFIG: DrizzleQueryParamsConfig = {
-  columns: {
-    // Replace with actual Drizzle Column references for type-safe filtering:
-    // name: ${n}s.name,
-    // status: ${n}s.status,
-  },
-  sortable: {
-    // name: ${n}s.name,
-    // createdAt: ${n}s.createdAt,
-  },
-  searchColumns: [
-    // ${n}s.name,
-  ],
-}
-`}function W(e){let{pascal:t,kebab:n,repoPrefix:r=`../../domain/repositories`,dtoPrefix:i=`../../application/dtos`}=e,a=n.replace(/-([a-z])/g,(e,t)=>t.toUpperCase());return`/**
- * Prisma ${t} Repository
- *
- * Implements the repository interface using Prisma Client.
- * Requires a PrismaClient instance injected via the DI container.
- *
- * Ensure your Prisma schema has a '${t}' model defined.
- *
- * For full Prisma field-level type safety, replace PrismaModelDelegate with your PrismaClient:
- *   @Inject(PRISMA_CLIENT) private prisma!: PrismaClient
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { Repository, HttpException, Inject } from '@forinda/kickjs'
-import { PRISMA_CLIENT, type PrismaModelDelegate } from '@forinda/kickjs-prisma'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${t}Repository } from '${r}/${n}.repository'
-import type { ${t}ResponseDTO } from '${i}/${n}-response.dto'
-import type { Create${t}DTO } from '${i}/create-${n}.dto'
-import type { Update${t}DTO } from '${i}/update-${n}.dto'
-
-@Repository()
-export class Prisma${t}Repository implements I${t}Repository {
-  @Inject(PRISMA_CLIENT) private prisma!: { ${a}: PrismaModelDelegate }
-
-  async findById(id: string): Promise<${t}ResponseDTO | null> {
-    return this.prisma.${a}.findUnique({ where: { id } }) as Promise<${t}ResponseDTO | null>
-  }
-
-  async findAll(): Promise<${t}ResponseDTO[]> {
-    return this.prisma.${a}.findMany() as Promise<${t}ResponseDTO[]>
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }> {
-    const [data, total] = await Promise.all([
-      this.prisma.${a}.findMany({
-        skip: parsed.pagination.offset,
-        take: parsed.pagination.limit,
-      }) as Promise<${t}ResponseDTO[]>,
-      this.prisma.${a}.count(),
-    ])
-    return { data, total }
-  }
-
-  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    return this.prisma.${a}.create({ data: dto as Record<string, unknown> }) as Promise<${t}ResponseDTO>
-  }
-
-  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    const existing = await this.prisma.${a}.findUnique({ where: { id } })
-    if (!existing) throw HttpException.notFound('${t} not found')
-    return this.prisma.${a}.update({ where: { id }, data: dto as Record<string, unknown> }) as Promise<${t}ResponseDTO>
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.prisma.${a}.deleteMany({ where: { id } })
-  }
-}
-`}function xe(e,t,n,r=[]){switch(t){case`cqrs`:{let t=[],i=[];return r.includes(`devtools`)&&(t.push(`import { DevToolsAdapter } from '@forinda/kickjs-devtools'`),i.push(`    DevToolsAdapter(),`)),r.includes(`swagger`)&&(t.push(`import { SwaggerAdapter } from '@forinda/kickjs-swagger'`),i.push(`    SwaggerAdapter({\n      info: { title: '${e}', version: '${n}' },\n    }),`)),`import 'reflect-metadata'
-// Side-effect import — registers the extended env schema with kickjs
-// **before** any controller / service / @Value gets resolved. Without
-// this line ConfigService.get('YOUR_KEY') returns undefined because the
-// cached schema would still be the base shape. See guide/configuration.
-import './config'
-import { bootstrap } from '@forinda/kickjs'
-// import { WsAdapter } from '@forinda/kickjs-ws'
-// import { QueueAdapter, BullMQProvider } from '@forinda/kickjs-queue'
-${t.length?t.join(`
-`)+`
-`:``}import { modules } from './modules'
-
-// Export the app for the Vite plugin (dev mode)
-export const app = await bootstrap({
-  modules,${t.length?`\n  adapters: [\n${i.join(`
-`)}\n    // Uncomment for WebSocket support:\n    // WsAdapter(),\n    // Uncomment when Redis is available:\n    // QueueAdapter({\n    //   provider: new BullMQProvider({ host: 'localhost', port: 6379 }),\n    // }),\n  ],`:`
-  adapters: [
-    // Uncomment for WebSocket support:
-    // WsAdapter(),
-    // Uncomment when Redis is available:
-    // QueueAdapter({
-    //   provider: new BullMQProvider({ host: 'localhost', port: 6379 }),
-    // }),
-  ],`}
-})
-`}case`minimal`:{let t=[],i=[];return r.includes(`swagger`)&&(t.push(`import { SwaggerAdapter } from '@forinda/kickjs-swagger'`),i.push(`    SwaggerAdapter({ info: { title: '${e}', version: '${n}' } }),`)),r.includes(`devtools`)&&(t.push(`import { DevToolsAdapter } from '@forinda/kickjs-devtools'`),i.push(`    DevToolsAdapter(),`)),`import 'reflect-metadata'
-// Side-effect import — registers the extended env schema with kickjs
-// **before** any controller / service / @Value gets resolved. Without
-// this line ConfigService.get('YOUR_KEY') returns undefined because the
-// cached schema would still be the base shape. See guide/configuration.
-import './config'
-import { bootstrap } from '@forinda/kickjs'
-${t.length?t.join(`
-`)+`
-`:``}import { modules } from './modules'
-
-// Export the app for the Vite plugin (dev mode)
-export const app = await bootstrap({ modules${i.length?`,\n  adapters: [\n${i.join(`
-`)}\n  ]`:``} })
-`}default:{let t=[],i=[];return r.includes(`devtools`)&&(t.push(`import { DevToolsAdapter } from '@forinda/kickjs-devtools'`),i.push(`    DevToolsAdapter(),`)),r.includes(`swagger`)&&(t.push(`import { SwaggerAdapter } from '@forinda/kickjs-swagger'`),i.push(`    SwaggerAdapter({\n      info: { title: '${e}', version: '${n}' },\n    }),`)),`import 'reflect-metadata'
-// Side-effect import — registers the extended env schema with kickjs
-// **before** any controller / service / @Value gets resolved. Without
-// this line ConfigService.get('YOUR_KEY') returns undefined because the
-// cached schema would still be the base shape. See guide/configuration.
-import './config'
-import express from 'express'
-import {
-  bootstrap,
-  requestId,
-  requestLogger,
-  helmet,
-  cors,
-} from '@forinda/kickjs'
-${t.length?t.join(`
-`)+`
-`:``}import { modules } from './modules'
-
-// Export the app for the Vite plugin (dev mode)
-export const app = await bootstrap({
-  modules,${i.length?`\n  adapters: [\n${i.join(`
-`)}\n  ],`:``}
-  middleware: [
-    helmet(),
-    cors({ origin: '*' }),
-    requestId(),
-    requestLogger(),
-    express.json(),
-  ],
-})
-`}}}function Se(){return`import { defineModules } from '@forinda/kickjs'
-import { HelloModule } from './hello/hello.module'
-
-// Remove HelloModule and run: kick g module <name>
-// \`defineModules()\` returns a chainable list — \`kick g module\` appends
-// \`.mount(NewModule())\` to the chain on every generation.
-export const modules = defineModules().mount(HelloModule())
-`}function Ce(e=`zod`){return e===`valibot`?`import { loadEnvFromSchema } from '@forinda/kickjs/config'
-import { fromValibot } from '@forinda/kickjs-schema/valibot'
-import * as v from 'valibot'
-
-/**
- * Project environment schema (Valibot).
- *
- * \`fromValibot\` wraps the Valibot schema as a \`KickSchema\` so the
- * env loader, validate middleware, and swagger spec generator all see
- * the same shape. The default export is the contract \`kick typegen\`
- * reads to populate \`KickEnv\` via \`InferSchemaOutput<typeof _envSchema>\`
- * — that's what makes \`@Value('FOO')\` autocomplete and
- * \`process.env.FOO\` typed.
- *
- * @example
- *   DATABASE_URL: v.pipe(v.string(), v.url()),
- *   JWT_SECRET:   v.pipe(v.string(), v.minLength(32)),
- *   REDIS_URL:    v.optional(v.pipe(v.string(), v.url())),
- */
-const envSchema = fromValibot(
-  v.object({
-    PORT: v.optional(v.pipe(v.string(), v.transform(Number)), '3000'),
-    NODE_ENV: v.optional(v.picklist(['development', 'production', 'test']), 'development'),
-    LOG_LEVEL: v.optional(v.string(), 'info'),
-    // DATABASE_URL: v.pipe(v.string(), v.url()),
-  }),
-)
-
-/**
- * IMPORTANT — side effect: register the schema with kickjs's env cache
- * **at module-load time**. \`ConfigService\` and \`@Value()\` both consume
- * this cache, and they will fall back to the base schema (or undefined)
- * if no extended schema has been registered before they're resolved.
- *
- * As long as \`src/index.ts\` imports this file (\`import './config'\`) at
- * the top — before \`bootstrap()\` runs — every controller and service
- * in the app sees the typed extended values.
- */
-export const env = loadEnvFromSchema(envSchema)
-
-export default envSchema
-`:e===`yup`?`import { loadEnvFromSchema } from '@forinda/kickjs/config'
-import { fromYup } from '@forinda/kickjs-schema/yup'
-import * as yup from 'yup'
-
-/**
- * Project environment schema (Yup).
- *
- * \`fromYup\` wraps the Yup schema as a \`KickSchema\` so the env loader,
- * validate middleware, and swagger spec generator all see the same
- * shape. The default export is the contract \`kick typegen\` reads to
- * populate \`KickEnv\` via \`InferSchemaOutput<typeof _envSchema>\`.
- *
- * Note: Yup's \`.url()\` defaults to http/https; database connection
- * strings like \`postgres://\` use \`.matches(/^[a-z]+:\\/\\/.+/i)\` or
- * a plain \`.string().required()\`.
- *
- * @example
- *   DATABASE_URL: yup.string().required(),
- *   JWT_SECRET:   yup.string().min(32).required(),
- *   REDIS_URL:    yup.string().url().optional(),
- */
-const envSchema = fromYup(
-  yup.object({
-    PORT: yup.number().default(3000),
-    NODE_ENV: yup
-      .string()
-      .oneOf(['development', 'production', 'test'])
-      .default('development'),
-    LOG_LEVEL: yup.string().default('info'),
-    // DATABASE_URL: yup.string().required(),
-  }),
-)
-
-/**
- * IMPORTANT — side effect: register the schema with kickjs's env cache
- * **at module-load time**. \`ConfigService\` and \`@Value()\` both consume
- * this cache, and they will fall back to the base schema (or undefined)
- * if no extended schema has been registered before they're resolved.
- *
- * As long as \`src/index.ts\` imports this file (\`import './config'\`) at
- * the top — before \`bootstrap()\` runs — every controller and service
- * in the app sees the typed extended values.
- */
-export const env = loadEnvFromSchema(envSchema)
-
-export default envSchema
-`:`import { loadEnvFromSchema } from '@forinda/kickjs/config'
-import { fromZod } from '@forinda/kickjs-schema/zod'
-import { z } from 'zod'
-
-/**
- * Project environment schema (Zod).
- *
- * \`fromZod\` wraps the Zod schema as a \`KickSchema\` so the env loader,
- * validate middleware, and swagger spec generator all see the same
- * shape. The default export is the contract \`kick typegen\` reads to
- * populate \`KickEnv\` via \`InferSchemaOutput<typeof _envSchema>\` —
- * that's what makes \`@Value('FOO')\` autocomplete and
- * \`process.env.FOO\` typed.
- *
- * @example
- *   DATABASE_URL: z.string().url(),
- *   JWT_SECRET: z.string().min(32),
- *   REDIS_URL: z.string().url().optional(),
- */
-const envSchema = fromZod(
-  z.object({
-    PORT: z.coerce.number().default(3000),
-    NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
-    LOG_LEVEL: z.string().default('info'),
-    // DATABASE_URL: z.string().url(),
-  }),
-)
-
-/**
- * IMPORTANT — side effect: register the schema with kickjs's env cache
- * **at module-load time**. \`ConfigService\` and \`@Value()\` both consume
- * this cache, and they will fall back to the base schema (or undefined)
- * if no extended schema has been registered before they're resolved.
- *
- * As long as \`src/index.ts\` imports this file (\`import './config'\`) at
- * the top — before \`bootstrap()\` runs — every controller and service
- * in the app sees the typed extended values.
- */
-export const env = loadEnvFromSchema(envSchema)
-
-export default envSchema
-`}function we(){return`import { Service } from '@forinda/kickjs'
-
-@Service()
-export class HelloService {
-  greet(name: string) {
-    return { message: \`Hello \${name} from KickJS!\`, timestamp: new Date().toISOString() }
-  }
-
-  healthCheck() {
-    return { status: 'ok', uptime: process.uptime() }
-  }
-}
-`}function Te(){return`import { Controller, Get, Autowired, type Ctx } from '@forinda/kickjs'
-import { HelloService } from './hello.service'
-
-// \`Ctx<KickRoutes.HelloController['<method>']>\` is generated by
-// \`kick typegen\` (auto-run on \`kick dev\`). The first run after a fresh
-// scaffold creates \`.kickjs/types/routes.ts\` so this file typechecks.
-// See https://forinda.github.io/kick-js/guide/typegen.
-
-@Controller()
-export class HelloController {
-  @Autowired() private readonly helloService!: HelloService
-
-  @Get('/')
-  index(ctx: Ctx<KickRoutes.HelloController['index']>) {
-    ctx.json(this.helloService.greet('World'))
-  }
-
-  @Get('/health')
-  health(ctx: Ctx<KickRoutes.HelloController['health']>) {
-    ctx.json(this.helloService.healthCheck())
-  }
-}
-`}function Ee(){return`import { defineModule } from '@forinda/kickjs'
-import { HelloController } from './hello.controller'
-
-export const HelloModule = defineModule({
-  name: 'HelloModule',
-  build: () => ({
-    // \`register(container)\` is optional — only implement it when you need
-    // to bind a token to a concrete implementation, e.g.
-    //   register(container) {
-    //     container.registerFactory(USER_REPOSITORY, () => container.resolve(InMemoryUserRepository))
-    //   }
-    // The HelloService uses @Service() so the decorator handles registration.
-
-    routes() {
-      return {
-        path: '/hello',
-        controller: HelloController,
-      }
-    },
-  }),
-})
-`}function De(e,t=`inmemory`,n=`pnpm`){return`import { defineConfig } from '@forinda/kickjs-cli'
-
-export default defineConfig({
-  pattern: '${e}',
-  // Pinned so \`kick add\` and other dep-installing commands always use the
-  // project's intended package manager, regardless of which lockfile exists.
-  packageManager: '${n}',
-  modules: {
-    dir: 'src/modules',
-    repo: ${[`drizzle`,`inmemory`,`prisma`].includes(t)?`'${t}'`:`{ name: '${t}' }`},
-    pluralize: true,
-  },
-
-  // \`kick typegen\` populates \`.kickjs/types/\` so \`Ctx<KickRoutes.X['method']>\`
-  // resolves to fully-typed params/body/query. Auto-runs on \`kick dev\`.
-  // \`'kickjs-schema'\` routes inference through \`InferSchemaOutput\` so the
-  // typegen works for any wrapped schema (Zod / Valibot / Yup). Switch
-  // to \`'zod'\` if you ship Zod schemas without \`fromZod()\` wrapping, or
-  // set \`schemaValidator: false\` to skip schema-driven body typing.
-  typegen: {
-    schemaValidator: 'kickjs-schema',
-  },
-
-  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: 'ci:check',
-      description: 'Run typecheck + format check',
-      steps: ['npx tsc --noEmit', 'npx prettier --check src/'],
-      aliases: ['verify'],
-    },
-  ],
-})
-`}async function Oe(e){let{pascal:t,kebab:n,plural:r,style:i,write:a}=e;await a(`${n}.module.ts`,oe({pascal:t,kebab:n,plural:r,style:i})),await a(`${n}.controller.ts`,`import { Controller, Get, type Ctx } from '@forinda/kickjs'
-
-// \`Ctx<KickRoutes.${t}Controller['<method>']>\` is generated by
-// \`kick typegen\` (auto-run on \`kick dev\`).
-
-@Controller()
-export class ${t}Controller {
-  @Get('/')
-  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
-    ctx.json({ message: '${t} list' })
-  }
-}
-`)}async function ke(e){let{pascal:t,kebab:n,plural:r,pluralPascal:i,repo:a,noTests:o,prismaClientPath:s,tokenScope:c,style:l,write:u}=e;await u(`${n}.module.ts`,ae({pascal:t,kebab:n,plural:r,repo:a,style:l})),await u(`${n}.constants.ts`,H({pascal:t,kebab:n})),await u(`${n}.controller.ts`,ce({pascal:t,kebab:n,plural:r,pluralPascal:i})),await u(`${n}.service.ts`,me({pascal:t,kebab:n})),await u(`dtos/create-${n}.dto.ts`,P({pascal:t,kebab:n})),await u(`dtos/update-${n}.dto.ts`,F({pascal:t,kebab:n})),await u(`dtos/${n}-response.dto.ts`,I({pascal:t,kebab:n})),await u(`${n}.repository.ts`,L({pascal:t,kebab:n,dtoPrefix:`./dtos`,tokenScope:c}));let d={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},f={inmemory:()=>R({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),drizzle:()=>U({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),prisma:()=>W({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`,prismaClientPath:s})},p=d[a]??`${E(a)}-${n}`,m=f[a]??(()=>z({pascal:t,kebab:n,repoType:a,repoPrefix:`.`,dtoPrefix:`./dtos`}));await u(`${p}.repository.ts`,m()),o||(a!==`inmemory`&&await u(`in-memory-${n}.repository.ts`,R({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`})),await u(`__tests__/${n}.controller.test.ts`,B({pascal:t,kebab:n,plural:r})),await u(`__tests__/${n}.repository.test.ts`,V({pascal:t,kebab:n,plural:r,repoPrefix:`../${d.inmemory??`in-memory-${n}`}.repository`})))}async function Ae(e){let{pascal:t,kebab:n,plural:r,pluralPascal:i,repo:a,noTests:o,prismaClientPath:s,tokenScope:c,style:l,write:u}=e;await u(`${n}.module.ts`,he({pascal:t,kebab:n,plural:r,repo:a,style:l})),await u(`${n}.constants.ts`,H({pascal:t,kebab:n})),await u(`${n}.controller.ts`,ge({pascal:t,kebab:n,plural:r,pluralPascal:i})),await u(`dtos/create-${n}.dto.ts`,P({pascal:t,kebab:n})),await u(`dtos/update-${n}.dto.ts`,F({pascal:t,kebab:n})),await u(`dtos/${n}-response.dto.ts`,I({pascal:t,kebab:n}));let d=_e({pascal:t,kebab:n});for(let e of d)await u(`commands/${e.file}`,e.content);let f=ve({pascal:t,kebab:n,plural:r,pluralPascal:i});for(let e of f)await u(`queries/${e.file}`,e.content);let p=ye({pascal:t,kebab:n});for(let e of p)await u(`events/${e.file}`,e.content);await u(`${n}.repository.ts`,L({pascal:t,kebab:n,dtoPrefix:`./dtos`,tokenScope:c}));let m={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},h={inmemory:()=>R({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),drizzle:()=>U({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),prisma:()=>W({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`,prismaClientPath:s})},g=m[a]??`${E(a)}-${n}`,_=h[a]??(()=>z({pascal:t,kebab:n,repoType:a,repoPrefix:`.`,dtoPrefix:`./dtos`}));await u(`${g}.repository.ts`,_()),o||(a!==`inmemory`&&await u(`in-memory-${n}.repository.ts`,R({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`})),await u(`__tests__/${n}.controller.test.ts`,B({pascal:t,kebab:n,plural:r})),await u(`__tests__/${n}.repository.test.ts`,V({pascal:t,kebab:n,plural:r,repoPrefix:`../${m.inmemory??`in-memory-${n}`}.repository`})))}async function je(e){let{pascal:t,kebab:n,plural:r,pluralPascal:i,repo:a,noEntity:o,noTests:s,prismaClientPath:c,tokenScope:l,style:u,write:d}=e;await d(`${n}.module.ts`,ie({pascal:t,kebab:n,plural:r,repo:a,style:u})),await d(`constants.ts`,a===`drizzle`?be({pascal:t,kebab:n}):le({pascal:t,kebab:n})),await d(`presentation/${n}.controller.ts`,se({pascal:t,kebab:n,plural:r,pluralPascal:i})),await d(`application/dtos/create-${n}.dto.ts`,P({pascal:t,kebab:n})),await d(`application/dtos/update-${n}.dto.ts`,F({pascal:t,kebab:n})),await d(`application/dtos/${n}-response.dto.ts`,I({pascal:t,kebab:n}));let f=ue({pascal:t,kebab:n,plural:r,pluralPascal:i});for(let e of f)await d(`application/use-cases/${e.file}`,e.content);await d(`domain/repositories/${n}.repository.ts`,L({pascal:t,kebab:n,tokenScope:l})),await d(`domain/services/${n}-domain.service.ts`,de({pascal:t,kebab:n}));let p={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},m={inmemory:()=>R({pascal:t,kebab:n}),drizzle:()=>U({pascal:t,kebab:n}),prisma:()=>W({pascal:t,kebab:n,prismaClientPath:c})},h=p[a]??`${E(a)}-${n}`,g=m[a]??(()=>z({pascal:t,kebab:n,repoType:a}));await d(`infrastructure/repositories/${h}.repository.ts`,g()),o||(await d(`domain/entities/${n}.entity.ts`,fe({pascal:t,kebab:n})),await d(`domain/value-objects/${n}-id.vo.ts`,pe({pascal:t,kebab:n}))),s||(a!==`inmemory`&&await d(`infrastructure/repositories/in-memory-${n}.repository.ts`,R({pascal:t,kebab:n})),await d(`__tests__/${n}.controller.test.ts`,B({pascal:t,kebab:n,plural:r})),await d(`__tests__/${n}.repository.test.ts`,V({pascal:t,kebab:n,plural:r})))}function Me(e){return e?typeof e==`string`?e:e.name:`inmemory`}async function Ne(t){let{name:n,modulesDir:a,noEntity:c,noTests:l,repo:u=`inmemory`,force:d,dryRun:p}=t,m=t.pluralize!==!1,h=t.pattern??`ddd`;t.minimal&&(h=`minimal`);let g=E(n),_=w(n),v=m?D(g):g,y=m?O(_):_,b=f(a,v),x=[],S=d??!1,C={kebab:g,pascal:_,plural:v,pluralPascal:y,moduleDir:b,repo:u,noEntity:c??!1,noTests:l??!1,prismaClientPath:t.prismaClientPath??`@prisma/client`,tokenScope:t.tokenScope??`app`,style:t.style??`define`,write:async(t,n)=>{let a=f(b,t);if(p){x.push(a);return}if(!S&&await s(a)&&!await o({message:`File exists: ${r.dim(t)}. Overwrite?`,initialValue:!1})){i.warn(`Skipped: ${t}`);return}await e(a,n),x.push(a)},files:x};switch(h){case`minimal`:await Oe(C);break;case`rest`:await ke(C);break;case`cqrs`:await Ae(C);break;default:await je(C);break}return p||await G(a,_,v,g,C.style),x}async function G(t,n,r,i,a=`define`){let o=f(t,`index.ts`),c=await s(o),l=`./${r}/${i}.module`,u=a===`class`?`${n}Module`:`${n}Module()`;if(!c){await e(o,a===`class`?`import type { AppModuleEntry } from '@forinda/kickjs'
-import { ${n}Module } from '${l}'
-
-export const modules: AppModuleEntry[] = [${u}]
-`:`import { defineModules } from '@forinda/kickjs'
-import { ${n}Module } from '${l}'
-
-export const modules = defineModules().mount(${u})
-`);return}let d=await y(o,`utf-8`),p=`import { ${n}Module } from '${l}'`,m=k(l);if(!RegExp(`^import\\s*\\{[^}]*\\b${k(n)}Module\\b[^}]*\\}\\s*from\\s*['"]${m}['"]`,`m`).test(d)){let e=d.lastIndexOf(`import `);if(e!==-1){let t=d.indexOf(`
-`,e);d=d.slice(0,t+1)+p+`
-`+d.slice(t+1)}else d=p+`
-`+d}let h=q(d);if(h){let e=d.slice(h.rhsStart,h.rhsEnd+1);RegExp(`\\b${k(n)}Module\\b`).test(e)||(d=K(d,u))}else d=K(d,u);await b(o,d,`utf-8`)}function K(e,t){let n=q(e);if(!n)return e;if(n.shape===`array`){let r=e.slice(n.rhsStart+1,n.rhsEnd),i=r.trim(),a;if(!i)a=`[${t}]`;else{let e=i.endsWith(`,`)?``:`,`;a=`[${r.trimEnd()}${e} ${t}]`}return e.slice(0,n.rhsStart)+a+e.slice(n.rhsEnd+1)}return`${e.slice(0,n.chainEnd)}\n  .mount(${t})${e.slice(n.chainEnd)}`}function q(e){let t=/export\s+const\s+modules\b[^=]*=/.exec(e);if(!t)return null;let n=t.index+t[0].length;for(;n<e.length&&/\s/.test(e[n]??``);)n++;if(e[n]===`[`){let t=Fe(e,n);return t===-1?null:{shape:`array`,rhsStart:n,rhsEnd:t}}if(e.slice(n,n+13)===`defineModules`){let t=Pe(e,n);return t===-1?null:{shape:`chain`,rhsStart:n,rhsEnd:t-1,chainEnd:t}}return null}function Pe(e,t=0){let n=/defineModules\s*\(/g;n.lastIndex=t;let r=n.exec(e);if(!r)return-1;let i=r.index+r[0].length-1;if(e[i]!==`(`||(i=Y(e,i),i===-1))return-1;for(i++;;){let t=i;for(;t<e.length&&/\s/.test(e[t]??``);)t++;if(e[t]!==`.`||e.slice(t,t+6)!==`.mount`)break;for(t+=6;t<e.length&&/\s/.test(e[t]??``);)t++;if(e[t]!==`(`)break;let n=Y(e,t);if(n===-1)break;i=n+1}return i}function J(e,t){let n=e.slice(t,t+2);if(n===`//`){for(t+=2;t<e.length&&e[t]!==`
-`;)t++;return t}if(n===`/*`){for(t+=2;t+1<e.length&&!(e[t]===`*`&&e[t+1]===`/`);)t++;return t+2}return t}function Fe(e,t){if(e[t]!==`[`)return-1;let n=1,r=t+1;for(;r<e.length;){let t=e.slice(r,r+2);if(t===`//`||t===`/*`){r=J(e,r);continue}let i=e[r]??``;if(i===`'`||i===`"`||i==="`"){let t=i;for(r++;r<e.length&&e[r]!==t;)e[r]===`\\`&&r++,r++;r<e.length&&r++;continue}if(i===`[`)n++;else if(i===`]`&&(n--,n===0))return r;r++}return-1}function Y(e,t){if(e[t]!==`(`)return-1;let n=1,r=t+1;for(;r<e.length;){let t=e.slice(r,r+2);if(t===`//`||t===`/*`){r=J(e,r);continue}let i=e[r]??``;if(i===`'`||i===`"`||i==="`"){let t=i;for(r++;r<e.length&&e[r]!==t;)e[r]===`\\`&&r++,r++;r<e.length&&r++;continue}if(i===`(`)n++;else if(i===`)`&&(n--,n===0))return r;r++}return-1}async function Ie(t){let{name:n,outDir:r}=t,i=E(n),a=w(n),o=[],s=f(r,`${i}.adapter.ts`);return await e(s,`import {
-  defineAdapter,
-  type AdapterContext,
-  type AdapterMiddleware,
-  type ContributorRegistrations,
-  type Constructor,
-} from '@forinda/kickjs'
-
-/**
- * Configuration for the ${a} adapter.
- *
- * Adapters typically take a small config object so callers can tune
- * behaviour at bootstrap time. Keep the shape narrow — anything
- * derived from the environment should be read inside the build
- * function via getEnv(), not forced onto the caller.
- */
-export interface ${a}AdapterConfig {
-  // Add your adapter configuration here, e.g.:
-  // enabled?: boolean
-  // apiKey?: string
-}
-
-/**
- * ${a} adapter — built via \`defineAdapter()\` so callers get the
- * factory's call / \`.scoped()\` / \`.async()\` surfaces for free.
- *
- * Hooks into the Application lifecycle to add middleware, routes,
- * Context Contributors, or external service connections.
- *
- * Every lifecycle hook below is OPTIONAL. The scaffold emits all of
- * them so adopters can browse what's available and delete what they
- * don't need — \`build()\` returning \`{}\` is also valid for an adapter
- * that only contributes config defaults.
- *
- * @example
- * \`\`\`ts
- * import { bootstrap } from '@forinda/kickjs'
- * import { ${a}Adapter } from './adapters/${i}.adapter'
- *
- * bootstrap({
- *   modules,
- *   adapters: [${a}Adapter({ /* config overrides *\\/ })],
- * })
- * \`\`\`
- */
-export const ${a}Adapter = defineAdapter<${a}AdapterConfig>({
-  name: '${a}Adapter',
-  defaults: {
-    // Default config values go here. The adopter's overrides shallow-merge
-    // on top of these before \`build()\` runs.
-  },
-  build: (_config, { name: _name }) => {
-    // Closures inside \`build()\` are how each adapter instance owns its
-    // own state (database client, Map, timer handle, …). The same
-    // \`_config\` is visible to every hook below.
-
-    return {
-      /**
-       * Express middleware entries the Application mounts at named phases.
-       *
-       * \`phase\` controls where each handler sits in the pipeline:
-       *   'beforeGlobal' | 'afterGlobal' | 'beforeRoutes' | 'afterRoutes'.
-       *
-       * \`path\` (optional) scopes the entry to a path prefix.
-       *
-       * Delete this hook entirely if you don't add middleware.
-       */
-      middleware(): AdapterMiddleware[] {
-        return [
-          // Example: add a custom header to all responses
-          // {
-          //   phase: 'beforeGlobal',
-          //   handler: (_req, res, next) => {
-          //     res.setHeader('X-${a}', 'true')
-          //     next()
-          //   },
-          // },
-          // Example: scope a rate limiter to one path prefix
-          // {
-          //   phase: 'beforeRoutes',
-          //   path: '/api/v1/auth',
-          //   handler: rateLimit({ max: 10 }),
-          // },
-        ]
-      },
-
-      /**
-       * Runs BEFORE global middleware. Mount routes that should bypass the
-       * middleware stack — health checks, docs UI, static assets, OAuth
-       * callbacks. Anything you want reachable even if a global middleware
-       * later in the chain rejects requests.
-       *
-       * Delete this hook if you have no early routes.
-       */
-      beforeMount(_ctx: AdapterContext): void {
-        // Example:
-        // _ctx.app.get('/${i}/status', (_req, res) => res.json({ status: 'ok' }))
-      },
-
-      /**
-       * Fires once per controller class as the router mounts. Use this to
-       * collect route metadata for OpenAPI specs, dependency graphs, route
-       * inventories, devtools dashboards.
-       *
-       * Delete this hook unless your adapter introspects the route registry.
-       */
-      onRouteMount(_controllerClass: Constructor, _mountPath: string): void {
-        // Example (Swagger-style): collect routes for the spec.
-        // openApiSpec.addController(_controllerClass, _mountPath)
-      },
-
-      /**
-       * Runs AFTER modules + routes are wired, BEFORE the server starts.
-       * Right place for late-stage DI registrations or final config validation.
-       *
-       * Delete this hook if there's nothing to wire post-modules.
-       */
-      beforeStart(_ctx: AdapterContext): void {
-        // Example: _ctx.container.registerInstance(MY_TOKEN, new MyService(_config))
-      },
-
-      /**
-       * Runs AFTER the HTTP server is listening. The raw \`http.Server\` is
-       * available on \`ctx.server\` — attach upgrade handlers (Socket.IO,
-       * gRPC, GraphQL subscriptions), warm caches, log a banner.
-       *
-       * Delete this hook if you don't need the running server reference.
-       */
-      afterStart(_ctx: AdapterContext): void {
-        // Example: const io = new Server(_ctx.server)
-      },
-
-      /**
-       * Returns Context Contributors to merge into every route's pipeline
-       * at the \`'adapter'\` precedence level. Per-route handlers can
-       * override the value at the method / class / module level.
-       *
-       * Delete this hook unless your adapter ships typed per-request values
-       * (auth user, tenant, locale, feature flags, geo, etc).
-       */
-      contributors(): ContributorRegistrations {
-        return [
-          // Example:
-          // import { defineHttpContextDecorator } from '@forinda/kickjs'
-          // declare module '@forinda/kickjs' { interface ContextMeta { ${i}: { id: string } } }
-          // const Load${a} = defineHttpContextDecorator({
-          //   key: '${i}',
-          //   resolve: (ctx) => ({ id: ctx.req.headers['x-${i}-id'] as string }),
-          // })
-          // return [Load${a}.registration]
-        ]
-      },
-
-      /**
-       * Runs on graceful shutdown (SIGINT/SIGTERM). Clean up long-lived
-       * resources the adapter owns: close connections, flush buffers,
-       * cancel timers. The framework runs every adapter's \`shutdown\`
-       * concurrently via \`Promise.allSettled\` — one failure won't block
-       * sibling adapters.
-       *
-       * Delete this hook if your adapter holds no resources.
-       */
-      async shutdown(): Promise<void> {
-        // Example: await this.pool.end()
-        // Example: clearInterval(this.heartbeatTimer)
-      },
-    }
-  },
-})
-`),o.push(s),o}const Le={controller:`presentation`,service:`domain/services`,dto:`application/dtos`,guard:`presentation/guards`,middleware:`middleware`,contributor:`presentation/contributors`},Re={controller:``,service:``,dto:`dtos`,guard:`guards`,middleware:`middleware`,contributor:`contributors`},ze={controller:``,service:``,dto:`dtos`,guard:`guards`,middleware:`middleware`,contributor:`contributors`,command:`commands`,query:`queries`,event:`events`};function X(e){let{type:t,outDir:n,moduleName:r,modulesDir:i=`src/modules`,defaultDir:a,pattern:o=`ddd`,shouldPluralize:s=!0}=e;if(n)return m(n);if(r){let e=o===`ddd`?Le:o===`cqrs`?ze:Re,n=E(r),a=s?D(n):n,c=e[t]??``,l=f(i,a);return m(c?f(l,c):l)}return m(a)}async function Be(t){let{name:n,moduleName:r,modulesDir:i,pattern:a}=t,o=X({type:`middleware`,outDir:t.outDir,moduleName:r,modulesDir:i,defaultDir:`src/middleware`,pattern:a,shouldPluralize:t.pluralize??!0}),s=E(n),c=T(n),l=[],u=f(o,`${s}.middleware.ts`);return await e(u,`import type { Request, Response, NextFunction } from 'express'
-
-export interface ${w(n)}Options {
-  // Add configuration options here. The factory below closes over the
-  // resolved options object; pass them at the call site —
-  // \`${c}({ foo: 'bar' })\` — and the closure preserves them across
-  // every request.
-}
-
-/**
- * ${w(n)} middleware.
- *
- * Usage in bootstrap (fires on every request):
- *   middleware: [${c}()]
- *
- * Usage with adapter — phase controls *when* the handler runs:
- *
- *   middleware() {
- *     return [{ handler: ${c}(), phase: 'afterGlobal' }]
- *   }
- *
- * Phase semantics (see \`MiddlewarePhase\` JSDoc for the full contract):
- *   - 'beforeGlobal' / 'afterGlobal' / 'beforeRoutes' — fire on every
- *     request, before module routes run.
- *   - 'afterRoutes' — fires ONLY when no route matched (404 fall-through)
- *     OR a route handler called \`next()\` without ending the response.
- *     Controllers that call \`ctx.json(…)\` end the chain and skip this
- *     phase. For per-response work (logging, metrics) attach to
- *     \`res.on('finish', …)\` from an earlier-phase middleware instead.
- *
- * Optional path scope — string, RegExp, or array of either:
- *   middleware() {
- *     return [{
- *       handler: ${c}({ region: 'eu' }),
- *       phase: 'afterGlobal',
- *       path: ['/api', /^\\/admin/],
- *     }]
- *   }
- *
- * Usage with @Middleware decorator:
- *   @Middleware(${c}())
- */
-export function ${c}(options: ${w(n)}Options = {}) {
-  return (req: Request, res: Response, next: NextFunction) => {
-    // Implement your middleware logic here. \`options\` is captured by
-    // closure — log or read it anywhere in this handler body.
-    void options
-    next()
-  }
-}
-`),l.push(u),l}async function Ve(t){let{name:n,moduleName:r,modulesDir:i,pattern:a}=t,o=X({type:`guard`,outDir:t.outDir,moduleName:r,modulesDir:i,defaultDir:`src/guards`,pattern:a,shouldPluralize:t.pluralize??!0}),s=E(n),c=T(n),l=w(n),u=[],d=f(o,`${s}.guard.ts`);return await e(d,`import { Container, HttpException } from '@forinda/kickjs'
-import type { RequestContext } from '@forinda/kickjs'
-
-/**
- * ${l} guard.
- *
- * Guards protect routes by checking conditions before the handler runs.
- * Return early with an error response to block access.
- *
- * Usage:
- *   @Middleware(${c}Guard)
- *   @Get('/protected')
- *   async handler(ctx: RequestContext) { ... }
- */
-export async function ${c}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' })
-  }
-}
-`),u.push(d),u}async function He(t){let{name:n,moduleName:r,modulesDir:i,pattern:a}=t,o=X({type:`service`,outDir:t.outDir,moduleName:r,modulesDir:i,defaultDir:`src/services`,pattern:a,shouldPluralize:t.pluralize??!0}),s=E(n),c=w(n),l=[],u=f(o,`${s}.service.ts`);return await e(u,`import { Service } from '@forinda/kickjs'
-
-@Service()
-export class ${c}Service {
-  // Inject dependencies via constructor
-  // constructor(
-  //   @Inject(MY_REPO) private readonly repo: IMyRepository,
-  // ) {}
-}
-`),l.push(u),l}async function Ue(t){let{name:n,moduleName:r,modulesDir:i,pattern:a}=t,o=X({type:`controller`,outDir:t.outDir,moduleName:r,modulesDir:i,defaultDir:`src/controllers`,pattern:a,shouldPluralize:t.pluralize??!0}),s=E(n),c=w(n),l=[],u=f(o,`${s}.controller.ts`);return await e(u,`import { Controller, Get, Post, type Ctx } from '@forinda/kickjs'
-
-// \`Ctx<KickRoutes.${c}Controller['<method>']>\` is generated by
-// \`kick typegen\` (auto-run on \`kick dev\`). After the first run, your IDE
-// will autocomplete \`ctx.params\`, \`ctx.body\`, and \`ctx.query\`.
-// See https://forinda.github.io/kick-js/guide/typegen for details.
-
-@Controller()
-export class ${c}Controller {
-  // @Autowired() private readonly myService!: MyService
-
-  @Get('/')
-  async list(ctx: Ctx<KickRoutes.${c}Controller['list']>) {
-    ctx.json({ message: '${c} list' })
-  }
-
-  @Post('/')
-  async create(ctx: Ctx<KickRoutes.${c}Controller['create']>) {
-    ctx.created({ message: '${c} created', data: ctx.body })
-  }
-}
-`),l.push(u),l}async function We(t){let{name:n,moduleName:r,modulesDir:i,pattern:a}=t,o=X({type:`dto`,outDir:t.outDir,moduleName:r,modulesDir:i,defaultDir:`src/dtos`,pattern:a,shouldPluralize:t.pluralize??!0}),s=E(n),c=w(n),l=T(n),u=[],d=f(o,`${s}.dto.ts`);return await e(d,`import { z } from 'zod'
-
-export const ${l}Schema = z.object({
-  // Define your schema fields here
-  name: z.string().min(1).max(200),
-})
-
-export type ${c}DTO = z.infer<typeof ${l}Schema>
-`),u.push(d),u}const Ge={swagger:`@forinda/kickjs-swagger`,ws:`@forinda/kickjs-ws`,queue:`@forinda/kickjs-queue`,devtools:`@forinda/kickjs-devtools`},Ke={zod:{name:`zod`,range:`^4.3.6`},valibot:{name:`valibot`,range:`^1.4.1`},yup:{name:`yup`,range:`^1.7.1`}};function Z(e,t){let n=e[t];if(!n)throw Error(`generatePackageJson: missing resolved version for ${t}. Add it to SIBLING_PACKAGES in generators/project.ts.`);return n}function qe(e,t,n,r=[],i=`zod`){let a=Ke[i],o={"@forinda/kickjs":Z(n,`@forinda/kickjs`),"@forinda/kickjs-schema":Z(n,`@forinda/kickjs-schema`),dotenv:`^17.3.1`,express:`^5.1.0`,"reflect-metadata":`^0.2.2`,[a.name]:a.range};for(let e of r){let t=Ge[e];t&&!o[t]&&(o[t]=Z(n,t))}return JSON.stringify({name:e,version:`0.0.0`,type:`module`,scripts:{dev:`vite`,"dev:debug":`kick dev:debug`,build:`kick build`,start:`kick start`,test:`vitest run`,"test:watch":`vitest`,typecheck:`tsc --noEmit`,typegen:`kick typegen`,lint:`eslint src/`,format:`prettier --write src/`},dependencies:o,devDependencies:{"@forinda/kickjs-cli":Z(n,`@forinda/kickjs-cli`),"@forinda/kickjs-vite":Z(n,`@forinda/kickjs-vite`),"@swc/core":`^1.15.21`,"@types/express":`^5.0.6`,"@types/node":`^25.0.0`,"unplugin-swc":`^1.5.9`,vite:`^8.0.3`,vitest:`^4.1.2`,typescript:`^6.0.3`,prettier:`^3.8.1`}},null,2)}function Je(){return`import { defineConfig } from 'vite'
-import { resolve } from 'node:path'
-import swc from 'unplugin-swc'
-import { kickjsVitePlugin, envWatchPlugin } from '@forinda/kickjs-vite'
-
-export default defineConfig({
-  oxc: false,
-  plugins: [
-    swc.vite(),
-    kickjsVitePlugin({ entry: 'src/index.ts' }),
-    // Watches .env files and triggers a full reload on change so the
-    // dev server picks up env tweaks without a manual restart.
-    envWatchPlugin(),
-  ],
-  resolve: {
-    alias: {
-      '@': resolve(__dirname, 'src'),
-    },
-  },
-  build: {
-    target: 'node20',
-    ssr: true,
-    outDir: 'dist',
-    sourcemap: true,
-    rollupOptions: {
-      input: resolve(__dirname, 'src/index.ts'),
-      output: { format: 'esm' },
-    },
-  },
-})
-`}function Ye(){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`,paths:{"@/*":[`./src/*`]}},include:[`src`,`.kickjs/types/**/*.d.ts`,`.kickjs/types/**/*.ts`]},null,2)}function Xe(){return JSON.stringify({semi:!1,singleQuote:!0,trailingComma:`all`,printWidth:100,tabWidth:2},null,2)}function Ze(){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 Qe(){return`node_modules/
-dist/
-.env
-coverage/
-.DS_Store
-*.tsbuildinfo
-.kickjs/
-`}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 et(){return`PORT=3000
-NODE_ENV=development
-`}function tt(){return`PORT=3000
-NODE_ENV=development
-`}function nt(){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'],
-  },
-})
-`}const rt=d(ee(import.meta.url)),Q=JSON.parse(g(f(rt,`..`,`package.json`),`utf-8`)),it=`^${Q.version}`,at=[`@forinda/kickjs`,`@forinda/kickjs-cli`,`@forinda/kickjs-schema`,`@forinda/kickjs-vite`,`@forinda/kickjs-swagger`,`@forinda/kickjs-ws`,`@forinda/kickjs-queue`,`@forinda/kickjs-devtools`,`@forinda/kickjs-testing`];async function ot(){let e=await Promise.all(at.map(async e=>{try{let t=S(`npm`,[`view`,e,`version`],{encoding:`utf-8`,timeout:5e3,stdio:[`ignore`,`pipe`,`ignore`]}).toString().trim();if(t&&/^\d+\.\d+\.\d+/.test(t))return[e,`^${t}`]}catch{}return[e,it]}));return Object.fromEntries(e)}async function st(t){let{name:n,directory:r,packageManager:i=`pnpm`,template:o=`rest`,defaultRepo:s=`inmemory`,packages:c=[],schemaLib:l=`zod`}=t,u=r,d=e=>console.log(`  ${e}`);console.log(`\n  Creating KickJS project: ${n}\n`),d(`Resolving package versions...`);let p=await ot();await e(f(u,`package.json`),qe(n,o,p,c,l)),await e(f(u,`vite.config.ts`),Je()),await e(f(u,`tsconfig.json`),Ye()),await e(f(u,`.prettierrc`),Xe()),await e(f(u,`.editorconfig`),Ze()),await e(f(u,`.gitignore`),Qe()),await e(f(u,`.gitattributes`),$e()),await e(f(u,`.env`),et()),await e(f(u,`.env.example`),tt()),await e(f(u,`src/config/index.ts`),Ce(l)),await e(f(u,`src/index.ts`),xe(n,o,Q.version,c)),await e(f(u,`src/modules/index.ts`),Se()),await e(f(u,`src/modules/hello/hello.service.ts`),we()),await e(f(u,`src/modules/hello/hello.controller.ts`),Te()),await e(f(u,`src/modules/hello/hello.module.ts`),Ee()),await e(f(u,`kick.config.ts`),De(o,s,i)),await e(f(u,`vitest.config.ts`),nt()),await e(f(u,`README.md`),a(n,o,i));let{generateAgentDocs:m}=await import(`./agent-docs-BuCTT-9g.mjs`).then(e=>e.t);if(await m({outDir:u,name:n,pm:i,template:o,only:`all`,force:!0}),t.installDeps){console.log(`\n  Installing dependencies with ${i}...\n`);try{C(`${i} install`,{cwd:u,stdio:`inherit`}),console.log(`
-  Dependencies installed successfully!`)}catch{console.log(`\n  Warning: ${i} install failed. Run it manually.`)}}try{let{runTypegen:e}=await import(`./typegen-CSLwAvgI.mjs`).then(e=>e.n);await e({cwd:u,allowDuplicates:!0,silent:!0})}catch{}if(t.initGit)try{C(`git init`,{cwd:u,stdio:`pipe`}),C(`git branch -M main`,{cwd:u,stdio:`pipe`}),C(`git add -A`,{cwd:u,stdio:`pipe`}),C(`git commit -m "chore: initial commit from kick new"`,{cwd:u,stdio:`pipe`}),d(`Git repository initialized`)}catch{d(`Warning: git init failed (git may not be installed)`)}console.log(`
-  Project scaffolded successfully!`),console.log();let h=u!==process.cwd();d(`Next steps:`),h&&d(`  cd ${n}`),t.installDeps||d(`  ${i} install`);let g={rest:`kick g module user`,ddd:`kick g module user --repo drizzle`,cqrs:`kick g module user --pattern cqrs`,minimal:`# add your routes to src/index.ts`};d(`  ${g[o]??g.rest}`),d(`  kick dev`),d(``),d(`Commands:`),d(`  kick dev                  Start dev server with Vite HMR`),d(`  kick build                Production build via Vite`),d(`  kick start                Run production build`),d(``),d(`Generators:`),d(`  kick g module <name>      Full DDD module (controller, DTOs, use-cases, repo)`),d(`  kick g scaffold <n> <f..> CRUD module from field definitions`),d(`  kick g controller <name>  Standalone controller`),d(`  kick g service <name>     @Service() class`),d(`  kick g middleware <name>   Express middleware`),d(`  kick g guard <name>       Route guard (auth, roles, etc.)`),d(`  kick g adapter <name>     AppAdapter with lifecycle hooks`),d(`  kick g dto <name>         Zod DTO schema`),o===`cqrs`&&d(`  kick g job <name>         Queue job processor`),d(`  kick g config             Generate kick.config.ts`),d(``),d(`Add packages:`),d(`  kick add <pkg>            Install a KickJS package + peers`),d(`  kick add --list           Show all available packages`),d(``),d(`Available: auth, swagger, drizzle, prisma, ws, queue, devtools, mcp, testing`),d(``)}function ct(e){return e}function lt(e){return E(e).replace(/-/g,`_`)}function ut(e){let t=e.cwd??process.cwd(),n=e.projectRoot??l(t),r=e.pluralize??!0,i=w(e.name),a=T(e.name),o=E(e.name),s=lt(e.name),c={name:e.name,pascal:i,camel:a,kebab:o,snake:s,modulesDir:e.modulesDir??`src/modules`,cwd:t,projectRoot:n,args:e.args??[],flags:e.flags??{}};if(r){let e=D(o);c.pluralKebab=e,c.pluralPascal=w(e),c.pluralCamel=T(e)}return c}function dt(e,t){return m(e.cwd,t)}async function ft(e){return import(te(e).href)}const pt=new Map;async function mt(e){let t=pt.get(e);if(t)return t;let n=ht(e);return pt.set(e,n),n}async function ht(e){let t=m(e,`package.json`);if(!h(t))return{generators:[],loaded:[],failed:[]};let n=gt(JSON.parse(await y(t,`utf-8`))),r=u(m(e,`package.json`)),i=[],a=[],o=[];for(let e of n){let t;try{t=r.resolve(`${e}/package.json`)}catch{continue}let n;try{n=JSON.parse(await y(t,`utf-8`))}catch(t){o.push({source:e,reason:`failed to parse package.json: ${t}`});continue}if(!n.kickjs?.generators)continue;let s=n.kickjs.generators,c=m(d(t),s);if(!h(c)){o.push({source:e,reason:`kickjs.generators points to missing file: ${s}`});continue}let l;try{l=await ft(c)}catch(t){o.push({source:e,reason:`failed to import manifest: ${t}`});continue}let u=l.default;if(!Array.isArray(u)){o.push({source:e,reason:`manifest's default export is not an array of GeneratorSpec`});continue}for(let t of u){if(!_t(t)){o.push({source:e,reason:`manifest entry is not a valid GeneratorSpec (missing name/files)`});continue}i.push({source:e,spec:t})}a.push(e)}return{generators:i,loaded:a,failed:o}}function gt(e){let t=new Set;for(let n of[e.dependencies,e.devDependencies,e.peerDependencies])if(n)for(let e of Object.keys(n))t.add(e);return Array.from(t)}function _t(e){if(!e||typeof e!=`object`)return!1;let t=e;return typeof t.name==`string`&&typeof t.files==`function`}async function vt(e,t=[]){let n=e.cwd??process.cwd(),r=t.find(t=>t.spec.name===e.generatorName);if(r)return xt(r.spec,r.source,e,n);let i=bt(await mt(n),e.generatorName);return i?xt(i.spec,i.source,e,n):null}async function yt(e,t=[]){let n=await mt(e),r=new Set(t.map(e=>e.spec.name)),i=n.generators.filter(e=>!r.has(e.spec.name));return{generators:[...t,...i],loaded:n.loaded,failed:n.failed}}function bt(e,t){return e.generators.find(e=>e.spec.name===t)}async function xt(t,n,r,i){let a=ut({name:r.itemName,args:r.args,flags:r.flags,modulesDir:r.modulesDir,pluralize:r.pluralize,cwd:i,projectRoot:r.projectRoot}),o=await t.files(a),s=[];for(let t of o){let n=dt(a,t.path);await e(n,t.content),s.push(n)}return{files:s,source:n}}function St(e){return e}function Ct(e){return e}function wt(e){try{return JSON.parse(g(e,`utf-8`))}catch{return null}}function $(e){try{return g(e,`utf-8`)}catch{return null}}function Tt(e){let t=$(f(e,`tsconfig.json`));if(!t)return null;let n=t.replace(/\/\*[\s\S]*?\*\//g,``).replace(/\/\/.*$/gm,``),r;try{r=JSON.parse(n)}catch{return null}if(typeof r?.extends==`string`){let t=Et(e,r.extends);if(t){let e=wt(t)??{};r.compilerOptions={...e.compilerOptions,...r.compilerOptions}}}return r}function Et(e,t){if(t.startsWith(`.`)){let n=m(e,t);return h(n)?n:null}let n=f(e,`node_modules`,t);return h(n)?n:null}function Dt(e){return e.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`)}function Ot(){let e=process.version,t=Number.parseInt(e.replace(/^v/,``).split(`.`)[0],10);return Number.isNaN(t)||t<20?{name:`Node version`,status:`fail`,message:e,fix:`KickJS requires Node 20 or newer.
-Install a supported version via nvm / fnm / volta.`}:{name:`Node version`,status:`pass`,message:e}}function kt(e){if(!e.pkg)return{name:`@forinda/kickjs installed`,status:`warn`,message:`no package.json`};let t={...e.pkg.dependencies,...e.pkg.peerDependencies};return t[`@forinda/kickjs`]?{name:`@forinda/kickjs installed`,status:`pass`,message:t[`@forinda/kickjs`]}:{name:`@forinda/kickjs installed`,status:`fail`,fix:"This directory does not look like a KickJS project — `@forinda/kickjs` is not in your package.json. Run `kick doctor` from the project root, or scaffold a fresh project with `kick new <name>`."}}function At(e){if(!e.pkg)return null;let t={...e.pkg.dependencies,...e.pkg.peerDependencies};return t[`@forinda/kickjs`]&&!t.express?{name:`express installed`,status:`fail`,fix:"`@forinda/kickjs` declares `express` as a required peer dependency, but your package.json does not include it. Install: pnpm add express"}:t.express?{name:`express installed`,status:`pass`,message:t.express}:null}function jt(e){if(!e.pkg)return{name:`reflect-metadata installed`,status:`warn`,message:`no package.json`};let t={...e.pkg.dependencies,...e.pkg.peerDependencies,...e.pkg.devDependencies};return t[`reflect-metadata`]?{name:`reflect-metadata installed`,status:`pass`,message:t[`reflect-metadata`]}:{name:`reflect-metadata installed`,status:`fail`,fix:`KickJS decorators require the reflect-metadata polyfill.
-Install it: pnpm add reflect-metadata
-Then import it at the top of src/index.ts:
-
-  import 'reflect-metadata'
-  // ... rest of bootstrap`}}function Mt(e){if(!e.tsconfig)return[{name:`tsconfig.json present`,status:`fail`,fix:"Create a tsconfig.json with `experimentalDecorators: true` and `emitDecoratorMetadata: true`. `kick new` scaffolds one automatically."}];let t=e.tsconfig.compilerOptions??{},n=[];return n.push(t.experimentalDecorators===!0?{name:`tsconfig: experimentalDecorators`,status:`pass`}:{name:`tsconfig: experimentalDecorators`,status:`fail`,fix:'Add `"experimentalDecorators": true` to compilerOptions in tsconfig.json. Without it, @Service / @Controller / @Get etc. don\'t register any metadata at compile time.'}),n.push(t.emitDecoratorMetadata===!0?{name:`tsconfig: emitDecoratorMetadata`,status:`pass`}:{name:`tsconfig: emitDecoratorMetadata`,status:`fail`,fix:'Add `"emitDecoratorMetadata": true` to compilerOptions in tsconfig.json. The DI container uses this metadata for constructor-parameter injection.'}),n}function Nt(e){let t=[`src/env.ts`,`src/env/index.ts`,`src/config/env.ts`,`src/config/index.ts`].map(t=>f(e.cwd,t)).filter(e=>h(e)).filter(e=>/\bloadEnv\s*\(/.test($(e)??``));if(t.length===0)return null;let n=[`src/index.ts`,`src/main.ts`].map(t=>f(e.cwd,t)).find(e=>h(e));if(!n)return{name:`env wiring`,status:`warn`,message:`env-init file exists but no src/index.ts or src/main.ts found`};let r=$(n)??``,i=d(n),a=[];for(let e of t){let t=p(i,e).replace(/\\/g,`/`).replace(/\.ts$/,``),n=t.startsWith(`.`)?t:`./`+t,r=n.replace(/\/index$/,``);a.push(n,r);let o=e.replace(/\\/g,`/`).match(/\/src\/(.+?)(?:\.ts)?$/);if(o){let e=`@/`+o[1],t=e.replace(/\/index$/,``);a.push(e,t)}}let o=-1;for(let e of new Set(a)){let t=RegExp(`^import\\s+(?:.*?from\\s+)?['"]${Dt(e)}['"]`,`m`),n=r.match(t);n&&n.index!==void 0&&(o===-1||n.index<o)&&(o=n.index)}let s=r.search(/\bbootstrap\s*\(/),c=t.map(t=>p(e.cwd,t).replace(/\\/g,`/`)).join(`, `);return o===-1?{name:`env wiring`,status:`fail`,message:c,fix:`An env-init file (${c}) calls \`loadEnv(...)\` but \`${p(e.cwd,n).replace(/\\/g,`/`)}\` doesn't import it.\nWithout this, ConfigService.get('X') returns undefined while @Value('X') works via process.env fallback — a half-broken config you won't notice until something is missing.\n\nFix: add a side-effect import at the top of ${p(e.cwd,n).replace(/\\/g,`/`)} (above bootstrap()), pointing at one of the detected files. For example:\n\n  import './env'\n  // or\n  import './config'\n  // or, with the @/ alias:\n  import '@/config/env'`}:s!==-1&&o>s?{name:`env wiring`,status:`warn`,message:`env-init imported AFTER bootstrap() — should be before`,fix:`Move the env import above the bootstrap() call so the schema runs before any service reads from ConfigService.`}:{name:`env wiring`,status:`pass`}}function Pt(e,t=Ft){let n=0,r=0,i=[e];for(;i.length>0&&r<t;){let e=i.pop(),a;try{a=_(e,{withFileTypes:!0})}catch{continue}for(let o of a){if(r>=t)break;r++;let a=f(e,o.name);if(o.isDirectory()){i.push(a);continue}try{let e=v(a).mtimeMs;e>n&&(n=e)}catch{}}}return n}const Ft=2e3;function It(e){let t=f(e.cwd,`.kickjs`,`types`);if(!h(t))return null;let n=Pt(t);if(n===0)return null;let r=Date.now()-n,i=Math.floor(r/6e4);return i>60?{name:`typegen freshness`,status:`warn`,message:`last updated ${i} minutes ago`,fix:"Re-run `kick typegen` (or `kick dev`, which runs it on every reload) so generated types match the current code."}:{name:`typegen freshness`,status:`pass`,message:i===0?`just now`:`${i}m ago`}}const Lt=[()=>Ot(),kt,At,jt,Mt,Nt,It];async function Rt(e,t={}){let n={cwd:e,pkg:wt(f(e,`package.json`)),tsconfig:Tt(e)},r=[...Lt,...t.extraChecks??[]],i=[];for(let e of r){let t;try{t=await e(n)}catch(t){i.push({name:e.name||`doctor check`,status:`fail`,message:t instanceof Error?t.message:String(t)});continue}t!=null&&(Array.isArray(t)?i.push(...t):i.push(t))}return i}function zt(e){switch(e){case`pass`:return r.green(`✔`);case`warn`:return r.yellow(`⚠`);case`fail`:return r.red(`✖`)}}function Bt(e){let t=zt(e.status),n=e.message?`  ${r.dim(`(${e.message})`)}`:``;return`${t}  ${e.name}${n}`}function Vt(e){return e.split(`
-`).map(e=>`   ${r.dim(`→`)} ${e}`).join(`
-`)}function Ht(e){return e?.doctor?.checks??[]}function Ut(e){e.command(`doctor`).description(`Pre-flight checks for your KickJS project (dev environment health)`).action(async()=>{let e=process.cwd(),a=Ht(await c(e));t(`KickJS Doctor`);let o=await Rt(e,{extraChecks:a});for(let e of o)i.message(Bt(e)),e.fix&&e.status!==`pass`&&i.message(Vt(e.fix));let s=o.filter(e=>e.status===`pass`).length,l=o.filter(e=>e.status===`warn`).length,u=o.filter(e=>e.status===`fail`).length,d=[r.green(`${s} passed`),l>0?r.yellow(`${l} warning${l===1?``:`s`}`):`${l} warnings`,u>0?r.red(`${u} error${u===1?``:`s`}`):`${u} errors`].join(`, `);u>0?(n(`${d} — fix the errors above before running the app`),process.exit(1)):n(l>0?`${d} — review the warnings`:r.green(`${d} — your environment looks good`))})}export{T as C,O as S,w as T,q as _,vt as a,k as b,st as c,He as d,Ve as f,G as g,Ie as h,yt as i,We as l,X as m,St as n,ut as o,Be as p,Ut as r,ct as s,Ct as t,Ue as u,Ne as v,E as w,D as x,Me as y};
-//# sourceMappingURL=doctor-Cin9GYv9.mjs.map