@restura/core 2.0.0 → 2.0.1

package/dist/index.js

@@ -2858,7 +2858,11 @@ async function getNewPublicSchemaAndScratchPool(targetPool, scratchDbName) {
     connectionTimeoutMillis: targetPool.poolConfig.connectionTimeoutMillis
   });
   await scratchPool.runQuery(`DROP SCHEMA public CASCADE;`, [], systemUser);
-  await scratchPool.runQuery(`CREATE SCHEMA public AUTHORIZATION ${escapeColumnName(targetPool.poolConfig.user)};`, [], systemUser);
+  await scratchPool.runQuery(
+    `CREATE SCHEMA public AUTHORIZATION ${escapeColumnName(targetPool.poolConfig.user)};`,
+    [],
+    systemUser
+  );
   const schemaComment = await targetPool.runQuery(
     `
 		SELECT pg_description.description
@@ -2869,7 +2873,8 @@ async function getNewPublicSchemaAndScratchPool(targetPool, scratchDbName) {
     systemUser
   );
   if (schemaComment[0]?.description) {
-    await scratchPool.runQuery(`COMMENT ON SCHEMA public IS $1;`, [schemaComment[0].description], systemUser);
+    const escaped = schemaComment[0].description.replace(/'/g, "''");
+    await scratchPool.runQuery(`COMMENT ON SCHEMA public IS '${escaped}';`, [], systemUser);
   }
   return scratchPool;
 }
@@ -2989,11 +2994,9 @@ var PsqlEngine = class extends SqlEngine {
     });
     try {
       await this.triggerClient.connect();
-      const promises = [];
-      promises.push(this.triggerClient.query("LISTEN insert"));
-      promises.push(this.triggerClient.query("LISTEN update"));
-      promises.push(this.triggerClient.query("LISTEN delete"));
-      await Promise.all(promises);
+      for (const channel of ["insert", "update", "delete"]) {
+        await this.triggerClient.query(`LISTEN ${channel}`);
+      }
       this.triggerClient.on("error", async (error) => {
         logger.error(`Trigger client error: ${error}`);
         await this.reconnectTriggerClient();
@@ -3996,7 +3999,7 @@ function diffSchemaToDatabase(schema, snapshot) {
   const changedChecksPerTable = /* @__PURE__ */ new Map();
   for (const desired of tablesToAlter) {
     const live = liveTableMap.get(desired.name);
-    const desiredFkNames = new Set(desired.foreignKeys.map((fk) => fk.name));
+    const desiredFkNames = new Set(desired.foreignKeys.map((fk) => pgTruncate(fk.name)));
     for (const liveFk of live.foreignKeys) {
       if (!desiredFkNames.has(liveFk.name) || isFkChanged(desired, liveFk)) {
         statements.push(`ALTER TABLE "${desired.name}" DROP CONSTRAINT "${liveFk.name}";`);
@@ -4004,11 +4007,14 @@ function diffSchemaToDatabase(schema, snapshot) {
     }
     const desiredCheckExprMap = /* @__PURE__ */ new Map();
     for (const check of desired.checkConstraints) {
-      desiredCheckExprMap.set(check.name, check.check);
+      desiredCheckExprMap.set(pgTruncate(check.name), check.check);
     }
     for (const col of desired.columns) {
       if (col.type === "ENUM" && col.value) {
-        desiredCheckExprMap.set(`${desired.name}_${col.name}_check`, `"${col.name}" IN (${col.value})`);
+        desiredCheckExprMap.set(
+          pgTruncate(`${desired.name}_${col.name}_check`),
+          `"${col.name}" IN (${col.value})`
+        );
       }
     }
     const changedChecks = /* @__PURE__ */ new Set();
@@ -4024,18 +4030,27 @@ function diffSchemaToDatabase(schema, snapshot) {
     const desiredIdxSignatures = /* @__PURE__ */ new Map();
     for (const idx of desired.indexes) {
       if (idx.isPrimaryKey) continue;
-      desiredIdxSignatures.set(idx.name, indexSignature(idx.name, idx.columns, idx.isUnique, idx.order, idx.where));
+      desiredIdxSignatures.set(
+        pgTruncate(idx.name),
+        indexSignature(pgTruncate(idx.name), idx.columns, idx.isUnique, idx.order, idx.where)
+      );
     }
     const autoUniqueNames = /* @__PURE__ */ new Set();
     for (const col of desired.columns) {
       if (col.isUnique) {
-        autoUniqueNames.add(`${desired.name}_${col.name}_unique_index`);
+        autoUniqueNames.add(pgTruncate(`${desired.name}_${col.name}_unique_index`));
       }
     }
     for (const liveIdx of live.indexes) {
       if (liveIdx.isPrimary) continue;
       if (autoUniqueNames.has(liveIdx.name)) continue;
-      const liveSig = indexSignature(liveIdx.name, liveIdx.columns, liveIdx.isUnique, liveIdx.order, liveIdx.where);
+      const liveSig = indexSignature(
+        liveIdx.name,
+        liveIdx.columns,
+        liveIdx.isUnique,
+        liveIdx.order,
+        liveIdx.where
+      );
       const desiredSig = desiredIdxSignatures.get(liveIdx.name);
       if (!desiredSig || desiredSig !== liveSig) {
         statements.push(`DROP INDEX "${liveIdx.name}";`);
@@ -4065,8 +4080,14 @@ function diffSchemaToDatabase(schema, snapshot) {
     }
     for (const index of desired.indexes) {
       if (index.isPrimaryKey) continue;
-      const desiredSig = indexSignature(index.name, index.columns, index.isUnique, index.order, index.where);
-      const liveSig = liveIdxSignatures.get(index.name);
+      const desiredSig = indexSignature(
+        pgTruncate(index.name),
+        index.columns,
+        index.isUnique,
+        index.order,
+        index.where
+      );
+      const liveSig = liveIdxSignatures.get(pgTruncate(index.name));
       if (!liveSig || liveSig !== desiredSig) {
         statements.push(buildCreateIndex(desired.name, index));
       }
@@ -4083,9 +4104,9 @@ function diffSchemaToDatabase(schema, snapshot) {
     const live = liveTableMap.get(desired.name);
     const liveFkNames = new Set(live.foreignKeys.map((fk) => fk.name));
     for (const fk of desired.foreignKeys) {
-      if (!liveFkNames.has(fk.name) || isFkChanged(
+      if (!liveFkNames.has(pgTruncate(fk.name)) || isFkChanged(
         desired,
-        liveTableMap.get(desired.name).foreignKeys.find((liveFk) => liveFk.name === fk.name)
+        liveTableMap.get(desired.name).foreignKeys.find((liveFk) => liveFk.name === pgTruncate(fk.name))
       )) {
         statements.push(buildAddForeignKey(desired.name, fk));
       }
@@ -4096,13 +4117,13 @@ function diffSchemaToDatabase(schema, snapshot) {
     const liveCheckNames = new Set(live.checkConstraints.map((check) => check.name));
     const changedChecks = changedChecksPerTable.get(desired.name) ?? /* @__PURE__ */ new Set();
     for (const check of desired.checkConstraints) {
-      if (!liveCheckNames.has(check.name) || changedChecks.has(check.name)) {
+      if (!liveCheckNames.has(pgTruncate(check.name)) || changedChecks.has(pgTruncate(check.name))) {
         statements.push(buildAddCheckConstraint(desired.name, check));
       }
     }
     for (const col of desired.columns) {
       if (col.type === "ENUM" && col.value) {
-        const checkName = `${desired.name}_${col.name}_check`;
+        const checkName = pgTruncate(`${desired.name}_${col.name}_check`);
         if (!liveCheckNames.has(checkName) || changedChecks.has(checkName)) {
           statements.push(
             `ALTER TABLE "${desired.name}" ADD CONSTRAINT "${checkName}" CHECK ("${col.name}" IN (${col.value}));`
@@ -4154,8 +4175,8 @@ function diffColumns(desired, live, statements) {
   }
 }
 function topologicalSortTables(tables) {
-  const tableNames = new Set(tables.map((t) => t.name));
-  const tableMap = new Map(tables.map((t) => [t.name, t]));
+  const tableNames = new Set(tables.map((table) => table.name));
+  const tableMap = new Map(tables.map((table) => [table.name, table]));
   const inDegree = /* @__PURE__ */ new Map();
   const tableDeps = /* @__PURE__ */ new Map();
   const reverseDeps = /* @__PURE__ */ new Map();
@@ -4189,7 +4210,7 @@ function topologicalSortTables(tables) {
   }
   const sortedSet = new Set(sorted);
   const deferredFkNames = /* @__PURE__ */ new Set();
-  const cycleTables = tables.filter((t) => !sortedSet.has(t.name));
+  const cycleTables = tables.filter((table) => !sortedSet.has(table.name));
   const placed = new Set(sorted);
   for (const table of cycleTables) {
     sorted.push(table.name);
@@ -4207,7 +4228,8 @@ function buildCreateTable(table, deferredFkNames = /* @__PURE__ */ new Set()) {
   for (const column of table.columns) {
     let definition = `"${column.name}" ${buildColumnType(column)}`;
     if (column.isPrimary) definition += " PRIMARY KEY";
-    if (column.isUnique) definition += ` CONSTRAINT "${table.name}_${column.name}_unique_index" UNIQUE`;
+    if (column.isUnique)
+      definition += ` CONSTRAINT "${pgTruncate(`${table.name}_${column.name}_unique_index`)}" UNIQUE`;
     if (!column.isNullable) definition += " NOT NULL";
     else definition += " NULL";
     if (column.default) definition += ` DEFAULT ${column.default}`;
@@ -4216,16 +4238,16 @@ function buildCreateTable(table, deferredFkNames = /* @__PURE__ */ new Set()) {
   for (const fk of table.foreignKeys) {
     if (deferredFkNames.has(fk.name)) continue;
     definitions.push(
-      `CONSTRAINT "${fk.name}" FOREIGN KEY ("${fk.column}") REFERENCES "${fk.refTable}" ("${fk.refColumn}") ON DELETE ${fk.onDelete} ON UPDATE ${fk.onUpdate}`
+      `CONSTRAINT "${pgTruncate(fk.name)}" FOREIGN KEY ("${fk.column}") REFERENCES "${fk.refTable}" ("${fk.refColumn}") ON DELETE ${fk.onDelete} ON UPDATE ${fk.onUpdate}`
     );
   }
   for (const check of table.checkConstraints) {
-    definitions.push(`CONSTRAINT "${check.name}" CHECK (${check.check})`);
+    definitions.push(`CONSTRAINT "${pgTruncate(check.name)}" CHECK (${check.check})`);
   }
   for (const col of table.columns) {
     if (col.type === "ENUM" && col.value) {
       definitions.push(
-        `CONSTRAINT "${table.name}_${col.name}_check" CHECK ("${col.name}" IN (${col.value}))`
+        `CONSTRAINT "${pgTruncate(`${table.name}_${col.name}_check`)}" CHECK ("${col.name}" IN (${col.value}))`
       );
     }
   }
@@ -4249,7 +4271,7 @@ function buildColumnType(column) {
 function buildAddColumn(tableName, column) {
   let definition = `ALTER TABLE "${tableName}" ADD COLUMN "${column.name}" ${buildColumnType(column)}`;
   if (column.isPrimary) definition += " PRIMARY KEY";
-  if (column.isUnique) definition += ` CONSTRAINT "${tableName}_${column.name}_unique_index" UNIQUE`;
+  if (column.isUnique) definition += ` CONSTRAINT "${pgTruncate(`${tableName}_${column.name}_unique_index`)}" UNIQUE`;
   if (!column.isNullable) definition += " NOT NULL";
   else definition += " NULL";
   if (column.default) definition += ` DEFAULT ${column.default}`;
@@ -4258,36 +4280,87 @@ function buildAddColumn(tableName, column) {
 }
 function buildCreateIndex(tableName, index) {
   const unique = index.isUnique ? "UNIQUE " : "";
-  let sql = `CREATE ${unique}INDEX "${index.name}" ON "${tableName}" (${index.columns.map((column) => `"${column}" ${index.order}`).join(", ")})`;
+  let sql = `CREATE ${unique}INDEX "${pgTruncate(index.name)}" ON "${tableName}" (${index.columns.map((column) => `"${column}" ${index.order}`).join(", ")})`;
   if (index.where) sql += ` WHERE ${index.where}`;
   sql += ";";
   return sql;
 }
 function buildAddForeignKey(tableName, foreignKey) {
-  return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${foreignKey.name}" FOREIGN KEY ("${foreignKey.column}") REFERENCES "${foreignKey.refTable}" ("${foreignKey.refColumn}") ON DELETE ${foreignKey.onDelete} ON UPDATE ${foreignKey.onUpdate};`;
+  return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${pgTruncate(foreignKey.name)}" FOREIGN KEY ("${foreignKey.column}") REFERENCES "${foreignKey.refTable}" ("${foreignKey.refColumn}") ON DELETE ${foreignKey.onDelete} ON UPDATE ${foreignKey.onUpdate};`;
 }
 function buildAddCheckConstraint(tableName, constraint) {
-  return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${constraint.name}" CHECK (${constraint.check});`;
+  return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${pgTruncate(constraint.name)}" CHECK (${constraint.check});`;
+}
+function lowercaseOutsideStrings(s) {
+  return s.replace(/'(?:[^']|'')*'|[^']+/g, (match) => {
+    if (match.startsWith("'")) return match;
+    return match.toLowerCase();
+  });
+}
+function stripLeafParens(expr) {
+  let prev = "";
+  let curr = expr;
+  while (prev !== curr) {
+    prev = curr;
+    curr = curr.replace(/\(([^()]*)\)/g, (match, inner) => {
+      if (/\b(?:and|or)\b/i.test(inner)) return match;
+      return inner;
+    });
+  }
+  return curr;
+}
+function normalizeWhere(whereExpr) {
+  if (!whereExpr) return "";
+  let normalized = whereExpr.replace(/::\w+(\[\])?/g, "").replace(/"(\w+)"/g, "$1").replace(/\((\w+)\)/g, "$1").replace(/\s+/g, " ").trim();
+  normalized = lowercaseOutsideStrings(normalized);
+  while (normalized.startsWith("(") && normalized.endsWith(")")) {
+    const inner = normalized.slice(1, -1);
+    let depth = 0;
+    let balanced = true;
+    for (const char of inner) {
+      if (char === "(") depth++;
+      if (char === ")") depth--;
+      if (depth < 0) {
+        balanced = false;
+        break;
+      }
+    }
+    if (balanced && depth === 0) normalized = inner.trim();
+    else break;
+  }
+  normalized = stripLeafParens(normalized);
+  return normalized;
 }
 function indexSignature(name, columns, isUnique, order, where) {
-  return `${name}|${columns.join(",")}|${isUnique}|${order}|${where || ""}`;
+  return `${name}|${columns.join(",")}|${isUnique}|${order}|${normalizeWhere(where)}`;
 }
 function isFkChanged(desired, liveFk) {
-  const desiredFk = desired.foreignKeys.find((fk) => fk.name === liveFk.name);
+  const desiredFk = desired.foreignKeys.find((fk) => pgTruncate(fk.name) === liveFk.name);
   if (!desiredFk) return true;
   return desiredFk.column !== liveFk.column || desiredFk.refTable !== liveFk.refTable || desiredFk.refColumn !== liveFk.refColumn || desiredFk.onDelete !== liveFk.onDelete || desiredFk.onUpdate !== liveFk.onUpdate;
 }
