arckode-framework 1.3.2 → 1.4.0

package/cli/commands/db-migrate.ts

@@ -1,121 +1,245 @@
-// cli/commands/db-migrate.ts — Ejecuta migraciones SQL versionadas
-// Corre los archivos de src/migrations/*.ts que tienen up() / down()
-// Usa _arckode_migrations para rastrear cuáles ya se aplicaron
-
-import Database from 'better-sqlite3'
-import { readdir, readFile } from 'node:fs/promises'
-import { join, resolve } from 'node:path'
+// cli/commands/db-migrate.ts — Migraciones SQL versionadas (multi-DB)
+// Soporta SQLite (bun:sqlite nativo), MySQL y PostgreSQL
+// Detecta BD desde .env: DATABASE_URL (postgres), DB_HOST (mysql), DB_PATH (sqlite)
+//
+// Acciones disponibles:
+//   up       — aplica migraciones pendientes (default)
+//   down     — revierte la última migración aplicada
+//   fresh    — dropea TODAS las tablas y re-corre todo desde cero
+//   reset    — revierte TODAS las migraciones (newest first)
+//   refresh  — reset + up (equivalente a migrate:refresh de Laravel)
+//   status   — muestra el estado de cada migración
+
+import { readdir } from 'node:fs/promises'
+import { join } from 'node:path'
 import { existsSync } from 'node:fs'
+import { parseEnv, createCliDbRunner, type CliDbRunner } from './db-utils'
+
+// Interfaz que reciben up() y down() en cada archivo de migración.
+// Importá este tipo en tus migraciones para evitar usar `any`:
+//   import type { MigrationRunner } from 'arckode-framework/cli/commands/db-migrate'
+export interface MigrationRunner {
+  run(sql: string, params?: unknown[]): Promise<void>
+  exec(sql: string): Promise<void>
+}
 
