@forinda/kickjs-cli 0.5.0 → 0.6.0

package/dist/cli.js

@@ -416,21 +416,12 @@ __name(pluralizePascal, "pluralizePascal");
 
 // src/generators/module.ts
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-async function generateModule(options) {
-  const { name, modulesDir, noEntity, noTests, repo = "inmemory", minimal } = options;
-  const kebab = toKebabCase(name);
-  const pascal = toPascalCase(name);
-  const camel = toCamelCase(name);
-  const plural = pluralize(kebab);
-  const pluralPascal = pluralizePascal(pascal);
-  const moduleDir = join2(modulesDir, plural);
-  const files = [];
-  const write = /* @__PURE__ */ __name(async (relativePath, content) => {
-    const fullPath = join2(moduleDir, relativePath);
-    await writeFileSafe(fullPath, content);
-    files.push(fullPath);
-  }, "write");
-  await write("index.ts", `/**
+
+// src/generators/templates/module-index.ts
+function generateModuleIndex(pascal, kebab, plural, repo) {
+  const repoClass = repo === "inmemory" ? `InMemory${pascal}Repository` : `Drizzle${pascal}Repository`;
+  const repoFile = repo === "inmemory" ? `in-memory-${kebab}` : `drizzle-${kebab}`;
+  return `/**
  * ${pascal} Module
  *
  * Self-contained feature module following Domain-Driven Design (DDD).
@@ -445,7 +436,7 @@ async function generateModule(options) {
 import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs-core'
 import { buildRoutes } from '@forinda/kickjs-http'
 import { ${pascal.toUpperCase()}_REPOSITORY } from './domain/repositories/${kebab}.repository'
-import { ${repo === "inmemory" ? `InMemory${pascal}Repository` : `Drizzle${pascal}Repository`} } from './infrastructure/repositories/${repo === "inmemory" ? `in-memory-${kebab}` : `drizzle-${kebab}`}.repository'
+import { ${repoClass} } from './infrastructure/repositories/${repoFile}.repository'
 import { ${pascal}Controller } from './presentation/${kebab}.controller'
 
 // Eagerly load decorated classes so @Service()/@Repository() decorators register in the DI container
@@ -462,7 +453,7 @@ export class ${pascal}Module implements AppModule {
    */
   register(container: Container): void {
     container.registerFactory(${pascal.toUpperCase()}_REPOSITORY, () =>
-      container.resolve(${repo === "inmemory" ? `InMemory${pascal}Repository` : `Drizzle${pascal}Repository`}),
+      container.resolve(${repoClass}),
     )
   }
 
@@ -479,24 +470,15 @@ export class ${pascal}Module implements AppModule {
     }
   }
 }
-`);
-  await write(`presentation/${kebab}.controller.ts`, `/**
- * ${pascal} Controller
- *
- * Presentation layer \u2014 handles HTTP requests and delegates to use cases.
- * Each method receives a RequestContext with typed body, params, and query.
- *
- * Decorators:
- *   @Controller(path?) \u2014 registers this class as an HTTP controller
- *   @Get/@Post/@Put/@Delete(path?, validation?) \u2014 defines routes with optional Zod validation
- *   @Autowired() \u2014 injects dependencies lazily from the DI container
- *   @Middleware(...handlers) \u2014 attach middleware at class or method level
- *
- * Add Swagger decorators (@ApiTags, @ApiOperation, @ApiResponse) from @forinda/kickjs-swagger
- * for automatic OpenAPI documentation.
- */
-import { Controller, Get, Post, Put, Delete, Autowired } from '@forinda/kickjs-core'
-import { RequestContext } from '@forinda/kickjs-http'
+`;
+}
+__name(generateModuleIndex, "generateModuleIndex");
+
+// src/generators/templates/controller.ts
+function generateController(pascal, kebab, plural, pluralPascal) {
+  return `import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams } from '@forinda/kickjs-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+import { ApiTags } from '@forinda/kickjs-swagger'
 import { Create${pascal}UseCase } from '../application/use-cases/create-${kebab}.use-case'
 import { Get${pascal}UseCase } from '../application/use-cases/get-${kebab}.use-case'
 import { List${pluralPascal}UseCase } from '../application/use-cases/list-${plural}.use-case'
