arckode-framework 1.0.5 → 1.0.7

package/kernel/framework.ts

@@ -386,8 +386,9 @@ export interface DbAdapter {
 
 // ── Definición de campo ──
 export interface FieldDefinition {
-  type: 'string' | 'number' | 'boolean' | 'json' | 'date'
+  type: 'string' | 'text' | 'number' | 'boolean' | 'json' | 'date'
   required?: boolean
+  nullable?: boolean       // alias semántico de !required — campo puede ser NULL
   default?: unknown
   unique?: boolean
   indexed?: boolean
@@ -503,6 +504,28 @@ export class ORM {
 
   // ── Helpers privados ──
 
+  private serializeForDb(def: ModelDefinition, record: Record<string, unknown>): Record<string, unknown> {
+    const out: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(record)) {
+      if (def.fields[k]?.type === 'json' && v !== null && v !== undefined && typeof v !== 'string') {
+        out[k] = JSON.stringify(v)
+      } else {
+        out[k] = v
+      }
+    }
+    return out
+  }
+
+  private deserializeFromDb(def: ModelDefinition, row: ModelResult): ModelResult {
+    const result = { ...row } as Record<string, unknown>
+    for (const [k, field] of Object.entries(def.fields)) {
+      if (field.type === 'json' && typeof result[k] === 'string') {
+        try { result[k] = JSON.parse(result[k] as string) } catch { /* no es JSON válido */ }
+      }
+    }
+    return result as ModelResult
+  }
+
   private getAllowedFields(def: ModelDefinition): Set<string> {
     const allowed = new Set(['id', ...Object.keys(def.fields)])
     if (def.timestamps) { allowed.add('createdAt'); allowed.add('updatedAt') }
@@ -566,7 +589,8 @@ export class ORM {
       }
     }
 
-    return (await this.db.query(sql, params)) as ModelResult[]
+    const rows = (await this.db.query(sql, params)) as ModelResult[]
+    return rows.map(r => this.deserializeFromDb(def, r))
   }
 
   async findById(name: string, id: string, select?: string[]): Promise<ModelResult | null> {
@@ -575,7 +599,8 @@ export class ORM {
     let sql = `SELECT ${selectClause} FROM ${def.table} WHERE id = ?`
     if (def.softDelete) sql += ' AND deletedAt IS NULL'
     const rows = await this.db.query(sql, [id])
-    return (rows as ModelResult[])[0] ?? null
+    const row = (rows as ModelResult[])[0] ?? null
+    return row ? this.deserializeFromDb(def, row) : null
   }
 
   async findOne(name: string, filters: Record<string, unknown>): Promise<ModelResult | null> {
@@ -621,8 +646,9 @@ export class ORM {
       record.updatedAt = now
     }
 
-    const keys = Object.keys(record)
-    const values = Object.values(record)
+    const dbRecord = this.serializeForDb(def, record)
+    const keys = Object.keys(dbRecord)
+    const values = Object.values(dbRecord)
     const placeholders = keys.map(() => '?').join(', ')
 
     await this.db.run(
@@ -640,8 +666,9 @@ export class ORM {
     const record = { ...data }
     if (def.timestamps) record.updatedAt = now
 
-    const keys = Object.keys(record)
-    const values = Object.values(record)
+    const dbRecord = this.serializeForDb(def, record)
+    const keys = Object.keys(dbRecord)
+    const values = Object.values(dbRecord)
     const setClause = keys.map(k => `${k} = ?`).join(', ')
 
     await this.db.run(`UPDATE ${def.table} SET ${setClause} WHERE id = ?`, [...values, id])
@@ -682,10 +709,11 @@ export class ORM {
       return record
     })
 
-    const keys = Object.keys(prepared[0] ?? {})
+    const dbPrepared = prepared.map(r => this.serializeForDb(def, r))
+    const keys = Object.keys(dbPrepared[0] ?? {})
     const rowPlaceholders = `(${keys.map(() => '?').join(', ')})`
-    const allPlaceholders = prepared.map(() => rowPlaceholders).join(', ')
-    const allValues = prepared.flatMap(r => Object.values(r))
+    const allPlaceholders = dbPrepared.map(() => rowPlaceholders).join(', ')
+    const allValues = dbPrepared.flatMap(r => Object.values(r))
 
     await this.db.run(
       `INSERT INTO ${def.table} (${keys.join(', ')}) VALUES ${allPlaceholders}`,
@@ -711,10 +739,11 @@ export class ORM {
     const data = { ...changes }
     if (def.timestamps) data.updatedAt = now
 
-    const setClause = Object.keys(data).map(k => `${k} = ?`).join(', ')
+    const dbData = this.serializeForDb(def, data)
+    const setClause = Object.keys(dbData).map(k => `${k} = ?`).join(', ')
     const result = await this.db.run(
       `UPDATE ${def.table} SET ${setClause}${clause}`,
-      [...Object.values(data), ...whereParams],
+      [...Object.values(dbData), ...whereParams],
     )
     return result.changes
   }
@@ -867,7 +896,7 @@ export class ORM {
     // Postgres / estándar SQL
     try {
       const rows = await this.db.query(
-        `SELECT column_name FROM information_schema.columns WHERE table_name = '${table}'`
+        `SELECT column_name FROM information_schema.columns WHERE table_name = '${table}' AND table_schema = 'public'`
       )
       if (Array.isArray(rows) && rows.length > 0) {
         return (rows as { column_name: string }[]).map(r => r.column_name)
@@ -880,6 +909,7 @@ export class ORM {
   private fieldTypeToSQL(type: FieldDefinition['type']): string {
     const map: Record<FieldDefinition['type'], string> = {
       string: 'TEXT',
+      text: 'TEXT',        // alias de string para TEXT largo
       number: 'REAL',
       boolean: 'BOOLEAN',  // INTEGER falla en Postgres con DEFAULT false/true
       json: 'TEXT',
@@ -1032,12 +1062,26 @@ export class Router {
     })
   }
 
-  get(path: string, handler: RouteHandler, mw?: MiddlewareHandler[]): void { this.add('GET', path, handler, mw) }
-  post(path: string, handler: RouteHandler, mw?: MiddlewareHandler[]): void { this.add('POST', path, handler, mw) }
-  put(path: string, handler: RouteHandler, mw?: MiddlewareHandler[]): void { this.add('PUT', path, handler, mw) }
-  patch(path: string, handler: RouteHandler, mw?: MiddlewareHandler[]): void { this.add('PATCH', path, handler, mw) }
-  delete(path: string, handler: RouteHandler, mw?: MiddlewareHandler[]): void { this.add('DELETE', path, handler, mw) }
-  options(path: string, handler: RouteHandler, mw?: MiddlewareHandler[]): void { this.add('OPTIONS', path, handler, mw) }
+  // Acepta ambas convenciones:
+  //   (path, handler)              — sin middlewares
+  //   (path, handler, mw[])        — handler primero (legado)
+  //   (path, mw[], handler)        — middlewares primero (Express-like, convención del framework)
+  private resolve2(
+    handlerOrMw: RouteHandler | MiddlewareHandler[],
+    handlerOrUndefined?: RouteHandler | MiddlewareHandler[],
+  ): { handler: RouteHandler; mw: MiddlewareHandler[] } {
+    if (Array.isArray(handlerOrMw)) {
+      return { handler: handlerOrUndefined as RouteHandler, mw: handlerOrMw }
+    }
+    return { handler: handlerOrMw, mw: (handlerOrUndefined as MiddlewareHandler[] | undefined) ?? [] }
+  }
+
+  get(path: string, handlerOrMw: RouteHandler | MiddlewareHandler[], h?: RouteHandler | MiddlewareHandler[]): void { const { handler, mw } = this.resolve2(handlerOrMw, h); this.add('GET', path, handler, mw) }
+  post(path: string, handlerOrMw: RouteHandler | MiddlewareHandler[], h?: RouteHandler | MiddlewareHandler[]): void { const { handler, mw } = this.resolve2(handlerOrMw, h); this.add('POST', path, handler, mw) }
+  put(path: string, handlerOrMw: RouteHandler | MiddlewareHandler[], h?: RouteHandler | MiddlewareHandler[]): void { const { handler, mw } = this.resolve2(handlerOrMw, h); this.add('PUT', path, handler, mw) }
+  patch(path: string, handlerOrMw: RouteHandler | MiddlewareHandler[], h?: RouteHandler | MiddlewareHandler[]): void { const { handler, mw } = this.resolve2(handlerOrMw, h); this.add('PATCH', path, handler, mw) }
+  delete(path: string, handlerOrMw: RouteHandler | MiddlewareHandler[], h?: RouteHandler | MiddlewareHandler[]): void { const { handler, mw } = this.resolve2(handlerOrMw, h); this.add('DELETE', path, handler, mw) }
+  options(path: string, handlerOrMw: RouteHandler | MiddlewareHandler[], h?: RouteHandler | MiddlewareHandler[]): void { const { handler, mw } = this.resolve2(handlerOrMw, h); this.add('OPTIONS', path, handler, mw) }
 
   async resolve(method: string, path: string, extras?: Partial<HttpRequest>): Promise<HttpResponse> {
     const reqId = crypto.randomUUID().slice(0, 8)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arckode-framework",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "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",