metal-orm 1.1.28 → 1.1.29

package/dist/index.cjs

@@ -11642,7 +11642,10 @@ var renderColumnDefinition = (table, col2, dialect, options = {}) => {
     parts.push(`CHECK (${col2.check})`);
   }
   if (col2.references) {
-    parts.push(dialect.renderReference(col2.references, table));
+    const referenceSql = dialect.renderReference(col2.references, table);
+    parts.push(
+      col2.references.name ? `CONSTRAINT ${dialect.quoteIdentifier(col2.references.name)} ${referenceSql}` : referenceSql
+    );
   }
   return { sql: parts.join(" "), inlinePrimary: !!(options.includePrimary && col2.primary) };
 };
@@ -11763,6 +11766,11 @@ var normalizeDefault = (value) => {
   if (value === void 0 || value === null) return void 0;
   return String(value).trim();
 };
+var normalizeReferenceAction = (value) => (value || "NO ACTION").toUpperCase().replace(/\s+/g, " ").trim();
+var sameReference = (expected, actual) => {
+  if (!expected || !actual) return expected === actual;
+  return expected.table === actual.table && expected.column === actual.column && expected.name === actual.name && normalizeReferenceAction(expected.onDelete) === normalizeReferenceAction(actual.onDelete) && normalizeReferenceAction(expected.onUpdate) === normalizeReferenceAction(actual.onUpdate) && !!expected.deferrable === !!actual.deferrable;
+};
 var diffColumn = (expected, actual, dialect) => {
   const expectedType = normalizeType(dialect.renderColumnType(expected));
   const actualType = normalizeType(actual.type);
@@ -11772,7 +11780,8 @@ var diffColumn = (expected, actual, dialect) => {
     typeChanged: expectedType !== actualType,
     nullabilityChanged: !!expected.notNull !== !!actual.notNull,
     defaultChanged: expectedDefault !== actualDefault,
-    autoIncrementChanged: !!expected.autoIncrement !== !!actual.autoIncrement
+    autoIncrementChanged: !!expected.autoIncrement !== !!actual.autoIncrement,
+    referenceChanged: !sameReference(expected.references, actual.references)
   };
 };
 var unsupportedMutationWarning = (dialect, operation, target) => `Dialect "${dialect.name}" does not provide the ${operation} capability for ${target}; manual migration is required.`;
