arckode-framework 1.0.0

package/cli/stubs/module-stub.ts

@@ -0,0 +1,469 @@
+// cli/stubs/module-stub.ts — Plantillas para generar módulos completos
+// Usadas por el generador. Cada stub produce código 100% correcto.
+
+export interface ModuleStubParams {
+  name: string       // PascalCase: Producto
+  module: string     // kebab-case: productos
+  fields: { name: string; type: 'string' | 'number' | 'boolean' | 'date'; required: boolean; default?: unknown }[]
+  relations?: { type: 'hasMany' | 'belongsTo'; model: string; foreignKey: string }[]
+  softDelete?: boolean
+}
+
+export function indexStub(p: ModuleStubParams): string {
+  const actions = ['list', 'getById', 'create', 'update', 'delete']
+  const events = [`on${p.name}Created`, `on${p.name}Updated`, `on${p.name}Deleted`]
+
+  return `// ${p.module}/index.ts — PUERTA PÚBLICA
+// Solo esto es visible para otros módulos y conectores.
+// ⚠ REGLA: Append-only. No sacar ni modificar exports existentes.
+
+import { createModule, OrmRepository } from 'arckode-framework'
+import { ${p.name}Service } from './actions/service'
+import { ${p.name}Controller } from './actions/controller'
+import type { ${p.name}DTO } from './types'
+
+export { ${p.name}Service }
+export type { ${p.name}DTO, Create${p.name}DTO, Update${p.name}DTO, ${p.name}Query, ${p.name}Paginated } from './types'
+export type { ${p.name}Sockets } from './sockets'
+export { ${p.name}Validator, Create${p.name}Schema, Update${p.name}Schema } from './validators/schema'
+
+export function ${p.name}Module(sockets?: import('./sockets').${p.name}Sockets) {
+  return createModule({
+    name: '${p.module}',
+    version: '1.0.0',
+    description: 'Módulo de ${p.module}',
+
+    contract: {
+      name: '${p.module}',
+      version: '1.0.0',
+      description: 'Módulo de ${p.module}',
+      actions: ${JSON.stringify(actions)},
+      events: ${JSON.stringify(events)},
+      tables: ['${p.module}'],
+      dependencies: [],
+      rules: ['No importar de otros módulos'],
+    },
+
+    create({ logger, orm, cache, router }) {
+      const repo = new OrmRepository<${p.name}DTO>(orm, '${p.name}')
+      const log = logger.child('${p.module}')
+      const service = new ${p.name}Service(repo, log, cache, sockets)
+      const controller = new ${p.name}Controller(service, log)
+
+      // Rutas públicas por defecto — agregar [auth.authenticate()] para proteger
+      router.get('/${p.module}', (req) => controller.index(req))
+      router.get('/${p.module}/:id', (req) => controller.show(req))
+      router.post('/${p.module}', (req) => controller.store(req))
+      router.put('/${p.module}/:id', (req) => controller.update(req))
+      router.delete('/${p.module}/:id', (req) => controller.destroy(req))
+
+      log.info('Módulo ${p.module} listo')
+      return service
+    },
+  })
+}
+`
+}
+
+export function typesStub(p: ModuleStubParams): string {
+  const fields = p.fields.map(f => `  ${f.name}${f.required ? '' : '?'}: ${mapTS(f.type)}`).join('\n')
+  const filterFields = p.fields.map(f => `  ${f.name}?: ${mapTS(f.type)}`).join('\n')
+
+  const modelFields = p.fields
+    .filter(f => !['id', 'createdAt', 'updatedAt', 'deletedAt'].includes(f.name))
+    .map(f => {
+      const parts = [`    ${f.name}: { type: '${f.type}'`]
+      if (f.required) parts.push(`, required: true`)
+      if (f.default !== undefined) parts.push(`, default: ${JSON.stringify(f.default)}`)
+      parts.push(` }`)
+      return parts.join('')
+    })
+    .join(',\n')
+
+  return `// ${p.module}/types.ts — DTOs y definición del modelo
+// Responsabilidad ÚNICA: definir la forma de los datos.
+// El módulo es dueño de su ModelDefinition — composition-root la importa desde aquí.
+
+import type { ModelDefinition } from 'arckode-framework'
+
+// Definición del modelo para ORM.define() — importar en composition-root.ts
+export const ${p.name}Model: ModelDefinition = {
+  table: '${p.module}',
+  fields: {
+${modelFields}
+  },
+  timestamps: true,
+${p.softDelete ? '  softDelete: true,' : ''}
+}
+
+export interface ${p.name}DTO {
+  id: string
+${fields}
+  createdAt: string
+  updatedAt: string
+${p.softDelete ? '  deletedAt: string | null' : ''}
+}
+
+export interface Create${p.name}DTO {
+${p.fields.filter(f => !f.name.match(/^(id|createdAt|updatedAt|deletedAt)$/)).map(f => `  ${f.name}${f.required ? '' : '?'}: ${mapTS(f.type)}`).join('\n')}
+}
+
+export interface Update${p.name}DTO {
+${p.fields.filter(f => !f.name.match(/^(id|createdAt|updatedAt|deletedAt)$/)).map(f => `  ${f.name}?: ${mapTS(f.type)}`).join('\n')}
+}
+
+// ─── Consultas y paginación ────────────────────────────
+export interface ${p.name}Query {
+${filterFields}
+  page?: number
+  limit?: number
+  sortBy?: string
+  sortOrder?: 'asc' | 'desc'
+  search?: string
+}
+
+export interface ${p.name}Paginated {
+  data: ${p.name}DTO[]
+  pagination: {
+    page: number
+    limit: number
+    total: number
+    totalPages: number
+    hasNext: boolean
+    hasPrev: boolean
+  }
+}
+`
+}
+
+export function socketsStub(p: ModuleStubParams): string {
+  return `// ${p.module}/sockets.ts — Hooks OPCIONALES hacia otros módulos
+// Los sockets son opcionales. El módulo funciona sin ellos.
+// Un conector puede pasar sockets para reaccionar a eventos del módulo.
+
+import type { ${p.name}DTO } from './types'
+
+export interface ${p.name}Sockets {
+  on${p.name}Created?: (data: ${p.name}DTO) => Promise<void>
+  on${p.name}Updated?: (data: ${p.name}DTO) => Promise<void>
+  on${p.name}Deleted?: (id: string) => Promise<void>
+}
+`
+}
+
+export function serviceStub(p: ModuleStubParams): string {
+  const hasSearch = p.fields.some(f => f.type === 'string')
+
+  return `// ${p.module}/actions/service.ts — Lógica de negocio
+// Responsabilidad ÚNICA: casos de uso del módulo.
+// NO sabe de HTTP. NO importa de otros módulos.
+// Recibe dependencias por constructor (Dependency Inversion).
+//
+// IMPORTANTE: depende de RepositoryAdapter<${p.name}DTO>, no del ORM directamente.
+// Esto permite swapear SQL → MongoDB → Prisma en composition-root.ts sin tocar este archivo.
+
+import type { RepositoryAdapter, Logger, CacheAdapter } from 'arckode-framework'
+import { NotFoundError } from 'arckode-framework'
+import type { ${p.name}DTO, Create${p.name}DTO, Update${p.name}DTO, ${p.name}Query, ${p.name}Paginated } from '../types'
+import type { ${p.name}Sockets } from '../sockets'
+
+export class ${p.name}Service {
+  constructor(
+    private readonly repo: RepositoryAdapter<${p.name}DTO>,
+    private readonly logger: Logger,
+    private readonly cache: CacheAdapter,
+    private readonly sockets?: ${p.name}Sockets,
+  ) {}
+
+  async list(query?: ${p.name}Query): Promise<${p.name}Paginated> {
+    this.logger.info('Listando ${p.module}', { query })
+
+    const page = query?.page ?? 1
+    const limit = query?.limit ?? 20
+    const offset = (page - 1) * limit
+    const filters: Record<string, unknown> = {}
+
+    ${p.fields.filter(f => f.name !== 'id').slice(0, 3).map(f => `if (query?.${f.name} !== undefined) filters.${f.name} = query.${f.name}`).join('\n    ')}
+
+    const result = await this.repo.paginate(filters, { limit, offset })
+
+    return {
+      data: result.data,
+      pagination: {
+        page,
+        limit,
+        total: result.total,
+        totalPages: result.pages,
+        hasNext: offset + limit < result.total,
+        hasPrev: page > 1,
+      },
+    }
+  }
+
+  async getById(id: string): Promise<${p.name}DTO> {
+    this.logger.info('Obteniendo ${p.module}', { id })
+    const item = await this.repo.findById(id)
+    if (!item) throw new NotFoundError('${p.name} no encontrado')
+    return item
+  }
+
+  async create(dto: Create${p.name}DTO): Promise<${p.name}DTO> {
+    this.logger.info('Creando ${p.module}')
+    const item = await this.repo.create(dto as Omit<${p.name}DTO, 'id'>)
+    await this.sockets?.on${p.name}Created?.(item)
+    await this.cache.delete('${p.module}:list')
+    return item
+  }
+
+  async update(id: string, dto: Update${p.name}DTO): Promise<${p.name}DTO> {
+    this.logger.info('Actualizando ${p.module}', { id })
+    const item = await this.repo.update(id, dto as Partial<Omit<${p.name}DTO, 'id'>>)
+    if (!item) throw new NotFoundError('${p.name} no encontrado')
+    await this.sockets?.on${p.name}Updated?.(item)
+    await this.cache.delete('${p.module}:list')
+    return item
+  }
+
+  async delete(id: string): Promise<void> {
+    this.logger.info('Eliminando ${p.module}', { id })
+    const deleted = await this.repo.delete(id)
+    if (!deleted) throw new NotFoundError('${p.name} no encontrado')
+    await this.sockets?.on${p.name}Deleted?.(id)
+    await this.cache.delete('${p.module}:list')
+  }
+}
+`
+}
+
+export function controllerStub(p: ModuleStubParams): string {
+  return `// ${p.module}/actions/controller.ts — Capa HTTP
+// Responsabilidad ÚNICA: traducir request/response.
+// SIN lógica de negocio. SIN validación directa.
+
+import type { HttpRequest, Logger } from 'arckode-framework'
+import { validateSchema } from 'arckode-framework'
+import type { ${p.name}Service } from './service'
+import { Create${p.name}Schema, Update${p.name}Schema } from '../validators/schema'
+
+export class ${p.name}Controller {
+  constructor(
+    private readonly service: ${p.name}Service,
+    private readonly logger: Logger,
+  ) {}
+
+  async index(req: HttpRequest) {
+    this.logger.info('GET /${p.module}')
+    const result = await this.service.list(req.query as any)
+    return { status: 200, body: result }
+  }
+
+  async show(req: HttpRequest) {
+    this.logger.info('GET /${p.module}/:id', { id: req.params.id })
+    const item = await this.service.getById(req.params.id)
+    return { status: 200, body: item }
+  }
+
+  async store(req: HttpRequest) {
+    this.logger.info('POST /${p.module}')
+    const data = validateSchema(Create${p.name}Schema, req.body)
+    const item = await this.service.create(data as any)
+    return { status: 201, body: item }
+  }
+
+  async update(req: HttpRequest) {
+    this.logger.info('PUT /${p.module}/:id', { id: req.params.id })
+    const data = validateSchema(Update${p.name}Schema, req.body)
+    const item = await this.service.update(req.params.id, data as any)
+    return { status: 200, body: item }
+  }
+
+  async destroy(req: HttpRequest) {
+    this.logger.info('DELETE /${p.module}/:id', { id: req.params.id })
+    await this.service.delete(req.params.id)
+    return { status: 204, body: null }
+  }
+}
+`
+}
+
+export function validatorStub(p: ModuleStubParams): string {
+  const createRules = p.fields
+    .filter(f => f.name !== 'id')
+    .map(f => {
+      const parts = [`  ${f.name}: { type: '${f.type}' as const`]
+      if (f.required && f.name !== 'createdAt' && f.name !== 'updatedAt') parts.push(', required: true')
+      if (f.type === 'string' && f.required) parts.push(', min: 2, max: 200')
+      parts.push(' }')
+      return parts.join('')
+    })
+    .join('\n')
+
+  const updateRules = p.fields
+    .filter(f => f.name !== 'id' && f.name !== 'createdAt')
+    .map(f => {
+      const parts = [`  ${f.name}: { type: '${f.type}' as const`]
+      if (f.type === 'string') parts.push(', min: 2, max: 200')
+      parts.push(' }')
+      return parts.join('')
+    })
+    .join('\n')
+
+  return `// ${p.module}/validators/schema.ts — Validación de entrada
+// Schemas planos, sin dependencias externas.
+
+import type { ValidationRule } from 'arckode-framework'
+
+export const Create${p.name}Schema: Record<string, ValidationRule> = {
+${createRules}
+}
+
+export const Update${p.name}Schema: Record<string, ValidationRule> = {
+${updateRules}
+}
+
+// Schema compuesto para usar en validación directa
+export const ${p.name}Validator = {
+  create: Create${p.name}Schema,
+  update: Update${p.name}Schema,
+}
+`
+}
+
+export function testStub(p: ModuleStubParams): string {
+  return `// ${p.module}/tests/service.test.ts — Tests del servicio
+// Usa RepositoryAdapter mock — sin dependencia de SQLite ni Postgres.
+
+import { describe, it, expect, beforeEach } from 'bun:test'
+import type { RepositoryAdapter, CacheAdapter } from 'arckode-framework'
+import { silentLogger } from 'arckode-framework/testing'
+import { ${p.name}Service } from '../actions/service'
+import type { ${p.name}DTO } from '../types'
+
+// Mock mínimo de RepositoryAdapter — devuelve datos predefinidos
+function makeRepo(overrides: Partial<RepositoryAdapter<${p.name}DTO>> = {}): RepositoryAdapter<${p.name}DTO> {
+  return {
+    findMany: async () => [],
+    findById: async () => null,
+    findOne: async () => null,
+    create: async (data) => ({ id: 'test-id', ...data } as ${p.name}DTO),
+    update: async (id, data) => ({ id, ...data } as ${p.name}DTO),
+    delete: async () => true,
+    count: async () => 0,
+    paginate: async () => ({ data: [], total: 0, limit: 20, offset: 0, pages: 0 }),
+    ...overrides,
+  }
+}
+
+const silentCache: CacheAdapter = { get: async () => null, set: async () => {}, delete: async () => {}, clear: async () => {} }
+
+describe('${p.name}Service', () => {
+  describe('getById', () => {
+    it('lanza NotFound si el item no existe', async () => {
+      const service = new ${p.name}Service(makeRepo(), silentLogger, silentCache)
+      await expect(service.getById('no-existe')).rejects.toThrow('${p.name} no encontrado')
+    })
+
+    it('retorna el item si existe', async () => {
+      const item = { id: '1' } as ${p.name}DTO
+      const service = new ${p.name}Service(makeRepo({ findById: async () => item }), silentLogger, silentCache)
+      expect(await service.getById('1')).toEqual(item)
+    })
+  })
+
+  describe('create', () => {
+    it('crea y retorna el item', async () => {
+      const service = new ${p.name}Service(makeRepo(), silentLogger, silentCache)
+      const result = await service.create({} as any)
+      expect(result.id).toBe('test-id')
+    })
+  })
+
+  describe('delete', () => {
+    it('lanza NotFound si el item no existe', async () => {
+      const service = new ${p.name}Service(makeRepo({ delete: async () => false }), silentLogger, silentCache)
+      await expect(service.delete('no-existe')).rejects.toThrow('${p.name} no encontrado')
+    })
+  })
+})
+`
+}
+
+export function migrationStub(p: ModuleStubParams): string {
+  // Tipos ANSI SQL — compatibles con SQLite, MySQL y Postgres sin modificaciones
+  const sqlType = (f: ModuleStubParams['fields'][0]): string => {
+    if (f.name === 'id') return 'VARCHAR(36)'
+    const map: Record<string, string> = {
+      string:  'VARCHAR(255)',
+      number:  'DECIMAL(15,4)',
+      boolean: 'BOOLEAN',
+      date:    'TIMESTAMP',
+      json:    'TEXT',
+    }
+    return map[f.type] ?? 'TEXT'
+  }
+
+  const cols = p.fields.map(f => {
+    const pk  = f.name === 'id' ? ' PRIMARY KEY' : ''
+    const req = f.required && f.name !== 'id' ? ' NOT NULL' : ''
+    const def = f.default !== undefined ? ` DEFAULT ${typeof f.default === 'string' ? `'${f.default}'` : f.default}` : ''
+    return `      ${f.name} ${sqlType(f)}${pk}${req}${def}`
+  }).join('\n')
+
+  return `// migrations/${Date.now()}_create_${p.module}.ts
+// Migración generada por arckode make:module
+// SQL ANSI — compatible con SQLite, MySQL y Postgres sin modificaciones.
+
+export async function up(db: any): Promise<void> {
+  await db.run(\`
+    CREATE TABLE IF NOT EXISTS ${p.module} (
+${cols},
+      createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      updatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP${p.softDelete ? ',\n      deletedAt TIMESTAMP NULL' : ''}
+    )
+  \`)
+}
+
+export async function down(db: any): Promise<void> {
+  await db.run(\`DROP TABLE IF EXISTS ${p.module}\`)
+}
+`
+}
+
+export function seedStub(p: ModuleStubParams): string {
+  const sampleData = p.fields
+    .filter(f => f.name !== 'id' && f.name !== 'createdAt' && f.name !== 'updatedAt')
+    .map(f => {
+      if (f.name === 'nombre' || f.name === 'name') return `    ${f.name}: '${p.name} de ejemplo'`
+      if (f.name === 'email') return `    ${f.name}: 'ejemplo@correo.com'`
+      if (f.name === 'activo' || f.name === 'active') return `    ${f.name}: true`
+      if (f.type === 'number') return `    ${f.name}: 100`
+      if (f.type === 'boolean') return `    ${f.name}: false`
+      return `    ${f.name}: 'valor'`
+    })
+    .join('\n')
+
+  return `// seeds/${p.module}.ts — Datos de prueba
+
+export async function seed${p.name}(orm: any): Promise<void> {
+  const items = [
+    {
+${sampleData}
+    },
+    {
+${sampleData.replace(`'${p.name} de ejemplo'`, `'${p.name} de ejemplo 2'`).replace(`'ejemplo@correo.com'`, `'ejemplo2@correo.com'`)}
+    },
+  ]
+
+  for (const item of items) {
+    await orm.create('${p.name}', item)
+  }
+
+  console.log('  ✓ ${p.name} seeded: ' + items.length + ' items')
+}
+`
+}
+
+function mapTS(type: string): string {
+  const map: Record<string, string> = { string: 'string', number: 'number', boolean: 'boolean', date: 'string' }
+  return map[type] ?? 'unknown'
+}

