@indiekitai/pg-dash 0.3.6 → 0.3.8

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
@@ -1107,6 +1285,8 @@ function countSchemaDrifts(schema) {
   for (const id of schema.indexDiffs) {
     n += id.missingIndexes.length + id.extraIndexes.length;
   }
+  n += (schema.constraintDiffs ?? []).length;
+  n += (schema.enumDiffs ?? []).length;
   return n;
 }
 async function diffEnvironments(sourceConn, targetConn, options) {
@@ -1119,22 +1299,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) {
@@ -1471,6 +1675,56 @@ 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 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({