arckode-framework 1.0.1 → 1.0.3

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.1",
+  "version": "1.0.3",
   "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",

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