metal-orm 1.1.28 → 1.1.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.1.28",
+  "version": "1.1.29",
   "type": "module",
   "repository": {
     "type": "git",

package/src/core/ddl/dialects/render-reference.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { composeSchemaDialect } from '../schema-dialect-composer.js';
 import { PostgresSchemaDialect } from './postgres-schema-dialect.js';
+import { SQLiteSchemaDialect } from './sqlite-schema-dialect.js';
 import type { TableDef } from '../../../schema/table.js';
 import type { ForeignKeyReference } from '../../../schema/column-types.js';
 import { createLiteralFormatter } from '../sql-writing.js';
@@ -42,9 +43,21 @@ describe('renderReference deferrable handling', () => {
     expect(sql).toContain('DEFERRABLE INITIALLY DEFERRED');
   });
 
+  it('SQLite dialect renders the deferrable clause', () => {
+    const dialect = new SQLiteSchemaDialect();
+    const sql = dialect.renderReference(deferrableReference, table);
+    expect(sql).toContain('DEFERRABLE INITIALLY DEFERRED');
+  });
+
   it('Postgres dialect skips the clause when the flag is missing', () => {
     const dialect = new PostgresSchemaDialect();
     const sql = dialect.renderReference({ table: 'parent', column: 'id' }, table);
     expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
   });
+
+  it('SQLite dialect skips the clause when the flag is missing', () => {
+    const dialect = new SQLiteSchemaDialect();
+    const sql = dialect.renderReference({ table: 'parent', column: 'id' }, table);
+    expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
+  });
 });

package/src/core/ddl/dialects/sqlite-schema-dialect.ts

@@ -79,6 +79,7 @@ export const createSqliteSchemaDialect = (): SchemaDialect =>
       void table;
       return !!(column.autoIncrement && primaryKey.length === 1 && primaryKey[0] === column.name);
     },
+    renderReferenceSuffix: ref => ref.deferrable ? 'DEFERRABLE INITIALLY DEFERRED' : undefined,
     renderIndex(table, index, services) {
       const name = index.name || deriveIndexName(table, index);
       const columns = renderIndexColumns(services, index.columns);

package/src/core/ddl/introspect/sqlite-foreign-key-ddl.ts

@@ -0,0 +1,321 @@
+export interface SqliteForeignKeyModifier {
+  column: string;
+  name?: string;
+  deferrable: boolean;
+}
+
+const isIdentifierChar = (value: string): boolean => /[A-Za-z0-9_]/.test(value);
+
+const keywordAt = (text: string, position: number, keyword: string): boolean => {
+  if (position < 0 || position + keyword.length > text.length) return false;
+  if (position > 0 && isIdentifierChar(text[position - 1])) return false;
+  if (position + keyword.length < text.length && isIdentifierChar(text[position + keyword.length])) {
+    return false;
+  }
+  return text.slice(position, position + keyword.length).toUpperCase() === keyword.toUpperCase();
+};
+
+const skipWhitespace = (text: string, position: number): number => {
+  let pos = position;
+  while (pos < text.length && /\s/.test(text[pos])) pos += 1;
+  return pos;
+};
+
+const readIdentifier = (text: string, position: number): { value: string; next: number } | undefined => {
+  let pos = skipWhitespace(text, position);
+  if (pos >= text.length) return undefined;
+
+  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 undefined;
+  }
+
+  const start = pos;
+  while (
+    pos < text.length
+    && !/\s/.test(text[pos])
+    && text[pos] !== '('
+    && text[pos] !== ')'
+    && text[pos] !== ','
+  ) {
+    pos += 1;
+  }
+  if (pos === start) return undefined;
+  return { value: text.slice(start, pos), next: pos };
+};
+
+const splitTableBody = (createSql: string): string[] => {
+  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: string[] = [];
+  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);
+};
+
+const findTopLevelKeyword = (text: string, keyword: string, start = 0): number => {
+  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;
+};
+
+const isInitiallyDeferred = (segment: string, start: number): boolean => {
+  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));
+};
+
+const parseTableForeignKey = (segment: string): SqliteForeignKeyModifier | undefined => {
+  let pos = skipWhitespace(segment, 0);
+  let name: string | undefined;
+
+  if (keywordAt(segment, pos, 'CONSTRAINT')) {
+    pos += 'CONSTRAINT'.length;
+    const parsedName = readIdentifier(segment, pos);
+    if (!parsedName) return undefined;
+    name = parsedName.value;
+    pos = skipWhitespace(segment, parsedName.next);
+  }
+
+  if (!keywordAt(segment, pos, 'FOREIGN')) return undefined;
+  pos += 'FOREIGN'.length;
+  pos = skipWhitespace(segment, pos);
+  if (!keywordAt(segment, pos, 'KEY')) return undefined;
+  pos += 'KEY'.length;
+  pos = skipWhitespace(segment, pos);
+  if (segment[pos] !== '(') return undefined;
+  pos += 1;
+
+  const source = readIdentifier(segment, pos);
+  if (!source) return undefined;
+  pos = skipWhitespace(segment, source.next);
+  if (segment[pos] === ',') return undefined;
+
+  const referencesPos = findTopLevelKeyword(segment, 'REFERENCES', pos);
+  if (referencesPos < 0) return undefined;
+
+  return {
+    column: source.value,
+    ...(name ? { name } : {}),
+    deferrable: isInitiallyDeferred(segment, referencesPos)
+  };
+};
+
+const parseInlineForeignKey = (segment: string): SqliteForeignKeyModifier | undefined => {
+  const source = readIdentifier(segment, 0);
+  if (!source) return undefined;
+
+  const referencesPos = findTopLevelKeyword(segment, 'REFERENCES', source.next);
+  if (referencesPos < 0) return undefined;
+
+  let name: string | undefined;
+  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)
+  };
+};
+
+export const parseSqliteForeignKeyModifiers = (createSql: string): SqliteForeignKeyModifier[] => {
+  const result: SqliteForeignKeyModifier[] = [];
+  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;
+};

