@dbsp/core 1.10.1 → 1.11.1

package/dist/index.d.ts

@@ -767,6 +767,8 @@ interface SelfRefRoles {
  * Options for ref() foreign key declarations.
  */
 interface RefOptions {
+    /** Target schema name (omit for same-schema references) */
+    schema?: string;
     /** Is this FK nullable? → optional relation */
     nullable?: boolean;
     /** Is this FK unique? → 1:1 instead of 1:N */
@@ -774,7 +776,7 @@ interface RefOptions {
     /** ON DELETE action */
     onDelete?: OnDeleteAction;
     /** ON UPDATE action */
-    onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+    onUpdate?: OnDeleteAction;
     /** Local relation name (e.g., 'createdBy' for createdById column) */
     as?: string;
     /** Inverse relation name on target table (e.g., 'writings' instead of 'author_posts') */
@@ -952,6 +954,8 @@ interface SchemaOptions {
 interface Schema<T extends SchemaDefinition> {
     /** The raw schema definition */
     readonly definition: T;
+    /** Table-level constraints supplied to schema() or reconstructed from introspection */
+    readonly constraints?: SchemaConstraints;
     /** Converted ModelIR for use with ORM */
     readonly model: ModelIR;
     /** Table names */
@@ -1229,6 +1233,8 @@ type SchemaOnDeleteAction = 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
  * When present, takes priority over convention-based FK detection.
  */
 interface SchemaForeignKeyReference {
+    /** Target schema name (omit for same-schema references) */
+    readonly schema?: string;
     /** Target table name */
     table: string;
     /** Target column name (defaults to 'id') */
@@ -4236,9 +4242,10 @@ interface GeneratedColumn {
     readonly autoIncrement?: boolean;
     readonly default?: string;
     readonly references?: {
+        readonly schema?: string;
         readonly table: string;
         readonly column?: string;
-        readonly onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+        readonly onDelete?: OnDeleteAction;
         /** Create an index on this FK column (matches ColumnDefinitionSchema index field) */
         readonly index?: boolean;
         /** Role name for parent traversal in self-ref hierarchies (e.g., 'parent') */
@@ -4255,11 +4262,12 @@ interface GeneratedColumn {
 interface GeneratedForeignKey {
     readonly columns: readonly string[];
     readonly references: {
+        readonly schema?: string;
         readonly table: string;
         readonly columns: readonly string[];
     };
-    readonly onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
-    readonly onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+    readonly onDelete?: OnDeleteAction;
+    readonly onUpdate?: OnDeleteAction;
 }
 interface GeneratedIndex {
     readonly columns: readonly string[];
@@ -4476,9 +4484,10 @@ declare const ResolvedSchemaValidation: v.ObjectSchema<{
             readonly autoIncrement: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
             readonly default: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>], undefined>, undefined>;
             readonly references: v.OptionalSchema<v.ObjectSchema<{
+                readonly schema: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TransformAction<string, string | undefined>]>, undefined>;
                 readonly table: v.StringSchema<undefined>;
                 readonly column: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                readonly onDelete: v.OptionalSchema<v.PicklistSchema<["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"], undefined>, undefined>;
+                readonly onDelete: v.OptionalSchema<v.PicklistSchema<readonly ["CASCADE", "SET NULL", "SET DEFAULT", "RESTRICT", "NO ACTION"], undefined>, undefined>;
                 readonly index: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
                 readonly parentRole: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly childRole: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
@@ -4489,11 +4498,12 @@ declare const ResolvedSchemaValidation: v.ObjectSchema<{
         readonly foreignKeys: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
             readonly columns: v.ArraySchema<v.StringSchema<undefined>, undefined>;
             readonly references: v.ObjectSchema<{
+                readonly schema: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TransformAction<string, string | undefined>]>, undefined>;
                 readonly table: v.StringSchema<undefined>;
                 readonly columns: v.ArraySchema<v.StringSchema<undefined>, undefined>;
             }, undefined>;
-            readonly onDelete: v.OptionalSchema<v.PicklistSchema<["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"], undefined>, undefined>;
-            readonly onUpdate: v.OptionalSchema<v.PicklistSchema<["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"], undefined>, undefined>;
+            readonly onDelete: v.OptionalSchema<v.PicklistSchema<readonly ["CASCADE", "SET NULL", "SET DEFAULT", "RESTRICT", "NO ACTION"], undefined>, undefined>;
+            readonly onUpdate: v.OptionalSchema<v.PicklistSchema<readonly ["CASCADE", "SET NULL", "SET DEFAULT", "RESTRICT", "NO ACTION"], undefined>, undefined>;
         }, undefined>, undefined>, undefined>;
         readonly indexes: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
             readonly columns: v.ArraySchema<v.StringSchema<undefined>, undefined>;
@@ -4508,9 +4518,10 @@ declare const ResolvedSchemaValidation: v.ObjectSchema<{
         readonly autoIncrement: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
         readonly default: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>], undefined>, undefined>;
         readonly references: v.OptionalSchema<v.ObjectSchema<{
+            readonly schema: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TransformAction<string, string | undefined>]>, undefined>;
             readonly table: v.StringSchema<undefined>;
             readonly column: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            readonly onDelete: v.OptionalSchema<v.PicklistSchema<["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"], undefined>, undefined>;
+            readonly onDelete: v.OptionalSchema<v.PicklistSchema<readonly ["CASCADE", "SET NULL", "SET DEFAULT", "RESTRICT", "NO ACTION"], undefined>, undefined>;
             readonly index: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
             readonly parentRole: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             readonly childRole: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
@@ -4845,16 +4856,21 @@ interface OrmInstance<DB = Record<string, unknown>> {
      * Use destructuring to get individual table references, then pass
      * them to `from()` for type-safe queries.
      *
+     * Each entry also carries the runtime DDL helpers (`.truncate()`,
+     * `.indexes.list()`, `.alterColumn()`, …) via the `TableDDL` mixin, mirroring
+     * what `wrapTablesProxyWithDDL` produces at runtime.
+     *
      * @example
      * ```typescript
      * const { users, posts } = orm.tables;
      * const activeUsers = await orm.from(users).where(eq(users.active, true)).all();
+     * const indexes = await orm.tables.users.indexes.list();
      * ```
      *
      * @since DX-040-SURFACE
      */
     readonly tables: {
-        [K in keyof DB & string]: TableRef<K, RowToColumnRefs<K, DB[K]>, any>;
+        [K in keyof DB & string]: TableRef<K, RowToColumnRefs<K, DB[K]>, any> & TableDDL;
     };
     /**
      * Start a type-safe SELECT query from a TableRef.

package/dist/index.js

@@ -58,6 +58,9 @@ __reExport(intent_ast_exports, types_star);
 import * as types_star from "@dbsp/types";
 
 // src/model-impl.ts
+function hasExternalSchema(schemaName) {
+  return schemaName != null && schemaName.trim().length > 0;
+}
 var ModelIRImpl = class {
   tables;
   externalTables;
@@ -178,7 +181,7 @@ var ModelIRImpl = class {
     }
     for (const table of this.tables.values()) {
       for (const fk of table.foreignKeys) {
-        if (!this.tables.has(fk.references.table) && !this.externalTables.has(fk.references.table)) {
+        if (!hasExternalSchema(fk.references.schema) && !this.tables.has(fk.references.table) && !this.externalTables.has(fk.references.table)) {
           errors.push(
             `Table "${table.name}" has FK referencing non-existent table "${fk.references.table}"`
           );
@@ -623,11 +626,25 @@ function createTablesProxy(model, tableNames, options) {
 }
 
 // src/dx/schema.ts
+function normalizeReferenceSchema(schemaName) {
+  if (schemaName == null) return void 0;
+  const t = schemaName.trim();
+  return t.length > 0 ? t : void 0;
+}
+function hasExternalSchema2(schemaName) {
+  return normalizeReferenceSchema(schemaName) !== void 0;
+}
+function normalizeRefOptions(options) {
+  const schemaName = normalizeReferenceSchema(options.schema);
+  if (schemaName === options.schema) return options;
+  const { schema: _schema, ...rest } = options;
+  return schemaName === void 0 ? rest : { ...rest, schema: schemaName };
+}
 function ref(target, options) {
   return {
     __brand: "ref",
     target,
-    options: options ?? {}
+    options: options ? normalizeRefOptions(options) : {}
   };
 }
 function isRef(value) {
@@ -653,6 +670,7 @@ function schema(definition, constraints, options, extras) {
   );
   return {
     definition,
+    ...constraints !== void 0 ? { constraints } : {},
     model,
     tableNames,
     tables,
@@ -721,21 +739,21 @@ function validateRefs(definition, tableNames) {
   for (const [tableName, tableDef] of Object.entries(definition)) {
     for (const [columnName, columnDef] of Object.entries(tableDef)) {
       if (isRef(columnDef)) {
-        if (!tableSet.has(columnDef.target)) {
+        if (!hasExternalSchema2(columnDef.options.schema) && !tableSet.has(columnDef.target)) {
           throw new SchemaValidationError(
             `Foreign key '${columnName}' references non-existent table '${columnDef.target}'`,
             tableName,
             columnName
           );
         }
-        if (columnDef.target === tableName && !columnDef.options.roles) {
+        if (!hasExternalSchema2(columnDef.options.schema) && columnDef.target === tableName && !columnDef.options.roles) {
           throw new SchemaValidationError(
             `Self-referential FK '${columnName}' must have 'roles' option with parent/children names`,
             tableName,
             columnName
           );
         }
-        if (columnDef.target !== tableName && columnDef.options.roles) {
+        if ((hasExternalSchema2(columnDef.options.schema) || columnDef.target !== tableName) && columnDef.options.roles) {
           throw new SchemaValidationError(
             `'roles' option is only valid for self-referential FKs, but '${columnName}' references '${columnDef.target}'`,
             tableName,
@@ -751,14 +769,6 @@ function validateFkTargets(tables) {
   const tableMap = new Map(tables.map((t) => [t.name, t]));
   for (const table of tables) {
     for (const fk of table.foreignKeys) {
-      const target = tableMap.get(fk.references.table);
-      if (!target) {
-        throw new SchemaValidationError(
-          `Foreign key in '${table.name}' references non-existent table '${fk.references.table}'`,
-          table.name,
-          fk.columns[0]
-        );
-      }
       for (const srcCol of fk.columns) {
         if (!table.columns.some((c) => c.name === srcCol)) {
           throw new SchemaValidationError(
@@ -782,6 +792,15 @@ function validateFkTargets(tables) {
           fk.columns[0]
         );
       }
+      if (hasExternalSchema2(fk.references.schema)) continue;
+      const target = tableMap.get(fk.references.table);
+      if (!target) {
+        throw new SchemaValidationError(
+          `Foreign key in '${table.name}' references non-existent table '${fk.references.table}'`,
+          table.name,
+          fk.columns[0]
+        );
+      }
       for (const refCol of fk.references.columns) {
         if (!target.columns.some((c) => c.name === refCol)) {
           throw new SchemaValidationError(
@@ -955,6 +974,14 @@ function getReferencedColumnType(targetDef, referencedCol, definition, visited)
 }
 function buildRefColumn(columnName, columnDef, definition) {
   const targetDef = definition[columnDef.target];
+  const externalSchema = normalizeReferenceSchema(columnDef.options.schema);
+  if (externalSchema !== void 0) {
+    throw new SchemaValidationError(
+      `Cannot infer column type for foreign key column '${columnName}' to external table '${externalSchema}.${columnDef.target}'. Declare the source column with an explicit type and add the external foreign key at the table level with SchemaConstraints.foreignKeys.`,
+      void 0,
+      columnName
+    );
+  }
   const targetCol = columnDef.options.references?.length === 1 ? columnDef.options.references[0] : void 0;
   const inferredType = targetCol && targetDef ? getReferencedColumnType(targetDef, targetCol, definition) ?? getTargetPkType(definition, columnDef.target) : getTargetPkType(definition, columnDef.target);
   const col2 = {
@@ -972,7 +999,8 @@ function buildRefColumn(columnName, columnDef, definition) {
     columns: [columnName],
     references: {
       table: columnDef.target,
-      columns: columnDef.options.references ?? ["id"]
+      columns: columnDef.options.references ?? ["id"],
+      ...externalSchema !== void 0 ? { schema: externalSchema } : {}
     }
   };
   if (columnDef.options.onDelete) fk.onDelete = columnDef.options.onDelete;
@@ -1028,7 +1056,7 @@ function buildPseudoColumns(tableName, refsByTable, finalPk) {
   const refs = refsByTable.get(tableName) ?? [];
   const pkColumn = typeof finalPk === "string" ? finalPk : finalPk?.[0] ?? "id";
   for (const ref3 of refs) {
-    if (ref3.options.roles && ref3.target === tableName) {
+    if (!hasExternalSchema2(ref3.options.schema) && ref3.options.roles && ref3.target === tableName) {
       pseudoColumns.push(
         createPseudoColumnMetadata(
           tableName,
@@ -1095,11 +1123,13 @@ function buildTableConstraints(tableName, constraints) {
           tableName
         );
       }
+      const externalSchema = normalizeReferenceSchema(fkRef.options.schema);
       const fk = {
         columns: [...fkRef.options.columns],
         references: {
           table: fkRef.target,
-          columns: fkRef.options.references ? [...fkRef.options.references] : ["id"]
+          columns: fkRef.options.references ? [...fkRef.options.references] : ["id"],
+          ...externalSchema !== void 0 ? { schema: externalSchema } : {}
         }
       };
       if (fkRef.options.onDelete) fk.onDelete = fkRef.options.onDelete;
@@ -1147,6 +1177,7 @@ function buildRelations(_definition, refsByTable, tableNames, constraints) {
   for (const tableName of tableNames) {
     const refs = refsByTable.get(tableName) || [];
     for (const ref3 of refs) {
+      if (hasExternalSchema2(ref3.options.schema)) continue;
       if (ref3.options.roles) {
         const roles = ref3.options.roles;
         relations.push({
@@ -1267,6 +1298,7 @@ function addCompositeConstraintRelations(relations, tableNames, constraints) {
     const foreignKeys = constraints[tableName]?.foreignKeys;
     if (!foreignKeys) continue;
     for (const fkRef of foreignKeys) {
+      if (hasExternalSchema2(fkRef.options.schema)) continue;
       if (!tableSet.has(fkRef.target)) continue;
       const columns = fkRef.options.columns;
       if (!columns?.length) continue;
@@ -1338,38 +1370,102 @@ async function getSchemaFromDb(adapter, options) {
   const model = introspectionResult;
   const introspectedAt = introspectionResult.introspectedAt;
   const fkLookup = /* @__PURE__ */ new Map();
+  const compositeExternalFkLookup = /* @__PURE__ */ new Map();
   for (const table of model.tables.values()) {
     const tableFks = /* @__PURE__ */ new Map();
     for (const fk of table.foreignKeys) {
+      const externalSchema = normalizeReferenceSchema(fk.references.schema);
+      if (externalSchema !== void 0 && fk.columns.length > 1) {
+        const tableCompositeFks = compositeExternalFkLookup.get(table.name) ?? [];
+        tableCompositeFks.push({
+          ...fk,
+          references: {
+            ...fk.references,
+            schema: externalSchema
+          }
+        });
+        compositeExternalFkLookup.set(table.name, tableCompositeFks);
+        continue;
+      }
       const fkColumn = fk.columns[0];
       if (!fkColumn) continue;
       const column = table.columns.find((c) => c.name === fkColumn);
       tableFks.set(fkColumn, {
         target: fk.references.table,
+        refs: fk.references.columns,
+        ...externalSchema !== void 0 ? { schema: externalSchema } : {},
         nullable: column?.nullable ?? true,
-        unique: column?.unique ?? false
+        unique: column?.unique ?? false,
+        ...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
+        ...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
       });
     }
     fkLookup.set(table.name, tableFks);
   }
   const definition = {};
+  const constraints = {};
   for (const table of model.tables.values()) {
     const tableDef = {};
     const tableFks = fkLookup.get(table.name) ?? /* @__PURE__ */ new Map();
+    const compositeExternalFks = compositeExternalFkLookup.get(table.name) ?? [];
     for (const column of table.columns) {
       const fk = tableFks.get(column.name);
       if (fk) {
+        if (fk.schema !== void 0) {
+          const sourceColumn = {
+            type: columnTypeToJsType(column.type),
+            nullable: fk.nullable
+          };
+          if (fk.unique) sourceColumn.unique = true;
+          tableDef[column.name] = sourceColumn;
+          constraints[table.name] ??= {};
+          const tableConstraints = constraints[table.name];
+          tableConstraints.foreignKeys ??= [];
+          const foreignKeys = tableConstraints.foreignKeys;
+          foreignKeys.push(
+            ref(fk.target, {
+              schema: fk.schema,
+              columns: [column.name],
+              references: fk.refs,
+              ...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
+              ...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
+            })
+          );
+          continue;
+        }
+        const usesDefaultReferences = fk.refs.length === 1 && fk.refs[0] === "id";
         tableDef[column.name] = ref(fk.target, {
           nullable: fk.nullable,
-          unique: fk.unique
+          unique: fk.unique,
+          ...!usesDefaultReferences ? { references: fk.refs } : {},
+          ...fk.onDelete !== void 0 && fk.onDelete !== "NO ACTION" ? { onDelete: fk.onDelete } : {},
+          ...fk.onUpdate !== void 0 && fk.onUpdate !== "NO ACTION" ? { onUpdate: fk.onUpdate } : {}
         });
       } else {
         tableDef[column.name] = columnTypeToJsType(column.type);
       }
     }
+    for (const fk of compositeExternalFks) {
+      const externalSchema = fk.references.schema;
+      if (externalSchema === void 0) continue;
+      constraints[table.name] ??= {};
+      const tableConstraints = constraints[table.name];
+      tableConstraints.foreignKeys ??= [];
+      const foreignKeys = tableConstraints.foreignKeys;
+      foreignKeys.push(
+        ref(fk.references.table, {
+          schema: externalSchema,
+          columns: fk.columns,
+          references: fk.references.columns,
+          ...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
+          ...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
+        })
+      );
+    }
     definition[table.name] = tableDef;
   }
   const tableNames = Object.keys(definition);
+  const generatedConstraints = Object.keys(constraints).length > 0 ? constraints : void 0;
   const tables = createTablesProxy(
     model,
     tableNames
@@ -1380,6 +1476,9 @@ async function getSchemaFromDb(adapter, options) {
     tableNames,
     tables
   };
+  if (generatedConstraints !== void 0) {
+    result.constraints = generatedConstraints;
+  }
   if (adapter.dbCasing !== void 0) {
     result.dbCasing = adapter.dbCasing;
   }
@@ -1464,7 +1563,7 @@ function detectForeignKeys(tableName, table, conventions, tableNames) {
   for (const [colName, colDef] of Object.entries(table)) {
     if (colDef.references) {
       const targetTable = colDef.references.table;
-      if (tableNames.has(targetTable)) {
+      if (colDef.references.schema === void 0 && tableNames.has(targetTable)) {
         const inferredName = colName.endsWith("Id") ? colName.slice(0, -2) : singularize(targetTable);
         const isSelfRef = targetTable === tableName;
         const detectedFK = {
@@ -10329,16 +10428,13 @@ function buildIndexAPI(tableName, schemaName, adapter, requireAdapter2) {
           "indexes.list() requires an adapter."
         );
       }
-      if (adapter.listIndexes) {
-        return adapter.listIndexes(tableName, schemaName, options);
-      }
-      const sql2 = `SELECT indexname AS name, indexdef AS definition, (SELECT indisunique FROM pg_index WHERE indexrelid = (SELECT oid FROM pg_class WHERE relname = indexname)) AS unique, CASE WHEN indexdef LIKE '%USING %' THEN split_part(indexdef, 'USING ', 2) ELSE 'btree' END AS method FROM pg_indexes WHERE tablename = '${tableName.replace(/'/g, "''")}' ` + (schemaName ? `AND schemaname = '${schemaName.replace(/'/g, "''")}' ` : "") + `ORDER BY indexname`;
-      if ("executeRaw" in adapter && typeof adapter.executeRaw === "function") {
-        const rows = await adapter.executeRaw(sql2, []);
-        return rows;
+      if (!adapter.listIndexes) {
+        throw new InvalidOperationError(
+          "indexes.list",
+          "indexes.list() requires an adapter that implements listIndexes()."
+        );
       }
-      if (adapter.executeDDL) await adapter.executeDDL(sql2);
-      return [];
+      return adapter.listIndexes(tableName, schemaName, options);
     },
     async exists(name) {
       if (!adapter) {
@@ -10963,6 +11059,14 @@ function rangeContainedBy(fieldOrColumn, valueOrRange, rangeType = "daterange")
 // src/dx/schema-bridge.ts
 import { buildRelationKeyFields, toColumnList as toColumnList3 } from "@dbsp/types";
 import * as v from "valibot";
+function normalizeReferenceSchema2(schemaName) {
+  if (schemaName == null) return void 0;
+  const t = schemaName.trim();
+  return t.length > 0 ? t : void 0;
+}
+function hasExternalSchema3(schemaName) {
+  return normalizeReferenceSchema2(schemaName) !== void 0;
+}
 function generatedTypeToColumnType(genType) {
   switch (genType) {
     case "string":
@@ -11035,11 +11139,11 @@ function findRelationForeignKey(sourceTable, genRelation, tables) {
   switch (genRelation.kind) {
     case "belongsTo":
       return tables.get(sourceTable)?.foreignKeys.find(
-        (fk) => fk.references.table === genRelation.target && columnListsEqual(fk.columns, genRelation.foreignKey)
+        (fk) => !hasExternalSchema3(fk.references.schema) && fk.references.table === genRelation.target && columnListsEqual(fk.columns, genRelation.foreignKey)
       );
     case "hasMany":
       return tables.get(genRelation.target)?.foreignKeys.find(
-        (fk) => fk.references.table === sourceTable && columnListsEqual(fk.columns, genRelation.foreignKey)
+        (fk) => !hasExternalSchema3(fk.references.schema) && fk.references.table === sourceTable && columnListsEqual(fk.columns, genRelation.foreignKey)
       );
     case "manyToMany":
       return void 0;
@@ -11074,11 +11178,13 @@ function buildTableIRFromDefinition(tableName, genTable, fkAutoIndex) {
       primaryKeys.push(colName);
     }
     if (colDef.references) {
+      const externalSchema = normalizeReferenceSchema2(colDef.references.schema);
       const fk = {
         columns: [colName],
         references: {
           table: colDef.references.table,
-          columns: [colDef.references.column ?? "id"]
+          columns: [colDef.references.column ?? "id"],
+          ...externalSchema !== void 0 ? { schema: externalSchema } : {}
         }
       };
       if (colDef.references.onDelete) {
@@ -11108,7 +11214,7 @@ function buildTableIRFromDefinition(tableName, genTable, fkAutoIndex) {
   for (const fk of foreignKeys) {
     const fkColumn = fk.columns[0];
     const targetColumn = fk.references.columns[0];
-    if (fk.references.table === tableName && fkColumn !== void 0 && targetColumn !== void 0) {
+    if (fk.references.table === tableName && !hasExternalSchema3(fk.references.schema) && fkColumn !== void 0 && targetColumn !== void 0) {
       const colDef = tableColumns[fkColumn];
       const inferredName = fkColumn.endsWith("Id") ? fkColumn.slice(0, -2) : "parent";
       const parentRole = colDef?.references?.parentRole ?? inferredName;
@@ -11141,11 +11247,13 @@ function buildTableIRFromDefinition(tableName, genTable, fkAutoIndex) {
   }
   if (isGeneratedTableWithConfig(genTable)) {
     for (const fk of genTable.foreignKeys ?? []) {
+      const externalSchema = normalizeReferenceSchema2(fk.references.schema);
       const foreignKey = {
         columns: [...fk.columns],
         references: {
           table: fk.references.table,
-          columns: [...fk.references.columns]
+          columns: [...fk.references.columns],
+          ...externalSchema !== void 0 ? { schema: externalSchema } : {}
         }
       };
       if (fk.onDelete) foreignKey.onDelete = fk.onDelete;
@@ -11362,12 +11470,25 @@ function safeRecord(valueSchema) {
     v.record(v.string(), valueSchema)
   );
 }
+var OptionalReferenceSchemaNameSchema = v.optional(
+  v.pipe(
+    v.string(),
+    v.transform((schemaName) => normalizeReferenceSchema2(schemaName))
+  )
+);
+var ForeignKeyActionValues = [
+  "CASCADE",
+  "SET NULL",
+  "SET DEFAULT",
+  "RESTRICT",
+  "NO ACTION"
+];
+var ForeignKeyActionSchema = v.picklist(ForeignKeyActionValues);
 var ForeignKeyReferenceSchema = v.object({
+  schema: OptionalReferenceSchemaNameSchema,
   table: v.string(),
   column: v.optional(v.string()),
-  onDelete: v.optional(
-    v.picklist(["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"])
-  ),
+  onDelete: v.optional(ForeignKeyActionSchema),
   index: v.optional(v.boolean()),
   parentRole: v.optional(v.string()),
   childRole: v.optional(v.string())
@@ -11392,15 +11513,12 @@ var TableDefWithConfigSchema = v.object({
       v.object({
         columns: v.array(v.string()),
         references: v.object({
+          schema: OptionalReferenceSchemaNameSchema,
           table: v.string(),
           columns: v.array(v.string())
         }),
-        onDelete: v.optional(
-          v.picklist(["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"])
-        ),
-        onUpdate: v.optional(
-          v.picklist(["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"])
-        )
+        onDelete: v.optional(ForeignKeyActionSchema),
+        onUpdate: v.optional(ForeignKeyActionSchema)
       })
     )
   ),
@@ -11534,8 +11652,10 @@ function convertColumn(col2) {
     result.default = col2.default;
   }
   if (col2.references) {
+    const externalSchema = normalizeReferenceSchema2(col2.references.schema);
     result.references = {
       table: col2.references.table,
+      ...externalSchema !== void 0 ? { schema: externalSchema } : {},
       ...col2.references.column !== void 0 ? { column: col2.references.column } : {},
       ...col2.references.onDelete ? { onDelete: col2.references.onDelete } : {},
       ...col2.references.index !== void 0 ? { index: col2.references.index } : {},