@saulwade/swl-ses 1.4.0 → 1.4.2

package/scripts/audit-tools/migration-checker.js

@@ -0,0 +1,392 @@
+// Adaptado de temp/ultraship-main/tools/migration-checker.mjs bajo MIT License
+// Fuente: Houseofmvps/ultraship (https://github.com/Houseofmvps/ultraship)
+'use strict';
+
+const { readFileSync, existsSync, readdirSync, statSync } = require('fs');
+const { join, relative, resolve } = require('path');
+const { outputJSON, outputError } = require('./lib/output');
+
+/**
+ * Detecta el ORM de un directorio revisando package.json o archivos Python.
+ * @param {string} dir
+ * @returns {string|null}
+ */
+function detectOrm(dir) {
+  // Verificar primero ORM de Python (Alembic)
+  const alembicDetected = (
+    existsSync(join(dir, 'alembic.ini')) ||
+    (existsSync(join(dir, 'alembic')) && existsSync(join(dir, 'alembic', 'versions')))
+  );
+  if (alembicDetected) return 'alembic';
+
+  // Verificar requirements.txt / pyproject.toml para alembic
+  const reqPath = join(dir, 'requirements.txt');
+  if (existsSync(reqPath)) {
+    const content = readFileSync(reqPath, 'utf8').toLowerCase();
+    if (content.includes('alembic')) return 'alembic';
+  }
+  const pyprojectPath = join(dir, 'pyproject.toml');
+  if (existsSync(pyprojectPath)) {
+    const content = readFileSync(pyprojectPath, 'utf8').toLowerCase();
+    if (content.includes('alembic')) return 'alembic';
+  }
+
+  // ORM de Node.js desde package.json
+  const pkgPath = join(dir, 'package.json');
+  if (!existsSync(pkgPath)) return null;
+
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  } catch {
+    return null;
+  }
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+  if (allDeps['drizzle-orm'] || allDeps['drizzle-kit']) return 'drizzle';
+  if (allDeps['prisma'] || allDeps['@prisma/client']) return 'prisma';
+  if (allDeps['knex']) return 'knex';
+  if (allDeps['typeorm']) return 'typeorm';
+  if (allDeps['sequelize']) return 'sequelize';
+  if (allDeps['mongoose']) return 'mongoose';
+  return null;
+}
+
+/**
+ * Revisa migraciones de Drizzle ORM.
+ * @param {string} dir
+ * @returns {object}
+ */
+function checkDrizzle(dir) {
+  const findings = [];
+  const info = { orm: 'drizzle', migration_dir: null, schema_files: [], migrations: [] };
+
+  // Buscar config de Drizzle
+  const configNames = ['drizzle.config.ts', 'drizzle.config.js', 'drizzle.config.mjs'];
+  let configPath = null;
+  for (const name of configNames) {
+    const p = join(dir, name);
+    if (existsSync(p)) { configPath = p; break; }
+  }
+
+  if (!configPath) {
+    findings.push({ severity: 'high', message: 'No se encontró drizzle.config — las migraciones podrían no estar configuradas' });
+  } else {
+    const config = readFileSync(configPath, 'utf8');
+    const outMatch = config.match(/out\s*:\s*['"]([^'"]+)['"]/);
+    if (outMatch) info.migration_dir = outMatch[1];
+  }
+
+  // Buscar directorio de migraciones
+  const migrationDirs = [info.migration_dir, 'drizzle', 'migrations', 'db/migrations'].filter(Boolean);
+  let migDir = null;
+  for (const d of migrationDirs) {
+    const p = join(dir, d);
+    try {
+      if (existsSync(p) && statSync(p).isDirectory()) { migDir = p; info.migration_dir = d; break; }
+    } catch { /* skip */ }
+  }
+
+  if (migDir) {
+    const files = readdirSync(migDir).filter(f => f.endsWith('.sql') || f.endsWith('.ts') || f.endsWith('.js'));
+    info.migrations = files.map(f => {
+      try {
+        const s = statSync(join(migDir, f));
+        return { name: f, modified: s.mtime.toISOString().split('T')[0] };
+      } catch { return { name: f }; }
+    });
+    info.migration_count = files.length;
+
+    // Verificar journal (Drizzle registra migraciones aplicadas)
+    const journalPath = join(migDir, 'meta', '_journal.json');
+    if (existsSync(journalPath)) {
+      try {
+        const journal = JSON.parse(readFileSync(journalPath, 'utf8'));
+        info.applied_count = journal.entries ? journal.entries.length : 0;
+        if (info.migration_count > info.applied_count) {
+          findings.push({
+            severity: 'critical',
+            message: `${info.migration_count - info.applied_count} migración(es) pendiente(s) sin aplicar — ejecutar: npx drizzle-kit push`,
+          });
+        }
+      } catch { /* ignorar */ }
+    }
+  } else {
+    findings.push({ severity: 'medium', message: 'No se encontró directorio de migraciones — ejecutar: npx drizzle-kit generate' });
+  }
+
+  // Buscar archivos de schema
+  const schemaPatterns = ['schema.ts', 'schema.js', 'db/schema.ts', 'src/db/schema.ts', 'src/schema.ts'];
+  for (const pattern of schemaPatterns) {
+    if (existsSync(join(dir, pattern))) info.schema_files.push(pattern);
+  }
+  const schemaDirs = ['src/db', 'db', 'src/schema'];
+  for (const d of schemaDirs) {
+    const p = join(dir, d);
+    try {
+      if (existsSync(p) && statSync(p).isDirectory()) {
+        const files = readdirSync(p).filter(f => f.includes('schema') && (f.endsWith('.ts') || f.endsWith('.js')));
+        for (const f of files) info.schema_files.push(join(d, f));
+      }
+    } catch { /* skip */ }
+  }
+
+  if (info.schema_files.length === 0) {
+    findings.push({ severity: 'high', message: 'No se encontraron archivos de schema — Drizzle ORM requiere definiciones de schema' });
+  }
+
+  return { ...info, findings };
+}
+
+/**
+ * Revisa migraciones de Prisma.
+ * @param {string} dir
+ * @returns {object}
+ */
+function checkPrisma(dir) {
+  const findings = [];
+  const info = { orm: 'prisma', schema_file: null, migrations: [] };
+
+  const schemaPaths = ['prisma/schema.prisma', 'schema.prisma'];
+  for (const p of schemaPaths) {
+    if (existsSync(join(dir, p))) { info.schema_file = p; break; }
+  }
+
+  if (!info.schema_file) {
+    findings.push({ severity: 'critical', message: 'No se encontró prisma/schema.prisma' });
+    return { ...info, findings };
+  }
+
+  const migDir = join(dir, 'prisma/migrations');
+  try {
+    if (existsSync(migDir) && statSync(migDir).isDirectory()) {
+      const dirs = readdirSync(migDir).filter(f => {
+        try {
+          const p = join(migDir, f);
+          return statSync(p).isDirectory() && f !== '_lock';
+        } catch { return false; }
+      });
+      info.migrations = dirs.map(d => ({ name: d }));
+      info.migration_count = dirs.length;
+    } else {
+      findings.push({ severity: 'medium', message: 'No se encontró directorio de migraciones de Prisma — ejecutar: npx prisma migrate dev' });
+    }
+  } catch { /* skip */ }
+
+  const nodeModulesPrisma = join(dir, 'node_modules/.prisma/client');
+  if (!existsSync(nodeModulesPrisma)) {
+    findings.push({ severity: 'high', message: 'Cliente de Prisma no generado — ejecutar: npx prisma generate' });
+  }
+
+  return { ...info, findings };
+}
+
+/**
+ * Revisa migraciones de Knex.
+ * @param {string} dir
+ * @returns {object}
+ */
+function checkKnex(dir) {
+  const findings = [];
+  const info = { orm: 'knex', migration_dir: null, migrations: [] };
+
+  const knexfileNames = ['knexfile.js', 'knexfile.ts', 'knexfile.mjs'];
+  let found = false;
+  for (const name of knexfileNames) {
+    if (existsSync(join(dir, name))) { found = true; break; }
+  }
+
+  if (!found) {
+    findings.push({ severity: 'medium', message: 'No se encontró knexfile — la configuración de migraciones podría estar inline' });
+  }
+
+  const migDirs = ['migrations', 'db/migrations', 'src/migrations'];
+  for (const d of migDirs) {
+    const p = join(dir, d);
+    try {
+      if (existsSync(p) && statSync(p).isDirectory()) {
+        info.migration_dir = d;
+        const files = readdirSync(p).filter(f => f.endsWith('.js') || f.endsWith('.ts'));
+        info.migrations = files.map(f => ({ name: f }));
+        info.migration_count = files.length;
+        break;
+      }
+    } catch { /* skip */ }
+  }
+
+  if (!info.migration_dir) {
+    findings.push({ severity: 'medium', message: 'No se encontró directorio de migraciones — ejecutar: npx knex migrate:make initial' });
+  }
+
+  return { ...info, findings };
+}
+
+/**
+ * Revisa migraciones de Alembic (Python/SQLAlchemy).
+ * Detecta mediante alembic.ini, directorio alembic/versions/, requirements.txt o pyproject.toml.
+ * Compara revisiones encontradas en archivos contra .alembic_applied.txt (opcional).
+ * @param {string} dir
+ * @returns {object}
+ */
+function checkAlembic(dir) {
+  const findings = [];
+  const info = {
+    orm: 'alembic',
+    versions_dir: null,
+    revisions_found: [],
+    revisions_applied: null,
+    pending: [],
+    extra_applied: [],
+  };
+
+  // Localizar directorio de versiones
+  const versionsDir = join(dir, 'alembic', 'versions');
+  if (existsSync(versionsDir)) {
+    info.versions_dir = 'alembic/versions';
+  }
+
+  if (!info.versions_dir) {
+    findings.push({
+      severity: 'medium',
+      message: 'No se encontró directorio alembic/versions/ — ejecutar: alembic init alembic',
+    });
+    return { ...info, findings };
+  }
+
+  // Parsear revision IDs de archivos de migración Python
+  let versionFiles = [];
+  try {
+    versionFiles = readdirSync(versionsDir).filter(f => f.endsWith('.py') && f !== '__init__.py');
+  } catch {
+    findings.push({ severity: 'high', message: `No se pudo leer el directorio ${info.versions_dir}` });
+    return { ...info, findings };
+  }
+
+  const revisionRegex = /revision\s*=\s*['"]([^'"]+)['"]/;
+  for (const file of versionFiles) {
+    try {
+      const content = readFileSync(join(versionsDir, file), 'utf8');
+      const match = content.match(revisionRegex);
+      if (match) {
+        info.revisions_found.push({ revision: match[1], file });
+      }
+    } catch { /* skip archivos no legibles */ }
+  }
+
+  if (info.revisions_found.length === 0 && versionFiles.length > 0) {
+    findings.push({
+      severity: 'medium',
+      message: `Se encontraron ${versionFiles.length} archivo(s) en alembic/versions/ pero ninguno tiene campo 'revision' — revisar formato`,
+    });
+  }
+
+  // Comparar contra .alembic_applied.txt (opcional)
+  const appliedPath = join(dir, '.alembic_applied.txt');
+  if (existsSync(appliedPath)) {
+    try {
+      const appliedContent = readFileSync(appliedPath, 'utf8');
+      const appliedRevisions = new Set(
+        appliedContent.split('\n').map(l => l.trim()).filter(Boolean)
+      );
+      info.revisions_applied = [...appliedRevisions];
+
+      const foundRevisions = new Set(info.revisions_found.map(r => r.revision));
+
+      // Pendientes: en archivos pero no aplicadas
+      info.pending = info.revisions_found
+        .filter(r => !appliedRevisions.has(r.revision))
+        .map(r => r.revision);
+
+      // Extra: aplicadas pero no en archivos (posible eliminación de migración)
+      info.extra_applied = [...appliedRevisions].filter(r => !foundRevisions.has(r));
+
+      if (info.pending.length > 0) {
+        findings.push({
+          severity: 'critical',
+          message: `${info.pending.length} migración(es) de Alembic pendiente(s) sin aplicar — ejecutar: alembic upgrade head`,
+          pending_revisions: info.pending,
+        });
+      }
+
+      if (info.extra_applied.length > 0) {
+        findings.push({
+          severity: 'high',
+          message: `${info.extra_applied.length} revisión(es) aplicada(s) no encontradas en archivos — posible eliminación de migración`,
+          extra_revisions: info.extra_applied,
+        });
+      }
+    } catch {
+      findings.push({ severity: 'low', message: 'No se pudo leer .alembic_applied.txt — sin comparación de estado aplicado' });
+    }
+  } else {
+    // Sin archivo de aplicadas — solo reportar conteo
+    if (info.revisions_found.length > 0) {
+      findings.push({
+        severity: 'info',
+        message: `${info.revisions_found.length} revisión(es) de Alembic encontradas. Crear .alembic_applied.txt con IDs aplicados para rastrear estado`,
+      });
+    }
+  }
+
+  info.revision_count = info.revisions_found.length;
+
+  return { ...info, findings };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const rawDir = args.find(a => !a.startsWith('--'));
+  const dir = resolve(rawDir || process.cwd());
+
+  if (!existsSync(dir)) {
+    outputError(`Directorio no encontrado: ${dir}`);
+    process.exit(0);
+  }
+
+  const orm = detectOrm(dir);
+
+  if (!orm) {
+    outputJSON({
+      success: true,
+      packages_scanned: 1,
+      orm: null,
+      message: 'No se detectó un ORM compatible (Drizzle, Prisma, Knex, Alembic, TypeORM, Sequelize)',
+      findings: [],
+    });
+    process.exit(0);
+  }
+
+  let result;
+  switch (orm) {
+    case 'drizzle':  result = checkDrizzle(dir); break;
+    case 'prisma':   result = checkPrisma(dir);  break;
+    case 'knex':     result = checkKnex(dir);    break;
+    case 'alembic':  result = checkAlembic(dir); break;
+    default:
+      result = {
+        orm,
+        findings: [{
+          severity: 'info',
+          message: `${orm} detectado pero la verificación de migraciones aún no está implementada para este ORM`,
+        }],
+      };
+  }
+
+  const allFindings = result.findings || [];
+  const deploySafe = allFindings.filter(f => f.severity === 'critical').length === 0;
+
+  outputJSON({
+    success:         true,
+    packages_scanned: 1,
+    deploy_safe:     deploySafe,
+    orm,
+    result,
+    findings:        allFindings,
+  });
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { detectOrm, checkDrizzle, checkPrisma, checkKnex, checkAlembic };