arckode-framework 1.3.2 → 1.4.0

package/cli/commands/db-utils.ts

@@ -0,0 +1,192 @@
+// cli/commands/db-utils.ts — Utilidades compartidas para comandos de BD
+// Detecta tipo de BD desde .env y crea la conexión correspondiente
+// Soporta: SQLite (bun:sqlite), MySQL (mysql2), PostgreSQL (pg)
+
+import { existsSync, readFileSync } from 'node:fs'
+import { join, resolve, dirname } from 'node:path'
+
+// ─── Env parsing ──────────────────────────────────────────────────────────────
+
+export function parseEnv(basePath: string): Record<string, string> {
+  const envFile = join(basePath, '.env')
+  if (!existsSync(envFile)) return {}
+  const vars: Record<string, string> = {}
+  for (const line of readFileSync(envFile, 'utf-8').split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#')) continue
+    const eqIdx = trimmed.indexOf('=')
+    if (eqIdx < 0) continue
+    vars[trimmed.slice(0, eqIdx).trim()] = trimmed.slice(eqIdx + 1).trim()
+  }
+  return vars
+}
+
+// ─── CliDbRunner — interfaz unificada para los comandos CLI ──────────────────
+// Compatible con bun:sqlite (sync envuelto), mysql2 single-connection, y pg Client
+
+export interface CliDbRunner {
+  run(sql: string, params?: unknown[]): Promise<void>
+  query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>
+  exec(sql: string): Promise<void>
+  inTransaction(fn: () => Promise<void>): Promise<void>
+  /** Dropea TODAS las tablas de usuario. Deshabilita FK checks internamente. */
+  dropAllTables(): Promise<void>
+  close(): Promise<void>
+}
+
+// ─── Factory ──────────────────────────────────────────────────────────────────
+
+export async function createCliDbRunner(
+  env: Record<string, string>,
+  basePath: string,
+): Promise<CliDbRunner> {
+  if (env.DATABASE_URL?.match(/^postgres(ql)?:\/\//)) {
+    return createPostgresRunner(env.DATABASE_URL)
+  }
+  if (env.DB_HOST) {
+    return createMysqlRunner(env)
+  }
+  const raw = env.DB_PATH ?? './data/db.sqlite'
+  const dbPath = raw.startsWith('.') ? resolve(basePath, raw) : raw
+  return createSqliteRunner(dbPath)
+}
+
+// ─── SQLite (bun:sqlite — sin dependencias externas) ─────────────────────────
+
+async function createSqliteRunner(dbPath: string): Promise<CliDbRunner> {
+  const { mkdir } = await import('node:fs/promises')
+  await mkdir(dirname(dbPath), { recursive: true })
+
+  const { Database } = await import('bun:sqlite')
+  const db = new Database(dbPath)
+
+  return {
+    async run(sql, params = []) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      params.length > 0 ? db.prepare(sql).run(...(params as any[])) : db.prepare(sql).run()
+    },
+    async query<T>(sql: string, params: unknown[] = []): Promise<T[]> {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return (params.length > 0 ? db.prepare(sql).all(...(params as any[])) : db.prepare(sql).all()) as T[]
+    },
+    async exec(sql) { db.exec(sql) },
+    async inTransaction(fn) {
+      db.exec('BEGIN')
+      try { await fn(); db.exec('COMMIT') } catch (err) {
+        try { db.exec('ROLLBACK') } catch { /* ya hizo rollback */ }
+        throw err
+      }
+    },
+    async dropAllTables() {
+      db.exec('PRAGMA foreign_keys = OFF')
+      const tables = db.prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+      ).all() as { name: string }[]
+      for (const { name } of tables) {
+        db.exec(`DROP TABLE IF EXISTS "${name}"`)
+      }
+      db.exec('PRAGMA foreign_keys = ON')
+    },
+    async close() { db.close() },
+  }
+}
+
+// ─── MySQL (mysql2 — conexión dedicada para transacciones correctas) ──────────
+
+async function createMysqlRunner(env: Record<string, string>): Promise<CliDbRunner> {
+  const mysql = await import('mysql2/promise').catch(() => {
+    throw new Error('mysql2 no instalado. Ejecutá: bun add mysql2')
+  })
+
+  const conn = await mysql.createConnection({
+    host:     env.DB_HOST,
+    port:     env.DB_PORT ? parseInt(env.DB_PORT, 10) : 3306,
+    user:     env.DB_USER ?? 'root',
+    password: env.DB_PASSWORD ?? '',
+    database: env.DB_NAME,
+  })
+
+  return {
+    async run(sql, params = []) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await conn.execute(sql, params as any[])
+    },
+    async query<T>(sql: string, params: unknown[] = []): Promise<T[]> {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const [rows] = await conn.execute(sql, params as any[])
+      return rows as T[]
+    },
+    async exec(sql) {
+      for (const stmt of sql.split(';').map(s => s.trim()).filter(Boolean)) {
+        await conn.execute(stmt)
+      }
+    },
+    async inTransaction(fn) {
+      await conn.beginTransaction()
+      try { await fn(); await conn.commit() } catch (err) {
+        try { await conn.rollback() } catch { /* ya revirtió */ }
+        throw err
+      }
+    },
+    async dropAllTables() {
+      await conn.execute('SET FOREIGN_KEY_CHECKS = 0')
+      const [rows] = await conn.execute(
+        'SELECT table_name AS name FROM information_schema.tables WHERE table_schema = DATABASE()'
+      )
+      for (const row of rows as { name: string }[]) {
+        await conn.execute(`DROP TABLE IF EXISTS \`${row.name}\``)
+      }
+      await conn.execute('SET FOREIGN_KEY_CHECKS = 1')
+    },
+    async close() { await conn.end() },
+  }
+}
+
+// ─── PostgreSQL (pg Client — single connection para serializar transacciones) ──
+
+async function createPostgresRunner(connectionString: string): Promise<CliDbRunner> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const pg = await import('pg').catch(() => {
+    throw new Error('pg no instalado. Ejecutá: bun add pg')
+  }) as any
+
+  // pg ESM exporta Client como named export en runtime pero el tipo de index.d.mts no lo expone
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+  const client = new pg.Client({ connectionString })
+  await client.connect()
+
+  // Convierte ? a $1, $2, ... para compatibilidad con PostgreSQL
+  const toPg = (sql: string) => {
+    let idx = 0
+    return sql.replace(/\?/g, () => `$${++idx}`)
+  }
+
+  return {
+    async run(sql, params = []) { await client.query(toPg(sql), params) },
+    async query<T>(sql: string, params: unknown[] = []): Promise<T[]> {
+      const result = await client.query(toPg(sql), params)
+      return result.rows as T[]
+    },
+    async exec(sql) {
+      for (const stmt of sql.split(';').map(s => s.trim()).filter(Boolean)) {
+        if (stmt) await client.query(stmt)
+      }
+    },
+    async inTransaction(fn) {
+      await client.query('BEGIN')
+      try { await fn(); await client.query('COMMIT') } catch (err) {
+        try { await client.query('ROLLBACK') } catch { /* ya revirtió */ }
+        throw err
+      }
+    },
+    async dropAllTables() {
+      const result = await client.query(
+        "SELECT tablename AS name FROM pg_tables WHERE schemaname = 'public'"
+      )
+      for (const row of result.rows as { name: string }[]) {
+        await client.query(`DROP TABLE IF EXISTS "${row.name}" CASCADE`)
+      }
+    },
+    async close() { await client.end() },
+  }
+}