+var PG_MAX_IDENTIFIER = 63;
+function pgTruncate(name) {
+  const buf = Buffer.from(name, "utf8");
+  if (buf.length <= PG_MAX_IDENTIFIER) return name;
+  let end = PG_MAX_IDENTIFIER;
+  while (end > 0 && (buf[end] & 192) === 128) end--;
+  return buf.subarray(0, end).toString("utf8");
+}
 function normalizeCheckExpression(expr) {
-  let s = expr;
-  const checkMatch = s.match(/^CHECK\s*\(([\s\S]*)\)\s*$/i);
-  if (checkMatch) s = checkMatch[1];
-  s = s.replace(/::\w+(\[\])?/g, "");
-  s = s.replace(/=\s*ANY\s*\(\s*\(?\s*ARRAY\s*\[([^\]]*)\]\s*\)?\s*\)/gi, "IN ($1)");
-  s = s.replace(/"(\w+)"/g, "$1");
-  s = s.replace(/\((\w+)\)/g, "$1");
-  s = s.replace(/\s+/g, " ").trim().toLowerCase();
-  while (s.startsWith("(") && s.endsWith(")")) {
-    const inner = s.slice(1, -1);
+  let normalized = expr;
+  const checkMatch = normalized.match(/^CHECK\s*\(([\s\S]*)\)\s*$/i);
+  if (checkMatch) normalized = checkMatch[1];
+  normalized = normalized.replace(/::\w+(\[\])?/g, "");
+  normalized = normalized.replace(/=\s*ANY\s*\(\s*\(\s*ARRAY\s*\[([^\]]*)\]\s*\)\s*\)/gi, "IN ($1)");
+  normalized = normalized.replace(/=\s*ANY\s*\(\s*ARRAY\s*\[([^\]]*)\]\s*\)/gi, "IN ($1)");
+  normalized = normalized.replace(/"(\w+)"/g, "$1");
+  normalized = normalized.replace(/\((\w+)\)/g, "$1");
+  normalized = normalized.replace(/\s+/g, " ").trim();
+  normalized = lowercaseOutsideStrings(normalized);
+  normalized = normalized.replace(/<>/g, "!=");
+  while (normalized.startsWith("(") && normalized.endsWith(")")) {
+    const inner = normalized.slice(1, -1);
     let depth = 0;
     let balanced = true;
     for (const char of inner) {
@@ -4298,11 +4371,12 @@ function normalizeCheckExpression(expr) {
         break;
       }
     }
-    if (balanced && depth === 0) s = inner.trim();
+    if (balanced && depth === 0) normalized = inner.trim();
     else break;
   }
