arckode-framework 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arckode-framework",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "AI-first TypeScript/Bun framework. Modular, SOLID, zero magic. The AI reads the composition root and knows everything.",
   "type": "module",
   "main": "./kernel/framework.ts",
@@ -25,9 +25,20 @@
   },
   "files": [
     "bin/",
-    "kernel/",
-    "adapters/",
-    "modules/",
+    "kernel/framework.ts",
+    "kernel/middlewares.ts",
+    "kernel/static.ts",
+    "kernel/testing.ts",
+    "adapters/jwt.ts",
+    "adapters/mysql.ts",
+    "adapters/postgres.ts",
+    "adapters/redis-cache.ts",
+    "adapters/sqlite.ts",
+    "modules/events/index.ts",
+    "modules/mail/",
+    "modules/queue/index.ts",
+    "modules/storage/",
+    "modules/ws/index.ts",
     "cli/",
     "skills/",
     "README.md"

package/adapters/__tests__/mysql.test.ts

@@ -1,283 +0,0 @@
-// adapters/__tests__/mysql.test.ts
-// Testea MySQLAdapter con mocks de mysql2/promise — sin servidor real.
-// Para tests de integración real ver el bloque comentado al final.
-
-import { describe, it, expect, beforeAll, beforeEach, mock } from 'bun:test'
-import type { MySQLAdapter } from '../mysql'
-
-// ── Mocks de conexión (transacciones) ────────────────────────────────────────
-const connMock = {
-  beginTransaction: mock(async () => {}),
-  execute:          mock(async (): Promise<unknown[]> => [[], []]),
-  commit:           mock(async () => {}),
-  rollback:         mock(async () => {}),
-  release:          mock(() => {}),
-}
-
-// ── Mock del pool ─────────────────────────────────────────────────────────────
-const poolMock = {
-  getConnection: mock(async () => connMock),
-  execute:       mock(async (): Promise<unknown[]> => [[], []]),
-  end:           mock(async () => {}),
-}
-
-// Registrar el mock ANTES de que el adapter importe mysql2/promise.
-// El dynamic import en beforeAll garantiza que mysql2/promise ya está mockeado.
-mock.module('mysql2/promise', () => ({
-  default: { createPool: mock(() => poolMock) },
-}))
-
-// ── Carga diferida del adapter ────────────────────────────────────────────────
-let Adapter: typeof MySQLAdapter
-
-beforeAll(async () => {
-  const mod = await import('../mysql')
-  Adapter = mod.MySQLAdapter
-})
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-function resetMocks() {
-  connMock.beginTransaction.mockClear()
-  connMock.execute.mockClear()
-  connMock.commit.mockClear()
-  connMock.rollback.mockClear()
-  connMock.release.mockClear()
-  poolMock.getConnection.mockClear()
-  poolMock.execute.mockClear()
-  poolMock.end.mockClear()
-}
-
-function makeAdapter() {
-  return new Adapter({ host: 'localhost', user: 'test', password: 'test', database: 'testdb' })
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('MySQLAdapter', () => {
-  beforeEach(resetMocks)
-
-  // ── connect() ───────────────────────────────────────────────────────────────
-  describe('connect()', () => {
-    it('crea el pool y verifica la conexión con getConnection+release', async () => {
-      const adapter = makeAdapter()
-      await adapter.connect()
-
-      expect(poolMock.getConnection).toHaveBeenCalledTimes(1)
-      expect(connMock.release).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  // ── query() ─────────────────────────────────────────────────────────────────
-  describe('query()', () => {
-    let adapter: MySQLAdapter
-
-    beforeEach(async () => {
-      adapter = makeAdapter()
-      await adapter.connect()
-      resetMocks() // limpia las calls de connect()
-    })
-
-    it('retorna el array de filas', async () => {
-      const filas = [{ id: '1', nombre: 'Laptop' }, { id: '2', nombre: 'Mouse' }]
-      poolMock.execute.mockImplementation(async () => [filas, []])
-
-      const result = await adapter.query('SELECT * FROM productos')
-      expect(result).toEqual(filas)
-    })
-
-    it('pasa los params al execute del pool', async () => {
-      poolMock.execute.mockImplementation(async () => [[{ id: '1' }], []])
-
-      await adapter.query('SELECT * FROM productos WHERE id = ?', ['1'])
-      expect(poolMock.execute).toHaveBeenCalledWith(
-        'SELECT * FROM productos WHERE id = ?',
-        ['1'],
-      )
-    })
-
-    it('retorna array vacío cuando no hay resultados', async () => {
-      poolMock.execute.mockImplementation(async () => [[], []])
-
-      const result = await adapter.query('SELECT * FROM productos WHERE id = ?', ['999'])
-      expect(result).toEqual([])
-    })
-  })
-
-  // ── run() ────────────────────────────────────────────────────────────────────
-  describe('run()', () => {
-    let adapter: MySQLAdapter
-
-    beforeEach(async () => {
-      adapter = makeAdapter()
-      await adapter.connect()
-      resetMocks()
-    })
-
-    it('INSERT retorna changes y lastId como string', async () => {
-      poolMock.execute.mockImplementation(async () => [{ affectedRows: 1, insertId: 42 }, []])
-
-      const result = await adapter.run(
-        'INSERT INTO productos (nombre, precio) VALUES (?, ?)',
-        ['Laptop', 999],
-      )
-
-      expect(result.changes).toBe(1)
-      expect(result.lastId).toBe('42')
-    })
-
-    it('UPDATE retorna changes y lastId undefined (insertId === 0)', async () => {
-      poolMock.execute.mockImplementation(async () => [{ affectedRows: 3, insertId: 0 }, []])
-
-      const result = await adapter.run(
-        'UPDATE productos SET activo = ? WHERE categoria = ?',
-        [false, 'perifericos'],
-      )
-
-      expect(result.changes).toBe(3)
-      expect(result.lastId).toBeUndefined()
-    })
-
-    it('DELETE retorna changes y sin lastId', async () => {
-      poolMock.execute.mockImplementation(async () => [{ affectedRows: 1, insertId: 0 }, []])
-
-      const result = await adapter.run('DELETE FROM productos WHERE id = ?', ['1'])
-      expect(result.changes).toBe(1)
-      expect(result.lastId).toBeUndefined()
-    })
-  })
-
-  // ── transaction() ────────────────────────────────────────────────────────────
-  describe('transaction()', () => {
-    let adapter: MySQLAdapter
-
-    beforeEach(async () => {
-      adapter = makeAdapter()
-      await adapter.connect()
-      resetMocks()
-    })
-
-    it('adquiere conexión, abre transacción, ejecuta fn y hace commit', async () => {
-      const filas = [{ id: '1' }]
-      connMock.execute.mockImplementation(async () => [filas, []])
-
-      const result = await adapter.transaction(async (tx) => {
-        return tx.query('SELECT * FROM productos')
-      })
-
-      expect(poolMock.getConnection).toHaveBeenCalledTimes(1)
-      expect(connMock.beginTransaction).toHaveBeenCalledTimes(1)
-      expect(connMock.commit).toHaveBeenCalledTimes(1)
-      expect(connMock.rollback).not.toHaveBeenCalled()
-      expect(connMock.release).toHaveBeenCalledTimes(1)
-      expect(result).toEqual(filas)
-    })
-
-    it('el adapter de transacción usa la conexión, no el pool', async () => {
-      connMock.execute.mockImplementation(async () => [[{ total: 5 }], []])
-
-      await adapter.transaction(async (tx) => {
-        await tx.query('SELECT COUNT(*) as total FROM productos')
-        await tx.run('INSERT INTO auditoria (evento) VALUES (?)', ['sync'])
-      })
-
-      // Ambas llamadas van a connMock.execute, NO a poolMock.execute
-      expect(connMock.execute).toHaveBeenCalledTimes(2)
-      expect(poolMock.execute).not.toHaveBeenCalled()
-    })
-
-    it('hace rollback y lanza el error si fn falla', async () => {
-      const error = new Error('error de negocio')
-
-      await expect(
-        adapter.transaction(async () => {
-          throw error
-        }),
-      ).rejects.toThrow('error de negocio')
-
-      expect(connMock.beginTransaction).toHaveBeenCalledTimes(1)
-      expect(connMock.rollback).toHaveBeenCalledTimes(1)
-      expect(connMock.commit).not.toHaveBeenCalled()
-      expect(connMock.release).toHaveBeenCalledTimes(1)
-    })
-
-    it('libera la conexión aunque el rollback falle (finally garantizado)', async () => {
-      connMock.rollback.mockImplementation(async () => {
-        throw new Error('rollback falló')
-      })
-
-      await expect(
-        adapter.transaction(async () => {
-          throw new Error('error original')
-        }),
-      ).rejects.toBeDefined()
-
-      // release() debe ejecutarse siempre — está en finally
-      expect(connMock.release).toHaveBeenCalledTimes(1)
-
-      // Restaurar implementación para tests siguientes
-      connMock.rollback.mockImplementation(async () => {})
-    })
-  })
-
-  // ── close() ──────────────────────────────────────────────────────────────────
-  describe('close()', () => {
-    it('termina el pool', async () => {
-      const adapter = makeAdapter()
-      await adapter.connect()
-      resetMocks()
-
-      await adapter.close()
-      expect(poolMock.end).toHaveBeenCalledTimes(1)
-    })
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Test de integración real (requiere MySQL corriendo):
-//
-//   describe('MySQLAdapter — integración', () => {
-//     let adapter: MySQLAdapter
-//
-//     beforeAll(async () => {
-//       const { MySQLAdapter } = await import('../mysql')
-//       adapter = new MySQLAdapter({
-//         host: 'localhost',
-//         user: 'test',
-//         password: 'test',
-//         database: 'arckode_test',
-//       })
-//       await adapter.connect()
-//       await adapter.run('CREATE TABLE IF NOT EXISTS test_items (id INT AUTO_INCREMENT PRIMARY KEY, nombre VARCHAR(255))')
-//     })
-//
-//     afterAll(async () => {
-//       await adapter.run('DROP TABLE IF EXISTS test_items')
-//       await adapter.close()
-//     })
-//
-//     it('INSERT + SELECT funcionan con placeholders ?', async () => {
-//       await adapter.run('INSERT INTO test_items (nombre) VALUES (?)', ['Laptop'])
-//       const rows = await adapter.query('SELECT * FROM test_items WHERE nombre = ?', ['Laptop'])
-//       expect(rows).toHaveLength(1)
-//       expect((rows[0] as any).nombre).toBe('Laptop')
-//     })
-//
-//     it('transacción commit persiste los datos', async () => {
-//       await adapter.transaction(async (tx) => {
-//         await tx.run('INSERT INTO test_items (nombre) VALUES (?)', ['Mouse'])
-//       })
-//       const rows = await adapter.query('SELECT * FROM test_items WHERE nombre = ?', ['Mouse'])
-//       expect(rows).toHaveLength(1)
-//     })
-//
-//     it('transacción rollback no persiste los datos', async () => {
-//       await expect(
-//         adapter.transaction(async (tx) => {
-//           await tx.run('INSERT INTO test_items (nombre) VALUES (?)', ['Keyboard'])
-//           throw new Error('forzar rollback')
-//         })
-//       ).rejects.toThrow()
-//       const rows = await adapter.query('SELECT * FROM test_items WHERE nombre = ?', ['Keyboard'])
-//       expect(rows).toHaveLength(0)
-//     })
-//   })

package/adapters/vendor.d.ts

@@ -1,48 +0,0 @@
-// adapters/vendor.d.ts — Minimal type stubs for optional peer dependencies.
-// pg and redis are optional — users install them only when using those adapters.
-// These stubs let TypeScript compile without the packages installed.
-
-declare module 'pg' {
-  export interface PoolConfig {
-    connectionString?: string
-    min?: number
-    max?: number
-    [key: string]: unknown
-  }
-
-  export interface QueryResult<R = Record<string, unknown>> {
-    rows: R[]
-    rowCount: number | null
-  }
-
-  export interface PoolClient {
-    release(): void
-  }
-
-  export class Pool {
-    constructor(config?: PoolConfig)
-    connect(): Promise<PoolClient>
-    query(sql: string, params?: unknown[]): Promise<QueryResult>
-    end(): Promise<void>
-  }
-
-  const pg: {
-    Pool: typeof Pool
-  } & typeof import('pg')
-  export default pg
-}
-
-declare module 'redis' {
-  export type RedisClientType = {
-    connect(): Promise<void>
-    get(key: string): Promise<string | null>
-    set(key: string, value: string): Promise<unknown>
-    setEx(key: string, seconds: number, value: string): Promise<unknown>
-    del(keys: string | string[]): Promise<unknown>
-    keys(pattern: string): Promise<string[]>
-    flushAll(): Promise<unknown>
-    quit(): Promise<unknown>
-  }
-
-  export function createClient(options?: { url?: string; [key: string]: unknown }): RedisClientType
-}

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')
-//     })
-//   })