@indiekitai/pg-dash 0.3.7 → 0.3.9

package/dist/mcp.js

@@ -63,6 +63,30 @@ async function getTables(pool2) {
 }
 
 // src/server/queries/schema.ts
+async function getSchemaTables(pool2) {
+  const client = await pool2.connect();
+  try {
+    const r = await client.query(`
+      SELECT
+        c.relname AS name,
+        n.nspname AS schema,
+        pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size,
+        pg_total_relation_size(c.oid) AS total_size_bytes,
+        pg_size_pretty(pg_relation_size(c.oid)) AS table_size,
+        pg_size_pretty(pg_total_relation_size(c.oid) - pg_relation_size(c.oid)) AS index_size,
+        s.n_live_tup AS row_count,
+        obj_description(c.oid) AS description
+      FROM pg_class c
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      LEFT JOIN pg_stat_user_tables s ON s.relid = c.oid
+      WHERE c.relkind = 'r' AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+      ORDER BY pg_total_relation_size(c.oid) DESC
+    `);
+    return r.rows;
+  } finally {
+    client.release();
+  }
+}
 async function getSchemaTableDetail(pool2, tableName) {
   const client = await pool2.connect();
   try {
@@ -160,6 +184,26 @@ async function getSchemaTableDetail(pool2, tableName) {
     client.release();
   }
 }
+async function getSchemaEnums(pool2) {
+  const client = await pool2.connect();
+  try {
+    const r = await client.query(`
+      SELECT
+        t.typname AS name,
+        n.nspname AS schema,
+        array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
+      FROM pg_type t
+      JOIN pg_namespace n ON t.typnamespace = n.oid
+      JOIN pg_enum e ON t.oid = e.enumtypid
+      WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+      GROUP BY t.typname, n.nspname
+      ORDER BY t.typname
+    `);
+    return r.rows;
+  } finally {
+    client.release();
+  }
+}
 
 // src/server/queries/activity.ts
 async function getActivity(pool2) {
@@ -989,6 +1033,140 @@ function diffSnapshots(prev, current) {
 
 // src/server/env-differ.ts
 import { Pool } from "pg";
+
+// src/server/schema-diff.ts
+function diffSnapshots2(oldSnap, newSnap) {
+  const changes = [];
+  const oldTableMap = new Map(oldSnap.tables.map((t) => [`${t.schema}.${t.name}`, t]));
+  const newTableMap = new Map(newSnap.tables.map((t) => [`${t.schema}.${t.name}`, t]));
+  for (const [key, t] of newTableMap) {
+    if (!oldTableMap.has(key)) {
+      changes.push({ change_type: "added", object_type: "table", table_name: key, detail: `Table ${key} added` });
+    }
+  }
+  for (const [key] of oldTableMap) {
+    if (!newTableMap.has(key)) {
+      changes.push({ change_type: "removed", object_type: "table", table_name: key, detail: `Table ${key} removed` });
+    }
+  }
+  for (const [key, newTable] of newTableMap) {
+    const oldTable = oldTableMap.get(key);
+    if (!oldTable) continue;
+    const oldCols = new Map(oldTable.columns.map((c) => [c.name, c]));
+    const newCols = new Map(newTable.columns.map((c) => [c.name, c]));
+    for (const [name, col] of newCols) {
+      const oldCol = oldCols.get(name);
+      if (!oldCol) {
+        changes.push({ change_type: "added", object_type: "column", table_name: key, detail: `Column ${name} added (${col.type})` });
+      } else {
+        if (oldCol.type !== col.type) {
+          changes.push({ change_type: "modified", object_type: "column", table_name: key, detail: `Column ${name} type changed: ${oldCol.type} \u2192 ${col.type}` });
+        }
+        if (oldCol.nullable !== col.nullable) {
+          changes.push({ change_type: "modified", object_type: "column", table_name: key, detail: `Column ${name} nullable changed: ${oldCol.nullable} \u2192 ${col.nullable}` });
+        }
+        if (oldCol.default_value !== col.default_value) {
+          changes.push({ change_type: "modified", object_type: "column", table_name: key, detail: `Column ${name} default changed: ${oldCol.default_value ?? "NULL"} \u2192 ${col.default_value ?? "NULL"}` });
+        }
+      }
+    }
+    for (const name of oldCols.keys()) {
+      if (!newCols.has(name)) {
+        changes.push({ change_type: "removed", object_type: "column", table_name: key, detail: `Column ${name} removed` });
+      }
+    }
+    const oldIdx = new Map(oldTable.indexes.map((i) => [i.name, i]));
+    const newIdx = new Map(newTable.indexes.map((i) => [i.name, i]));
+    for (const [name, idx] of newIdx) {
+      if (!oldIdx.has(name)) {
+        changes.push({ change_type: "added", object_type: "index", table_name: key, detail: `Index ${name} added` });
+      } else if (oldIdx.get(name).definition !== idx.definition) {
+        changes.push({ change_type: "modified", object_type: "index", table_name: key, detail: `Index ${name} definition changed` });
+      }
+    }
+    for (const name of oldIdx.keys()) {
+      if (!newIdx.has(name)) {
+        changes.push({ change_type: "removed", object_type: "index", table_name: key, detail: `Index ${name} removed` });
+      }
+    }
+    const oldCon = new Map(oldTable.constraints.map((c) => [c.name, c]));
+    const newCon = new Map(newTable.constraints.map((c) => [c.name, c]));
+    for (const [name, con] of newCon) {
+      if (!oldCon.has(name)) {
+        changes.push({ change_type: "added", object_type: "constraint", table_name: key, detail: `Constraint ${name} added (${con.type})` });
+      } else if (oldCon.get(name).definition !== con.definition) {
+        changes.push({ change_type: "modified", object_type: "constraint", table_name: key, detail: `Constraint ${name} definition changed` });
+      }
+    }
+    for (const name of oldCon.keys()) {
+      if (!newCon.has(name)) {
+        changes.push({ change_type: "removed", object_type: "constraint", table_name: key, detail: `Constraint ${name} removed` });
+      }
+    }
+  }
+  const oldEnums = new Map((oldSnap.enums || []).map((e) => [`${e.schema}.${e.name}`, e]));
+  const newEnums = new Map((newSnap.enums || []).map((e) => [`${e.schema}.${e.name}`, e]));
+  for (const [key, en] of newEnums) {
+    const oldEn = oldEnums.get(key);
+    if (!oldEn) {
+      changes.push({ change_type: "added", object_type: "enum", table_name: null, detail: `Enum ${key} added (${en.values.join(", ")})` });
+    } else {
+      const added = en.values.filter((v) => !oldEn.values.includes(v));
+      const removed = oldEn.values.filter((v) => !en.values.includes(v));
+      for (const v of added) {
+        changes.push({ change_type: "modified", object_type: "enum", table_name: null, detail: `Enum ${key}: value '${v}' added` });
+      }
+      for (const v of removed) {
+        changes.push({ change_type: "modified", object_type: "enum", table_name: null, detail: `Enum ${key}: value '${v}' removed` });
+      }
+    }
+  }
+  for (const key of oldEnums.keys()) {
+    if (!newEnums.has(key)) {
+      changes.push({ change_type: "removed", object_type: "enum", table_name: null, detail: `Enum ${key} removed` });
+    }
+  }
+  return changes;
+}
+
+// src/server/schema-tracker.ts
+async function buildLiveSnapshot(pool2) {
+  const tables = await getSchemaTables(pool2);
+  const enums = await getSchemaEnums(pool2);
+  const detailedTables = await Promise.all(
+    tables.map(async (t) => {
+      const detail = await getSchemaTableDetail(pool2, `${t.schema}.${t.name}`);
+      if (!detail) return null;
+      return {
+        name: detail.name,
+        schema: detail.schema,
+        columns: detail.columns.map((c) => ({
+          name: c.name,
+          type: c.type,
+          nullable: c.nullable,
+          default_value: c.default_value
+        })),
+        indexes: detail.indexes.map((i) => ({
+          name: i.name,
+          definition: i.definition,
+          is_unique: i.is_unique,
+          is_primary: i.is_primary
+        })),
+        constraints: detail.constraints.map((c) => ({
+          name: c.name,
+          type: c.type,
+          definition: c.definition
+        }))
+      };
+    })
+  );
+  return {
+    tables: detailedTables.filter(Boolean),
+    enums: enums.map((e) => ({ name: e.name, schema: e.schema, values: e.values }))
+  };
+}
+
+// src/server/env-differ.ts
 async function fetchTables(pool2) {
   const res = await pool2.query(`
     SELECT table_name
@@ -1009,7 +1187,7 @@ async function fetchColumns(pool2) {
 }
 async function fetchIndexes(pool2) {
   const res = await pool2.query(`
-    SELECT tablename, indexname
+    SELECT tablename, indexname, indexdef
     FROM pg_indexes
     WHERE schemaname = 'public' AND indexname NOT LIKE '%_pkey'
     ORDER BY tablename, indexname
@@ -1050,6 +1228,8 @@ function diffColumns(sourceCols, targetCols, commonTables) {
     const missingColumns = [];
     const extraColumns = [];
     const typeDiffs = [];
+    const nullableDiffs = [];
+    const defaultDiffs = [];
     for (const [colName, srcInfo] of srcMap) {
       if (!tgtMap.has(colName)) {
         missingColumns.push(srcInfo);
@@ -1058,6 +1238,12 @@ function diffColumns(sourceCols, targetCols, commonTables) {
         if (srcInfo.type !== tgtInfo.type) {
           typeDiffs.push({ column: colName, sourceType: srcInfo.type, targetType: tgtInfo.type });
         }
+        if (srcInfo.nullable !== tgtInfo.nullable) {
+          nullableDiffs.push({ column: colName, sourceNullable: srcInfo.nullable, targetNullable: tgtInfo.nullable });
+        }
+        if ((srcInfo.default ?? null) !== (tgtInfo.default ?? null)) {
+          defaultDiffs.push({ column: colName, sourceDefault: srcInfo.default ?? null, targetDefault: tgtInfo.default ?? null });
+        }
       }
     }
     for (const [colName, tgtInfo] of tgtMap) {
@@ -1065,8 +1251,8 @@ function diffColumns(sourceCols, targetCols, commonTables) {
         extraColumns.push(tgtInfo);
       }
     }
-    if (missingColumns.length > 0 || extraColumns.length > 0 || typeDiffs.length > 0) {
-      diffs.push({ table, missingColumns, extraColumns, typeDiffs });
+    if (missingColumns.length > 0 || extraColumns.length > 0 || typeDiffs.length > 0 || nullableDiffs.length > 0 || defaultDiffs.length > 0) {
+      diffs.push({ table, missingColumns, extraColumns, typeDiffs, nullableDiffs, defaultDiffs });
     }
   }
   return diffs;
@@ -1074,8 +1260,8 @@ function diffColumns(sourceCols, targetCols, commonTables) {
 function groupIndexesByTable(indexes) {
   const map = /* @__PURE__ */ new Map();
   for (const idx of indexes) {
-    if (!map.has(idx.tablename)) map.set(idx.tablename, /* @__PURE__ */ new Set());
-    map.get(idx.tablename).add(idx.indexname);
+    if (!map.has(idx.tablename)) map.set(idx.tablename, /* @__PURE__ */ new Map());
+    map.get(idx.tablename).set(idx.indexname, idx.indexdef);
   }
   return map;
 }
@@ -1089,12 +1275,21 @@ function diffIndexes(sourceIdxs, targetIdxs, commonTables) {
   ]);
   for (const table of allTables) {
     if (!commonTables.includes(table)) continue;
-    const srcSet = srcByTable.get(table) ?? /* @__PURE__ */ new Set();
-    const tgtSet = tgtByTable.get(table) ?? /* @__PURE__ */ new Set();
-    const missingIndexes = [...srcSet].filter((i) => !tgtSet.has(i));
-    const extraIndexes = [...tgtSet].filter((i) => !srcSet.has(i));
-    if (missingIndexes.length > 0 || extraIndexes.length > 0) {
-      diffs.push({ table, missingIndexes, extraIndexes });
+    const srcMap = srcByTable.get(table) ?? /* @__PURE__ */ new Map();
+    const tgtMap = tgtByTable.get(table) ?? /* @__PURE__ */ new Map();
+    const missingIndexes = [...srcMap.keys()].filter((i) => !tgtMap.has(i));
+    const extraIndexes = [...tgtMap.keys()].filter((i) => !srcMap.has(i));
+    const modifiedIndexes = [];
+    for (const [name, srcDef] of srcMap) {
+      if (tgtMap.has(name)) {
+        const tgtDef = tgtMap.get(name);
+        if (srcDef !== tgtDef) {
+          modifiedIndexes.push({ name, sourceDef: srcDef, targetDef: tgtDef });
+        }
+      }
+    }
+    if (missingIndexes.length > 0 || extraIndexes.length > 0 || modifiedIndexes.length > 0) {
+      diffs.push({ table, missingIndexes, extraIndexes, modifiedIndexes });
     }
   }
   return diffs;
@@ -1102,11 +1297,13 @@ function diffIndexes(sourceIdxs, targetIdxs, commonTables) {
 function countSchemaDrifts(schema) {
   let n = schema.missingTables.length + schema.extraTables.length;
   for (const cd of schema.columnDiffs) {
-    n += cd.missingColumns.length + cd.extraColumns.length + cd.typeDiffs.length;
+    n += cd.missingColumns.length + cd.extraColumns.length + cd.typeDiffs.length + cd.nullableDiffs.length + cd.defaultDiffs.length;
   }
   for (const id of schema.indexDiffs) {
-    n += id.missingIndexes.length + id.extraIndexes.length;
+    n += id.missingIndexes.length + id.extraIndexes.length + id.modifiedIndexes.length;
   }
+  n += (schema.constraintDiffs ?? []).length;
+  n += (schema.enumDiffs ?? []).length;
   return n;
 }
 async function diffEnvironments(sourceConn, targetConn, options) {
@@ -1119,22 +1316,46 @@ async function diffEnvironments(sourceConn, targetConn, options) {
       sourceCols,
       targetCols,
       sourceIdxs,
-      targetIdxs
+      targetIdxs,
+      sourceSnap,
+      targetSnap
     ] = await Promise.all([
       fetchTables(sourcePool),
       fetchTables(targetPool),
       fetchColumns(sourcePool),
       fetchColumns(targetPool),
       fetchIndexes(sourcePool),
-      fetchIndexes(targetPool)
+      fetchIndexes(targetPool),
+      buildLiveSnapshot(sourcePool).catch(() => null),
+      buildLiveSnapshot(targetPool).catch(() => null)
     ]);
     const { missingTables, extraTables } = diffTables(sourceTables, targetTables);
-    const sourceSet = new Set(sourceTables);
     const targetSet = new Set(targetTables);
     const commonTables = sourceTables.filter((t) => targetSet.has(t));
     const columnDiffs = diffColumns(sourceCols, targetCols, commonTables);
     const indexDiffs = diffIndexes(sourceIdxs, targetIdxs, commonTables);
-    const schema = { missingTables, extraTables, columnDiffs, indexDiffs };
+    const constraintDiffs = [];
+    const enumDiffs = [];
+    if (sourceSnap && targetSnap) {
+      const snapChanges = diffSnapshots2(sourceSnap, targetSnap);
+      for (const c of snapChanges) {
+        if (c.object_type === "constraint") {
+          constraintDiffs.push({
+            table: c.table_name ?? null,
+            type: c.change_type === "added" ? "extra" : c.change_type === "removed" ? "missing" : "modified",
+            name: c.detail.split(" ")[1] ?? c.detail,
+            detail: c.detail
+          });
+        } else if (c.object_type === "enum") {
+          enumDiffs.push({
+            type: c.change_type === "added" ? "extra" : c.change_type === "removed" ? "missing" : "modified",
+            name: c.detail.split(" ")[1] ?? c.detail,
+            detail: c.detail
+          });
+        }
+      }
+    }
+    const schema = { missingTables, extraTables, columnDiffs, indexDiffs, constraintDiffs, enumDiffs };
     const schemaDrifts = countSchemaDrifts(schema);
     let health;
     if (options?.includeHealth) {
@@ -1276,12 +1497,23 @@ async function analyzeExplainPlan(explainJson, pool2) {
     if (pool2) {
       existingIndexCols = await getExistingIndexColumns(pool2, scan.table);
     }
-    for (const col of cols) {
-      const alreadyCovered = existingIndexCols.some(
-        (idxCols) => idxCols.length > 0 && idxCols[0] === col
-      );
-      if (alreadyCovered) continue;
-      const benefit = rateBenefit(scan.rowCount);
+    const uncoveredCols = cols.filter(
+      (col) => !existingIndexCols.some((idxCols) => idxCols.length > 0 && idxCols[0] === col)
+    );
+    if (uncoveredCols.length === 0) continue;
+    const benefit = rateBenefit(scan.rowCount);
+    if (uncoveredCols.length >= 2) {
+      const idxName = `idx_${scan.table}_${uncoveredCols.join("_")}`;
+      const sql = `CREATE INDEX CONCURRENTLY ${idxName} ON ${scan.table} (${uncoveredCols.join(", ")})`;
+      result.missingIndexes.push({
+        table: scan.table,
+        columns: uncoveredCols,
+        reason: `Seq Scan with multi-column filter (${uncoveredCols.join(", ")}) on ${fmtRows(scan.rowCount)} rows \u2014 composite index preferred`,
+        sql,
+        estimatedBenefit: benefit
+      });
+    } else {
+      const col = uncoveredCols[0];
       const idxName = `idx_${scan.table}_${col}`;
       const sql = `CREATE INDEX CONCURRENTLY ${idxName} ON ${scan.table} (${col})`;
       result.missingIndexes.push({
@@ -1471,6 +1703,83 @@ function staticCheck(sql) {
       lineNumber: findLineNumber(sql, m.index)
     });
   }
+  const alterTypeRe = /\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?([\w."]+)\s+ALTER\s+(?:COLUMN\s+)?[\w"]+\s+TYPE\b/gi;
+  while ((m = alterTypeRe.exec(sql)) !== null) {
+    const table = bareTable(m[1]);
+    issues.push({
+      severity: "warning",
+      code: "ALTER_COLUMN_TYPE",
+      message: "ALTER COLUMN TYPE rewrites the entire table and acquires an exclusive lock.",
+      suggestion: "Consider using a new column + backfill + rename strategy to avoid downtime.",
+      lineNumber: findLineNumber(sql, m.index),
+      tableName: table
+    });
+  }
+  const dropColRe = /\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?([\w."]+)\s+DROP\s+(?:COLUMN\s+)(?:IF\s+EXISTS\s+)?[\w"]+\b/gi;
+  while ((m = dropColRe.exec(sql)) !== null) {
+    const table = bareTable(m[1]);
+    issues.push({
+      severity: "info",
+      code: "DROP_COLUMN",
+      message: "DROP COLUMN is safe in PostgreSQL (no table rewrite), but may break application code referencing that column.",
+      suggestion: "Ensure no application code references this column before dropping it.",
+      lineNumber: findLineNumber(sql, m.index),
+      tableName: table
+    });
+  }
+  const renameTableRe = /ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(\w+)\s+RENAME\s+TO\s+(\w+)/gi;
+  while ((m = renameTableRe.exec(sql)) !== null) {
+    const oldName = m[1];
+    const newName = m[2];
+    issues.push({
+      severity: "warning",
+      code: "RENAME_TABLE",
+      message: `Renaming table "${oldName}" to "${newName}" breaks application code referencing the old name`,
+      suggestion: "Deploy application code that handles both names before renaming, or use a view with the old name after renaming.",
+      lineNumber: findLineNumber(sql, m.index),
+      tableName: oldName
+    });
+  }
+  const renameColumnRe = /ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(\w+)\s+RENAME\s+COLUMN\s+(\w+)\s+TO\s+(\w+)/gi;
+  while ((m = renameColumnRe.exec(sql)) !== null) {
+    const table = m[1];
+    const oldCol = m[2];
+    const newCol = m[3];
+    issues.push({
+      severity: "warning",
+      code: "RENAME_COLUMN",
+      message: `Renaming column "${oldCol}" to "${newCol}" on table "${table}" breaks application code referencing the old column name`,
+      suggestion: "Add new column, backfill data, update application to use new column, then drop old column (expand/contract pattern).",
+      lineNumber: findLineNumber(sql, m.index),
+      tableName: table
+    });
+  }
+  const addConRe = /\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?([\w."]+)\s+ADD\s+CONSTRAINT\b[^;]*(;|$)/gi;
+  while ((m = addConRe.exec(sql)) !== null) {
+    const fragment = m[0];
+    const table = bareTable(m[1]);
+    const fragUpper = fragment.toUpperCase();
+    if (!/\bNOT\s+VALID\b/.test(fragUpper)) {
+      issues.push({
+        severity: "warning",
+        code: "ADD_CONSTRAINT_SCANS_TABLE",
+        message: "ADD CONSTRAINT validates all existing rows and holds an exclusive lock during the scan.",
+        suggestion: "Use ADD CONSTRAINT ... NOT VALID to skip validation, then VALIDATE CONSTRAINT in a separate transaction.",
+        lineNumber: findLineNumber(sql, m.index),
+        tableName: table
+      });
+    }
+  }
+  const hasTransaction = /\bBEGIN\b/i.test(sql) || /\bSTART\s+TRANSACTION\b/i.test(sql);
+  const hasConcurrently = /\bCREATE\s+(?:UNIQUE\s+)?INDEX\s+CONCURRENTLY\b/i.test(sql);
+  if (hasTransaction && hasConcurrently) {
+    issues.push({
+      severity: "error",
+      code: "CONCURRENTLY_IN_TRANSACTION",
+      message: "CREATE INDEX CONCURRENTLY cannot run inside a transaction block. It will fail at runtime.",
+      suggestion: "Remove the BEGIN/COMMIT wrapper, or use a migration tool that runs CONCURRENTLY outside transactions."
+    });
+  }
   const truncRe = /\bTRUNCATE\b/gi;
   while ((m = truncRe.exec(sql)) !== null) {
     issues.push({