@@ -11809,6 +11818,11 @@ var diffSchema = (expectedTables, actualSchema, dialect, options = {}) => {
       const expectedColumn = table.columns[columnName];
       const actualColumn = actualColumns.get(columnName);
       const columnDiff = diffColumn(expectedColumn, actualColumn, dialect);
+      if (columnDiff.referenceChanged) {
+        plan.warnings.push(
+          `Foreign key definition on ${key}.${columnName} differs from the expected schema; manual constraint migration is required.`
+        );
+      }
       const shouldAlter = columnDiff.typeChanged || columnDiff.nullabilityChanged || columnDiff.defaultChanged || columnDiff.autoIncrementChanged;
       if (shouldAlter) {
         const capability = dialect.mutations.alterColumn;
@@ -12890,6 +12904,288 @@ var mysqlIntrospector = {
   }
 };
 
+// src/core/ddl/introspect/sqlite-foreign-key-ddl.ts
+var isIdentifierChar = (value) => /[A-Za-z0-9_]/.test(value);
+var keywordAt = (text, position2, keyword) => {
+  if (position2 < 0 || position2 + keyword.length > text.length) return false;
+  if (position2 > 0 && isIdentifierChar(text[position2 - 1])) return false;
+  if (position2 + keyword.length < text.length && isIdentifierChar(text[position2 + keyword.length])) {
+    return false;
+  }
+  return text.slice(position2, position2 + keyword.length).toUpperCase() === keyword.toUpperCase();
+};
+var skipWhitespace = (text, position2) => {
+  let pos = position2;
+  while (pos < text.length && /\s/.test(text[pos])) pos += 1;
+  return pos;
+};
+var readIdentifier = (text, position2) => {
+  let pos = skipWhitespace(text, position2);
+  if (pos >= text.length) return void 0;
+  const quote = text[pos];
+  if (quote === '"' || quote === "`" || quote === "[") {
+    const close = quote === "[" ? "]" : quote;
+    pos += 1;
+    let value = "";
+    while (pos < text.length) {
+      const current = text[pos++];
+      if (current === close) {
+        if (pos < text.length && text[pos] === close) {
+          value += close;
+          pos += 1;
+          continue;
+        }
+        return { value, next: pos };
+      }
+      value += current;
+    }
+    return void 0;
+  }
+  const start = pos;
+  while (pos < text.length && !/\s/.test(text[pos]) && text[pos] !== "(" && text[pos] !== ")" && text[pos] !== ",") {
+    pos += 1;
+  }
+  if (pos === start) return void 0;
+  return { value: text.slice(start, pos), next: pos };
+};
+var splitTableBody = (createSql) => {
+  const open = createSql.indexOf("(");
+  if (open < 0) return [];
+  let depth = 1;
+  let quote = "";
+  let bracket = false;
+  let lineComment = false;
+  let blockComment = false;
+  let close = -1;
+  for (let i = open + 1; i < createSql.length; i += 1) {
+    const current = createSql[i];
+    const next = createSql[i + 1] ?? "";
+    if (lineComment) {
+      if (current === "\n" || current === "\r") lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (current === "*" && next === "/") {
+        blockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (current === quote) {
+        if (next === quote) i += 1;
+        else quote = "";
+      }
+      continue;
+    }
+    if (bracket) {
+      if (current === "]") {
+        if (next === "]") i += 1;
+        else bracket = false;
+      }
+      continue;
+    }
+    if (current === "-" && next === "-") {
+      lineComment = true;
+      i += 1;
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      blockComment = true;
+      i += 1;
+      continue;
+    }
+    if (current === "'" || current === '"' || current === "`") {
+      quote = current;
+      continue;
+    }
+    if (current === "[") {
+      bracket = true;
+      continue;
+    }
+    if (current === "(") depth += 1;
+    else if (current === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        close = i;
+        break;
+      }
+    }
+  }
+  if (close < 0) return [];
+  const body = createSql.slice(open + 1, close);
+  const segments = [];
+  let start = 0;
+  depth = 0;
+  quote = "";
+  bracket = false;
+  lineComment = false;
+  blockComment = false;
+  for (let i = 0; i < body.length; i += 1) {
+    const current = body[i];
+    const next = body[i + 1] ?? "";
+    if (lineComment) {
+      if (current === "\n" || current === "\r") lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (current === "*" && next === "/") {
+        blockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (current === quote) {
+        if (next === quote) i += 1;
+        else quote = "";
+      }
+      continue;
+    }
+    if (bracket) {
+      if (current === "]") {
+        if (next === "]") i += 1;
+        else bracket = false;
+      }
+      continue;
+    }
+    if (current === "-" && next === "-") {
+      lineComment = true;
+      i += 1;
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      blockComment = true;
+      i += 1;
+      continue;
+    }
+    if (current === "'" || current === '"' || current === "`") {
+      quote = current;
+      continue;
+    }
+    if (current === "[") {
+      bracket = true;
+      continue;
+    }
+    if (current === "(") depth += 1;
+    else if (current === ")" && depth > 0) depth -= 1;
+    else if (current === "," && depth === 0) {
+      segments.push(body.slice(start, i).trim());
+      start = i + 1;
+    }
+  }
+  segments.push(body.slice(start).trim());
+  return segments.filter(Boolean);
+};
+var findTopLevelKeyword = (text, keyword, start = 0) => {
+  let depth = 0;
+  let quote = "";
+  let bracket = false;
+  for (let i = start; i < text.length; i += 1) {
+    const current = text[i];
+    const next = text[i + 1] ?? "";
+    if (quote) {
+      if (current === quote) {
+        if (next === quote) i += 1;
+        else quote = "";
+      }
+      continue;
+    }
+    if (bracket) {
+      if (current === "]") {
+        if (next === "]") i += 1;
+        else bracket = false;
+      }
+      continue;
+    }
+    if (current === "'" || current === '"' || current === "`") {
+      quote = current;
+      continue;
+    }
+    if (current === "[") {
+      bracket = true;
+      continue;
+    }
+    if (current === "(") {
+      depth += 1;
+      continue;
+    }
+    if (current === ")") {
+      if (depth > 0) depth -= 1;
+      continue;
+    }
+    if (depth === 0 && keywordAt(text, i, keyword)) return i;
+  }
+  return -1;
+};
+var isInitiallyDeferred = (segment, start) => {
+  const deferrablePos = findTopLevelKeyword(segment, "DEFERRABLE", start);
+  if (deferrablePos < 0) return false;
+  const before = segment.slice(start, deferrablePos).trimEnd();
+  if (/\bNOT$/i.test(before)) return false;
+  return /^DEFERRABLE\s+INITIALLY\s+DEFERRED\b/i.test(segment.slice(deferrablePos));
+};
+var parseTableForeignKey = (segment) => {
+  let pos = skipWhitespace(segment, 0);
+  let name;
+  if (keywordAt(segment, pos, "CONSTRAINT")) {
+    pos += "CONSTRAINT".length;
+    const parsedName = readIdentifier(segment, pos);
+    if (!parsedName) return void 0;
+    name = parsedName.value;
+    pos = skipWhitespace(segment, parsedName.next);
+  }
+  if (!keywordAt(segment, pos, "FOREIGN")) return void 0;
+  pos += "FOREIGN".length;
+  pos = skipWhitespace(segment, pos);
+  if (!keywordAt(segment, pos, "KEY")) return void 0;
+  pos += "KEY".length;
+  pos = skipWhitespace(segment, pos);
+  if (segment[pos] !== "(") return void 0;
+  pos += 1;
+  const source = readIdentifier(segment, pos);
+  if (!source) return void 0;
+  pos = skipWhitespace(segment, source.next);
+  if (segment[pos] === ",") return void 0;
+  const referencesPos = findTopLevelKeyword(segment, "REFERENCES", pos);
+  if (referencesPos < 0) return void 0;
+  return {
+    column: source.value,
+    ...name ? { name } : {},
+    deferrable: isInitiallyDeferred(segment, referencesPos)
+  };
+};
+var parseInlineForeignKey = (segment) => {
+  const source = readIdentifier(segment, 0);
+  if (!source) return void 0;
+  const referencesPos = findTopLevelKeyword(segment, "REFERENCES", source.next);
+  if (referencesPos < 0) return void 0;
+  let name;
+  const constraintPos = findTopLevelKeyword(segment, "CONSTRAINT", source.next);
+  if (constraintPos >= 0 && constraintPos < referencesPos) {
+    const parsedName = readIdentifier(segment, constraintPos + "CONSTRAINT".length);
+    if (parsedName) name = parsedName.value;
+  }
+  return {
+    column: source.value,
+    ...name ? { name } : {},
+    deferrable: isInitiallyDeferred(segment, referencesPos)
+  };
+};
+var parseSqliteForeignKeyModifiers = (createSql) => {
+  const result = [];
+  for (const segment of splitTableBody(createSql)) {
+    const tableConstraint = parseTableForeignKey(segment);
+    if (tableConstraint) {
+      result.push(tableConstraint);
+      continue;
+    }
+    const inlineConstraint = parseInlineForeignKey(segment);
+    if (inlineConstraint) result.push(inlineConstraint);
+  }
+  return result;
+};
+
 // src/core/ddl/introspect/sqlite.ts
 var toReferentialAction = (value) => {
   if (!value) return void 0;
@@ -12907,7 +13203,7 @@ var columnNode2 = (table, name, alias) => ({
 });
 var buildPragmaQuery = (name, table, alias, columnAliases) => ({
   type: "SelectQuery",
-  from: fnTable(name, [valueToOperand(table)], alias, { columnAliases }),
+  from: fnTable(name, [valueToOperand(table)], alias),
   columns: columnAliases.map((column) => columnNode2(alias, column)),
   joins: []
 });
@@ -12968,7 +13264,10 @@ var sqliteIntrospector = {
     const tablesQuery = {
       type: "SelectQuery",
       from: { type: "Table", name: "sqlite_master" },
-      columns: [columnNode2(alias, "name")],
+      columns: [
+        columnNode2(alias, "name"),
+        columnNode2(alias, "sql")
+      ],
       joins: [],
       where: and(
         eq(columnNode2(alias, "type"), "table"),
@@ -13038,6 +13337,14 @@ var sqliteIntrospector = {
           };
         }
       });
+      if (row.sql) {
+        for (const modifier of parseSqliteForeignKeyModifiers(row.sql)) {
+          const reference = tableEntry.columns.find((column) => column.name === modifier.column)?.references;
+          if (!reference) continue;
+          if (modifier.name) reference.name = modifier.name;
+          reference.deferrable = modifier.deferrable;
+        }
+      }
       for (const idx of indexList) {
         if (!idx.name) continue;
         const indexColumns = await runPragma(
@@ -14261,6 +14568,7 @@ var createSqliteSchemaDialect = () => composeSchemaDialect({
     void table;
     return !!(column.autoIncrement && primaryKey.length === 1 && primaryKey[0] === column.name);
   },
+  renderReferenceSuffix: (ref) => ref.deferrable ? "DEFERRABLE INITIALLY DEFERRED" : void 0,
   renderIndex(table, index, services) {
     const name = index.name || deriveIndexName(table, index);
     const columns = renderIndexColumns(services, index.columns);