pg-migration-engine 0.1.0

package/src/risk/data-loss-checker.js

@@ -0,0 +1,32 @@
+/**
+ * @param {import('../types/changes.js').SchemaChange} change
+ * @returns {import('../types/risk.js').RiskFinding[]}
+ */
+export function checkDataLoss(change) {
+  const findings = [];
+  if (change.type === 'ALTER_COLUMN' && change.before?.dataType !== change.after?.dataType) {
+    const from = change.before.dataType;
+    const to = change.after.dataType;
+    if (isNarrowingCast(from, to)) {
+      findings.push({
+        category: 'data_loss',
+        severity: 'high',
+        changeId: change.id,
+        message: `Narrowing type from ${from} to ${to} may truncate data`,
+        recommendation: 'Add a CHECK constraint first to validate, then alter type',
+        safeAlternative: `ALTER TABLE ${change.objectKey.split('.').slice(0, -1).join('.')} ALTER COLUMN ${change.after.name} TYPE ${to} USING ${change.after.name}::${to};`,
+        autoFixable: true,
+      });
+    }
+  }
+  return findings;
+}
+
+function isNarrowingCast(from, to) {
+  const narrowing = [
+    ['bigint', 'integer'], ['bigint', 'smallint'], ['integer', 'smallint'],
+    ['numeric', 'integer'], ['numeric', 'bigint'],
+    ['character varying', 'character'], ['text', 'character varying'],
+  ];
+  return narrowing.some(([f, t]) => from.toLowerCase().includes(f) && to.toLowerCase().includes(t));
+}

package/src/risk/destructive-checker.js

@@ -0,0 +1,38 @@
+/**
+ * @param {import('../types/changes.js').SchemaChange} change
+ * @returns {import('../types/risk.js').RiskFinding[]}
+ */
+export function checkDestructive(change) {
+  const findings = [];
+  if (change.type === 'DROP' && change.objectType === 'TABLE') {
+    findings.push({
+      category: 'destructive',
+      severity: 'critical',
+      changeId: change.id,
+      message: `Dropping table ${change.objectKey} will permanently delete all data`,
+      recommendation: 'Consider renaming instead of dropping, or ensure data is backed up',
+      autoFixable: false,
+    });
+  }
+  if (change.type === 'DROP_COLUMN') {
+    findings.push({
+      category: 'destructive',
+      severity: 'high',
+      changeId: change.id,
+      message: `Dropping column ${change.name} from ${change.objectKey} will delete data`,
+      recommendation: 'Stage the column drop: deprecate -> stop using -> drop',
+      autoFixable: false,
+    });
+  }
+  if (change.type === 'DROP' && change.objectType === 'VIEW') {
+    findings.push({
+      category: 'destructive',
+      severity: 'medium',
+      changeId: change.id,
+      message: `Dropping view ${change.objectKey}`,
+      recommendation: 'Ensure no applications depend on this view',
+      autoFixable: false,
+    });
+  }
+  return findings;
+}

package/src/risk/index.js

@@ -0,0 +1,6 @@
+export { RiskEngine } from './risk-engine.js';
+export { checkDestructive } from './destructive-checker.js';
+export { checkDataLoss } from './data-loss-checker.js';
+export { checkLockRisk } from './lock-analyzer.js';
+export { checkCompatibility } from './compatibility-checker.js';
+export { computeOverallRisk } from './recommendations.js';

package/src/risk/lock-analyzer.js

@@ -0,0 +1,39 @@
+/**
+ * @param {import('../types/changes.js').SchemaChange} change
+ * @returns {import('../types/risk.js').RiskFinding[]}
+ */
+export function checkLockRisk(change) {
+  const findings = [];
+  if (change.type === 'ADD_INDEX' && !change.sql?.includes('CONCURRENTLY')) {
+    findings.push({
+      category: 'lock_risk',
+      severity: 'medium',
+      changeId: change.id,
+      message: `Creating index without CONCURRENTLY will lock ${change.objectKey} for writes`,
+      recommendation: 'Use CREATE INDEX CONCURRENTLY for zero-downtime index creation',
+      safeAlternative: change.sql?.replace('CREATE INDEX', 'CREATE INDEX CONCURRENTLY'),
+      autoFixable: true,
+    });
+  }
+  if (change.type === 'ADD_CONSTRAINT' && change.after?.type === 'FOREIGN_KEY' && !change.sql?.includes('NOT VALID')) {
+    findings.push({
+      category: 'lock_risk',
+      severity: 'medium',
+      changeId: change.id,
+      message: `Adding FK constraint directly will scan and lock the table`,
+      recommendation: 'Add constraint NOT VALID first, then VALIDATE',
+      autoFixable: true,
+    });
+  }
+  if (change.type === 'ALTER_COLUMN' && change.before?.isNullable !== change.after?.isNullable && !change.after?.isNullable) {
+    findings.push({
+      category: 'lock_risk',
+      severity: 'medium',
+      changeId: change.id,
+      message: `Setting NOT NULL directly will lock the table for a full scan`,
+      recommendation: 'Use 3-step pattern: ADD CHECK NOT NULL NOT VALID -> VALIDATE -> SET NOT NULL',
+      autoFixable: true,
+    });
+  }
+  return findings;
+}

package/src/risk/recommendations.js