package/kernel/__tests__/adapters.test.ts

@@ -0,0 +1,101 @@
+// kernel/__tests__/adapters.test.ts — Tests de adapters reales
+// Bun:test. Requiere: better-sqlite3 (SQLite), pg (Postgres), redis (Redis)
+
+import { describe, it, expect, beforeAll, afterAll } from 'bun:test'
+
+// ─── SQLite Adapter ────────────────────────────────────
+describe('SQLiteAdapter', () => {
+  let adapter: any
+
+  beforeAll(async () => {
+    const { SqliteAdapter } = await import('../../adapters/sqlite')
+    adapter = new SqliteAdapter({ path: ':memory:' })
+    await adapter.connect()
+  })
+
+  afterAll(async () => {
+    await adapter.close()
+  })
+
+  it('crea tabla e inserta datos', async () => {
+    await adapter.run('CREATE TABLE IF NOT EXISTS test (id TEXT PRIMARY KEY, nombre TEXT)')
+    await adapter.run('INSERT INTO test (id, nombre) VALUES (?, ?)', ['1', 'Test'])
+    const rows = await adapter.query('SELECT * FROM test WHERE id = ?', ['1'])
+    expect(rows).toHaveLength(1)
+    expect((rows[0] as any).nombre).toBe('Test')
+  })
+
+  it('query con múltiples resultados', async () => {
+    await adapter.run('INSERT INTO test (id, nombre) VALUES (?, ?)', ['2', 'Otro'])
+    const rows = await adapter.query('SELECT * FROM test ORDER BY id')
+    expect(rows).toHaveLength(2)
+  })
+
+  it('run devuelve changes', async () => {
+    const result = await adapter.run('DELETE FROM test WHERE id = ?', ['1'])
+    expect(result.changes).toBeGreaterThan(0)
+    expect(result.lastId).toBeDefined()
+  })
+
+  it('query sin resultados devuelve array vacío', async () => {
+    const rows = await adapter.query('SELECT * FROM test WHERE id = ?', ['999'])
+    expect(rows).toEqual([])
+  })
+})
+
+// ─── JWT Adapter ───────────────────────────────────────
+describe('JwtAdapter', () => {
+  it('sign y verify funcionan', async () => {
+    const { jwtTokenAdapter } = await import('../../adapters/jwt')
+    const token = jwtTokenAdapter.sign({ id: '1', role: 'admin' }, 'secret', '1h')
+    expect(token).toBeTruthy()
+    expect(typeof token).toBe('string')
+
+    const payload = jwtTokenAdapter.verify(token, 'secret')
+    expect(payload.id).toBe('1')
+    expect(payload.role).toBe('admin')
+  })
+
+  it('verify rechaza token con secret incorrecto', async () => {
+    const { jwtTokenAdapter } = await import('../../adapters/jwt')
+    const token = jwtTokenAdapter.sign({ id: '1' }, 'correct', '1h')
+    expect(() => jwtTokenAdapter.verify(token, 'wrong')).toThrow()
+  })
+
+  it('verify rechaza token expirado', async () => {
+    const { jwtTokenAdapter } = await import('../../adapters/jwt')
+    const token = jwtTokenAdapter.sign({ id: '1' }, 'secret', '0s')
+    expect(() => jwtTokenAdapter.verify(token, 'secret')).toThrow()
+  })
+})
+
+// ═════════════════════════════════════════════════════════
+// Nota: PostgresAdapter y RedisCacheAdapter requieren
+// servidores externos. Se testean con mock o con docker.
+//
+// Test Postgres (requiere pg instalado y servidor postgres):
+//   describe('PostgresAdapter', () => {
+//     it('conecta y ejecuta query', async () => {
+//       const { PostgresAdapter } = await import('../../adapters/postgres')
+//       const adapter = new PostgresAdapter({
+//         connectionString: 'postgres://test:test@localhost:5432/test'
+//       })
+//       await adapter.connect()
+//       const rows = await adapter.query('SELECT 1 as num')
+//       expect((rows[0] as any).num).toBe(1)
+//       await adapter.close()
+//     })
+//   })
+//
+// Test Redis (requiere redis instalado y servidor redis):
+//   describe('RedisCacheAdapter', () => {
+//     it('set y get', async () => {
+//       const { RedisCacheAdapter } = await import('../../adapters/redis-cache')
+//       const cache = new RedisCacheAdapter({ url: 'redis://localhost:6379' })
+//       await cache.connect()
+//       await cache.set('test', { ok: true })
+//       const val = await cache.get('test')
+//       expect(val).toEqual({ ok: true })
+//       await cache.delete('test')
+//     })
+//   })