aiplang 2.11.2 → 2.11.4

package/bin/aiplang.js

@@ -5,7 +5,7 @@ const fs   = require('fs')
 const path = require('path')
 const http = require('http')
 
-const VERSION     = '2.11.2'
+const VERSION     = '2.11.4'
 const RUNTIME_DIR = path.join(__dirname, '..', 'runtime')
 const cmd         = process.argv[2]
 const args        = process.argv.slice(3)
@@ -37,6 +37,7 @@ if (!cmd||cmd==='--help'||cmd==='-h') {
     npx aiplang serve [dir]                  dev server + hot reload
     npx aiplang build [dir/file]             compile → static HTML
     npx aiplang validate <app.aip>           validate syntax with AI-friendly errors
+    npx aiplang types   <app.aip>            generate TypeScript types (.d.ts)
     npx aiplang context [app.aip]            dump minimal AI context (<500 tokens)
     npx aiplang new <page>                   new page template
     npx aiplang --version
@@ -59,6 +60,12 @@ if (!cmd||cmd==='--help'||cmd==='-h') {
     {{year}}  current year
 
   Customization:
+    # Bancos de dados suportados:
+    #   ~db sqlite   ./app.db          (padrão — sem configuração)
+    #   ~db pg       $DATABASE_URL     (PostgreSQL)
+    #   ~db mysql    $MYSQL_URL        (MySQL / MariaDB)
+    #   ~db mongodb  $MONGODB_URL      (MongoDB)
+    #   ~db redis    $REDIS_URL        (Redis — cache/session)
     ~theme accent=#7c3aed radius=1.5rem font=Syne bg=#000 text=#fff
     hero{...} animate:fade-up
     row3{...} class:my-class animate:stagger
@@ -451,6 +458,242 @@ const _KNOWN_TYPES = new Set([
   'bigint','smallint','tinyint','currency','money','price'
 ])
 
+
+
+function _parseForTypes(src) {
+  const app = { models:[], apis:[], auth:null }
+  const _ta = {
+    integer:'int',boolean:'bool',double:'float',number:'float',string:'text',
+    varchar:'text',datetime:'timestamp',email:'email',url:'url',uri:'url',
+    phone:'phone',currency:'float',money:'float',price:'float',
+    json:'json',jsonb:'json',bigint:'int',smallint:'int',tinyint:'int'
+  }
+  const norm = t => _ta[(t||'').toLowerCase()] || t || 'text'
+
+  function parseField(line) {
+    const p = line.split(/\s*:\s*/)
+    const f = { name:(p[0]||'').trim(), type:norm(p[1]), modifiers:[], enumVals:[], constraints:{}, default:null }
+    if (f.type === 'enum') {
+      const ev = p.slice(2).find(x => x && !x.startsWith('default=') && !['required','unique','hashed','pk','auto','index'].includes(x.trim()))
+      if (ev) f.enumVals = ev.includes('|') ? ev.split('|').map(v=>v.trim()) : ev.split(',').map(v=>v.trim())
+    }
+    for (let j=2; j<p.length; j++) {
+      const x = (p[j]||'').trim()
+      if (!x) continue
+      if (x.startsWith('default='))     f.default = x.slice(8)
+      else if (x.startsWith('min='))    f.constraints.min = Number(x.slice(4))
+      else if (x.startsWith('max='))    f.constraints.max = Number(x.slice(4))
+      else if (x.startsWith('minLen=')) f.constraints.minLen = Number(x.slice(7))
+      else if (x.startsWith('maxLen=')) f.constraints.maxLen = Number(x.slice(7))
+      else if (x.startsWith('enum:'))   f.enumVals = x.slice(5).includes('|') ? x.slice(5).split('|').map(v=>v.trim()) : x.slice(5).split(',').map(v=>v.trim())
+      else if (x && !x.includes('='))   f.modifiers.push(x)
+    }
+    return f
+  }
+
+  // Juntar todas as linhas e tokenizar por estado
+  const lines = src.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'))
+  let inModel=false, inAPI=false, curModel=null, depth=0
+
+  for (let i=0; i<lines.length; i++) {
+    const line = lines[i]
+
+    // Auth
+    if (line.startsWith('~auth ')) { app.auth = { type: line.includes('jwt') ? 'jwt' : 'basic' }; continue }
+
+    // Model
+    if (line.startsWith('model ') || (line.startsWith('model') && line.includes('{'))) {
+      if (inModel && curModel) app.models.push(curModel)
+      curModel = { name: line.replace(/^model\s+/, '').replace(/\s*\{.*$/, '').trim(), fields:[] }
+      inModel=true; inAPI=false; depth=0
+      if (line.includes('{')) depth++
+      continue
+    }
+
+    // API
+    if (line.startsWith('api ')) {
+      if (inModel && curModel) { app.models.push(curModel); curModel=null; inModel=false }
+      const m = line.match(/^api\s+(\w+)\s+(\S+)/)
+      if (m) {
+        const guards = []
+        // Procura guard tanto na linha atual quanto nas próximas linhas do bloco
+        const blockLines = []
+        let j=i; let bd=0
+        while(j<lines.length) {
+          const bl = lines[j]
+          for(const ch of bl) { if(ch==='{') bd++; else if(ch==='}') bd-- }
+          blockLines.push(bl)
+          if(bd===0 && j>i) break
+          j++
+        }
+        const blockStr = blockLines.join(' ')
+        if (blockStr.includes('~guard auth'))  guards.push('auth')
+        if (blockStr.includes('~guard admin')) guards.push('admin')
+        if (blockStr.includes('=> auth'))      guards.push('auth')
+        if (blockStr.includes('=> admin'))     guards.push('admin')
+        app.apis.push({ method:m[1].toUpperCase(), path:m[2], guards })
+      }
+      inAPI=true; inModel=false
+      // Contar profundidade das chaves para saber quando o bloco fecha
+      depth=0
+      for(const ch of line) { if(ch==='{') depth++; else if(ch==='}') depth-- }
+      if(depth<=0) { inAPI=false; depth=0 }
+      continue
+    }
+
+    // Dentro de api block: rastrear chaves
+    if (inAPI) {
+      for(const ch of line) { if(ch==='{') depth++; else if(ch==='}') depth-- }
+      if(depth<=0) { inAPI=false; depth=0 }
+      continue
+    }
+
+    // Fechar model
+    if (line === '}' && inModel) {
+      if (curModel) { app.models.push(curModel); curModel=null }
+      inModel=false; continue
+    }
+
+    // Campos do model
+    if (inModel && curModel && line && line !== '{' && !line.startsWith('~') && line.includes(':')) {
+      const f = parseField(line)
+      if (f.name) curModel.fields.push(f)
+    }
+  }
+  if (inModel && curModel) app.models.push(curModel)
+  return app
+}
+
+// ── TypeScript type generator ────────────────────────────────────
+// Maps aiplang types to TypeScript equivalents
+const _AIP_TO_TS = {
+  text:'string', string:'string', email:'string', url:'string',
+  phone:'string', slug:'string', color:'string', file:'string', image:'string',
+  int:'number', integer:'number', float:'number', double:'number',
+  number:'number', currency:'number', money:'number', price:'number',
+  bool:'boolean', boolean:'boolean',
+  uuid:'string', date:'string', timestamp:'string', datetime:'string',
+  json:'Record<string,unknown>', jsonb:'Record<string,unknown>',
+}
+
+function generateTypes(app, srcFile) {
+  const lines = [
+    '// ─────────────────────────────────────────────────────────────',
+    `// aiplang generated types — ${srcFile || 'app.aip'}`,
+    `// Generated: ${new Date().toISOString()}`,
+    '// DO NOT EDIT — regenerate with: npx aiplang types <app.aip>',
+    '// ─────────────────────────────────────────────────────────────',
+    '',
+  ]
+
+  // Model interfaces
+  for (const model of (app.models || [])) {
+    const name = model.name
+    lines.push(`// Model: ${name}`)
+
+    // Enum types first
+    for (const f of (model.fields || [])) {
+      if (f.type === 'enum' && f.enumVals && f.enumVals.length) {
+        lines.push(`export type ${name}${_cap(f.name)} = ${f.enumVals.map(v => `'${v}'`).join(' | ')}`)
+      }
+    }
+
+    // Main interface
+    lines.push(`export interface ${name} {`)
+    for (const f of (model.fields || [])) {
+      const req   = f.modifiers && f.modifiers.includes('required')
+      const pk    = f.modifiers && f.modifiers.includes('pk')
+      const auto  = f.modifiers && f.modifiers.includes('auto')
+      const opt   = !req || pk || auto
+      let tsType
+      if (f.type === 'enum' && f.enumVals && f.enumVals.length) {
+        tsType = `${name}${_cap(f.name)}`
+      } else {
+        tsType = _AIP_TO_TS[f.type] || 'string'
+      }
+      // Constraint comments
+      const constraints = []
+      if (f.constraints) {
+        if (f.constraints.min != null)    constraints.push(`min:${f.constraints.min}`)
+        if (f.constraints.max != null)    constraints.push(`max:${f.constraints.max}`)
+        if (f.constraints.minLen != null) constraints.push(`minLen:${f.constraints.minLen}`)
+        if (f.constraints.maxLen != null) constraints.push(`maxLen:${f.constraints.maxLen}`)
+        if (f.constraints.format)         constraints.push(`format:${f.constraints.format}`)
+      }
+      const comment = constraints.length ? `  // ${constraints.join(', ')}` : ''
+      const mods = []
+      if (f.modifiers) {
+        if (f.modifiers.includes('unique')) mods.push('@unique')
+        if (f.modifiers.includes('hashed')) mods.push('@hashed')
+        if (pk)   mods.push('@pk')
+        if (auto) mods.push('@auto')
+      }
+      const modStr = mods.length ? ` /** ${mods.join(' ')} */` : ''
+      lines.push(`  ${f.name}${opt ? '?' : ''}: ${tsType}${modStr}${comment}`)
+    }
+    lines.push(`}`)
+    lines.push(``)
+
+    // Input type (for POST/PUT — excludes pk/auto, optional for patches)
+    const inputFields = (model.fields || []).filter(f =>
+      !(f.modifiers && f.modifiers.includes('pk')) &&
+      !(f.modifiers && f.modifiers.includes('auto')) &&
+      f.name !== 'created_at' && f.name !== 'updated_at'
+    )
+    if (inputFields.length) {
+      lines.push(`export interface ${name}Input {`)
+      for (const f of inputFields) {
+        const req = f.modifiers && f.modifiers.includes('required')
+        let tsType
+        if (f.type === 'enum' && f.enumVals && f.enumVals.length) {
+          tsType = `${name}${_cap(f.name)}`
+        } else {
+          tsType = _AIP_TO_TS[f.type] || 'string'
+        }
+        lines.push(`  ${f.name}${req ? '' : '?'}: ${tsType}`)
+      }
+      lines.push(`}`)
+      lines.push(``)
+    }
+  }
+
+  // API route types
+  if ((app.apis || []).length) {
+    lines.push(`// ── API Route types ──────────────────────────────────────────`)
+    lines.push(``)
+    lines.push(`export interface AiplangRoutes {`)
+    for (const api of (app.apis || [])) {
+      const method = api.method.toUpperCase()
+      const path   = api.path.replace(/\//g, '_').replace(/[^a-zA-Z0-9_]/g,'').replace(/^_/,'')
+      const guards = (api.guards || []).join(', ')
+      const guardComment = guards ? ` /** guards: ${guards} */` : ''
+      lines.push(`  '${method} ${api.path}': {${guardComment}}`)
+    }
+    lines.push(`}`)
+    lines.push(``)
+  }
+
+  // Convenience type for auth user
+  const hasAuth = app.auth && app.auth.type
+  if (hasAuth) {
+    const userModel = (app.models || []).find(m => m.name === 'User' || m.name === 'user')
+    if (userModel) {
+      lines.push(`// ── Auth types ───────────────────────────────────────────────`)
+      lines.push(`export type AuthUser = Pick<User, 'id' | 'email'${(userModel.fields||[]).some(f=>f.name==='role')?" | 'role'":''}> & { type: 'access' | 'refresh', iat: number, exp: number }`)
+      lines.push(`declare global { namespace Express { interface Request { user?: AuthUser } } }`)
+      lines.push(``)
+    }
+  }
+
+  lines.push(`// ── aiplang version ──────────────────────────────────────────`)
+  lines.push(`export const AIPLANG_VERSION     = '2.11.4'`)
+  lines.push(``)
+  return lines.join('\n')
+}
+
+function _cap(s) { return s ? s[0].toUpperCase() + s.slice(1) : s }
+
+
 function validateAipSrc(source) {
   const errors = []
   const lines = source.split('\n')
@@ -490,6 +733,34 @@ function validateAipSrc(source) {
   return errors
 }
 
+if (cmd==='types'||cmd==='type'||cmd==='dts') {
+  const file = args[0]
+  if (!file) { console.error('\n  Usage: aiplang types <app.aip> [--out types.d.ts]\n'); process.exit(1) }
+  if (!require('fs').existsSync(file)) { console.error(`\n  ✗  Arquivo não encontrado: ${file}\n`); process.exit(1) }
+  const src = require('fs').readFileSync(file,'utf8')
+  const errs = validateAipSrc(src)
+  if (errs.some(e => e.severity === 'error')) {
+    console.error('\n  ✗  Corrija os erros antes de gerar tipos:\n')
+    errs.filter(e=>e.severity==='error').forEach(e=>console.error(`  Line ${e.line}: ${e.message}`))
+    process.exit(1)
+  }
+  const serverPath = require('path').join(__dirname,'../server/server.js')
+  // Parse models and routes from .aip source for type generation
+  // Lightweight inline parser — no DB, no server init required
+  const app = _parseForTypes(src)
+  const _outIdx = args.indexOf('--out')
+  const outFile = (_outIdx >= 0 && args[_outIdx+1]) ? args[_outIdx+1] : file.replace(/\.aip$/,'') + '.d.ts'
+  const dts = generateTypes(app, require('path').basename(file))
+  require('fs').writeFileSync(outFile, dts)
+  console.log(`\n  ✅  Tipos gerados: ${outFile}`)
+  console.log(`  ${(app.models||[]).length} models · ${(app.apis||[]).length} routes\n`)
+  // Also show preview
+  const preview = dts.split('\n').slice(0,30).join('\n')
+  console.log(preview)
+  if (dts.split('\n').length > 30) console.log('  ...')
+  process.exit(0)
+}
+
 if (cmd==='validate'||cmd==='check'||cmd==='lint') {
   const file = args[0]
   if (!file) { console.error('\n  Usage: aiplang validate <app.aip>\n'); process.exit(1) }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiplang",
-  "version": "2.11.2",
+  "version": "2.11.4",
   "description": "AI-first web language. One .aip file = complete app. Frontend + backend + database + auth.",
   "keywords": [
     "aiplang",
@@ -43,12 +43,18 @@
     "@sqlite.org/sqlite-wasm": "^3.51.2-build8",
     "bcryptjs": "^2.4.3",
     "better-sqlite3": "^12.8.0",
+    "ioredis": "^5.3.2",
     "jsonwebtoken": "^9.0.2",
+    "mongodb": "^6.5.0",
+    "mysql2": "^3.9.0",
     "nodemailer": "^8.0.3",
     "pg": "^8.11.0",
     "sql.js": "^1.10.3",
     "stripe": "^14.0.0",
     "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.44.0",
     "ws": "^8.16.0"
+  },
+  "optionalDependencies": {
+    "better-sqlite3": "^9.4.0"
   }
 }

package/server/server.js

@@ -32,6 +32,12 @@ let SQL, DB_FILE, _db = null
 let _pgPool = null // PostgreSQL connection pool
 let _dbDriver = 'sqlite' // 'sqlite' | 'postgres'
 let _useBetter = false  // true when better-sqlite3 is available
+let _mysqlPool  = null  // MySQL/MariaDB (mysql2)
+let _mongoClient= null  // MongoDB client
+let _mongoDB    = null  // MongoDB database
+let _redisClient= null  // Redis (ioredis)
+let _useMongo   = false
+let _useRedis   = false
 
 async function getDB(dbConfig = { driver: 'sqlite', dsn: ':memory:' }) {
   if (_db || _pgPool) return _db || _pgPool
@@ -39,16 +45,72 @@ async function getDB(dbConfig = { driver: 'sqlite', dsn: ':memory:' }) {
   const dsn = dbConfig.dsn || ':memory:'
   _dbDriver = driver
 
-  if (driver === 'postgres' || driver === 'postgresql' || dsn.startsWith('postgres')) {
+  // ── PostgreSQL ────────────────────────────────────────────────
+  if (driver === 'postgres' || dsn.startsWith('postgres')) {
     try {
       const { Pool } = require('pg')
       _pgPool = new Pool({ connectionString: dsn, ssl: dsn.includes('ssl=true') ? { rejectUnauthorized: false } : false })
-      await _pgPool.query('SELECT 1') // test connection
+      await _pgPool.query('SELECT 1')
       console.log('[aiplang] DB:     PostgreSQL ✓')
       return _pgPool
     } catch (e) {
-      console.error('[aiplang] PostgreSQL connection failed:', e.message)
-      console.log('[aiplang] Falling back to SQLite :memory:')
+      console.error('[aiplang] PostgreSQL falhou:', e.message)
+      _dbDriver = 'sqlite'
+    }
+  }
+
+  // ── MySQL / MariaDB ───────────────────────────────────────────
+  if (driver === 'mysql' || dsn.startsWith('mysql') || dsn.startsWith('mariadb')) {
+    try {
+      const mysql = require('mysql2/promise')
+      _mysqlPool = await mysql.createPool({
+        uri: dsn.startsWith('mariadb') ? dsn.replace('mariadb://', 'mysql://') : dsn,
+        waitForConnections: true,
+        connectionLimit: 10,
+        queueLimit: 0,
+        ssl: dsn.includes('ssl=true') ? { rejectUnauthorized: false } : undefined
+      })
+      await _mysqlPool.query('SELECT 1')
+      _dbDriver = 'mysql'
+      console.log('[aiplang] DB:     MySQL/MariaDB ✓')
+      return _mysqlPool
+    } catch (e) {
+      console.error('[aiplang] MySQL falhou:', e.message)
+      _dbDriver = 'sqlite'
+    }
+  }
+
+  // ── MongoDB ───────────────────────────────────────────────────
+  if (driver === 'mongodb' || dsn.startsWith('mongodb')) {
+    try {
+      const { MongoClient } = require('mongodb')
+      _mongoClient = new MongoClient(dsn)
+      await _mongoClient.connect()
+      // Extrair nome do banco da URL
+      const dbName = dsn.split('/').pop()?.split('?')[0] || 'aiplang'
+      _mongoDB = _mongoClient.db(dbName)
+      _useMongo = true
+      _dbDriver = 'mongodb'
+      console.log('[aiplang] DB:     MongoDB ✓ (' + dbName + ')')
+      return _mongoDB
+    } catch (e) {
+      console.error('[aiplang] MongoDB falhou:', e.message)
+      _dbDriver = 'sqlite'
+    }
+  }
+
+  // ── Redis ─────────────────────────────────────────────────────
+  if (driver === 'redis' || dsn.startsWith('redis')) {
+    try {
+      const Redis = require('ioredis')
+      _redisClient = new Redis(dsn, { lazyConnect: false, maxRetriesPerRequest: 3 })
+      await _redisClient.ping()
+      _useRedis = true
+      _dbDriver = 'redis'
+      console.log('[aiplang] DB:     Redis ✓')
+      return _redisClient
+    } catch (e) {
+      console.error('[aiplang] Redis falhou:', e.message)
       _dbDriver = 'sqlite'
     }
   }
@@ -89,7 +151,48 @@ function persistDB() {
 }
 let _dirty = false, _persistTimer = null
 
+// ── MongoDB helpers ───────────────────────────────────────────────
+function _sqlWhereToMongo(sql, params) {
+  // Converte WHERE simples: id = ? / email = ? → {id: val, email: val}
+  const filter = {}
+  const whereMatch = sql.match(/WHERE\s+(.+?)(?:ORDER|LIMIT|$)/is)
+  if (!whereMatch) return filter
+  const conditions = whereMatch[1].trim()
+  const parts = conditions.split(/\s+AND\s+/i)
+  let paramIdx = 0
+  for (const part of parts) {
+    const m = part.trim().match(/^(\w+)\s*=\s*\?$/)
+    if (m && paramIdx < params.length) {
+      filter[m[1]] = params[paramIdx++]
+    }
+  }
+  return filter
+}
+
+function _mongoToObj(doc) {
+  if (!doc) return null
+  const { _id, ...rest } = doc
+  return { id: _id?.toString() || rest.id, ...rest }
+}
+
+// ── MySQL: CREATE TABLE equivalente ──────────────────────────────
+function _mysqlType(sqliteType) {
+  return {
+    'TEXT': 'TEXT',
+    'INTEGER': 'INT',
+    'REAL': 'DOUBLE',
+    'BLOB': 'BLOB'
+  }[sqliteType] || 'TEXT'
+}
+
+
 function dbRun(sql, params = []) {
+  if (_mysqlPool) {
+    // MySQL: async, mas dbRun é chamado sync em alguns contextos
+    // Enfileirar de forma segura
+    _mysqlPool.execute(sql, params).catch(e => console.debug('[aiplang:mysql]', e?.message))
+    return
+  }
   if (_useBetter && !_pgPool) {
     // better-sqlite3: synchronous, native — 30x faster than sql.js writes
     _getStmt(sql).run(...params)
@@ -117,7 +220,8 @@ function convertPlaceholders(sql) {
 }
 
 async function dbRunAsync(sql, params = []) {
-  if (_pgPool) return _pgPool.query(convertPlaceholders(sql), params)
+  if (_mysqlPool) return _mysqlPool.execute(sql, params)
+  if (_pgPool)    return _pgPool.query(convertPlaceholders(sql), params)
   dbRun(sql, params)
 }
 
@@ -181,18 +285,18 @@ function _getStmt(sql) {
 }
 
 function dbAll(sql, params = [], _cacheKey = null, _cacheTables = null) {
-  if (_pgPool) return []
+  if (_pgPool)    return []  // PostgreSQL usa dbAllAsync
+  if (_mysqlPool) return []  // MySQL usa dbAllAsync
+  if (_useMongo)  return []  // MongoDB usa dbAllAsync
   if (_cacheKey && !params.length) {
     const cached = _cacheGet(_cacheKey)
     if (cached !== null) return { __cached: true, __body: cached }
   }
   let rows
   if (_useBetter) {
-    // better-sqlite3: synchronous, native, 7x faster
     const stmt = _getStmt(sql)
     rows = params.length ? stmt.all(...params) : stmt.all()
   } else {
-    // sql.js fallback
     const stmt = _db.prepare(sql)
     stmt.bind(params); rows = []
     while (stmt.step()) rows.push(stmt.getAsObject())
@@ -202,12 +306,33 @@ function dbAll(sql, params = [], _cacheKey = null, _cacheTables = null) {
   return rows
 }
 
-async function dbAllAsync(sql, params = []) {
+async function dbAllAsync(sql, params = [], _cacheKey = null, _cacheTables = null) {
+  // Cache check (universal)
+  if (_cacheKey && !params.length) {
+    const cached = _cacheGet(_cacheKey)
+    if (cached !== null) return { __cached: true, __body: cached }
+  }
+  let rows
   if (_pgPool) {
     const r = await _pgPool.query(convertPlaceholders(sql), params)
-    return r.rows
+    rows = r.rows
+  } else if (_mysqlPool) {
+    const [result] = await _mysqlPool.execute(sql, params)
+    rows = result
+  } else if (_useMongo) {
+    // MongoDB: extrair collection do SQL "SELECT * FROM table WHERE..."
+    const tableMatch = sql.match(/FROM\s+(\w+)/i)
+    const collection = tableMatch ? tableMatch[1] : null
+    if (!collection) return []
+    const filter = _sqlWhereToMongo(sql, params)
+    rows = await _mongoDB.collection(collection).find(filter).toArray()
+  } else {
+    rows = dbAll(sql, params)
+  }
+  if (Array.isArray(rows) && _cacheKey && !params.length) {
+    _cacheSet(_cacheKey, JSON.stringify(rows), _cacheTables)
   }
-  return dbAll(sql, params)
+  return rows
 }
 
 function dbGet(sql, params = []) { return dbAll(sql, params)[0] || null }
@@ -460,9 +585,15 @@ function validateAip(source) {
 }
 
 function cacheSet(key, value, ttlMs = 60000) {
+  // Redis: persistir em redis além do cache em memória
+  if (_useRedis) {
+    try { _redisClient.set('aip:' + key, JSON.stringify(value), 'PX', ttlMs).catch(() => {}) } catch {}
+  }
   _cache.set(key, { value, expires: Date.now() + ttlMs })
 }
 function cacheGet(key) {
+  // Redis: verificar redis se não tiver na memória
+  // (retorna null para busca assíncrona — o caller deve usar cacheGetAsync se precisar)
   const item = _cache.get(key)
   if (!item) return null
   if (item.expires < Date.now()) { _cache.delete(key); return null }
@@ -621,6 +752,19 @@ class Model {
 
   // ── Core queries ────────────────────────────────────────────────
   all(opts = {}) {
+    // MongoDB
+    if (_useMongo) {
+      const filter = this.softDelete ? { deleted_at: { $exists: false } } : {}
+      const mongoOpts = {}
+      if (opts.limit)  mongoOpts.limit = parseInt(opts.limit)
+      if (opts.offset) mongoOpts.skip  = parseInt(opts.offset)
+      if (opts.order) {
+        const p = String(opts.order).trim().split(/\s+/)
+        mongoOpts.sort = { [p[0]]: p[1]?.toLowerCase()==='desc' ? -1 : 1 }
+      }
+      return _mongoDB.collection(this.tableName).find(filter, mongoOpts).toArray()
+        .then(docs => docs.map(d => { const { _id, ...rest } = d; return { id: _id?.toString(), ...rest } }))
+    }
     let sql = `SELECT * FROM ${this.tableName}`
     const params = [], conditions = []
     if (this.softDelete) conditions.push('deleted_at IS NULL')
@@ -684,6 +828,11 @@ class Model {
       if (!row.updated_at) row.updated_at = now()
     }
     const keys = Object.keys(row), vals = Object.values(row)
+    // MongoDB: usar insertOne
+    if (_useMongo) {
+      _mongoDB.collection(this.tableName).insertOne({ ...row }).catch(e => console.debug('[aiplang:mongo]', e?.message))
+      return row
+    }
     dbRun(`INSERT INTO ${this.tableName} (${keys.join(',')}) VALUES (${keys.map(()=>'?').join(',')})`, vals)
     emit(`${this.modelName}.created`, row)
     return row
@@ -767,13 +916,39 @@ class Model {
 // MIGRATION
 // ═══════════════════════════════════════════════════════════════════
 function migrateModels(models) {
+  // ── Seleção de mapa de tipos por banco ───────────────────────────
+  const _sqliteTypes = { uuid:'TEXT',int:'INTEGER',integer:'INTEGER',float:'REAL',bool:'INTEGER',timestamp:'TEXT',date:'TEXT',json:'TEXT',enum:'TEXT',text:'TEXT',email:'TEXT',url:'TEXT',phone:'TEXT' }
+  const _mysqlTypes  = { uuid:'VARCHAR(36)',int:'INT',integer:'INT',float:'DOUBLE',bool:'TINYINT(1)',timestamp:'DATETIME',date:'DATE',json:'JSON',enum:'TEXT',text:'TEXT',email:'VARCHAR(255)',url:'TEXT',phone:'VARCHAR(20)' }
+  const _pgTypes     = { uuid:'UUID',int:'INTEGER',integer:'INTEGER',float:'DOUBLE PRECISION',bool:'BOOLEAN',timestamp:'TIMESTAMPTZ',date:'DATE',json:'JSONB',enum:'TEXT',text:'TEXT',email:'TEXT',url:'TEXT',phone:'TEXT' }
+  const typeMap = _mysqlPool ? _mysqlTypes : (_pgPool ? _pgTypes : _sqliteTypes)
+
   for (const model of models) {
     const table = toTable(model.name)
+
+    // ── MongoDB: criar collection com índices ──────────────────────
+    if (_useMongo) {
+      _mongoDB.collection(table)  // cria collection implicitamente
+      for (const f of model.fields) {
+        const colName = toCol(f.name)
+        if (f.modifiers.includes('unique')) {
+          _mongoDB.collection(table).createIndex({ [colName]: 1 }, { unique: true }).catch(() => {})
+        }
+      }
+      console.log(`[aiplang] ✓  ${table}  (MongoDB)`)
+      continue
+    }
+
     const cols = []
     for (const f of model.fields) {
-      let sqlType = { uuid:'TEXT',int:'INTEGER',integer:'INTEGER',float:'REAL',bool:'INTEGER',timestamp:'TEXT',date:'TEXT',json:'TEXT',enum:'TEXT',text:'TEXT',email:'TEXT',url:'TEXT',phone:'TEXT' }[f.type] || 'TEXT'
+      let sqlType = typeMap[f.type] || 'TEXT'
       let def = `${toCol(f.name)} ${sqlType}`
-      if (f.modifiers.includes('pk')) def += ' PRIMARY KEY'
+      if (f.modifiers.includes('pk')) {
+        if (_mysqlPool) def += ' PRIMARY KEY'
+        else def += ' PRIMARY KEY'
+      }
+      if (f.modifiers.includes('auto') && f.type !== 'uuid') {
+        if (_mysqlPool) def += ' AUTO_INCREMENT'
+      }
       if (f.modifiers.includes('required')) def += ' NOT NULL'
       if (f.modifiers.includes('unique')) def += ' UNIQUE'
       if (f.default !== null) def += ` DEFAULT '${f.default}'`
@@ -905,7 +1080,18 @@ function parseApp(src) {
 }
 
 function parseEnvLine(s) { const p=s.split(/\s+/); const ev={name:'',required:false,default:null}; for(const x of p){if(x==='required')ev.required=true;else if(x.includes('=')){const[k,v]=x.split('=');ev.name=k;ev.default=v}else ev.name=x}; return ev }
-function parseDBLine(s) { const p=s.split(/\s+/); const d=p[0]||'sqlite'; return{driver:d==='pg'||d==='psql'?'postgres':d,dsn:p[1]||'./app.db'} }
+function parseDBLine(s) {
+  const p = s.split(/\s+/)
+  let d = (p[0]||'sqlite').toLowerCase()
+  // Normalizar aliases
+  if (d==='pg'||d==='psql'||d==='postgresql') d='postgres'
+  if (d==='mariadb') d='mysql'
+  if (d==='mongo') d='mongodb'
+  if (d==='redis'||d==='cache') d='redis'
+  if (d==='sqlite3') d='sqlite'
+  const dsn = p[1] || (d==='sqlite'?'./app.db':d==='redis'?'redis://localhost:6379':'')
+  return { driver:d, dsn }
+}
 function parseAuthLine(s) { const p=s.split(/\s+/); const a={provider:'jwt',secret:p[1]||'$JWT_SECRET',expire:'7d',refresh:'30d'}; for(const x of p){if(x.startsWith('expire='))a.expire=x.slice(7);if(x.startsWith('refresh='))a.refresh=x.slice(8);if(x==='google')a.oauth=['google'];if(x==='github')a.oauth=[...(a.oauth||[]),'google']}; return a }
 function parseMailLine(s) { const parts=s.split(/\s+/); const m={driver:parts[0]||'smtp'}; for(const x of parts.slice(1)){const[k,v]=x.split('='); m[k]=v}; return m }
 function parseStripeLine(s) {
@@ -2246,7 +2432,7 @@ async function startServer(aipFile, port = 3000) {
   })
 
   srv.addRoute('GET', '/health', (req, res) => res.json(200, {
-    status:'ok', version:'2.11.2',
+    status:'ok', version:'2.11.4',
     models: app.models.map(m=>m.name),
     routes: app.apis.length, pages: app.pages.length,
     admin: app.admin?.prefix || null,