@forinda/kickjs-cli 1.3.2 → 1.4.0

package/dist/index.js

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