@@ -0,0 +1,44 @@
+/**
+ * @param {import('../types/risk.js').RiskFinding} finding
+ * @returns {string}
+ */
+export function generateRecommendation(finding) {
+  if (finding.safeAlternative) {
+    return `${finding.recommendation}\nSafe alternative:\n${finding.safeAlternative}`;
+  }
+  return finding.recommendation;
+}
+
+/**
+ * @param {import('../types/risk.js').RiskFinding[]} findings
+ * @returns {import('../types/risk.js').RiskAssessment}
+ */
+export function computeOverallRisk(findings) {
+  const destructive = findings.filter(f => f.category === 'destructive').length;
+  const dataLoss = findings.filter(f => f.category === 'data_loss').length;
+  const lockRisk = findings.filter(f => f.category === 'lock_risk').length;
+  const canAutoFix = findings.filter(f => f.autoFixable).length;
+  const requiresReview = findings.filter(f => !f.autoFixable).length;
+
+  let overallRisk = 'none';
+  if (findings.some(f => f.severity === 'critical')) overallRisk = 'critical';
+  else if (findings.some(f => f.severity === 'high')) overallRisk = 'high';
+  else if (findings.some(f => f.severity === 'medium')) overallRisk = 'medium';
+  else if (findings.some(f => f.severity === 'low')) overallRisk = 'low';
+
+  let estimatedDowntime = 'none';
+  if (destructive > 0 || dataLoss > 0) estimatedDowntime = 'significant';
+  else if (lockRisk > 2) estimatedDowntime = 'moderate';
+  else if (lockRisk > 0) estimatedDowntime = 'minimal';
+
+  return {
+    overallRisk,
+    findings,
+    destructiveChanges: destructive,
+    dataLossChanges: dataLoss,
+    lockRiskChanges: lockRisk,
+    canAutoFix,
+    requiresReview,
+    estimatedDowntime,
+  };
+}

package/src/risk/risk-engine.js

@@ -0,0 +1,25 @@
+import { checkDestructive } from './destructive-checker.js';
+import { checkDataLoss } from './data-loss-checker.js';
+import { checkLockRisk } from './lock-analyzer.js';
+import { checkCompatibility } from './compatibility-checker.js';
+import { computeOverallRisk } from './recommendations.js';
+
+export class RiskEngine {
+  /**
+   * @param {import('../types/changes.js').SchemaChange[]} changes
+   * @param {number} [pgVersion]
+   * @returns {import('../types/risk.js').RiskAssessment}
+   */
+  assess(changes, pgVersion = 150000) {
+    const findings = [];
+
+    for (const change of changes) {
+      findings.push(...checkDestructive(change));
+      findings.push(...checkDataLoss(change));
+      findings.push(...checkLockRisk(change));
+      findings.push(...checkCompatibility(change, pgVersion));
+    }
+
+    return computeOverallRisk(findings);
+  }
+}

package/src/storage/index.js

@@ -0,0 +1,5 @@
+export { InMemoryStorageProvider } from './memory-storage.js';
+// FileStorageProvider and GitHubStorageProvider removed - not integrated into pipeline
+// Schema files are stored in user's GitHub repo or browser cache, not storage layer
+export { MigrationTable } from './migration-table.js';
+export { RollbackGenerator } from './rollback-generator.js';

package/src/storage/memory-storage.js

@@ -0,0 +1,87 @@
+export class InMemoryStorageProvider {
+  constructor() {
+    this.snapshots = new Map();
+    this.migrations = new Map();
+    this.files = new Map();
+  }
+
+  async saveSnapshot(checksum, schema) {
+    this.snapshots.set(checksum, { schema, timestamp: new Date().toISOString() });
+  }
+
+  async loadSnapshot(checksum) {
+    const entry = this.snapshots.get(checksum);
+    if (!entry) throw new Error(`Snapshot not found: ${checksum}`);
+    return entry.schema;
+  }
+
+  async listSnapshots() {
+    return Array.from(this.snapshots.entries()).map(([checksum, entry]) => ({
+      checksum,
+      timestamp: entry.timestamp,
+    }));
+  }
+
+  async saveMigration(migration) {
+    const connectionId = migration.connectionId || 'default';
+    if (!this.migrations.has(connectionId)) {
+      this.migrations.set(connectionId, []);
+    }
+    this.migrations.get(connectionId).push(migration);
+    return migration;
+  }
+
+  async getMigration(id, connectionId) {
+    const cid = connectionId || 'default';
+    const migrations = this.migrations.get(cid) || [];
+    return migrations.find(m => m.id === id) || null;
+  }
+
+  async getLatestMigration(connectionId) {
+    const cid = connectionId || 'default';
+    const migrations = this.migrations.get(cid) || [];
+    if (migrations.length === 0) return null;
+    return migrations[migrations.length - 1];
+  }
+
+  async getMigrationHistory(connectionId) {
+    const cid = connectionId || 'default';
+    return this.migrations.get(cid) || [];
+  }
+
+  async getStats(connectionId) {
+    const cid = connectionId || 'default';
+    const migrations = this.migrations.get(cid) || [];
+    return {
+      totalMigrations: migrations.length,
+      total_migrations: migrations.length,
+      completed: migrations.filter(m => m.status === 'completed').length,
+      failed: migrations.filter(m => m.status === 'failed').length,
+      running: migrations.filter(m => m.status === 'running').length,
+    };
+  }
+
+  async saveMigrationFile(name, sql) {
+    this.files.set(name, sql);
+  }
+
+  async loadMigrationFile(name) {
+    const sql = this.files.get(name);
+    if (!sql) throw new Error(`Migration file not found: ${name}`);
+    return sql;
+  }
+
+  async listMigrationFiles() {
+    return Array.from(this.files.keys());
+  }
+
+  async clearConnection(connectionId) {
+    this.migrations.delete(connectionId);
+  }
+
+  async clearAll() {
+    this.migrations.clear();
+    this.snapshots.clear();
+    this.files.clear();
+  }
+}