-async function readDbPath(basePath: string): Promise<string> {
-  const envFile = join(basePath, '.env')
-  if (existsSync(envFile)) {
-    const content = await readFile(envFile, 'utf-8')
-    const match = content.match(/^DB_PATH=(.+)$/m)
-    if (match?.[1]) return match[1].trim()
-  }
-  return './data/db.sqlite'
+export type MigrateAction = 'up' | 'down' | 'fresh' | 'reset' | 'refresh' | 'status'
+
+// ─── Tracking table (_arckode_migrations) ────────────────────────────────────
+
+async function ensureTable(db: CliDbRunner): Promise<void> {
+  await db.exec(`
+    CREATE TABLE IF NOT EXISTS _arckode_migrations (
+      name VARCHAR(255) PRIMARY KEY,
+      direction VARCHAR(10) NOT NULL DEFAULT 'up',
+      runAt VARCHAR(50) NOT NULL
+    )
+  `)
 }
 
-interface DbRunner {
-  run(sql: string, params?: unknown[]): void
-  exec(sql: string): void
+async function getApplied(db: CliDbRunner): Promise<Set<string>> {
+  const rows = await db.query<{ name: string }>(
+    'SELECT name FROM _arckode_migrations WHERE direction = ?', ['up'],
+  )
+  return new Set(rows.map(r => r.name))
 }
 
-export async function dbMigrate(direction: 'up' | 'down' = 'up') {
-  const basePath = process.cwd()
-  const migrationsDir = join(basePath, 'src', 'migrations')
+async function getAllAppliedOrdered(db: CliDbRunner): Promise<string[]> {
+  const rows = await db.query<{ name: string }>(
+    'SELECT name FROM _arckode_migrations WHERE direction = ? ORDER BY runAt ASC', ['up'],
+  )
+  return rows.map(r => r.name)
+}
 
-  if (!existsSync(migrationsDir)) {
-    console.error('❌ No se encuentra src/migrations/')
-    console.error('   Creá una con: arckode make:migration <nombre>')
+async function getAppliedAt(db: CliDbRunner, name: string): Promise<string> {
+  const rows = await db.query<{ runAt: string }>(
+    'SELECT runAt FROM _arckode_migrations WHERE name = ?', [name],
+  )
+  return rows[0]?.runAt ?? '?'
+}
+
+async function markApplied(db: CliDbRunner, name: string): Promise<void> {
+  await db.run(
+    'INSERT INTO _arckode_migrations (name, direction, runAt) VALUES (?, ?, ?)',
+    [name, 'up', new Date().toISOString()],
+  )
+}
+
+async function markReverted(db: CliDbRunner, name: string): Promise<void> {
+  await db.run('DELETE FROM _arckode_migrations WHERE name = ?', [name])
+}
+
+async function getLastApplied(db: CliDbRunner): Promise<string | undefined> {
+  const rows = await db.query<{ name: string }>(
+    'SELECT name FROM _arckode_migrations WHERE direction = ? ORDER BY runAt DESC LIMIT 1', ['up'],
+  )
+  return rows[0]?.name
+}
+
+// ─── Helpers de ejecución ────────────────────────────────────────────────────
+
+async function applyOne(db: CliDbRunner, file: string, filePath: string): Promise<void> {
+  const migration = await import(filePath)
+  if (typeof migration.up !== 'function') {
+    console.warn(`⚠️  ${file} no exporta up() — saltando`)
     return
   }
+  console.log(`  ▶ Aplicando: ${file}`)
+  await db.inTransaction(async () => {
+    await migration.up(db as MigrationRunner)
+    await markApplied(db, file)
+  })
+  console.log(`  ✅ ${file}`)
+}
 
-  const dbRelPath = await readDbPath(basePath)
-  const dbAbsPath = resolve(basePath, dbRelPath)
+async function revertOne(db: CliDbRunner, name: string, migrationsDir: string): Promise<void> {
+  const filePath = join(migrationsDir, name)
+  if (!existsSync(filePath)) {
+    console.warn(`  ⚠️  Archivo ${name} no existe — saltando revert`)
+    await markReverted(db, name)
+    return
+  }
+  const migration = await import(filePath)
+  if (typeof migration.down !== 'function') {
+    console.warn(`  ⚠️  ${name} no exporta down() — saltando`)
+    return
+  }
+  console.log(`  ▶ Revirtiendo: ${name}`)
+  await db.inTransaction(async () => {
+    await migration.down(db as MigrationRunner)
+    await markReverted(db, name)
+  })
+  console.log(`  ✅ Revertida: ${name}`)
+}
 
-  const db = new Database(dbAbsPath)
+// ─── Acciones ────────────────────────────────────────────────────────────────
 
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS _arckode_migrations (
-      name TEXT PRIMARY KEY,
-      direction TEXT NOT NULL,
-      runAt TEXT NOT NULL
-    )
-  `)
+async function runUp(db: CliDbRunner, files: string[], migrationsDir: string): Promise<void> {
+  const applied = await getApplied(db)
+  const pending = files.filter(f => !applied.has(f))
 
-  const files = (await readdir(migrationsDir))
-    .filter(f => f.endsWith('.ts') || f.endsWith('.js'))
-    .sort()
-
-  if (files.length === 0) {
-    console.log('📭 No hay archivos en src/migrations/')
-    db.close()
+  if (pending.length === 0) {
+    console.log('✅ No hay migraciones pendientes')
     return
   }
 
-  const applied = new Set<string>(
-    (db.prepare('SELECT name FROM _arckode_migrations WHERE direction = ?').all('up') as { name: string }[])
-      .map(r => r.name)
-  )
+  for (const file of pending) {
+    await applyOne(db, file, join(migrationsDir, file))
+  }
+  console.log(`\n${pending.length} migración(es) aplicada(s)`)
+}
+
+async function runDown(db: CliDbRunner, migrationsDir: string): Promise<void> {
+  const last = await getLastApplied(db)
+  if (!last) { console.log('📭 No hay migraciones para revertir'); return }
+  await revertOne(db, last, migrationsDir)
+}
 
-  const runner: DbRunner = {
-    run(sql, params = []) { db.prepare(sql).run(...params) },
-    exec(sql) { db.exec(sql) },
+async function runReset(db: CliDbRunner, migrationsDir: string): Promise<void> {
+  const applied = await getAllAppliedOrdered(db)
+  if (applied.length === 0) { console.log('📭 No hay migraciones para revertir'); return }
+
+  console.log(`🔄 Revirtiendo ${applied.length} migración(es)...\n`)
+  for (const name of [...applied].reverse()) {
+    await revertOne(db, name, migrationsDir)
   }
+  console.log(`\n${applied.length} migración(es) revertida(s)`)
+}
 
-  if (direction === 'up') {
-    const pending = files.filter(f => !applied.has(f))
+async function runFresh(db: CliDbRunner, files: string[], migrationsDir: string): Promise<void> {
+  console.log('🗑  Dropeando todas las tablas...')
+  await db.dropAllTables()
+  console.log('✅ Tablas dropeadas\n')
 
-    if (pending.length === 0) {
-      console.log('✅ No hay migraciones pendientes')
-      db.close()
-      return
-    }
+  await ensureTable(db)
 
-    for (const file of pending) {
-      const filePath = join(migrationsDir, file)
-      const migration = await import(filePath)
+  console.log(`▶ Aplicando ${files.length} migración(es)...\n`)
+  for (const file of files) {
+    await applyOne(db, file, join(migrationsDir, file))
+  }
+  console.log(`\n${files.length} migración(es) aplicada(s)`)
+}
 
-      if (typeof migration.up !== 'function') {
-        console.warn(`⚠️  ${file} no exporta up() — saltando`)
-        continue
-      }
+async function runRefresh(db: CliDbRunner, files: string[], migrationsDir: string): Promise<void> {
+  console.log('🔄 Refresh: reset + migrate\n')
+  await runReset(db, migrationsDir)
+  console.log()
+  await ensureTable(db)
+  await runUp(db, files, migrationsDir)
+}
 
-      console.log(`▶ Aplicando: ${file}`)
-      await migration.up(runner)
-      db.prepare('INSERT INTO _arckode_migrations (name, direction, runAt) VALUES (?, ?, ?)')
-        .run(file, 'up', new Date().toISOString())
-      console.log(`✅ ${file}`)
-    }
+async function runStatus(db: CliDbRunner, files: string[]): Promise<void> {
+  const applied = await getApplied(db)
 
-    console.log(`\n${pending.length} migración(es) aplicada(s)`)
-  } else {
-    // down: revertir la última aplicada
-    const last = db.prepare('SELECT name FROM _arckode_migrations WHERE direction = ? ORDER BY runAt DESC LIMIT 1')
-      .get('up') as { name: string } | undefined
+  const COL_NAME = Math.max(40, ...files.map(f => f.length)) + 2
+  const header = `  ${'Migración'.padEnd(COL_NAME)}  ${'Estado'.padEnd(10)}  Aplicada en`
+  const sep = `  ${'-'.repeat(COL_NAME)}  ${'-'.repeat(10)}  ${'-'.repeat(26)}`
 
-    if (!last) {
-      console.log('📭 No hay migraciones para revertir')
-      db.close()
-      return
-    }
+  console.log('\n📋 Estado de migraciones\n')
+  console.log(header)
+  console.log(sep)
 
-    const filePath = join(migrationsDir, last.name)
-    const migration = await import(filePath)
+  let appliedCount = 0
+  let pendingCount = 0
+
+  for (const file of files) {
+    const isApplied = applied.has(file)
+    const status = isApplied ? '✅ aplicada' : '⏳ pendiente'
+    const when = isApplied ? await getAppliedAt(db, file) : '—'
+    console.log(`  ${file.padEnd(COL_NAME)}  ${status.padEnd(10)}  ${when}`)
+    if (isApplied) appliedCount++; else pendingCount++
+  }
 
-    if (typeof migration.down !== 'function') {
-      console.error(`❌ ${last.name} no exporta down()`)
-      db.close()
-      return
+  // Migraciones aplicadas cuyo archivo ya no existe (huérfanas)
+  for (const name of applied) {
+    if (!files.includes(name)) {
+      console.log(`  ${name.padEnd(COL_NAME)}  ⚠️ sin archivo  (archivo eliminado del repo)`)
     }
+  }
+
+  console.log(sep)
+  console.log(`\n  ${appliedCount} aplicada(s)  ·  ${pendingCount} pendiente(s)\n`)
+}
 
-    console.log(`▶ Revirtiendo: ${last.name}`)
-    await migration.down(runner)
-    db.prepare('DELETE FROM _arckode_migrations WHERE name = ?').run(last.name)
-    console.log(`✅ Revertida: ${last.name}`)
+// ─── Comando principal ────────────────────────────────────────────────────────
+
+export async function dbMigrate(action: MigrateAction = 'up'): Promise<void> {
+  const basePath = process.cwd()
+  const migrationsDir = join(basePath, 'src', 'migrations')
+
+  if (!existsSync(migrationsDir)) {
+    console.error('❌ No se encuentra src/migrations/')
+    console.error('   Creá una con: arckode make:migration <nombre>')
+    return
   }
 
-  db.close()
+  const files = (await readdir(migrationsDir))
+    .filter(f => f.endsWith('.ts') || f.endsWith('.js'))
+    .sort()
+
+  const env = parseEnv(basePath)
+  const db = await createCliDbRunner(env, basePath)
+
+  try {
+    // fresh no llama ensureTable antes de dropear (dropeará todo incluyendo la tracking table)
+    if (action !== 'fresh') await ensureTable(db)
+
+    switch (action) {
+      case 'up':      await runUp(db, files, migrationsDir); break
+      case 'down':    await runDown(db, migrationsDir); break
+      case 'reset':   await runReset(db, migrationsDir); break
+      case 'fresh':   await runFresh(db, files, migrationsDir); break
+      case 'refresh': await runRefresh(db, files, migrationsDir); break
+      case 'status':  {
+        if (files.length === 0) { console.log('📭 No hay migraciones en src/migrations/'); break }
+        await runStatus(db, files)
+        break
+      }
+      default:
+        console.error(`❌ Acción desconocida: "${action}"`)
+        console.error('   Opciones: up | down | fresh | reset | refresh | status')
+    }
+  } finally {
+    await db.close()
+  }
 }

package/cli/commands/db-seed.ts

@@ -1,54 +1,119 @@
-// cli/commands/db-seed.ts — Comando arckode db:seed
-// Ejecuta los seeds definidos en el composition root
+// cli/commands/db-seed.ts — Ejecuta seeds en src/seeds/
+// Conecta a la BD (misma detección que db:migrate) y corre cada seed file.
+// Cada archivo exporta funciones que reciben un proxy del ORM con create().
+// Úsalo para cargar datos de prueba o datos iniciales de producción.
 
-import { readFile } from 'node:fs/promises'
+import { readdir } from 'node:fs/promises'
 import { join } from 'node:path'
 import { existsSync } from 'node:fs'
+import { parseEnv, createCliDbRunner, type CliDbRunner } from './db-utils'
 
-export async function dbSeed(seedName?: string) {
-  const basePath = process.cwd()
-  const crPath = join(basePath, 'src', 'composition-root.ts')
+// Interfaz pública para los archivos de seed auto-generados.
+// Importá este tipo en tus seeds para evitar usar `any`:
+//   import type { SeedOrm } from 'arckode-framework/cli/commands/db-seed'
+export interface SeedOrm {
+  create(modelName: string, data: Record<string, unknown>): Promise<Record<string, unknown>>
+}
 
-  if (!existsSync(crPath)) {
-    console.error('❌ No se encuentra src/composition-root.ts')
-    console.error('   Ejecutá este comando desde la raíz del proyecto.')
-    return
+// Proxy mínimo que imita orm.create() para seeds auto-generados.
+// Infiere el nombre de tabla convirtiendo el model name a lowercase.
+// Para seeds que necesiten JOINs o lógica compleja, importá el composition root.
+function makeSeedProxy(db: CliDbRunner): SeedOrm {
+  return {
+    async create(modelName: string, data: Record<string, unknown>): Promise<Record<string, unknown>> {
+      const table = modelName.toLowerCase()
+      const record: Record<string, unknown> = {
+        id: (data.id as string | undefined) ?? crypto.randomUUID(),
+        ...data,
+        createdAt: (data.createdAt as string | undefined) ?? new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+      const cols = Object.keys(record)
+      const vals = Object.values(record)
+      const placeholders = cols.map(() => '?').join(', ')
+      await db.run(
+        `INSERT INTO ${table} (${cols.join(', ')}) VALUES (${placeholders})`,
+        vals,
+      )
+      return record
+    },
+  }
+}
+
+async function runSeedFile(filePath: string, db: CliDbRunner): Promise<void> {
+  const mod = await import(filePath)
+  const proxy = makeSeedProxy(db)
+  let ran = 0
+
+  for (const [key, value] of Object.entries(mod)) {
+    if (typeof value !== 'function') continue
+    // Convención: funciones seed* o run o default
+    if (!key.toLowerCase().startsWith('seed') && key !== 'run' && key !== 'default') continue
+
+    await (value as (orm: typeof proxy) => Promise<void>)(proxy)
+    ran++
+  }
+
+  if (ran === 0) {
+    console.warn(`   ⚠️  No se encontró ninguna función seed en ${filePath}`)
+    console.warn(`      Asegurate de exportar una función que empiece con "seed".`)
   }
+}
+
+export async function dbSeed(seedName?: string): Promise<void> {
+  const basePath = process.cwd()
+  const seedsDir = join(basePath, 'src', 'seeds')
 
-  // Leer seeds/ y detectar archivos disponibles
-  const seedsPath = join(basePath, 'src', 'seeds')
-  if (!existsSync(seedsPath)) {
+  if (!existsSync(seedsDir)) {
     console.error('❌ No hay directorio src/seeds/')
     console.error('   Creá seeds con: arckode make:seed <Nombre>')
     return
   }
 
-  const { readdir } = await import('node:fs/promises')
-  const seedFiles = (await readdir(seedsPath)).filter(f => f.endsWith('.ts'))
+  const allFiles = (await readdir(seedsDir))
+    .filter(f => f.endsWith('.ts') || f.endsWith('.js'))
+    .sort()
 
-  if (seedFiles.length === 0) {
+  if (allFiles.length === 0) {
     console.log('📭 No hay seeds para ejecutar.')
     return
   }
 
-  if (seedName) {
-    const file = seedFiles.find(f => f.startsWith(seedName))
-    if (!file) {
-      console.error(`❌ Seed "${seedName}" no encontrado.`)
-      console.log(`   Seeds disponibles: ${seedFiles.join(', ')}`)
-      return
-    }
-    console.log(`🌱 Ejecutando seed: ${file}`)
-    // La IA o el usuario debe agregar la lógica en composition-root según el seed
-    console.log(`   Para ejecutarlo, corré: RUN_SEEDS=true bun run src/composition-root.ts`)
+  // Sin argumento: listar + pedir confirmación o ejecutar todos
+  if (!seedName) {
+    console.log('🌱 Seeds disponibles:')
+    for (const f of allFiles) console.log(`   - ${f.replace(/\.(ts|js)$/, '')}`)
+    console.log('\n   Para ejecutar todos:  arckode db:seed --all')
+    console.log('   Para ejecutar uno:    arckode db:seed <nombre>')
+    return
+  }
+
+  const runAll = seedName === '--all'
+  const targets = runAll
+    ? allFiles
+    : allFiles.filter(f => f.startsWith(seedName))
+
+  if (targets.length === 0) {
+    console.error(`❌ Seed "${seedName}" no encontrado.`)
+    console.log(`   Seeds disponibles: ${allFiles.map(f => f.replace(/\.(ts|js)$/, '')).join(', ')}`)
     return
   }
 
-  console.log('🌱 Seeds disponibles:')
-  for (const file of seedFiles) {
-    console.log(`   - ${file.replace('.ts', '')}`)
+  const env = parseEnv(basePath)
+  const db = await createCliDbRunner(env, basePath)
+
+  try {
+    for (const file of targets) {
+      const filePath = join(seedsDir, file)
+      console.log(`🌱 Ejecutando: ${file}`)
+      await runSeedFile(filePath, db)
+      console.log(`✅ ${file}`)
+    }
+    console.log(`\n${targets.length} seed(s) ejecutado(s)`)
+  } catch (err) {
+    console.error('❌ Error ejecutando seed:', err instanceof Error ? err.message : err)
+    throw err
+  } finally {
+    await db.close()
   }
-  console.log('')
-  console.log('   Para ejecutar todos: RUN_SEEDS=true bun run src/composition-root.ts')
-  console.log('   Para ejecutar uno:   bun arckode db:seed <nombre>')
 }