arckode-framework 1.0.0 → 1.0.1

package/kernel/__tests__/framework.test.ts

@@ -1,617 +0,0 @@
-// kernel/__tests__/framework.test.ts — Tests del kernel
-// Bun:test. Cubre: Config, Logger, Container, ORM, Router, Auth, Cache, Validator, System
-
-import { describe, it, expect, beforeAll, beforeEach } from 'bun:test'
-import {
-  ConfigStore, Logger, Container, ORM, Router, NodeServer,
-  MemoryCache, Auth, validateSchema, System, createModule,
-  NotFoundError, ValidationError, AuthError,
-} from '../framework'
-import { jwtTokenAdapter } from '../../adapters/jwt'
-
-// ─── MOCK DB — simula almacenamiento para tests de comportamiento ──────────
-const mockDb = {
-  _tables: new Map<string, any[]>(),
-  query: async (sql: string, params?: unknown[]) => {
-    const table = sql.match(/FROM (\w+)/i)?.[1] ?? ''
-    const data = mockDb._tables.get(table) ?? []
-    if (sql.includes('SELECT') && sql.includes('WHERE') && params && params.length > 0) {
-      // params es un array: [id] para findById, o [valor, ...] para filtros
-      const whereClause = sql.match(/WHERE (.+)/i)?.[1] ?? ''
-      const conditions = whereClause.split(' AND ')
-      return data.filter(row => {
-        return conditions.every((cond, i) => {
-          const col = cond.split(' ')[0] ?? ''
-          return params![i] !== undefined && row[col] === params![i]
-        })
-      })
-    }
-    return data
-  },
-  run: async (sql: string, params?: unknown[]) => {
-    if (sql.includes('CREATE TABLE')) return { changes: 0 }
-    if (sql.includes('INSERT INTO')) {
-      const table = sql.match(/INTO (\w+)/i)?.[1] ?? ''
-      const data = mockDb._tables.get(table) ?? []
-      const id = params?.[0] ?? crypto.randomUUID()
-      const row = { id } as any
-      const keys = sql.match(/\(([^)]+)\)/g)?.[0]?.replace(/[()]/g, '')?.split(', ').map(s => s.trim()) ?? []
-      keys.forEach((k, i) => { row[k] = params?.[i] })
-      data.push(row)
-      mockDb._tables.set(table, data)
-      return { changes: 1, lastId: id }
-    }
-    if (sql.includes('DELETE')) {
-      const table = sql.match(/FROM (\w+)/i)?.[1] ?? ''
-      const id = params?.[0]
-      const data = mockDb._tables.get(table) ?? []
-      mockDb._tables.set(table, data.filter((r: any) => r.id !== id))
-      return { changes: 1 }
-    }
-    return { changes: 0 }
-  },
-  close: async () => {},
-}
-
-// ─── RECORDING MOCK — graba SQL generado para verificar contratos del ORM ──
-// El ORM es una abstracción. Sus tests validan qué SQL genera y delega al adapter,
-// no cómo lo ejecuta (eso es responsabilidad de cada adapter: SQLite, Postgres, etc.)
-function createRecordingDb(opts: { countValue?: number; queryData?: unknown[] } = {}) {
-  const calls: { sql: string; params: unknown[] }[] = []
-  const countValue = opts.countValue ?? 0
-  const queryData = opts.queryData ?? []
-
-  return {
-    calls,
-    lastSql: () => calls.at(-1)?.sql ?? '',
-    lastParams: () => calls.at(-1)?.params ?? [],
-    reset: () => { calls.length = 0 },
-
-    query: async (sql: string, params: unknown[] = []) => {
-      calls.push({ sql, params })
-      // COUNT(*) → devuelve el total configurado
-      if (sql.includes('COUNT(*)')) return [{ n: countValue }]
-      return queryData
-    },
-    run: async (sql: string, params: unknown[] = []) => {
-      calls.push({ sql, params })
-      return { changes: 1 }
-    },
-    close: async () => {},
-  }
-}
-
-// ═════════════════════════════════════════════════════
-// 1. CONFIG
-// ═════════════════════════════════════════════════════
-describe('ConfigStore', () => {
-  it('define y carga valores correctamente', () => {
-    const c = new ConfigStore()
-    c.define({ PORT: { type: 'number', default: 3000 }, JWT_SECRET: { type: 'string', required: true } })
-    c.load({ JWT_SECRET: 'test123' })
-    expect(c.get<number>('PORT')).toBe(3000)
-    expect(c.get<string>('JWT_SECRET')).toBe('test123')
-  })
-
-  it('fail fast si falta required', () => {
-    const c = new ConfigStore()
-    c.define({ REQUIRED: { type: 'string', required: true } })
-    expect(() => c.load({})).toThrow('CONFIG')
-  })
-
-  it('falla si no se llamó load()', () => {
-    const c = new ConfigStore()
-    c.define({ X: { type: 'string' } })
-    expect(() => c.get('X')).toThrow('Config no cargada')
-  })
-
-  it('falla si la key no existe', () => {
-    const c = new ConfigStore()
-    expect(() => c.get('NOEXISTE')).toThrow()
-  })
-
-  it('type: url valida URLs correctas', () => {
-    const c = new ConfigStore()
-    c.define({ URL: { type: 'url', required: true } })
-    c.load({ URL: 'https://example.com' })
-    expect(c.get<string>('URL')).toBe('https://example.com')
-  })
-
-  it('type: url rechaza URLs inválidas', () => {
-    const c = new ConfigStore()
-    c.define({ URL: { type: 'url', required: true } })
-    expect(() => c.load({ URL: 'no-es-url' })).toThrow()
-  })
-})
-
-// ═════════════════════════════════════════════════════
-// 2. LOGGER
-// ═════════════════════════════════════════════════════
-describe('Logger', () => {
-  it('crea logger con source', () => {
-    const l = new Logger('test')
-    expect(l.source).toBe('test')
-  })
-
-  it('child hereda source', () => {
-    const l = new Logger('app').child('modulo')
-    expect(l.source).toBe('app.modulo')
-  })
-
-  it('no rompe al loguear', () => {
-    const l = new Logger('test', 'error')
-    l.info('no debería aparecer')
-    l.error('debería aparecer')
-  })
-})
-
-// ═════════════════════════════════════════════════════
-// 3. CONTAINER
-// ═════════════════════════════════════════════════════
-describe('Container', () => {
-  it('registra y resuelve servicios', () => {
-    const c = new Container()
-    c.register('num', () => 42)
-    c.init()
-    expect(c.get<number>('num')).toBe(42)
-  })
-
-  it('tira error si no existe', () => {
-    const c = new Container()
-    c.init()
-    expect(() => c.get('no-existe')).toThrow('no registrado')
-  })
-
-  it('tira error si se registra después de init', () => {
-    const c = new Container()
-    c.init()
-    expect(() => c.register('x', () => 1)).toThrow('registered after init')
-  })
-
-  it('singleton: misma instancia', () => {
-    const c = new Container()
-    c.register('obj', () => ({ a: 1 }))
-    c.init()
-    const a = c.get<{ a: number }>('obj')
-    const b = c.get<{ a: number }>('obj')
-    expect(a).toBe(b)
-  })
-})
-
-// ═════════════════════════════════════════════════════
-// 4. ORM
-// ═════════════════════════════════════════════════════
-describe('ORM', () => {
-  let orm: ORM
-
-  beforeAll(() => {
-    orm = new ORM(mockDb as any)
-    orm.define('Producto', {
-      table: 'productos',
-      fields: { nombre: { type: 'string', required: true }, precio: { type: 'number' } },
-      timestamps: true,
-    })
-  })
-
-  it('findMany devuelve array vacío al inicio', async () => {
-    const items = await orm.findMany('Producto')
-    expect(items).toEqual([])
-  })
-
-  it('create y findById funcionan', async () => {
-    const created = await orm.create('Producto', { nombre: 'Test', precio: 100 })
-    expect(created.id).toBeDefined()
-    expect(created.nombre).toBe('Test')
-    expect(created.createdAt).toBeDefined()
-
-    const found = await orm.findById('Producto', created.id)
-    expect(found).not.toBeNull()
-    expect(found?.nombre).toBe('Test')
-  })
-
-  it('findById devuelve null si no existe', async () => {
-    const found = await orm.findById('Producto', 'no-existe')
-    expect(found).toBeNull()
-  })
-
-  it('delete devuelve true si existía', async () => {
-    const created = await orm.create('Producto', { nombre: 'Borrar' })
-    const deleted = await orm.delete('Producto', created.id)
-    expect(deleted).toBe(true)
-
-    const found = await orm.findById('Producto', created.id)
-    expect(found).toBeNull()
-  })
-
-  it('tira error si modelo no existe', async () => {
-    await expect(orm.findMany('NoExiste')).rejects.toThrow(NotFoundError)
-  })
-})
-
-// ═════════════════════════════════════════════════════
-// 4b. ORM — GENERACIÓN DE SQL (Recording Mock)
-// Verifica el contrato del ORM con el adapter.
-// Independiente de SQLite, Postgres o cualquier implementación.
-// ═════════════════════════════════════════════════════
-describe('ORM — Generación de SQL', () => {
-  const FIELDS = { nombre: { type: 'string' as const }, precio: { type: 'number' as const } }
-  const fakeItem = { id: 'uuid-1', nombre: 'Laptop', precio: 1500 }
-
-  function makeOrm(db: ReturnType<typeof createRecordingDb>) {
-    const orm = new ORM(db as any)
-    orm.define('Producto', { table: 'productos', fields: FIELDS })
-    return orm
-  }
-
-  it('findMany sin opciones genera SELECT * FROM tabla', async () => {
-    const db = createRecordingDb({ queryData: [] })
-    await makeOrm(db).findMany('Producto')
-    expect(db.lastSql()).toBe('SELECT * FROM productos')
-  })
-
-  it('findMany con filtro genera WHERE con params', async () => {
-    const db = createRecordingDb({ queryData: [fakeItem] })
-    await makeOrm(db).findMany('Producto', { nombre: 'Laptop' })
-    expect(db.lastSql()).toContain('WHERE nombre = ?')
-    expect(db.lastParams()).toEqual(['Laptop'])
-  })
-
-  it('findMany con orderBy DESC genera ORDER BY campo DESC', async () => {
-    const db = createRecordingDb({ queryData: [fakeItem] })
-    await makeOrm(db).findMany('Producto', {}, { orderBy: { field: 'precio', dir: 'DESC' } })
-    expect(db.lastSql()).toContain('ORDER BY precio DESC')
-  })
-
-  it('findMany con orderBy ASC por defecto', async () => {
-    const db = createRecordingDb({ queryData: [fakeItem] })
-    await makeOrm(db).findMany('Producto', {}, { orderBy: { field: 'nombre' } })
-    expect(db.lastSql()).toContain('ORDER BY nombre ASC')
-  })
-
-  it('findMany con múltiples orderBy genera cláusula compuesta', async () => {
-    const db = createRecordingDb({ queryData: [fakeItem] })
-    await makeOrm(db).findMany('Producto', {}, {
-      orderBy: [{ field: 'precio', dir: 'DESC' }, { field: 'nombre', dir: 'ASC' }],
-    })
-    expect(db.lastSql()).toContain('ORDER BY precio DESC, nombre ASC')
-  })
-
-  it('findMany con limit genera LIMIT N', async () => {
-    const db = createRecordingDb({ queryData: [fakeItem] })
-    await makeOrm(db).findMany('Producto', {}, { limit: 10 })
-    expect(db.lastSql()).toContain('LIMIT 10')
-  })
-
-  it('findMany con limit y offset genera LIMIT N OFFSET M', async () => {
-    const db = createRecordingDb({ queryData: [fakeItem] })
-    await makeOrm(db).findMany('Producto', {}, { limit: 10, offset: 20 })
-    const sql = db.lastSql()
-    expect(sql).toContain('LIMIT 10')
-    expect(sql).toContain('OFFSET 20')
-  })
-
-  it('findMany combina filtro + orderBy + limit en el orden correcto', async () => {
-    const db = createRecordingDb({ queryData: [fakeItem] })
-    await makeOrm(db).findMany('Producto', { nombre: 'X' }, {
-      orderBy: { field: 'precio', dir: 'ASC' },
-      limit: 5,
-      offset: 10,
-    })
-    const sql = db.lastSql()
-    // Orden SQL: WHERE → ORDER BY → LIMIT → OFFSET
-    expect(sql.indexOf('WHERE')).toBeLessThan(sql.indexOf('ORDER BY'))
-    expect(sql.indexOf('ORDER BY')).toBeLessThan(sql.indexOf('LIMIT'))
-    expect(sql.indexOf('LIMIT')).toBeLessThan(sql.indexOf('OFFSET'))
-  })
-
-  it('findMany rechaza campo orderBy no definido en el modelo', async () => {
-    const db = createRecordingDb()
-    await expect(
-      makeOrm(db).findMany('Producto', {}, { orderBy: { field: 'campoFalso', dir: 'DESC' } })
-    ).rejects.toThrow(ValidationError)
-  })
-
-  it('findMany rechaza filtro con campo no definido en el modelo', async () => {
-    const db = createRecordingDb()
-    await expect(
-      makeOrm(db).findMany('Producto', { campoFalso: 'x' })
-    ).rejects.toThrow(ValidationError)
-  })
-
-  it('count genera SELECT COUNT(*) FROM tabla', async () => {
-    const db = createRecordingDb({ countValue: 7 })
-    const total = await makeOrm(db).count('Producto')
-    expect(total).toBe(7)
-    expect(db.lastSql()).toMatch(/SELECT COUNT\(\*\) as n FROM productos/)
-  })
-
-  it('count con filtros agrega WHERE', async () => {
-    const db = createRecordingDb({ countValue: 3 })
-    await makeOrm(db).count('Producto', { nombre: 'X' })
-    expect(db.lastSql()).toContain('WHERE nombre = ?')
-  })
-
-  it('paginate devuelve { data, total, limit, offset, pages }', async () => {
-    const db = createRecordingDb({ countValue: 47, queryData: [fakeItem] })
-    const result = await makeOrm(db).paginate('Producto', {}, { limit: 10 })
-    expect(result.total).toBe(47)
-    expect(result.limit).toBe(10)
-    expect(result.offset).toBe(0)
-    expect(result.pages).toBe(5)   // ceil(47/10)
-    expect(Array.isArray(result.data)).toBe(true)
-  })
-
-  it('paginate calcula pages redondeando para arriba', async () => {
-    const db = createRecordingDb({ countValue: 21, queryData: [fakeItem] })
-    const result = await makeOrm(db).paginate('Producto', {}, { limit: 10, offset: 10 })
-    expect(result.pages).toBe(3)   // ceil(21/10)
-    expect(result.offset).toBe(10)
-  })
-
-  it('paginate con 0 resultados devuelve pages: 0', async () => {
-    const db = createRecordingDb({ countValue: 0, queryData: [] })
-    const result = await makeOrm(db).paginate('Producto', {}, { limit: 10 })
-    expect(result.total).toBe(0)
-    expect(result.pages).toBe(0)
-    expect(result.data).toEqual([])
-  })
-})
-
-// ═════════════════════════════════════════════════════
-// 5. ROUTER
-// ═════════════════════════════════════════════════════
-describe('Router', () => {
-  it('resuelve rutas GET', async () => {
-    const r = new Router()
-    r.get('/test', () => ({ status: 200, body: { ok: true } }))
-    const res = await r.resolve('GET', '/test')
-    expect(res.status).toBe(200)
-    expect(res.body).toEqual({ ok: true })
-  })
-
-  it('resuelve params en ruta', async () => {
-    const r = new Router()
-    r.get('/users/:id', (req) => ({ status: 200, body: { id: req.params.id } }))
-    const res = await r.resolve('GET', '/users/42')
-    expect(res.body).toEqual({ id: '42' })
-  })
-
-  it('devuelve 404 si no hay match', async () => {
-    const r = new Router()
-    const res = await r.resolve('GET', '/no-existe')
-    expect(res.status).toBe(404)
-  })
-
-  it('ejecuta middlewares en orden', async () => {
-    const r = new Router()
-    const order: string[] = []
-
-    r.use(async (req, next) => { order.push('global'); return next() })
-    r.get('/test', () => { order.push('handler'); return { status: 200, body: {} } }, [
-      async (req, next) => { order.push('route'); return next() },
-    ])
-
-    await r.resolve('GET', '/test')
-    expect(order).toEqual(['global', 'route', 'handler'])
-  })
-
-  it('POST con body', async () => {
-    const r = new Router()
-    r.post('/data', (req) => ({ status: 201, body: req.body }))
-    const res = await r.resolve('POST', '/data', { body: { nombre: 'test' } })
-    expect(res.status).toBe(201)
-    expect(res.body).toEqual({ nombre: 'test' })
-  })
-})
-
-// ═════════════════════════════════════════════════════
-// 6. AUTH
-// ═════════════════════════════════════════════════════
-describe('Auth', () => {
-  const auth = new Auth(jwtTokenAdapter, 'test-secret', new Logger('auth', 'error'))
-
-  it('createToken y verifyToken funcionan', () => {
-    const token = auth.createToken({ id: '1', role: 'admin' })
-    const payload = auth.verifyToken(token)
-    expect(payload.id).toBe('1')
-    expect(payload.role).toBe('admin')
-  })
-
-  it('verifyToken rechaza token inválido', () => {
-    expect(() => auth.verifyToken('token-invalido')).toThrow(AuthError)
-  })
-
-  it('authenticate middleware funciona', async () => {
-    const token = auth.createToken({ id: '1', role: 'admin' })
-    const mw = auth.authenticate('admin')
-    const req = { headers: { authorization: `Bearer ${token}` } } as any
-    let called = false
-    await mw(req, async () => { called = true; return { status: 200, body: {} } })
-    expect(called).toBe(true)
-    expect(req.user?.id).toBe('1')
-  })
-
-  it('authenticate rechaza si falta token', async () => {
-    const mw = auth.authenticate()
-    const req = { headers: {} } as any
-    await expect(mw(req, async () => ({ status: 200, body: {} }))).rejects.toThrow(AuthError)
-  })
-
-  it('authenticate rechaza si rol no coincide', async () => {
-    const token = auth.createToken({ id: '1', role: 'user' })
-    const mw = auth.authenticate('admin')
-    const req = { headers: { authorization: `Bearer ${token}` } } as any
-    await expect(mw(req, async () => ({ status: 200, body: {} }))).rejects.toThrow(/required role/i)
-  })
-})
-
-// ═════════════════════════════════════════════════════
-// 7. CACHE
-// ═════════════════════════════════════════════════════
-describe('MemoryCache', () => {
-  it('set y get', async () => {
-    const c = new MemoryCache()
-    await c.set('key', { data: 42 })
-    const val = await c.get('key')
-    expect(val).toEqual({ data: 42 })
-  })
-
-  it('get devuelve null si no existe', async () => {
-    const c = new MemoryCache()
-    const val = await c.get('no-existe')
-    expect(val).toBeNull()
-  })
-
-  it('delete elimina', async () => {
-    const c = new MemoryCache()
-    await c.set('key', 'valor')
-    await c.delete('key')
-    const val = await c.get('key')
-    expect(val).toBeNull()
-  })
-
-  it('flush limpia todo', async () => {
-    const c = new MemoryCache()
-    await c.set('a', 1)
-    await c.set('b', 2)
-    await c.flush()
-    expect(await c.get('a')).toBeNull()
-    expect(await c.get('b')).toBeNull()
-  })
-
-  it('expira después del TTL', async () => {
-    const c = new MemoryCache()
-    await c.set('key', 'valor', 0) // 0 segundos = expira inmediato
-    await new Promise(r => setTimeout(r, 10))
-    const val = await c.get('key')
-    expect(val).toBeNull()
-  })
-})
-
-// ═════════════════════════════════════════════════════
-// 8. VALIDATOR
-// ═════════════════════════════════════════════════════
-describe('validateSchema', () => {
-  it('valida campos requeridos', () => {
-    const data = validateSchema({
-      nombre: { type: 'string', required: true },
-      edad: { type: 'number', required: true },
-    }, { nombre: 'Juan', edad: 30 })
-    expect(data.nombre).toBe('Juan')
-    expect(data.edad).toBe(30)
-  })
-
-  it('tira error si falta required', () => {
-    expect(() => validateSchema({
-      nombre: { type: 'string', required: true },
-    }, {})).toThrow(ValidationError)
-  })
-
-  it('valida email', () => {
-    expect(() => validateSchema({
-      email: { type: 'email', required: true },
-    }, { email: 'no-es-email' })).toThrow(ValidationError)
-
-    const data = validateSchema({
-      email: { type: 'email', required: true },
-    }, { email: 'test@correo.com' })
-    expect(data.email).toBe('test@correo.com')
-  })
-
-  it('valida min/max en strings', () => {
-    expect(() => validateSchema({
-      name: { type: 'string', min: 3, max: 10 },
-    }, { name: 'ab' })).toThrow()
-
-    const data = validateSchema({
-      name: { type: 'string', min: 3, max: 10 },
-    }, { name: 'Juan Pérez' })
-    expect(data.name).toBe('Juan Pérez')
-  })
-
-  it('valida enum', () => {
-    const schema = { rol: { type: 'string', enum: ['admin', 'user'] } as any }
-
-    expect(() => validateSchema(schema, { rol: 'superadmin' })).toThrow()
-
-    const data = validateSchema(schema, { rol: 'admin' })
-    expect(data.rol).toBe('admin')
-  })
-
-  it('tira error si body no es objeto', () => {
-    expect(() => validateSchema({}, 'texto')).toThrow(ValidationError)
-  })
-})
-
-// ═════════════════════════════════════════════════════
-// 9. SYSTEM (módulos + conectores)
-// ═════════════════════════════════════════════════════
-describe('System', () => {
-  it('inicializa módulos y ejecuta conectores', async () => {
-    const config = new ConfigStore()
-    config.define({ TEST: { type: 'string', default: 'ok' } }).load({})
-    const container = new Container()
-    container.register('cfg', () => config).init()
-    const orm = new ORM(mockDb as any)
-    const router = new Router()
-    const http = { start: async () => {}, stop: async () => {} }
-    const cache = new MemoryCache()
-
-    const TestModule = createModule({
-      name: 'test',
-      version: '1.0.0',
-      description: 'Test',
-      contract: { name: 'test', version: '1', description: '', actions: [], events: [], tables: [], dependencies: [], rules: [] },
-      create: ({ logger }) => ({ ok: true, logger }),
-    })
-
-    const system = new System({ config, container, logger: new Logger('test', 'error'), orm, router, http, cache })
-    system.addModule(TestModule)
-    system.addConnector('test-connector', (ctx) => {
-      const mod = ctx.resolveModule<any>('test')
-      expect(mod.ok).toBe(true)
-    })
-    system.init()
-
-    const mod = system.getModule<any>('test')
-    expect(mod.ok).toBe(true)
-  })
-
-  it('tira error si módulo no existe', async () => {
-    const config = new ConfigStore()
-    config.define({}).load({})
-    const container = new Container()
-    container.register('c', () => config).init()
-
-    const system = new System({
-      config, container, logger: new Logger('test', 'error'),
-      orm: new ORM(mockDb as any), router: new Router(),
-      http: { start: async () => {}, stop: async () => {} },
-      cache: new MemoryCache(),
-    })
-    expect(() => system.getModule('no-existe')).toThrow(NotFoundError)
-  })
-})
-
-// ═════════════════════════════════════════════════════
-// 10. ERRORES
-// ═════════════════════════════════════════════════════
-describe('Errors', () => {
-  it('NotFoundError tiene httpStatus 404', () => {
-    const e = new NotFoundError('test')
-    expect(e.httpStatus).toBe(404)
-    expect(e.isExpected).toBe(true)
-    expect(e.toJSON()).toHaveProperty('error')
-  })
-
-  it('ValidationError acepta fields', () => {
-    const e = new ValidationError('error', { campo: ['requerido'] })
-    expect(e.httpStatus).toBe(400)
-    expect(e.toJSON().details).toBeDefined()
-  })
-
-  it('AuthError tiene httpStatus 401', () => {
-    const e = new AuthError()
-    expect(e.httpStatus).toBe(401)
-  })
-})