@@ -504,6 +486,7 @@ import { Update${pascal}UseCase } from '../application/use-cases/update-${kebab}
 import { Delete${pascal}UseCase } from '../application/use-cases/delete-${kebab}.use-case'
 import { create${pascal}Schema } from '../application/dtos/create-${kebab}.dto'
 import { update${pascal}Schema } from '../application/dtos/update-${kebab}.dto'
+import { ${pascal.toUpperCase()}_QUERY_CONFIG } from '../constants'
 
 @Controller()
 export class ${pascal}Controller {
@@ -513,39 +496,65 @@ export class ${pascal}Controller {
   @Autowired() private update${pascal}UseCase!: Update${pascal}UseCase
   @Autowired() private delete${pascal}UseCase!: Delete${pascal}UseCase
 
-  @Post('/', { body: create${pascal}Schema })
-  async create(ctx: RequestContext) {
-    const result = await this.create${pascal}UseCase.execute(ctx.body)
-    ctx.created(result)
-  }
-
   @Get('/')
+  @ApiTags('${pascal}')
+  @ApiQueryParams(${pascal.toUpperCase()}_QUERY_CONFIG)
   async list(ctx: RequestContext) {
-    const result = await this.list${pluralPascal}UseCase.execute()
-    ctx.json(result)
+    return ctx.paginate(
+      (parsed) => this.list${pluralPascal}UseCase.execute(parsed),
+      ${pascal.toUpperCase()}_QUERY_CONFIG,
+    )
   }
 
   @Get('/:id')
+  @ApiTags('${pascal}')
   async getById(ctx: RequestContext) {
     const result = await this.get${pascal}UseCase.execute(ctx.params.id)
     if (!result) return ctx.notFound('${pascal} not found')
     ctx.json(result)
   }
 
-  @Put('/:id', { body: update${pascal}Schema })
+  @Post('/', { body: create${pascal}Schema, name: 'Create${pascal}' })
+  @ApiTags('${pascal}')
+  async create(ctx: RequestContext) {
+    const result = await this.create${pascal}UseCase.execute(ctx.body)
+    ctx.created(result)
+  }
+
+  @Put('/:id', { body: update${pascal}Schema, name: 'Update${pascal}' })
+  @ApiTags('${pascal}')
   async update(ctx: RequestContext) {
     const result = await this.update${pascal}UseCase.execute(ctx.params.id, ctx.body)
     ctx.json(result)
   }
 
   @Delete('/:id')
+  @ApiTags('${pascal}')
   async remove(ctx: RequestContext) {
     await this.delete${pascal}UseCase.execute(ctx.params.id)
     ctx.noContent()
   }
 }
-`);
-  await write(`application/dtos/create-${kebab}.dto.ts`, `import { z } from 'zod'
+`;
+}
+__name(generateController, "generateController");
+
+// src/generators/templates/constants.ts
+function generateConstants(pascal) {
+  return `import type { QueryParamsConfig } from '@forinda/kickjs-core'
+
+export const ${pascal.toUpperCase()}_QUERY_CONFIG: QueryParamsConfig = {
+  filterable: ['name'],
+  sortable: ['name', 'createdAt'],
+  searchable: ['name'],
+}
+`;
+}
+__name(generateConstants, "generateConstants");
+
+// src/generators/templates/dtos.ts
+function generateCreateDTO(pascal, kebab) {
+  return `import { z } from 'zod'
 
 /**
  * Create ${pascal} DTO \u2014 Zod schema for validating POST request bodies.
@@ -561,23 +570,34 @@ export const create${pascal}Schema = z.object({
 })
 
 export type Create${pascal}DTO = z.infer<typeof create${pascal}Schema>
-`);
-  await write(`application/dtos/update-${kebab}.dto.ts`, `import { z } from 'zod'
+`;
+}
+__name(generateCreateDTO, "generateCreateDTO");
+function generateUpdateDTO(pascal, kebab) {
+  return `import { z } from 'zod'
 
 export const update${pascal}Schema = z.object({
   name: z.string().min(1).max(200).optional(),
 })
 
 export type Update${pascal}DTO = z.infer<typeof update${pascal}Schema>
-`);
-  await write(`application/dtos/${kebab}-response.dto.ts`, `export interface ${pascal}ResponseDTO {
+`;
+}
+__name(generateUpdateDTO, "generateUpdateDTO");
+function generateResponseDTO(pascal, kebab) {
+  return `export interface ${pascal}ResponseDTO {
   id: string
   name: string
   createdAt: string
   updatedAt: string
 }
-`);
-  const useCases = [
+`;
+}
+__name(generateResponseDTO, "generateResponseDTO");
+
+// src/generators/templates/use-cases.ts
+function generateUseCases(pascal, kebab, plural, pluralPascal) {
+  return [
     {
       file: `create-${kebab}.use-case.ts`,
       content: `/**
@@ -626,7 +646,7 @@ export class Get${pascal}UseCase {
       file: `list-${plural}.use-case.ts`,
       content: `import { Service, Inject } from '@forinda/kickjs-core'
 import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
-import type { ${pascal}ResponseDTO } from '../dtos/${kebab}-response.dto'
+import type { ParsedQuery } from '@forinda/kickjs-http'
 
 @Service()
 export class List${pluralPascal}UseCase {
@@ -634,8 +654,8 @@ export class List${pluralPascal}UseCase {
     @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
   ) {}
 
-  async execute(): Promise<${pascal}ResponseDTO[]> {
-    return this.repo.findAll()
+  async execute(parsed: ParsedQuery) {
+    return this.repo.findPaginated(parsed)
   }
 }
 `
@@ -677,10 +697,12 @@ export class Delete${pascal}UseCase {
 `
     }
   ];
-  for (const uc of useCases) {
-    await write(`application/use-cases/${uc.file}`, uc.content);
-  }
-  await write(`domain/repositories/${kebab}.repository.ts`, `/**
+}
+__name(generateUseCases, "generateUseCases");
+
+// src/generators/templates/repository.ts
+function generateRepositoryInterface(pascal, kebab) {
+  return `/**
  * ${pascal} Repository Interface
  *
  * Domain layer \u2014 defines the contract for data access.
@@ -693,43 +715,23 @@ export class Delete${pascal}UseCase {
 import type { ${pascal}ResponseDTO } from '../../application/dtos/${kebab}-response.dto'
 import type { Create${pascal}DTO } from '../../application/dtos/create-${kebab}.dto'
 import type { Update${pascal}DTO } from '../../application/dtos/update-${kebab}.dto'
+import type { ParsedQuery } from '@forinda/kickjs-http'
 
 export interface I${pascal}Repository {
   findById(id: string): Promise<${pascal}ResponseDTO | null>
   findAll(): Promise<${pascal}ResponseDTO[]>
+  findPaginated(parsed: ParsedQuery): Promise<{ data: ${pascal}ResponseDTO[]; total: number }>
   create(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO>
   update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO>
   delete(id: string): Promise<void>
 }
 
 export const ${pascal.toUpperCase()}_REPOSITORY = Symbol('I${pascal}Repository')
-`);
-  await write(`domain/services/${kebab}-domain.service.ts`, `/**
- * ${pascal} 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 { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../repositories/${kebab}.repository'
-
-@Service()
-export class ${pascal}DomainService {
-  constructor(
-    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
-  ) {}
-
-  async ensureExists(id: string): Promise<void> {
-    const entity = await this.repo.findById(id)
-    if (!entity) {
-      throw HttpException.notFound('${pascal} not found')
-    }
-  }
+`;
 }
-`);
-  if (repo === "inmemory") {
-    await write(`infrastructure/repositories/in-memory-${kebab}.repository.ts`, `/**
+__name(generateRepositoryInterface, "generateRepositoryInterface");
+function generateInMemoryRepository(pascal, kebab) {
+  return `/**
  * In-Memory ${pascal} Repository
  *
  * Infrastructure layer \u2014 implements the repository interface using a Map.
@@ -740,6 +742,7 @@ export class ${pascal}DomainService {
  */
 import { randomUUID } from 'node:crypto'
 import { Repository, HttpException } from '@forinda/kickjs-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
 import type { I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
 import type { ${pascal}ResponseDTO } from '../../application/dtos/${kebab}-response.dto'
 import type { Create${pascal}DTO } from '../../application/dtos/create-${kebab}.dto'
@@ -757,6 +760,12 @@ export class InMemory${pascal}Repository implements I${pascal}Repository {
     return Array.from(this.store.values())
   }
 
+  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${pascal}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${pascal}DTO): Promise<${pascal}ResponseDTO> {
     const now = new Date().toISOString()
     const entity: ${pascal}ResponseDTO = {
@@ -782,10 +791,40 @@ export class InMemory${pascal}Repository implements I${pascal}Repository {
     this.store.delete(id)
   }
 }
-`);
+`;
+}
+__name(generateInMemoryRepository, "generateInMemoryRepository");
+
+// src/generators/templates/domain.ts
+function generateDomainService(pascal, kebab) {
+  return `/**
+ * ${pascal} 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 { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../repositories/${kebab}.repository'
+
+@Service()
+export class ${pascal}DomainService {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+  ) {}
+
+  async ensureExists(id: string): Promise<void> {
+    const entity = await this.repo.findById(id)
+    if (!entity) {
+      throw HttpException.notFound('${pascal} not found')
+    }
   }
-  if (!noEntity && !minimal) {
-    await write(`domain/entities/${kebab}.entity.ts`, `/**
+}
+`;
+}
+__name(generateDomainService, "generateDomainService");
+function generateEntity(pascal, kebab) {
+  return `/**
  * ${pascal} Entity
  *
  * Domain layer \u2014 the core business object.
@@ -854,8 +893,11 @@ export class ${pascal} {
     }
   }
 }
-`);
-    await write(`domain/value-objects/${kebab}-id.vo.ts`, `/**
+`;
+}
+__name(generateEntity, "generateEntity");
+function generateValueObject(pascal, kebab) {
+  return `/**
  * ${pascal} ID Value Object
  *
  * Domain layer \u2014 wraps a primitive ID with type safety and validation.
@@ -889,7 +931,171 @@ export class ${pascal}Id {
     return this.value === other.value
   }
 }
-`);
+`;
+}
+__name(generateValueObject, "generateValueObject");
+
+// src/generators/templates/tests.ts
+function generateControllerTest(pascal, kebab, plural) {
+  return `import { describe, it, expect, beforeEach } from 'vitest'
+import { Container } from '@forinda/kickjs-core'
+
+describe('${pascal}Controller', () => {
+  beforeEach(() => {
+    Container.reset()
+  })
+
+  it('should be defined', () => {
+    expect(true).toBe(true)
+  })
+
+  describe('POST /${plural}', () => {
+    it('should create a new ${kebab}', async () => {
+      // TODO: Set up test module, call create endpoint, assert 201
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('GET /${plural}', () => {
+    it('should return paginated ${plural}', async () => {
+      // TODO: Set up test module, call list endpoint, assert { data, meta }
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('GET /${plural}/:id', () => {
+    it('should return a ${kebab} by id', async () => {
+      // TODO: Create a ${kebab}, then fetch by id, assert match
+      expect(true).toBe(true)
+    })
+
+    it('should return 404 for non-existent ${kebab}', async () => {
+      // TODO: Fetch non-existent id, assert 404
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('PUT /${plural}/:id', () => {
+    it('should update an existing ${kebab}', async () => {
+      // TODO: Create, update, assert changes
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('DELETE /${plural}/:id', () => {
+    it('should delete a ${kebab}', async () => {
+      // TODO: Create, delete, assert gone
+      expect(true).toBe(true)
+    })
+  })
+})
+`;
+}
+__name(generateControllerTest, "generateControllerTest");
+function generateRepositoryTest(pascal, kebab, plural) {
+  return `import { describe, it, expect, beforeEach } from 'vitest'
+import { InMemory${pascal}Repository } from '../infrastructure/repositories/in-memory-${kebab}.repository'
+
+describe('InMemory${pascal}Repository', () => {
+  let repo: InMemory${pascal}Repository
+
+  beforeEach(() => {
+    repo = new InMemory${pascal}Repository()
+  })
+
+  it('should create and retrieve a ${kebab}', async () => {
+    const created = await repo.create({ name: 'Test ${pascal}' })
+    expect(created).toBeDefined()
+    expect(created.name).toBe('Test ${pascal}')
+    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 ${plural}', async () => {
+    await repo.create({ name: '${pascal} 1' })
+    await repo.create({ name: '${pascal} 2' })
+
+    const all = await repo.findAll()
+    expect(all).toHaveLength(2)
+  })
+
+  it('should return paginated results', async () => {
+    await repo.create({ name: '${pascal} 1' })
+    await repo.create({ name: '${pascal} 2' })
+    await repo.create({ name: '${pascal} 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 ${kebab}', 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 ${kebab}', async () => {
+    const created = await repo.create({ name: 'To Delete' })
+    await repo.delete(created.id)
+    const found = await repo.findById(created.id)
+    expect(found).toBeNull()
+  })
+})
+`;
+}
+__name(generateRepositoryTest, "generateRepositoryTest");
+
+// src/generators/module.ts
+async function generateModule(options) {
+  const { name, modulesDir, noEntity, noTests, repo = "inmemory", minimal } = options;
+  const kebab = toKebabCase(name);
+  const pascal = toPascalCase(name);
+  const camel = toCamelCase(name);
+  const plural = pluralize(kebab);
+  const pluralPascal = pluralizePascal(pascal);
+  const moduleDir = join2(modulesDir, plural);
+  const files = [];
+  const write = /* @__PURE__ */ __name(async (relativePath, content) => {
+    const fullPath = join2(moduleDir, relativePath);
+    await writeFileSafe(fullPath, content);
+    files.push(fullPath);
+  }, "write");
+  await write("index.ts", generateModuleIndex(pascal, kebab, plural, repo));
+  await write("constants.ts", generateConstants(pascal));
+  await write(`presentation/${kebab}.controller.ts`, generateController(pascal, kebab, plural, pluralPascal));
+  await write(`application/dtos/create-${kebab}.dto.ts`, generateCreateDTO(pascal, kebab));
+  await write(`application/dtos/update-${kebab}.dto.ts`, generateUpdateDTO(pascal, kebab));
+  await write(`application/dtos/${kebab}-response.dto.ts`, generateResponseDTO(pascal, kebab));
+  const useCases = generateUseCases(pascal, kebab, plural, pluralPascal);
+  for (const uc of useCases) {
+    await write(`application/use-cases/${uc.file}`, uc.content);
+  }
+  await write(`domain/repositories/${kebab}.repository.ts`, generateRepositoryInterface(pascal, kebab));
+  await write(`domain/services/${kebab}-domain.service.ts`, generateDomainService(pascal, kebab));
+  if (repo === "inmemory") {
+    await write(`infrastructure/repositories/in-memory-${kebab}.repository.ts`, generateInMemoryRepository(pascal, kebab));
+  }
+  if (!noEntity && !minimal) {
+    await write(`domain/entities/${kebab}.entity.ts`, generateEntity(pascal, kebab));
+    await write(`domain/value-objects/${kebab}-id.vo.ts`, generateValueObject(pascal, kebab));
+  }
+  if (!noTests) {
+    await write(`__tests__/${kebab}.controller.test.ts`, generateControllerTest(pascal, kebab, plural));
+    await write(`__tests__/${kebab}.repository.test.ts`, generateRepositoryTest(pascal, kebab, plural));
   }
   await autoRegisterModule(modulesDir, pascal, plural);
   return files;
@@ -1143,7 +1349,7 @@ __name(generateService, "generateService");
 
 // src/generators/controller.ts
 import { join as join7 } from "path";
-async function generateController(options) {
+async function generateController2(options) {
   const { name, outDir } = options;
   const kebab = toKebabCase(name);
   const pascal = toPascalCase(name);
@@ -1170,7 +1376,7 @@ export class ${pascal}Controller {
   files.push(filePath);
   return files;
 }
-__name(generateController, "generateController");
+__name(generateController2, "generateController");
 
 // src/generators/dto.ts
 import { join as join8 } from "path";
@@ -1313,7 +1519,7 @@ function registerGenerateCommand(program) {
     printGenerated(files);
   });
   gen.command("controller <name>").description("Generate a @Controller() class with basic routes").option("-o, --out <dir>", "Output directory", "src/controllers").action(async (name, opts) => {
-    const files = await generateController({
+    const files = await generateController2({
       name,
       outDir: resolve2(opts.out)
     });