-  s = s.replace(/\s*,\s*/g, ", ");
-  return s;
+  normalized = stripLeafParens(normalized);
+  normalized = normalized.replace(/\s*,\s*/g, ", ");
+  return normalized;
 }
 function isSerialMatch(column, liveCol) {
   if (column.hasAutoIncrement || column.type === "BIGSERIAL" || column.type === "SERIAL") {
@@ -4315,7 +4389,7 @@ function modifiersDiffer(column, liveColumn) {
   const desiredLength = column.length ?? null;
   if (desiredLength !== liveColumn.characterMaximumLength) return true;
   if (column.type === "DECIMAL" && column.value) {
-    const parts = column.value.replace(/['"]/g, "").split("-");
+    const parts = column.value.replace(/['"]/g, "").split(/[-,]/);
     const desiredPrecision = parseInt(parts[0], 10);
     const desiredScale = parts.length > 1 ? parseInt(parts[1], 10) : 0;
     if (liveColumn.numericPrecision !== desiredPrecision || liveColumn.numericScale !== desiredScale) return true;
@@ -4350,8 +4424,8 @@ function defaultsMatch(desired, live, column) {
   if (column.hasAutoIncrement || column.type === "BIGSERIAL" || column.type === "SERIAL") return true;
   if (desired === null && live === null) return true;
   if (desired === null || live === null) return false;
-  const normalizedLive = live.replace(/::[^\s]+$/g, "").trim();
-  return desired.trim() === normalizedLive;
+  const normalizedLive = live.replace(/::[a-z][a-z0-9_ ]*(\[\])?$/gi, "").trim();
+  return lowercaseOutsideStrings(desired.trim()) === lowercaseOutsideStrings(normalizedLive);
 }
 
 // src/restura/sql/PsqlTransaction.ts