arckode-framework 1.0.0 → 1.0.2

package/adapters/redis-cache.ts

@@ -5,7 +5,10 @@ import { createClient, type RedisClientType } from 'redis'
 import type { CacheAdapter } from '../kernel/framework'
 
 export interface RedisCacheConfig {
-  url: string
+  /** URL completa: redis://localhost:6379 o rediss://user:pass@host:6380 */
+  url?: string
+  /** Config por host/port como alternativa a url */
+  socket?: { host: string; port: number; password?: string }
   keyPrefix?: string
   defaultTTL?: number
 }
@@ -17,7 +20,10 @@ export class RedisCacheAdapter implements CacheAdapter {
   constructor(private config: RedisCacheConfig) {}
 
   async connect(): Promise<void> {
-    this.client = createClient({ url: this.config.url })
+    const clientConfig = this.config.url
+      ? { url: this.config.url }
+      : { socket: this.config.socket, password: this.config.socket?.password }
+    this.client = createClient(clientConfig)
     await this.client.connect()
     this.connected = true
   }

package/cli/stubs/module-stub.ts

@@ -27,7 +27,7 @@ export type { ${p.name}DTO, Create${p.name}DTO, Update${p.name}DTO, ${p.name}Que
 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) {
+export function ${p.name}Module() {
   return createModule({
     name: '${p.module}',
     version: '1.0.0',
@@ -44,10 +44,10 @@ export function ${p.name}Module(sockets?: import('./sockets').${p.name}Sockets)
       rules: ['No importar de otros módulos'],
     },
 
-    create({ logger, orm, cache, router }) {
+    create({ logger, orm, cache, router, auth }) {
       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 service = new ${p.name}Service(repo, log, cache)
       const controller = new ${p.name}Controller(service, log)
 
       // Rutas públicas por defecto — agregar [auth.authenticate()] para proteger
@@ -168,13 +168,18 @@ import type { ${p.name}DTO, Create${p.name}DTO, Update${p.name}DTO, ${p.name}Que
 import type { ${p.name}Sockets } from '../sockets'
 
 export class ${p.name}Service {
+  private sockets: ${p.name}Sockets = {}
+
   constructor(
     private readonly repo: RepositoryAdapter<${p.name}DTO>,
     private readonly logger: Logger,
     private readonly cache: CacheAdapter,
-    private readonly sockets?: ${p.name}Sockets,
   ) {}
 
+  setSockets(s: Partial<${p.name}Sockets>): void {
+    this.sockets = { ...this.sockets, ...s }
+  }
+
   async list(query?: ${p.name}Query): Promise<${p.name}Paginated> {
     this.logger.info('Listando ${p.module}', { query })
 
@@ -210,7 +215,7 @@ export class ${p.name}Service {
   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.sockets.on${p.name}Created?.(item)
     await this.cache.delete('${p.module}:list')
     return item
   }
@@ -219,7 +224,7 @@ export class ${p.name}Service {
     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.sockets.on${p.name}Updated?.(item)
     await this.cache.delete('${p.module}:list')
     return item
   }
@@ -228,7 +233,7 @@ export class ${p.name}Service {
     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.sockets.on${p.name}Deleted?.(id)
     await this.cache.delete('${p.module}:list')
   }
 }
@@ -333,13 +338,16 @@ 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 { describe, it, expect } 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
+// silentLogger es una factory function — SIEMPRE llamarla con ()
+const log = silentLogger()
+const silentCache: CacheAdapter = { get: async () => null, set: async () => {}, delete: async () => {}, clear: async () => {}, flush: async () => {} }
+
 function makeRepo(overrides: Partial<RepositoryAdapter<${p.name}DTO>> = {}): RepositoryAdapter<${p.name}DTO> {
   return {
     findMany: async () => [],
@@ -354,25 +362,23 @@ function makeRepo(overrides: Partial<RepositoryAdapter<${p.name}DTO>> = {}): Rep
   }
 }
 
-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)
+      const service = new ${p.name}Service(makeRepo(), log, 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)
+      const service = new ${p.name}Service(makeRepo({ findById: async () => item }), log, 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 service = new ${p.name}Service(makeRepo(), log, silentCache)
       const result = await service.create({} as any)
       expect(result.id).toBe('test-id')
     })
@@ -380,7 +386,7 @@ describe('${p.name}Service', () => {
 
   describe('delete', () => {
     it('lanza NotFound si el item no existe', async () => {
-      const service = new ${p.name}Service(makeRepo({ delete: async () => false }), silentLogger, silentCache)
+      const service = new ${p.name}Service(makeRepo({ delete: async () => false }), log, silentCache)
       await expect(service.delete('no-existe')).rejects.toThrow('${p.name} no encontrado')
     })
   })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arckode-framework",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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/skills/connectors/SKILL.md

@@ -66,9 +66,9 @@ import type { PedidosSockets } from '../sockets'
 export class PedidosService {
   private sockets: PedidosSockets = {}
 
-  // Requerido para que el conector pueda inyectar
-  setSockets(sockets: PedidosSockets): void {
-    this.sockets = sockets
+  // MERGE — no replace. Si dos conectores inyectan sockets, el segundo no pisa al primero.
+  setSockets(s: Partial<PedidosSockets>): void {
+    this.sockets = { ...this.sockets, ...s }
   }
 
   async confirmar(id: string): Promise<PedidoDTO> {
@@ -253,7 +253,8 @@ test('confirmar pedido funciona sin sockets registrados', async () => {
 
 - [ ] Solo importa tipos (no implementaciones) desde `index.ts` de módulos
 - [ ] Sin `if`, `for`, ni lógica de negocio — solo llamadas de delegación
-- [ ] El service emisor implementa `setSockets()` y usa `?.` al llamarlos
+- [ ] El service emisor implementa `setSockets()` con MERGE (`{...this.sockets, ...s}`) — no replace
+- [ ] `setSockets()` usa `?.` al llamar los hooks (son opcionales)
 - [ ] Registrado en composition-root DESPUÉS de los módulos
 - [ ] El módulo funciona correctamente sin el conector (sockets son opcionales)
 - [ ] `arckode analyze` detecta: `CONNECTOR_BUSINESS_LOGIC` si hay lógica

package/skills/testing/SKILL.md

@@ -8,18 +8,36 @@
 
 ```ts
 import { describe, test, expect, beforeEach, mock } from 'bun:test'
-import { createRecordingOrm, createSilentLogger, createNullCache } from 'arckode-framework/testing'
-import { OrmRepository } from 'arckode-framework'
+// NOMBRES REALES: silentLogger (factory), createRecordingDb, createTestClient
+// createRecordingOrm / createSilentLogger / createNullCache NO existen — nunca usar esos nombres
+import { silentLogger, createRecordingDb } from 'arckode-framework/testing'
+import type { RepositoryAdapter, CacheAdapter } from 'arckode-framework'
 import { ProductosService } from '../actions/service'
 import type { ProductoDTO } from '../types'
 
+// silentLogger es factory function — SIEMPRE llamar con ()
+const log = silentLogger()
+const silentCache: CacheAdapter = { get: async () => null, set: async () => {}, delete: async () => {}, flush: async () => {} }
+
+function makeRepo(overrides: Partial<RepositoryAdapter<ProductoDTO>> = {}): RepositoryAdapter<ProductoDTO> {
+  return {
+    findMany: async () => [],
+    findById: async () => null,
+    findOne: async () => null,
+    create: async (data) => ({ id: 'test-id', ...data } as ProductoDTO),
+    update: async (id, data) => ({ id, ...data } as ProductoDTO),
+    delete: async () => true,
+    count: async () => 0,
+    paginate: async () => ({ data: [], total: 0, limit: 20, offset: 0, pages: 0 }),
+    ...overrides,
+  }
+}
+
 describe('ProductosService', () => {
   let service: ProductosService
 
   beforeEach(() => {
-    const orm  = createRecordingOrm()   // captura SQL sin ejecutar BD
-    const repo = new OrmRepository<ProductoDTO>(orm, 'Producto')
-    service    = new ProductosService(repo, createSilentLogger(), createNullCache())
+    service = new ProductosService(makeRepo(), log, silentCache)
   })
 })
 ```
@@ -31,24 +49,31 @@ describe('ProductosService', () => {
 ## 2. UTILIDADES DE TESTING
 
 ```ts
+// Exports REALES del módulo arckode-framework/testing:
 import {
-  createRecordingOrm,    // ORM que captura queries sin ejecutar nada
-  createSilentLogger,    // Logger que descarta todo (sin ruido en tests)
-  createNullCache,       // Cache que nunca cachea (siempre miss)
-  createTestClient,      // Cliente HTTP para integration tests
+  silentLogger,              // factory: silentLogger() → Logger (NO usarla sin ())
+  createRecordingDb,         // captura SQL sin ejecutar BD real → db.calls, db.lastSql()
+  createTestClient,          // cliente HTTP sin levantar servidor
+  createIntegrationClient,   // cliente HTTP con servidor real (puerto aleatorio)
+  mockAuth,                  // middleware mock para simular autenticación
 } from 'arckode-framework/testing'
 
-// RecordingOrm — verificar queries generadas sin BD
-const orm = createRecordingOrm()
-await service.listar()
-const queries = orm.getRecordedQueries()
-expect(queries[0]).toContain('SELECT')
+// ❌ ESTOS NO EXISTEN — nunca usar:
+// createRecordingOrm, createSilentLogger, createNullCache
+
+// silentLogger — factory, siempre con ()
+const log = silentLogger()
+
+// createRecordingDb — captura SQL sin ejecutar nada
+const db = createRecordingDb({ queryData: [{ id: '1', nombre: 'Laptop' }] })
+// db.calls      → array de { sql, params, type }
+// db.lastSql()  → último SQL ejecutado
+// db.reset()    → limpia el historial
 
-// TestClient — integration tests con router real
+// TestClient — router real, sin HTTP
 const client = createTestClient(router)
 const res = await client.get('/productos')
 expect(res.status).toBe(200)
-expect(res.body).toBeArray()
 ```
 
 ---
@@ -119,9 +144,7 @@ describe('Productos API', () => {
   beforeEach(() => {
     const router = new Router()
     // montar el módulo de prueba
-    const orm    = createRecordingOrm()
-    const repo   = new OrmRepository<ProductoDTO>(orm, 'Producto')
-    const service = new ProductosService(repo, createSilentLogger(), createNullCache())
+    const service = new ProductosService(makeRepo(), log, silentCache)
     const controller = new ProductosController(service)
 
     router.get('/productos',     req => controller.index(req))
@@ -161,7 +184,7 @@ describe('Productos API', () => {
 import { Auth } from 'arckode-framework'
 import { jwtTokenAdapter } from 'arckode-framework/adapters/jwt'
 
-const auth = new Auth(jwtTokenAdapter, 'test-secret-12345678901234567890', createSilentLogger())
+const auth = new Auth(jwtTokenAdapter, 'test-secret-12345678901234567890', silentLogger())
 const token = auth.createToken({ id: 'user-1', role: 'user' })
 const adminToken = auth.createToken({ id: 'admin-1', role: 'admin' })
 
@@ -249,9 +272,9 @@ test('ORM recibe query INSERT', async () => {
 ## 10. CHECKLIST TESTING
 
 - [ ] Mínimo 2 test cases: happy path + error esperado
-- [ ] Usar `createRecordingOrm` (sin BD real en unit tests)
-- [ ] Usar `createSilentLogger` (sin ruido en consola)
-- [ ] Usar `createNullCache` (cache predecible)
+- [ ] `silentLogger()` — con paréntesis, es factory function (no objeto)
+- [ ] Cache mock inline (`get: async () => null`, etc.) — no hay createNullCache
+- [ ] `RepositoryAdapter<T>` mock inline con `makeRepo()` — no hay createRecordingOrm
 - [ ] Todo `expect(...).rejects` tiene `await`
 - [ ] Los nombres de test describen comportamiento, no implementación
 - [ ] `bun test` pasa sin errores antes del commit

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
-}