arckode-framework 1.0.4 → 1.0.6

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
   }
@@ -769,6 +798,7 @@ export class ORM {
       }
 
       // 1. Crear tabla si no existe
+      const hasExplicitId = Object.keys(def.fields).includes('id')
       const columns = Object.entries(def.fields).map(([name, field]) => {
         const sqlType = this.fieldTypeToSQL(field.type)
         const parts = [name, sqlType]
@@ -783,6 +813,11 @@ export class ORM {
         return parts.join(' ')
       })
 
+      // Auto-añadir id TEXT PRIMARY KEY si el modelo no lo declara explícitamente
+      if (!hasExplicitId) {
+        columns.unshift('id TEXT PRIMARY KEY')
+      }
+
       if (def.timestamps) {
         columns.push('createdAt TEXT')
         columns.push('updatedAt TEXT')
@@ -818,11 +853,12 @@ export class ORM {
       }
 
       // 4. Detectar drift de schema: columnas en la BD que ya no están en el modelo
+      // Normalizar a lowercase para compatibilidad con PostgreSQL (retorna nombres en minúscula)
       const definedCols = new Set([
         'id',
-        ...Object.keys(def.fields),
-        ...(def.timestamps ? ['createdAt', 'updatedAt'] : []),
-        ...(def.softDelete ? ['deletedAt'] : []),
+        ...Object.keys(def.fields).map(k => k.toLowerCase()),
+        ...(def.timestamps ? ['createdat', 'updatedat'] : []),
+        ...(def.softDelete ? ['deletedat'] : []),
       ])
 
       const dbCols = await this.getTableColumns(def.table)
@@ -860,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)
@@ -873,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',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arckode-framework",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "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",
@@ -55,6 +55,7 @@
     "analyze:framework": "bun run cli/index.ts analyze"
   },
   "dependencies": {
+    "arckode-framework": "^1.0.3",
     "jsonwebtoken": "^9.0.0"
   },
   "peerDependencies": {