arckode-framework 1.0.0 → 1.0.2

package/kernel/__tests__/adapters.test.ts

@@ -1,101 +0,0 @@
-// 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')
-//     })
-//   })

package/kernel/__tests__/analyzer.test.ts

@@ -1,282 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'bun:test'
-import { mkdir, writeFile, rm } from 'node:fs/promises'
-import { join } from 'node:path'
-import { analyzeProject } from '../../cli/analyze'
-
-const TMP = join(import.meta.dirname, '..', '__test_fixtures__')
-
-async function createProject(name: string): Promise<string> {
-  const dir = join(TMP, name)
-  await mkdir(dir, { recursive: true })
-  return dir
-}
-
-async function createFile(base: string, path: string, content: string): Promise<void> {
-  const fullPath = join(base, path)
-  await mkdir(fullPath.replace(/\/[^/]+$/, ''), { recursive: true })
-  await writeFile(fullPath, content)
-}
-
-async function cleanup(name: string): Promise<void> {
-  await rm(join(TMP, name), { recursive: true, force: true })
-}
-
-const CR = `import { ConfigStore, Logger, ORM, Router, System } from 'arckode-framework'
-const c = new ConfigStore(); c.define({X:{type:'string',default:'ok'}}).load({})
-const l = new Logger('test','error'); new System({config:c,container:{} as any,logger:l,orm:{} as any,router:new Router(),http:{start:async()=>{},stop:async()=>{}},cache:{} as any})
-`
-
-const MOD_INDEX = `import { createModule } from 'arckode-framework'
-export function M() {
-  return createModule({name:'m',version:'1',description:'ok',
-    contract:{name:'m',version:'1',description:'ok',actions:[],events:[],tables:[],dependencies:[],rules:[]},
-    create:({logger})=>({ok:true})})
-}`
-
-const TYPES = `export interface DTO { id: string; name: string }`
-
-const SERVICE = `export class S {
-  constructor(private repo: any) {}
-  async list() { return this.repo.findMany() }
-}`
-
-const CTRL = `import type { HttpRequest } from 'arckode-framework'
-export class C {
-  constructor(private s: any) {}
-  async idx(req: HttpRequest) { return { status: 200, body: await this.s.list() } }
-}`
-
-const SCHEMA = `import type { ValidationSchema } from 'arckode-framework'
-export const S: ValidationSchema = { name: { type: 'string', required: true } }`
-
-const TEST_OK = `import { it } from 'bun:test'; it('works', () => {})`
-
-async function fullModule(base: string, name: string): Promise<void> {
-  await createFile(base, `src/modules/${name}/index.ts`, MOD_INDEX)
-  await createFile(base, `src/modules/${name}/types.ts`, TYPES)
-  await createFile(base, `src/modules/${name}/actions/service.ts`, SERVICE)
-  await createFile(base, `src/modules/${name}/actions/controller.ts`, CTRL)
-  await createFile(base, `src/modules/${name}/validators/schema.ts`, SCHEMA)
-  await createFile(base, `src/modules/${name}/tests/service.test.ts`, TEST_OK)
-  await createFile(base, `src/modules/${name}/sockets.ts`, `export const sockets = {}`)
-}
-
-describe('analyzeProject', () => {
-  describe('estructura básica', () => {
-    it('detecta falta de composition-root', async () => {
-      const dir = await createProject('no-cr')
-      await mkdir(join(dir, 'src', 'modules'), { recursive: true })
-      const result = await analyzeProject(dir)
-      expect(result.valid).toBe(false)
-      expect(result.warnings.some(w => w.type === 'NO_COMPOSITION_ROOT')).toBe(true)
-      await cleanup('no-cr')
-    })
-
-    it('proyecto válido sin violaciones', async () => {
-      const dir = await createProject('valid')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await fullModule(dir, 'test')
-      const result = await analyzeProject(dir)
-      if (!result.valid) {
-        console.log('DEBUG violations:', JSON.stringify(result.violations.map(v => ({type:v.type, msg:v.message}))))
-        console.log('DEBUG warnings:', JSON.stringify(result.warnings))
-      }
-      expect(result.valid).toBe(true)
-      expect(result.violations).toHaveLength(0)
-      await cleanup('valid')
-    })
-
-    it('detecta módulo sin index.ts', async () => {
-      const dir = await createProject('no-index')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await mkdir(join(dir, 'src/modules/noindex'), { recursive: true })
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'MISSING_INDEX')).toBe(true)
-      await cleanup('no-index')
-    })
-
-    it('detecta módulo sin types.ts', async () => {
-      const dir = await createProject('no-types')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await createFile(dir, 'src/modules/x/index.ts', MOD_INDEX)
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'MISSING_TYPES')).toBe(true)
-      await cleanup('no-types')
-    })
-
-    it('detecta módulo sin tests', async () => {
-      const dir = await createProject('no-tests')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await createFile(dir, 'src/modules/x/index.ts', MOD_INDEX)
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'MISSING_TESTS')).toBe(true)
-      await cleanup('no-tests')
-    })
-  })
-
-  describe('acoplamiento', () => {
-    it('detecta imports directos entre módulos', async () => {
-      const dir = await createProject('direct-import')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      // Module "a" with service that imports from modules/b
-      await fullModule(dir, 'a')
-      await createFile(dir, 'src/modules/a/actions/service.ts',
-        `import { algo } from '../../../modules/b/types'\nexport class S { async list() { return [] } }`)
-      await fullModule(dir, 'b')
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'DIRECT_MODULE_IMPORT')).toBe(true)
-      await cleanup('direct-import')
-    })
-  })
-
-  describe('conectores', () => {
-    it('detecta falta de conectores entre múltiples módulos', async () => {
-      const dir = await createProject('no-conn')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await fullModule(dir, 'a')
-      await fullModule(dir, 'b')
-      // No connectors directory
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'MISSING_CONNECTORS')).toBe(true)
-      await cleanup('no-conn')
-    })
-
-    it('detecta lógica de negocio en conectores', async () => {
-      const dir = await createProject('conn-logic')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await fullModule(dir, 'a')
-      await fullModule(dir, 'b')
-      await mkdir(join(dir, 'src/connectors'), { recursive: true })
-      await createFile(dir, 'src/connectors/bad.ts', `export function c(ctx: any) {
-const a = ctx.resolveModule('a'); const b = ctx.resolveModule('b')
-if (a.x > 1) { for (const i of b.y) { if (i.active) { a.update(i.id, i) } } }
-try { a.create(b.get()) } catch(e) { console.error(e) }
-}`)
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'CONNECTOR_BUSINESS_LOGIC')).toBe(true)
-      await cleanup('conn-logic')
-    })
-  })
-
-  describe('reglas de diseño', () => {
-    it('detecta controller sin validateSchema en rutas mutantes', async () => {
-      const dir = await createProject('no-validation')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await createFile(dir, 'src/modules/x/index.ts', MOD_INDEX)
-      await createFile(dir, 'src/modules/x/types.ts', TYPES)
-      await createFile(dir, 'src/modules/x/actions/service.ts', SERVICE)
-      // Controller with router.post but no validateSchema
-      // Controller que define ruta POST pero no valida — el analyzer
-      // detecta router.post() en el archivo del controller
-      await createFile(dir, 'src/modules/x/actions/controller.ts',
-        `import type { HttpRequest } from 'arckode-framework'
-// router.post('/x', handler) — sin validateSchema
-export class C {
-  async store(req: HttpRequest) {
-    return { status: 201, body: req.body }
-  }
-}`)
-      await createFile(dir, 'src/modules/x/validators/schema.ts', SCHEMA)
-      await createFile(dir, 'src/modules/x/tests/service.test.ts', TEST_OK)
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'CONTROLLER_MISSING_VALIDATION')).toBe(true)
-      await cleanup('no-validation')
-    })
-
-    it('detecta descripción vacía en módulo', async () => {
-      const dir = await createProject('empty-desc')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await createFile(dir, 'src/modules/x/index.ts',
-        `import { createModule } from 'arckode-framework'
-export function M() {
-  return createModule({name:'x',version:'1',description:'',
-    contract:{name:'x',version:'1',description:'',actions:[],events:[],tables:[],dependencies:[],rules:[]},
-    create:()=>({})})
-}`)
-      await createFile(dir, 'src/modules/x/types.ts', TYPES)
-      await createFile(dir, 'src/modules/x/actions/service.ts', SERVICE)
-      await createFile(dir, 'src/modules/x/actions/controller.ts', CTRL)
-      await createFile(dir, 'src/modules/x/validators/schema.ts', SCHEMA)
-      await createFile(dir, 'src/modules/x/tests/service.test.ts', TEST_OK)
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'EMPTY_MODULE_DESCRIPTION')).toBe(true)
-      await cleanup('empty-desc')
-    })
-
-    it('detecta service que inyecta ORM en vez de RepositoryAdapter', async () => {
-      const dir = await createProject('orm-dep')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await createFile(dir, 'src/modules/x/index.ts', MOD_INDEX)
-      await createFile(dir, 'src/modules/x/types.ts', TYPES)
-      await createFile(dir, 'src/modules/x/actions/service.ts',
-        `import { ORM } from 'arckode-framework'\nexport class S {\n  constructor(private orm: ORM) {}\n  async list() { return this.orm.findMany('X') }\n}`)
-      await createFile(dir, 'src/modules/x/actions/controller.ts', CTRL)
-      await createFile(dir, 'src/modules/x/validators/schema.ts', SCHEMA)
-      await createFile(dir, 'src/modules/x/tests/service.test.ts', TEST_OK)
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'SERVICE_DEPENDS_ON_ORM')).toBe(true)
-      await cleanup('orm-dep')
-    })
-
-    it('detecta God Service (>200 líneas)', async () => {
-      const dir = await createProject('god')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await createFile(dir, 'src/modules/x/index.ts', MOD_INDEX)
-      await createFile(dir, 'src/modules/x/types.ts', TYPES)
-      await createFile(dir, 'src/modules/x/actions/service.ts', `export class S {\n${'  x = 1\n'.repeat(210)}}`)
-      await createFile(dir, 'src/modules/x/actions/controller.ts', CTRL)
-      await createFile(dir, 'src/modules/x/validators/schema.ts', SCHEMA)
-      await createFile(dir, 'src/modules/x/tests/service.test.ts', TEST_OK)
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'GOD_SERVICE')).toBe(true)
-      await cleanup('god')
-    })
-
-    it('detecta tests sin casos reales', async () => {
-      const dir = await createProject('empty-tests')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await createFile(dir, 'src/modules/x/index.ts', MOD_INDEX)
-      await createFile(dir, 'src/modules/x/types.ts', TYPES)
-      await createFile(dir, 'src/modules/x/actions/service.ts', SERVICE)
-      await createFile(dir, 'src/modules/x/actions/controller.ts', CTRL)
-      await createFile(dir, 'src/modules/x/validators/schema.ts', SCHEMA)
-      // File exists but no test/it/describe calls
-      await createFile(dir, 'src/modules/x/tests/service.test.ts', `// just a comment\nconst x = 1\n`)
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'TESTS_WITHOUT_CASES')).toBe(true)
-      await cleanup('empty-tests')
-    })
-  })
-
-  describe('seguridad y performance', () => {
-    it('detecta ORM en loop (N+1)', async () => {
-      const dir = await createProject('nplus1')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await createFile(dir, 'src/modules/x/index.ts', MOD_INDEX)
-      await createFile(dir, 'src/modules/x/types.ts', TYPES)
-      await createFile(dir, 'src/modules/x/actions/service.ts',
-        `export class S {\n  async bad(orm: any) {\n    const items = await orm.findMany('X')\n    for (const item of items) {\n      const d = await orm.findById('Y', item.id)\n    }\n    return items\n  }\n}`)
-      await createFile(dir, 'src/modules/x/actions/controller.ts', CTRL)
-      await createFile(dir, 'src/modules/x/validators/schema.ts', SCHEMA)
-      await createFile(dir, 'src/modules/x/tests/service.test.ts', TEST_OK)
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'N_PLUS_ONE_RISK')).toBe(true)
-      await cleanup('nplus1')
-    })
-
-    it('detecta findById sin assertOwnership (IDOR)', async () => {
-      const dir = await createProject('idor')
-      await createFile(dir, 'src/composition-root.ts', CR)
-      await createFile(dir, 'src/modules/x/index.ts', MOD_INDEX)
-      await createFile(dir, 'src/modules/x/types.ts', TYPES)
-      await createFile(dir, 'src/modules/x/actions/service.ts',
-        `export class S {\n  private repo: any\n  async getById(id: string) {\n    const item = await this.repo.findById(id)\n    return item\n  }\n}`)
-      await createFile(dir, 'src/modules/x/actions/controller.ts', CTRL)
-      await createFile(dir, 'src/modules/x/validators/schema.ts', SCHEMA)
-      await createFile(dir, 'src/modules/x/tests/service.test.ts', TEST_OK)
-      const result = await analyzeProject(dir)
-      expect(result.violations.some(v => v.type === 'IDOR_RISK')).toBe(true)
-      await cleanup('idor')
-    })
-  })
-})