@launchsecure/launch-kit 0.0.19 → 0.0.21

package/dist/server/chart-serve.js

@@ -1694,51 +1694,149 @@ function pgTypeToPrisma(pgType) {
   const upper = pgType.toUpperCase().trim();
   return PG_TO_PRISMA[upper] ?? upper;
 }
+var ID = `(?:"[\\w$]+"|[\\w$]+)`;
+var QID = `(?:${ID}\\.)?${ID}`;
+function bareName(captured) {
+  const parts = captured.split(".");
+  const last = parts[parts.length - 1];
+  return last.replace(/^"(.*)"$/, "$1").trim();
+}
 function parseCreateTable(sql, state) {
-  const re = /CREATE\s+TABLE\s+"(\w+)"\s*\(([\s\S]*?)\);/gi;
+  const re = new RegExp(
+    `CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s*\\(([\\s\\S]*?)\\);`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const tableName = m[1];
+    const tableName = bareName(m[1]);
     const body = m[2];
     const columns = /* @__PURE__ */ new Map();
     let primaryCol = null;
-    for (const line of body.split("\n")) {
-      const trimmed = line.trim().replace(/,\s*$/, "");
+    const inlineFks = [];
+    const lines = splitTopLevelCommas(body);
+    for (const raw of lines) {
+      const trimmed = raw.trim().replace(/,\s*$/, "");
       if (!trimmed || trimmed.startsWith("--")) continue;
-      const pkMatch = trimmed.match(/CONSTRAINT\s+"[^"]+"\s+PRIMARY\s+KEY\s*\("(\w+)"\)/i);
-      if (pkMatch) {
-        primaryCol = pkMatch[1];
+      const namedPk = trimmed.match(new RegExp(`^CONSTRAINT\\s+${ID}\\s+PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
+      if (namedPk) {
+        primaryCol = bareName(namedPk[1]);
         continue;
       }
-      if (/^\s*CONSTRAINT\s/i.test(trimmed)) continue;
-      const colMatch = trimmed.match(/^"(\w+)"\s+(.+)/);
+      const tablePk = trimmed.match(new RegExp(`^PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
+      if (tablePk) {
+        primaryCol = bareName(tablePk[1]);
+        continue;
+      }
+      if (/^UNIQUE\s*\(/i.test(trimmed)) continue;
+      const namedFk = trimmed.match(new RegExp(
+        `^CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (namedFk) {
+        inlineFks.push({
+          constraintName: bareName(namedFk[1]),
+          sourceTable: tableName,
+          sourceColumn: bareName(namedFk[2]),
+          targetTable: bareName(namedFk[3]),
+          targetColumn: bareName(namedFk[4]),
+          onDelete: namedFk[5] ?? null
+        });
+        continue;
+      }
+      const bareFk = trimmed.match(new RegExp(
+        `^FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (bareFk) {
+        inlineFks.push({
+          constraintName: `${tableName}_${bareName(bareFk[1])}_fkey`,
+          sourceTable: tableName,
+          sourceColumn: bareName(bareFk[1]),
+          targetTable: bareName(bareFk[2]),
+          targetColumn: bareName(bareFk[3]),
+          onDelete: bareFk[4] ?? null
+        });
+        continue;
+      }
+      if (/^CONSTRAINT\s/i.test(trimmed)) continue;
+      const colMatch = trimmed.match(new RegExp(`^(${ID})\\s+(.+)`, "i"));
       if (!colMatch) continue;
-      const colName = colMatch[1];
+      const colName = bareName(colMatch[1]);
       let rest = colMatch[2];
+      const inlineRefMatch = rest.match(new RegExp(
+        `\\bREFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (inlineRefMatch) {
+        inlineFks.push({
+          constraintName: `${tableName}_${colName}_fkey`,
+          sourceTable: tableName,
+          sourceColumn: colName,
+          targetTable: bareName(inlineRefMatch[1]),
+          targetColumn: bareName(inlineRefMatch[2]),
+          onDelete: inlineRefMatch[3] ?? null
+        });
+        rest = rest.replace(inlineRefMatch[0], "").trim();
+      }
       const isNotNull = /\bNOT\s+NULL\b/i.test(rest);
+      const isPrimaryKey = /\bPRIMARY\s+KEY\b/i.test(rest);
+      const isUnique = /\bUNIQUE\b/i.test(rest);
       const defaultMatch = rest.match(/\bDEFAULT\s+(.+?)(?:\s*,?\s*$)/i);
       const defaultVal = defaultMatch ? defaultMatch[1].trim() : null;
-      let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim().replace(/,\s*$/, "").trim();
+      let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bPRIMARY\s+KEY\b/gi, "").replace(/\bUNIQUE\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim().replace(/,\s*$/, "").trim();
       columns.set(colName, {
         name: colName,
         type: colType,
-        nullable: !isNotNull,
-        primary: false,
-        unique: false,
+        nullable: !isNotNull && !isPrimaryKey,
+        primary: isPrimaryKey,
+        unique: isUnique,
         default: defaultVal
       });
+      if (isPrimaryKey) primaryCol = colName;
     }
     if (primaryCol && columns.has(primaryCol)) {
       columns.get(primaryCol).primary = true;
     }
     state.tables.set(tableName, { name: tableName, columns });
+    state.fks.push(...inlineFks);
   }
 }
+function splitTopLevelCommas(body) {
+  const out = [];
+  let depth = 0;
+  let buf = "";
+  let inString = null;
+  for (const ch of body) {
+    if (inString) {
+      buf += ch;
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      inString = ch;
+      buf += ch;
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      out.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.trim()) out.push(buf);
+  return out;
+}
 function parseCreateEnum(sql, state) {
-  const re = /CREATE\s+TYPE\s+"(\w+)"\s+AS\s+ENUM\s*\(([^)]+)\)/gi;
+  const re = new RegExp(
+    `CREATE\\s+TYPE\\s+(${QID})\\s+AS\\s+ENUM\\s*\\(([^)]+)\\)`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const enumName = m[1];
+    const enumName = bareName(m[1]);
     const valuesStr = m[2];
     const values = new Set(
       valuesStr.split(",").map((v) => v.trim().replace(/^'(.*)'$/, "$1")).filter(Boolean)
@@ -1747,11 +1845,14 @@ function parseCreateEnum(sql, state) {
   }
 }
 function parseAlterTable(sql, state) {
-  const addColRe = /ALTER\s+TABLE\s+"(\w+)"\s+ADD\s+COLUMN\s+"(\w+)"\s+(.+?);/gi;
+  const addColRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+COLUMN\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s+(.+?);`,
+    "gi"
+  );
   let m;
   while ((m = addColRe.exec(sql)) !== null) {
-    const tableName = m[1];
-    const colName = m[2];
+    const tableName = bareName(m[1]);
+    const colName = bareName(m[2]);
     let rest = m[3];
     const table = state.tables.get(tableName);
     if (!table) continue;
@@ -1768,48 +1869,66 @@ function parseAlterTable(sql, state) {
       default: defaultVal
     });
   }
-  const dropColRe = /ALTER\s+TABLE\s+"(\w+)"\s+DROP\s+COLUMN\s+"(\w+)"/gi;
+  const dropColRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+DROP\\s+COLUMN\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
+    "gi"
+  );
   while ((m = dropColRe.exec(sql)) !== null) {
-    const table = state.tables.get(m[1]);
-    if (table) table.columns.delete(m[2]);
+    const table = state.tables.get(bareName(m[1]));
+    if (table) table.columns.delete(bareName(m[2]));
   }
-  const fkRe = /ALTER\s+TABLE\s+"(\w+)"\s+ADD\s+CONSTRAINT\s+"([^"]+)"\s+FOREIGN\s+KEY\s*\("(\w+)"\)\s+REFERENCES\s+"(\w+)"\("(\w+)"\)(?:\s+ON\s+DELETE\s+(\w+(?:\s+\w+)?))?/gi;
+  const fkRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+    "gi"
+  );
   while ((m = fkRe.exec(sql)) !== null) {
     state.fks.push({
-      constraintName: m[2],
-      sourceTable: m[1],
-      sourceColumn: m[3],
-      targetTable: m[4],
-      targetColumn: m[5],
+      constraintName: bareName(m[2]),
+      sourceTable: bareName(m[1]),
+      sourceColumn: bareName(m[3]),
+      targetTable: bareName(m[4]),
+      targetColumn: bareName(m[5]),
       onDelete: m[6] ?? null
     });
   }
 }
 function parseAlterEnum(sql, state) {
-  const re = /ALTER\s+TYPE\s+"(\w+)"\s+ADD\s+VALUE\s+'([^']+)'/gi;
+  const re = new RegExp(
+    `ALTER\\s+TYPE\\s+(${QID})\\s+ADD\\s+VALUE\\s+'([^']+)'`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const en = state.enums.get(m[1]);
+    const en = state.enums.get(bareName(m[1]));
     if (en) en.values.add(m[2]);
   }
 }
 function parseDropTable(sql, state) {
-  const re = /DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?"(\w+)"/gi;
+  const re = new RegExp(
+    `DROP\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    state.tables.delete(m[1]);
-    state.fks = state.fks.filter((fk) => fk.sourceTable !== m[1] && fk.targetTable !== m[1]);
+    const dropped = bareName(m[1]);
+    state.tables.delete(dropped);
+    state.fks = state.fks.filter((fk) => fk.sourceTable !== dropped && fk.targetTable !== dropped);
   }
 }
 function parseUniqueIndex(sql, state) {
-  const re = /CREATE\s+UNIQUE\s+INDEX\s+"[^"]+"\s+ON\s+"(\w+)"\("(\w+)"\)/gi;
+  const re = new RegExp(
+    `CREATE\\s+UNIQUE\\s+INDEX\\s+(?:(?:IF\\s+NOT\\s+EXISTS\\s+)?(?:${ID}\\s+)?)?ON\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const table = state.tables.get(m[1]);
-    const col = table?.columns.get(m[2]);
+    const tableName = bareName(m[1]);
+    const colName = bareName(m[2]);
+    const table = state.tables.get(tableName);
+    const col = table?.columns.get(colName);
     if (col) col.unique = true;
-    if (!state.uniqueIndexes.has(m[1])) state.uniqueIndexes.set(m[1], /* @__PURE__ */ new Set());
-    state.uniqueIndexes.get(m[1]).add(m[2]);
+    if (!state.uniqueIndexes.has(tableName)) state.uniqueIndexes.set(tableName, /* @__PURE__ */ new Set());
+    state.uniqueIndexes.get(tableName).add(colName);
   }
 }
 function discoverMigrationFiles(migrationsDir) {

package/dist/server/cli.js

@@ -8051,51 +8051,149 @@ function pgTypeToPrisma(pgType) {
   const upper = pgType.toUpperCase().trim();
   return PG_TO_PRISMA[upper] ?? upper;
 }
+var ID = `(?:"[\\w$]+"|[\\w$]+)`;
+var QID = `(?:${ID}\\.)?${ID}`;
+function bareName(captured) {
+  const parts = captured.split(".");
+  const last = parts[parts.length - 1];
+  return last.replace(/^"(.*)"$/, "$1").trim();
+}
 function parseCreateTable(sql, state) {
-  const re = /CREATE\s+TABLE\s+"(\w+)"\s*\(([\s\S]*?)\);/gi;
+  const re = new RegExp(
+    `CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s*\\(([\\s\\S]*?)\\);`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const tableName = m[1];
+    const tableName = bareName(m[1]);
     const body = m[2];
     const columns = /* @__PURE__ */ new Map();
     let primaryCol = null;
-    for (const line of body.split("\n")) {
-      const trimmed = line.trim().replace(/,\s*$/, "");
+    const inlineFks = [];
+    const lines = splitTopLevelCommas(body);
+    for (const raw of lines) {
+      const trimmed = raw.trim().replace(/,\s*$/, "");
       if (!trimmed || trimmed.startsWith("--")) continue;
-      const pkMatch = trimmed.match(/CONSTRAINT\s+"[^"]+"\s+PRIMARY\s+KEY\s*\("(\w+)"\)/i);
-      if (pkMatch) {
-        primaryCol = pkMatch[1];
+      const namedPk = trimmed.match(new RegExp(`^CONSTRAINT\\s+${ID}\\s+PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
+      if (namedPk) {
+        primaryCol = bareName(namedPk[1]);
         continue;
       }
-      if (/^\s*CONSTRAINT\s/i.test(trimmed)) continue;
-      const colMatch = trimmed.match(/^"(\w+)"\s+(.+)/);
+      const tablePk = trimmed.match(new RegExp(`^PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
+      if (tablePk) {
+        primaryCol = bareName(tablePk[1]);
+        continue;
+      }
+      if (/^UNIQUE\s*\(/i.test(trimmed)) continue;
+      const namedFk = trimmed.match(new RegExp(
+        `^CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (namedFk) {
+        inlineFks.push({
+          constraintName: bareName(namedFk[1]),
+          sourceTable: tableName,
+          sourceColumn: bareName(namedFk[2]),
+          targetTable: bareName(namedFk[3]),
+          targetColumn: bareName(namedFk[4]),
+          onDelete: namedFk[5] ?? null
+        });
+        continue;
+      }
+      const bareFk = trimmed.match(new RegExp(
+        `^FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (bareFk) {
+        inlineFks.push({
+          constraintName: `${tableName}_${bareName(bareFk[1])}_fkey`,
+          sourceTable: tableName,
+          sourceColumn: bareName(bareFk[1]),
+          targetTable: bareName(bareFk[2]),
+          targetColumn: bareName(bareFk[3]),
+          onDelete: bareFk[4] ?? null
+        });
+        continue;
+      }
+      if (/^CONSTRAINT\s/i.test(trimmed)) continue;
+      const colMatch = trimmed.match(new RegExp(`^(${ID})\\s+(.+)`, "i"));
       if (!colMatch) continue;
-      const colName = colMatch[1];
+      const colName = bareName(colMatch[1]);
       let rest = colMatch[2];
+      const inlineRefMatch = rest.match(new RegExp(
+        `\\bREFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (inlineRefMatch) {
+        inlineFks.push({
+          constraintName: `${tableName}_${colName}_fkey`,
+          sourceTable: tableName,
+          sourceColumn: colName,
+          targetTable: bareName(inlineRefMatch[1]),
+          targetColumn: bareName(inlineRefMatch[2]),
+          onDelete: inlineRefMatch[3] ?? null
+        });
+        rest = rest.replace(inlineRefMatch[0], "").trim();
+      }
       const isNotNull = /\bNOT\s+NULL\b/i.test(rest);
+      const isPrimaryKey = /\bPRIMARY\s+KEY\b/i.test(rest);
+      const isUnique = /\bUNIQUE\b/i.test(rest);
       const defaultMatch = rest.match(/\bDEFAULT\s+(.+?)(?:\s*,?\s*$)/i);
       const defaultVal = defaultMatch ? defaultMatch[1].trim() : null;
-      let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim().replace(/,\s*$/, "").trim();
+      let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bPRIMARY\s+KEY\b/gi, "").replace(/\bUNIQUE\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim().replace(/,\s*$/, "").trim();
       columns.set(colName, {
         name: colName,
         type: colType,
-        nullable: !isNotNull,
-        primary: false,
-        unique: false,
+        nullable: !isNotNull && !isPrimaryKey,
+        primary: isPrimaryKey,
+        unique: isUnique,
         default: defaultVal
       });
+      if (isPrimaryKey) primaryCol = colName;
     }
     if (primaryCol && columns.has(primaryCol)) {
       columns.get(primaryCol).primary = true;
     }
     state.tables.set(tableName, { name: tableName, columns });
+    state.fks.push(...inlineFks);
   }
 }
+function splitTopLevelCommas(body) {
+  const out = [];
+  let depth = 0;
+  let buf = "";
+  let inString = null;
+  for (const ch of body) {
+    if (inString) {
+      buf += ch;
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      inString = ch;
+      buf += ch;
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      out.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.trim()) out.push(buf);
+  return out;
+}
 function parseCreateEnum(sql, state) {
-  const re = /CREATE\s+TYPE\s+"(\w+)"\s+AS\s+ENUM\s*\(([^)]+)\)/gi;
+  const re = new RegExp(
+    `CREATE\\s+TYPE\\s+(${QID})\\s+AS\\s+ENUM\\s*\\(([^)]+)\\)`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const enumName = m[1];
+    const enumName = bareName(m[1]);
     const valuesStr = m[2];
     const values = new Set(
       valuesStr.split(",").map((v) => v.trim().replace(/^'(.*)'$/, "$1")).filter(Boolean)
@@ -8104,11 +8202,14 @@ function parseCreateEnum(sql, state) {
   }
 }
 function parseAlterTable(sql, state) {
-  const addColRe = /ALTER\s+TABLE\s+"(\w+)"\s+ADD\s+COLUMN\s+"(\w+)"\s+(.+?);/gi;
+  const addColRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+COLUMN\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s+(.+?);`,
+    "gi"
+  );
   let m;
   while ((m = addColRe.exec(sql)) !== null) {
-    const tableName = m[1];
-    const colName = m[2];
+    const tableName = bareName(m[1]);
+    const colName = bareName(m[2]);
     let rest = m[3];
     const table = state.tables.get(tableName);
     if (!table) continue;
@@ -8125,48 +8226,66 @@ function parseAlterTable(sql, state) {
       default: defaultVal
     });
   }
-  const dropColRe = /ALTER\s+TABLE\s+"(\w+)"\s+DROP\s+COLUMN\s+"(\w+)"/gi;
+  const dropColRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+DROP\\s+COLUMN\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
+    "gi"
+  );
   while ((m = dropColRe.exec(sql)) !== null) {
-    const table = state.tables.get(m[1]);
-    if (table) table.columns.delete(m[2]);
+    const table = state.tables.get(bareName(m[1]));
+    if (table) table.columns.delete(bareName(m[2]));
   }
-  const fkRe = /ALTER\s+TABLE\s+"(\w+)"\s+ADD\s+CONSTRAINT\s+"([^"]+)"\s+FOREIGN\s+KEY\s*\("(\w+)"\)\s+REFERENCES\s+"(\w+)"\("(\w+)"\)(?:\s+ON\s+DELETE\s+(\w+(?:\s+\w+)?))?/gi;
+  const fkRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+    "gi"
+  );
   while ((m = fkRe.exec(sql)) !== null) {
     state.fks.push({
-      constraintName: m[2],
-      sourceTable: m[1],
-      sourceColumn: m[3],
-      targetTable: m[4],
-      targetColumn: m[5],
+      constraintName: bareName(m[2]),
+      sourceTable: bareName(m[1]),
+      sourceColumn: bareName(m[3]),
+      targetTable: bareName(m[4]),
+      targetColumn: bareName(m[5]),
       onDelete: m[6] ?? null
     });
   }
 }
 function parseAlterEnum(sql, state) {
-  const re = /ALTER\s+TYPE\s+"(\w+)"\s+ADD\s+VALUE\s+'([^']+)'/gi;
+  const re = new RegExp(
+    `ALTER\\s+TYPE\\s+(${QID})\\s+ADD\\s+VALUE\\s+'([^']+)'`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const en = state.enums.get(m[1]);
+    const en = state.enums.get(bareName(m[1]));
     if (en) en.values.add(m[2]);
   }
 }
 function parseDropTable(sql, state) {
-  const re = /DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?"(\w+)"/gi;
+  const re = new RegExp(
+    `DROP\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    state.tables.delete(m[1]);
-    state.fks = state.fks.filter((fk) => fk.sourceTable !== m[1] && fk.targetTable !== m[1]);
+    const dropped = bareName(m[1]);
+    state.tables.delete(dropped);
+    state.fks = state.fks.filter((fk) => fk.sourceTable !== dropped && fk.targetTable !== dropped);
   }
 }
 function parseUniqueIndex(sql, state) {
-  const re = /CREATE\s+UNIQUE\s+INDEX\s+"[^"]+"\s+ON\s+"(\w+)"\("(\w+)"\)/gi;
+  const re = new RegExp(
+    `CREATE\\s+UNIQUE\\s+INDEX\\s+(?:(?:IF\\s+NOT\\s+EXISTS\\s+)?(?:${ID}\\s+)?)?ON\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const table = state.tables.get(m[1]);
-    const col = table?.columns.get(m[2]);
+    const tableName = bareName(m[1]);
+    const colName = bareName(m[2]);
+    const table = state.tables.get(tableName);
+    const col = table?.columns.get(colName);
     if (col) col.unique = true;
-    if (!state.uniqueIndexes.has(m[1])) state.uniqueIndexes.set(m[1], /* @__PURE__ */ new Set());
-    state.uniqueIndexes.get(m[1]).add(m[2]);
+    if (!state.uniqueIndexes.has(tableName)) state.uniqueIndexes.set(tableName, /* @__PURE__ */ new Set());
+    state.uniqueIndexes.get(tableName).add(colName);
   }
 }
 function discoverMigrationFiles(migrationsDir) {
@@ -12016,7 +12135,7 @@ function handleAuditLayer(args) {
     }
     lines.push("");
   }
-  return okText(lines.join("\n"));
+  return ok(lines.join("\n"));
 }
 function handleDetectProjectStack() {
   const rootDir = process.cwd();

package/dist/server/graph-mcp-entry.js

@@ -1767,51 +1767,147 @@ function pgTypeToPrisma(pgType) {
   const upper = pgType.toUpperCase().trim();
   return PG_TO_PRISMA[upper] ?? upper;
 }
+function bareName(captured) {
+  const parts = captured.split(".");
+  const last = parts[parts.length - 1];
+  return last.replace(/^"(.*)"$/, "$1").trim();
+}
 function parseCreateTable(sql, state) {
-  const re = /CREATE\s+TABLE\s+"(\w+)"\s*\(([\s\S]*?)\);/gi;
+  const re = new RegExp(
+    `CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s*\\(([\\s\\S]*?)\\);`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const tableName = m[1];
+    const tableName = bareName(m[1]);
     const body = m[2];
     const columns = /* @__PURE__ */ new Map();
     let primaryCol = null;
-    for (const line of body.split("\n")) {
-      const trimmed = line.trim().replace(/,\s*$/, "");
+    const inlineFks = [];
+    const lines = splitTopLevelCommas(body);
+    for (const raw of lines) {
+      const trimmed = raw.trim().replace(/,\s*$/, "");
       if (!trimmed || trimmed.startsWith("--")) continue;
-      const pkMatch = trimmed.match(/CONSTRAINT\s+"[^"]+"\s+PRIMARY\s+KEY\s*\("(\w+)"\)/i);
-      if (pkMatch) {
-        primaryCol = pkMatch[1];
+      const namedPk = trimmed.match(new RegExp(`^CONSTRAINT\\s+${ID}\\s+PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
+      if (namedPk) {
+        primaryCol = bareName(namedPk[1]);
         continue;
       }
-      if (/^\s*CONSTRAINT\s/i.test(trimmed)) continue;
-      const colMatch = trimmed.match(/^"(\w+)"\s+(.+)/);
+      const tablePk = trimmed.match(new RegExp(`^PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
+      if (tablePk) {
+        primaryCol = bareName(tablePk[1]);
+        continue;
+      }
+      if (/^UNIQUE\s*\(/i.test(trimmed)) continue;
+      const namedFk = trimmed.match(new RegExp(
+        `^CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (namedFk) {
+        inlineFks.push({
+          constraintName: bareName(namedFk[1]),
+          sourceTable: tableName,
+          sourceColumn: bareName(namedFk[2]),
+          targetTable: bareName(namedFk[3]),
+          targetColumn: bareName(namedFk[4]),
+          onDelete: namedFk[5] ?? null
+        });
+        continue;
+      }
+      const bareFk = trimmed.match(new RegExp(
+        `^FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (bareFk) {
+        inlineFks.push({
+          constraintName: `${tableName}_${bareName(bareFk[1])}_fkey`,
+          sourceTable: tableName,
+          sourceColumn: bareName(bareFk[1]),
+          targetTable: bareName(bareFk[2]),
+          targetColumn: bareName(bareFk[3]),
+          onDelete: bareFk[4] ?? null
+        });
+        continue;
+      }
+      if (/^CONSTRAINT\s/i.test(trimmed)) continue;
+      const colMatch = trimmed.match(new RegExp(`^(${ID})\\s+(.+)`, "i"));
       if (!colMatch) continue;
-      const colName = colMatch[1];
+      const colName = bareName(colMatch[1]);
       let rest = colMatch[2];
+      const inlineRefMatch = rest.match(new RegExp(
+        `\\bREFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (inlineRefMatch) {
+        inlineFks.push({
+          constraintName: `${tableName}_${colName}_fkey`,
+          sourceTable: tableName,
+          sourceColumn: colName,
+          targetTable: bareName(inlineRefMatch[1]),
+          targetColumn: bareName(inlineRefMatch[2]),
+          onDelete: inlineRefMatch[3] ?? null
+        });
+        rest = rest.replace(inlineRefMatch[0], "").trim();
+      }
       const isNotNull = /\bNOT\s+NULL\b/i.test(rest);
+      const isPrimaryKey = /\bPRIMARY\s+KEY\b/i.test(rest);
+      const isUnique = /\bUNIQUE\b/i.test(rest);
       const defaultMatch = rest.match(/\bDEFAULT\s+(.+?)(?:\s*,?\s*$)/i);
       const defaultVal = defaultMatch ? defaultMatch[1].trim() : null;
-      let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim().replace(/,\s*$/, "").trim();
+      let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bPRIMARY\s+KEY\b/gi, "").replace(/\bUNIQUE\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim().replace(/,\s*$/, "").trim();
       columns.set(colName, {
         name: colName,
         type: colType,
-        nullable: !isNotNull,
-        primary: false,
-        unique: false,
+        nullable: !isNotNull && !isPrimaryKey,
+        primary: isPrimaryKey,
+        unique: isUnique,
         default: defaultVal
       });
+      if (isPrimaryKey) primaryCol = colName;
     }
     if (primaryCol && columns.has(primaryCol)) {
       columns.get(primaryCol).primary = true;
     }
     state.tables.set(tableName, { name: tableName, columns });
+    state.fks.push(...inlineFks);
   }
 }
+function splitTopLevelCommas(body) {
+  const out = [];
+  let depth = 0;
+  let buf = "";
+  let inString = null;
+  for (const ch of body) {
+    if (inString) {
+      buf += ch;
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      inString = ch;
+      buf += ch;
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      out.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.trim()) out.push(buf);
+  return out;
+}
 function parseCreateEnum(sql, state) {
-  const re = /CREATE\s+TYPE\s+"(\w+)"\s+AS\s+ENUM\s*\(([^)]+)\)/gi;
+  const re = new RegExp(
+    `CREATE\\s+TYPE\\s+(${QID})\\s+AS\\s+ENUM\\s*\\(([^)]+)\\)`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const enumName = m[1];
+    const enumName = bareName(m[1]);
     const valuesStr = m[2];
     const values = new Set(
       valuesStr.split(",").map((v) => v.trim().replace(/^'(.*)'$/, "$1")).filter(Boolean)
@@ -1820,11 +1916,14 @@ function parseCreateEnum(sql, state) {
   }
 }
 function parseAlterTable(sql, state) {
-  const addColRe = /ALTER\s+TABLE\s+"(\w+)"\s+ADD\s+COLUMN\s+"(\w+)"\s+(.+?);/gi;
+  const addColRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+COLUMN\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s+(.+?);`,
+    "gi"
+  );
   let m;
   while ((m = addColRe.exec(sql)) !== null) {
-    const tableName = m[1];
-    const colName = m[2];
+    const tableName = bareName(m[1]);
+    const colName = bareName(m[2]);
     let rest = m[3];
     const table = state.tables.get(tableName);
     if (!table) continue;
@@ -1841,48 +1940,66 @@ function parseAlterTable(sql, state) {
       default: defaultVal
     });
   }
-  const dropColRe = /ALTER\s+TABLE\s+"(\w+)"\s+DROP\s+COLUMN\s+"(\w+)"/gi;
+  const dropColRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+DROP\\s+COLUMN\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
+    "gi"
+  );
   while ((m = dropColRe.exec(sql)) !== null) {
-    const table = state.tables.get(m[1]);
-    if (table) table.columns.delete(m[2]);
+    const table = state.tables.get(bareName(m[1]));
+    if (table) table.columns.delete(bareName(m[2]));
   }
-  const fkRe = /ALTER\s+TABLE\s+"(\w+)"\s+ADD\s+CONSTRAINT\s+"([^"]+)"\s+FOREIGN\s+KEY\s*\("(\w+)"\)\s+REFERENCES\s+"(\w+)"\("(\w+)"\)(?:\s+ON\s+DELETE\s+(\w+(?:\s+\w+)?))?/gi;
+  const fkRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+    "gi"
+  );
   while ((m = fkRe.exec(sql)) !== null) {
     state.fks.push({
-      constraintName: m[2],
-      sourceTable: m[1],
-      sourceColumn: m[3],
-      targetTable: m[4],
-      targetColumn: m[5],
+      constraintName: bareName(m[2]),
+      sourceTable: bareName(m[1]),
+      sourceColumn: bareName(m[3]),
+      targetTable: bareName(m[4]),
+      targetColumn: bareName(m[5]),
       onDelete: m[6] ?? null
     });
   }
 }
 function parseAlterEnum(sql, state) {
-  const re = /ALTER\s+TYPE\s+"(\w+)"\s+ADD\s+VALUE\s+'([^']+)'/gi;
+  const re = new RegExp(
+    `ALTER\\s+TYPE\\s+(${QID})\\s+ADD\\s+VALUE\\s+'([^']+)'`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const en = state.enums.get(m[1]);
+    const en = state.enums.get(bareName(m[1]));
     if (en) en.values.add(m[2]);
   }
 }
 function parseDropTable(sql, state) {
-  const re = /DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?"(\w+)"/gi;
+  const re = new RegExp(
+    `DROP\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    state.tables.delete(m[1]);
-    state.fks = state.fks.filter((fk) => fk.sourceTable !== m[1] && fk.targetTable !== m[1]);
+    const dropped = bareName(m[1]);
+    state.tables.delete(dropped);
+    state.fks = state.fks.filter((fk) => fk.sourceTable !== dropped && fk.targetTable !== dropped);
   }
 }
 function parseUniqueIndex(sql, state) {
-  const re = /CREATE\s+UNIQUE\s+INDEX\s+"[^"]+"\s+ON\s+"(\w+)"\("(\w+)"\)/gi;
+  const re = new RegExp(
+    `CREATE\\s+UNIQUE\\s+INDEX\\s+(?:(?:IF\\s+NOT\\s+EXISTS\\s+)?(?:${ID}\\s+)?)?ON\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const table = state.tables.get(m[1]);
-    const col = table?.columns.get(m[2]);
+    const tableName = bareName(m[1]);
+    const colName = bareName(m[2]);
+    const table = state.tables.get(tableName);
+    const col = table?.columns.get(colName);
     if (col) col.unique = true;
-    if (!state.uniqueIndexes.has(m[1])) state.uniqueIndexes.set(m[1], /* @__PURE__ */ new Set());
-    state.uniqueIndexes.get(m[1]).add(m[2]);
+    if (!state.uniqueIndexes.has(tableName)) state.uniqueIndexes.set(tableName, /* @__PURE__ */ new Set());
+    state.uniqueIndexes.get(tableName).add(colName);
   }
 }
 function discoverMigrationFiles(migrationsDir) {
@@ -2168,7 +2285,7 @@ function generate3(rootDir) {
     flagged_edges: flaggedEdges
   };
 }
-var import_node_fs8, import_node_path7, PG_TO_PRISMA, sqlMigrationsParser;
+var import_node_fs8, import_node_path7, PG_TO_PRISMA, ID, QID, sqlMigrationsParser;
 var init_sql_migrations = __esm({
   "src/server/graph/parsers/db/sql-migrations.ts"() {
     "use strict";
@@ -2202,6 +2319,8 @@ var init_sql_migrations = __esm({
       "UUID": "String",
       "TEXT[]": "String[]"
     };
+    ID = `(?:"[\\w$]+"|[\\w$]+)`;
+    QID = `(?:${ID}\\.)?${ID}`;
     sqlMigrationsParser = {
       id: "sql-migrations",
       layer: "db",
@@ -5923,7 +6042,7 @@ function handleAuditLayer(args) {
     }
     lines.push("");
   }
-  return okText(lines.join("\n"));
+  return ok(lines.join("\n"));
 }
 function handleDetectProjectStack() {
   const rootDir = process.cwd();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@launchsecure/launch-kit",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "LaunchSecure toolkit — launch-pod (pipeline), launch-chart (project graph MCP), launch-deck (visual playground MCP).",
   "license": "MIT",
   "author": "LaunchSecure - AutomateWithUs",