package/cli/commands/new.ts

@@ -0,0 +1,175 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { claudeMdStub } from '../stubs/claude-md-stub'
+
+export type DbDriver = 'sqlite' | 'mysql' | 'postgres'
+
+export async function newProject(name: string, db: DbDriver = 'sqlite'): Promise<void> {
+  const base = join(process.cwd(), name)
+
+  await mkdir(join(base, 'src', 'modules'), { recursive: true })
+  await mkdir(join(base, 'src', 'connectors'), { recursive: true })
+  await mkdir(join(base, 'data'), { recursive: true })
+
+  await writeFile(join(base, 'CLAUDE.md'), claudeMdStub({ projectName: name, db }))
+  await writeFile(join(base, 'src', 'composition-root.ts'), buildCompositionRoot(name, db))
+  await writeFile(join(base, 'package.json'), buildPackageJson(name, db))
+  await writeFile(join(base, '.env'), buildEnv(name, db))
+  await writeFile(join(base, '.env.example'), buildEnv(name, db))
+  await writeFile(join(base, '.gitignore'), `node_modules/\ndist/\ndata/\n.env\n`)
+
+  console.log(`\n✅ Proyecto "${name}" creado (DB: ${db})`)
+  console.log(`\n  Siguientes pasos:`)
+  console.log(`  cd ${name}`)
+  console.log(`  bun install`)
+  console.log(`  bun run dev`)
+  console.log(`\n  La IA arranca leyendo CLAUDE.md → arckode.json`)
+}
+
+function buildCompositionRoot(name: string, db: DbDriver): string {
+  const dbAdapterImport = db === 'sqlite'
+    ? `import { SqliteAdapter } from 'arckode-framework/adapters/sqlite'`
+    : db === 'mysql'
+      ? `import { MySQLAdapter } from 'arckode-framework/adapters/mysql'`
+      : `import { PostgresAdapter } from 'arckode-framework/adapters/postgres'`
+
+  const dbConfigFields = db === 'sqlite'
+    ? `  DB_PATH:    { type: 'string', default: './data/db.sqlite' },`
+    : db === 'mysql'
+      ? [
+          `  DB_HOST:    { type: 'string', required: true },`,
+          `  DB_USER:    { type: 'string', required: true },`,
+          `  DB_PASSWORD:{ type: 'string', required: true },`,
+          `  DB_NAME:    { type: 'string', required: true },`,
+          `  DB_PORT:    { type: 'number', default: 3306 },`,
+        ].join('\n')
+      : `  DATABASE_URL: { type: 'string', required: true },`
+
+  const dbAdapterInit = db === 'sqlite'
+    ? `const dbAdapter = new SqliteAdapter({ path: config.get('DB_PATH') })`
+    : db === 'mysql'
+      ? [
+          `const dbAdapter = new MySQLAdapter({`,
+          `  host:     config.get('DB_HOST'),`,
+          `  port:     config.get<number>('DB_PORT'),`,
+          `  user:     config.get('DB_USER'),`,
+          `  password: config.get('DB_PASSWORD'),`,
+          `  database: config.get('DB_NAME'),`,
+          `})`,
+        ].join('\n')
+      : `const dbAdapter = new PostgresAdapter({ connectionString: config.get('DATABASE_URL') })`
+
+  return `// composition-root.ts — ÚNICO archivo que describe TODO el sistema
+// La IA lee esto y sabe: módulos, conectores, dependencias.
+// ============================================================
+
+import {
+  ConfigStore, Container, Logger, ORM, Router,
+  NodeServer, MemoryCache, System, Auth, loadEnv,
+} from 'arckode-framework'
+${dbAdapterImport}
+import { jwtTokenAdapter } from 'arckode-framework/adapters/jwt'
+
+// ─── 1. ENV + CONFIG ─────────────────────────
+const env = await loadEnv()
+
+const config = new ConfigStore()
+config.define({
+  PORT:       { type: 'number', default: 3000 },
+${dbConfigFields}
+  JWT_SECRET: { type: 'string', required: true },
+  LOG_LEVEL:  { type: 'string', default: 'info' },
+}).load(env)
+
+// ─── 2. INFRAESTRUCTURA ──────────────────────
+const logger = new Logger('app', config.get('LOG_LEVEL') as any)
+const container = new Container()
+${dbAdapterInit}
+await dbAdapter.connect()
+const orm = new ORM(dbAdapter)
+const router = new Router()
+const http = new NodeServer(config.get<number>('PORT'), logger)
+const cache = new MemoryCache()
+const auth = new Auth(jwtTokenAdapter, config.get('JWT_SECRET'), logger)
+
+// ─── 3. CONTAINER ────────────────────────────
+container.register('config', () => config)
+container.register('logger', () => logger)
+container.register('db', () => dbAdapter, () => dbAdapter.close())
+container.register('orm', () => orm)
+container.register('cache', () => cache)
+container.init()
+
+// ─── 4. SISTEMA ───────────────────────────────
+const system = new System({
+  config, container, logger, orm, router, http, cache, auth,
+})
+
+// ─── 5. MÓDULOS ───────────────────────────────
+// import { MiModuloModule } from './modules/mi-modulo'
+// system.addModule(MiModuloModule())
+
+// ─── 6. CONECTORES ────────────────────────────
+// import { connectModAModB } from './connectors/mod-a-mod-b'
+// system.addConnector('mod-a-mod-b', connectModAModB)
+
+// ─── 7. RUTAS BASE ────────────────────────────
+router.get('/health', async () => ({
+  status: 200, body: { status: 'ok', uptime: process.uptime() }
+}))
+
+// ─── 8. INIT + MIGRATE + START ────────────────
+system.init()
+await orm.migrate()
+
+await system.start()
+
+process.on('SIGINT', async () => { await system.stop(); process.exit(0) })
+process.on('SIGTERM', async () => { await system.stop(); process.exit(0) })
+`
+}
+
+function buildPackageJson(name: string, db: DbDriver): string {
+  const dbDeps = db === 'mysql'
+    ? { 'mysql2': '^3.0.0' }
+    : db === 'postgres'
+      ? { 'pg': '^8.0.0' }
+      : {}
+
+  const dbDevDeps = db === 'postgres'
+    ? { '@types/pg': '^8.0.0' }
+    : {}
+
+  return JSON.stringify({
+    name,
+    version: '1.0.0',
+    type: 'module',
+    scripts: {
+      dev:          `bun --watch src/composition-root.ts`,
+      start:        `bun run src/composition-root.ts`,
+      test:         `bun test`,
+      'test:watch': `bun test --watch`,
+      analyze:      `bun run node_modules/arckode-framework/cli/index.ts analyze`,
+      'analyze:ci': `bun run node_modules/arckode-framework/cli/index.ts analyze --ci`,
+    },
+    dependencies: {
+      'arckode-framework': 'latest',
+      'jsonwebtoken': '^9.0.0',
+      ...dbDeps,
+    },
+    devDependencies: {
+      '@types/jsonwebtoken': '^9.0.0',
+      ...dbDevDeps,
+    },
+  }, null, 2)
+}
+
+function buildEnv(name: string, db: DbDriver): string {
+  if (db === 'mysql') {
+    return `PORT=3000\nDB_HOST=localhost\nDB_PORT=3306\nDB_USER=root\nDB_PASSWORD=secret\nDB_NAME=${name}\nJWT_SECRET=cambiar-en-produccion\nLOG_LEVEL=info\n`
+  }
+  if (db === 'postgres') {
+    return `PORT=3000\nDATABASE_URL=postgres://user:password@localhost:5432/${name}\nJWT_SECRET=cambiar-en-produccion\nLOG_LEVEL=info\n`
+  }
+  return `PORT=3000\nDB_PATH=./data/db.sqlite\nJWT_SECRET=cambiar-en-produccion\nLOG_LEVEL=info\n`
+}