package/src/core/ddl/introspect/sqlite.ts

@@ -3,6 +3,7 @@ import { shouldIncludeTable, shouldIncludeView, queryRows } from './utils.js';
 import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn, DatabaseView } from '../schema-types.js';
 import type { IntrospectContext } from './context.js';
 import { runSelectNode } from './run-select.js';
+import { parseSqliteForeignKeyModifiers } from './sqlite-foreign-key-ddl.js';
 import type { SelectQueryNode, TableNode } from '../../ast/query.js';
 import type { ColumnNode } from '../../ast/expression-nodes.js';
 import { eq, notLike, and, valueToOperand } from '../../ast/expression-builders.js';
@@ -11,6 +12,7 @@ import type { ReferentialAction } from '../../../schema/column-types.js';
 
 type SqliteTableRow = {
   name: string;
+  sql: string | null;
 };
 
 type SqliteTableInfoRow = {
@@ -73,7 +75,7 @@ const buildPragmaQuery = (
   columnAliases: string[]
 ): SelectQueryNode => ({
   type: 'SelectQuery',
-  from: fnTable(name, [valueToOperand(table)], alias, { columnAliases }),
+  from: fnTable(name, [valueToOperand(table)], alias),
   columns: columnAliases.map(column => columnNode(alias, column)),
   joins: []
 });
@@ -151,7 +153,10 @@ export const sqliteIntrospector: SchemaIntrospector = {
     const tablesQuery: SelectQueryNode = {
       type: 'SelectQuery',
       from: { type: 'Table', name: 'sqlite_master' } as TableNode,
-      columns: [columnNode(alias, 'name')],
+      columns: [
+        columnNode(alias, 'name'),
+        columnNode(alias, 'sql')
+      ],
       joins: [],
       where: and(
         eq(columnNode(alias, 'type'), 'table'),
@@ -230,6 +235,15 @@ export const sqliteIntrospector: SchemaIntrospector = {
         }
       });
 
+      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<SqliteIndexInfoRow>(

package/src/core/ddl/schema-diff.ts

@@ -1,5 +1,5 @@
 import type { TableDef } from '../../schema/table.js';
-import type { ColumnDef } from '../../schema/column-types.js';
+import type { ColumnDef, ForeignKeyReference } from '../../schema/column-types.js';
 import type { DbExecutor } from '../execution/db-executor.js';
 import type { SchemaDialect } from './schema-dialect.js';
 import { deriveIndexName } from './naming-strategy.js';
@@ -54,6 +54,22 @@ const normalizeDefault = (value: unknown): string | undefined => {
   return String(value).trim();
 };
 
+const normalizeReferenceAction = (value: string | undefined): string =>
+  (value || 'NO ACTION').toUpperCase().replace(/\s+/g, ' ').trim();
+
+const sameReference = (
+  expected: ForeignKeyReference | undefined,
+  actual: ForeignKeyReference | undefined
+): boolean => {
+  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;
+};
+
 const diffColumn = (
   expected: ColumnDef,
   actual: DatabaseColumn,
@@ -69,7 +85,8 @@ const diffColumn = (
     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)
   };
 };
 
@@ -121,6 +138,13 @@ export const diffSchema = (
       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

package/src/core/ddl/schema-generator.ts

@@ -50,7 +50,12 @@ export const renderColumnDefinition = (
     parts.push(`CHECK (${col.check})`);
   }
   if (col.references) {
-    parts.push(dialect.renderReference(col.references, table));
+    const referenceSql = dialect.renderReference(col.references, table);
+    parts.push(
+      col.references.name
+        ? `CONSTRAINT ${dialect.quoteIdentifier(col.references.name)} ${referenceSql}`
+        : referenceSql
+    );
   }
 
   return { sql: parts.join(' '), inlinePrimary: !!(options.includePrimary && col.primary) };

package/src/core/ddl/schema-types.ts

@@ -7,6 +7,7 @@ export interface ColumnDiff {
   nullabilityChanged?: boolean;
   defaultChanged?: boolean;
   autoIncrementChanged?: boolean;
+  referenceChanged?: boolean;
 }
 
 /** Represents a column in the database schema. */