package/cli/commands/routes.ts

@@ -0,0 +1,94 @@
+import { readdir, readFile, stat } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+
+const METHODS = ['get', 'post', 'put', 'patch', 'delete'] as const
+const METHOD_COLORS: Record<string, string> = {
+  get: '\x1b[32m',
+  post: '\x1b[33m',
+  put: '\x1b[34m',
+  patch: '\x1b[35m',
+  delete: '\x1b[31m',
+}
+const RESET = '\x1b[0m'
+
+async function collectTsFiles(dir: string): Promise<string[]> {
+  const files: string[] = []
+  if (!existsSync(dir)) return files
+  for (const entry of await readdir(dir)) {
+    const full = join(dir, entry)
+    const s = await stat(full)
+    if (s.isDirectory()) files.push(...await collectTsFiles(full))
+    else if (entry.endsWith('.ts') && !entry.endsWith('.test.ts') && !entry.endsWith('.d.ts')) files.push(full)
+  }
+  return files
+}
+
+function extractRoutes(src: string, seen: Set<string>): string[] {
+  const found: string[] = []
+  for (const method of METHODS) {
+    const re = new RegExp("router\\." + method + "\\s*\\(\\s*['\"`]([^'\"`${}]+)['\"`]", 'g')
+    let match: RegExpExecArray | null
+    while ((match = re.exec(src)) !== null) {
+      const key = `${method}:${match[1]}`
+      if (seen.has(key)) continue
+      seen.add(key)
+      const color = METHOD_COLORS[method]
+      found.push(`  ${color}${method.toUpperCase().padEnd(7)}${RESET} ${match[1]}`)
+    }
+  }
+  return found
+}
+
+export async function routes(cwd = process.cwd()): Promise<void> {
+  const modulesPath = join(cwd, 'src', 'modules')
+
+  if (!existsSync(modulesPath)) {
+    console.log('❌ No se encuentra src/modules/')
+    return
+  }
+
+  console.log('\n📋 Rutas registradas (análisis estático)\n')
+
+  const moduleDirs = await readdir(modulesPath)
+  let total = 0
+  const globalSeen = new Set<string>()
+
+  for (const mod of moduleDirs) {
+    const modDir = join(modulesPath, mod)
+    const s = await stat(modDir).catch(() => null)
+    if (!s?.isDirectory()) continue
+
+    const files = await collectTsFiles(modDir)
+    const seen = new Set<string>()
+    const routeLines: string[] = []
+
+    for (const file of files) {
+      const src = await readFile(file, 'utf-8')
+      routeLines.push(...extractRoutes(src, seen))
+    }
+
+    for (const key of seen) globalSeen.add(key)
+
+    if (routeLines.length > 0) {
+      console.log(`[${mod}]`)
+      routeLines.forEach(r => console.log(r))
+      console.log()
+      total += routeLines.length
+    }
+  }
+
+  const crPath = join(cwd, 'src', 'composition-root.ts')
+  if (existsSync(crPath)) {
+    const src = await readFile(crPath, 'utf-8')
+    const globalRoutes = extractRoutes(src, globalSeen)
+    if (globalRoutes.length > 0) {
+      console.log('[global]')
+      globalRoutes.forEach(r => console.log(r))
+      console.log()
+      total += globalRoutes.length
+    }
+  }
+
+  console.log(`Total: ${total} ruta(s)`)
+}