@prisma-next/target-postgres 0.3.0-dev.5 → 0.3.0-dev.52

package/package.json

@@ -1,29 +1,32 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.3.0-dev.5",
+  "version": "0.3.0-dev.52",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
     "arktype": "^2.0.0",
-    "@prisma-next/contract": "0.3.0-dev.5",
-    "@prisma-next/core-control-plane": "0.3.0-dev.5",
-    "@prisma-next/core-execution-plane": "0.3.0-dev.5",
-    "@prisma-next/family-sql": "0.3.0-dev.5",
-    "@prisma-next/sql-contract": "0.3.0-dev.5",
-    "@prisma-next/sql-errors": "0.3.0-dev.5",
-    "@prisma-next/sql-schema-ir": "0.3.0-dev.5",
-    "@prisma-next/utils": "0.3.0-dev.5",
-    "@prisma-next/cli": "0.3.0-dev.5"
+    "@prisma-next/cli": "0.3.0-dev.52",
+    "@prisma-next/contract": "0.3.0-dev.52",
+    "@prisma-next/core-control-plane": "0.3.0-dev.52",
+    "@prisma-next/core-execution-plane": "0.3.0-dev.52",
+    "@prisma-next/family-sql": "0.3.0-dev.52",
+    "@prisma-next/sql-contract": "0.3.0-dev.52",
+    "@prisma-next/sql-errors": "0.3.0-dev.52",
+    "@prisma-next/sql-relational-core": "0.3.0-dev.52",
+    "@prisma-next/sql-schema-ir": "0.3.0-dev.52",
+    "@prisma-next/utils": "0.3.0-dev.52",
+    "@prisma-next/sql-runtime": "0.3.0-dev.52"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "4.0.16",
-    "tsup": "8.5.1",
+    "tsdown": "0.18.4",
     "typescript": "5.9.3",
-    "vitest": "4.0.16",
-    "@prisma-next/adapter-postgres": "0.3.0-dev.5",
-    "@prisma-next/driver-postgres": "0.3.0-dev.5",
-    "@prisma-next/test-utils": "0.0.1"
+    "vitest": "4.0.17",
+    "@prisma-next/adapter-postgres": "0.3.0-dev.52",
+    "@prisma-next/driver-postgres": "0.3.0-dev.52",
+    "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/tsconfig": "0.0.0"
   },
   "files": [
     "dist",
@@ -31,27 +34,24 @@
     "packs"
   ],
   "exports": {
-    "./control": {
-      "types": "./dist/exports/control.d.ts",
-      "import": "./dist/exports/control.js"
-    },
-    "./runtime": {
-      "types": "./dist/exports/runtime.d.ts",
-      "import": "./dist/exports/runtime.js"
-    },
-    "./pack": {
-      "types": "./dist/exports/pack.d.ts",
-      "import": "./dist/exports/pack.js"
-    }
+    "./control": "./dist/control.mjs",
+    "./pack": "./dist/pack.mjs",
+    "./runtime": "./dist/runtime.mjs",
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/3-targets/3-targets/postgres"
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
+    "build": "tsdown",
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests",
     "typecheck": "tsc --project tsconfig.json --noEmit",
-    "lint": "biome check . --config-path ../../../../biome.json --error-on-warnings",
-    "lint:fix": "biome check --write . --config-path ../../../biome.json",
-    "lint:fix:unsafe": "biome check --write --unsafe . --config-path ../../../biome.json",
-    "clean": "node ../../../../scripts/clean.mjs"
+    "lint": "biome check . --error-on-warnings",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
   }
 }

package/src/core/migrations/planner.ts

@@ -1,5 +1,14 @@
+import {
+  escapeLiteral,
+  expandParameterizedNativeType,
+  normalizeSchemaNativeType,
+  parsePostgresDefault,
+  quoteIdentifier,
+} from '@prisma-next/adapter-postgres/control';
+import { isTaggedBigInt } from '@prisma-next/contract/types';
 import type { SchemaIssue } from '@prisma-next/core-control-plane/types';
 import type {
+  CodecControlHooks,
   MigrationOperationPolicy,
   SqlMigrationPlanner,
   SqlMigrationPlannerPlanOptions,
@@ -8,20 +17,29 @@ import type {
 } from '@prisma-next/family-sql/control';
 import {
   createMigrationPlan,
+  extractCodecControlHooks,
   plannerFailure,
   plannerSuccess,
 } from '@prisma-next/family-sql/control';
-import { arraysEqual, verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
+import {
+  arraysEqual,
+  isIndexSatisfied,
+  isUniqueConstraintSatisfied,
+  verifySqlSchema,
+} from '@prisma-next/family-sql/schema-verify';
 import type {
   ForeignKey,
+  ReferentialAction,
   SqlContract,
   SqlStorage,
   StorageColumn,
   StorageTable,
 } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+import { ifDefined } from '@prisma-next/utils/defined';
+import type { PostgresColumnDefault } from '../types';
 
-type OperationClass = 'extension' | 'table' | 'unique' | 'index' | 'foreignKey';
+type OperationClass = 'extension' | 'type' | 'table' | 'unique' | 'index' | 'foreignKey';
 
 type PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {
   readonly frameworkComponents: infer T;
@@ -83,11 +101,21 @@ class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTarget
       return plannerFailure(classification.conflicts);
     }
 
+    // Extract codec control hooks once at entry point for reuse across all operations.
+    // This avoids repeated iteration over frameworkComponents for each method that needs hooks.
+    const codecHooks = extractCodecControlHooks(options.frameworkComponents);
+
     const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
 
+    const storageTypePlan = this.buildStorageTypeOperations(options, schemaName, codecHooks);
+    if (storageTypePlan.conflicts.length > 0) {
+      return plannerFailure(storageTypePlan.conflicts);
+    }
+
     // Build extension operations from component-owned database dependencies
     operations.push(
       ...this.buildDatabaseDependencyOperations(options),
+      ...storageTypePlan.operations,
       ...this.buildTableOperations(options.contract.storage.tables, options.schema, schemaName),
       ...this.buildColumnOperations(options.contract.storage.tables, options.schema, schemaName),
       ...this.buildPrimaryKeyOperations(
@@ -97,6 +125,11 @@ class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTarget
       ),
       ...this.buildUniqueOperations(options.contract.storage.tables, options.schema, schemaName),
       ...this.buildIndexOperations(options.contract.storage.tables, options.schema, schemaName),
+      ...this.buildFkBackingIndexOperations(
+        options.contract.storage.tables,
+        options.schema,
+        schemaName,
+      ),
       ...this.buildForeignKeyOperations(
         options.contract.storage.tables,
         options.schema,
@@ -108,8 +141,8 @@ class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTarget
       targetId: 'postgres',
       origin: null,
       destination: {
-        coreHash: options.contract.coreHash,
-        ...(options.contract.profileHash ? { profileHash: options.contract.profileHash } : {}),
+        storageHash: options.contract.storageHash,
+        ...ifDefined('profileHash', options.contract.profileHash),
       },
       operations,
     });
@@ -166,6 +199,55 @@ class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTarget
 
     return operations;
   }
+
+  private buildStorageTypeOperations(
+    options: PlannerOptionsWithComponents,
+    schemaName: string,
+    codecHooks: Map<string, CodecControlHooks>,
+  ): {
+    readonly operations: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[];
+    readonly conflicts: readonly SqlPlannerConflict[];
+  } {
+    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
+    const conflicts: SqlPlannerConflict[] = [];
+    const storageTypes = options.contract.storage.types ?? {};
+
+    for (const [typeName, typeInstance] of sortedEntries(storageTypes)) {
+      const hook = codecHooks.get(typeInstance.codecId);
+      const planResult = hook?.planTypeOperations?.({
+        typeName,
+        typeInstance,
+        contract: options.contract,
+        schema: options.schema,
+        schemaName,
+        policy: options.policy,
+      });
+      if (!planResult) {
+        continue;
+      }
+      for (const operation of planResult.operations) {
+        if (!options.policy.allowedOperationClasses.includes(operation.operationClass)) {
+          conflicts.push({
+            kind: 'missingButNonAdditive',
+            summary: `Storage type "${typeName}" requires "${operation.operationClass}" operation "${operation.id}"`,
+            location: {
+              type: typeName,
+            },
+          });
+          continue;
+        }
+        operations.push({
+          ...operation,
+          target: {
+            id: operation.target.id,
+            details: this.buildTargetDetails('type', typeName, schemaName),
+          },
+        });
+      }
+    }
+
+    return { operations, conflicts };
+  }
   private collectDependencies(
     options: PlannerOptionsWithComponents,
   ): ReadonlyArray<PlannerDatabaseDependency> {
@@ -258,15 +340,20 @@ class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTarget
   ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
     const qualified = qualifyTableName(schema, tableName);
     const notNull = column.nullable === false;
+    const hasDefault = column.default !== undefined;
+    // Only require empty table for NOT NULL columns WITHOUT defaults.
+    // PostgreSQL allows adding NOT NULL columns with defaults to non-empty tables
+    // because the default value is applied to existing rows.
+    const requiresEmptyTable = notNull && !hasDefault;
     const precheck = [
       {
         description: `ensure column "${columnName}" is missing`,
         sql: columnExistsCheck({ schema, table: tableName, column: columnName, exists: false }),
       },
-      ...(notNull
+      ...(requiresEmptyTable
         ? [
             {
-              description: `ensure table "${tableName}" is empty before adding NOT NULL column`,
+              description: `ensure table "${tableName}" is empty before adding NOT NULL column without default`,
               sql: tableIsEmptyCheck(qualified),
             },
           ]
@@ -454,6 +541,65 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(', ')})`,
     return operations;
   }
 
+  /**
+   * Generates FK-backing index operations for FKs with `index: true`,
+   * but only when no matching user-declared index exists in `contractTable.indexes`.
+   */
+  private buildFkBackingIndexOperations(
+    tables: SqlContract<SqlStorage>['storage']['tables'],
+    schema: SqlSchemaIR,
+    schemaName: string,
+  ): readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] {
+    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
+    for (const [tableName, table] of sortedEntries(tables)) {
+      const schemaTable = schema.tables[tableName];
+      // Collect column sets of user-declared indexes to avoid duplicates
+      const declaredIndexColumns = new Set(table.indexes.map((idx) => idx.columns.join(',')));
+
+      for (const fk of table.foreignKeys) {
+        if (fk.index === false) continue;
+        // Skip if user already declared an index with these columns
+        if (declaredIndexColumns.has(fk.columns.join(','))) continue;
+        // Skip if the index already exists in the database
+        if (schemaTable && hasIndex(schemaTable, fk.columns)) continue;
+
+        const indexName = `${tableName}_${fk.columns.join('_')}_idx`;
+        operations.push({
+          id: `index.${tableName}.${indexName}`,
+          label: `Create FK-backing index ${indexName} on ${tableName}`,
+          summary: `Creates FK-backing index ${indexName} on ${tableName}`,
+          operationClass: 'additive',
+          target: {
+            id: 'postgres',
+            details: this.buildTargetDetails('index', indexName, schemaName, tableName),
+          },
+          precheck: [
+            {
+              description: `ensure index "${indexName}" is missing`,
+              sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`,
+            },
+          ],
+          execute: [
+            {
+              description: `create FK-backing index "${indexName}"`,
+              sql: `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualifyTableName(
+                schemaName,
+                tableName,
+              )} (${fk.columns.map(quoteIdentifier).join(', ')})`,
+            },
+          ],
+          postcheck: [
+            {
+              description: `verify index "${indexName}" exists`,
+              sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`,
+            },
+          ],
+        });
+      }
+    }
+    return operations;
+  }
+
   private buildForeignKeyOperations(
     tables: SqlContract<SqlStorage>['storage']['tables'],
     schema: SqlSchemaIR,
@@ -463,6 +609,7 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(', ')})`,
     for (const [tableName, table] of sortedEntries(tables)) {
       const schemaTable = schema.tables[tableName];
       for (const foreignKey of table.foreignKeys) {
+        if (foreignKey.constraint === false) continue;
         if (schemaTable && hasForeignKey(schemaTable, foreignKey)) {
           continue;
         }
@@ -489,12 +636,7 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(', ')})`,
           execute: [
             {
               description: `add foreign key "${fkName}"`,
-              sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
-ADD CONSTRAINT ${quoteIdentifier(fkName)}
-FOREIGN KEY (${foreignKey.columns.map(quoteIdentifier).join(', ')})
-REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${foreignKey.references.columns
-                .map(quoteIdentifier)
-                .join(', ')})`,
+              sql: buildForeignKeySql(schemaName, tableName, fkName, foreignKey),
             },
           ],
           postcheck: [
@@ -519,7 +661,7 @@ REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${forei
       schema,
       objectType,
       name,
-      ...(table ? { table } : {}),
+      ...ifDefined('table', table),
     };
   }
 
@@ -535,6 +677,8 @@ REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${forei
       strict: false,
       typeMetadataRegistry: new Map(),
       frameworkComponents: options.frameworkComponents,
+      normalizeDefault: parsePostgresDefault,
+      normalizeNativeType: normalizeSchemaNativeType,
     };
     const verifyResult = verifySqlSchema(verifyOptions);
 
@@ -583,16 +727,16 @@ REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${forei
     const meta =
       issue.expected || issue.actual
         ? Object.freeze({
-            ...(issue.expected ? { expected: issue.expected } : {}),
-            ...(issue.actual ? { actual: issue.actual } : {}),
+            ...ifDefined('expected', issue.expected),
+            ...ifDefined('actual', issue.actual),
           })
         : undefined;
 
     return {
       kind,
       summary: issue.message,
-      ...(location ? { location } : {}),
-      ...(meta ? { meta } : {}),
+      ...ifDefined('location', location),
+      ...ifDefined('meta', meta),
     };
   }
 }
@@ -633,7 +777,8 @@ function buildCreateTableSql(qualifiedTableName: string, table: StorageTable): s
     ([columnName, column]: [string, StorageColumn]) => {
       const parts = [
         quoteIdentifier(columnName),
-        column.nativeType,
+        buildColumnTypeSql(column),
+        buildColumnDefaultSql(column.default, column),
         column.nullable ? '' : 'NOT NULL',
       ].filter(Boolean);
       return parts.join(' ');
@@ -651,6 +796,117 @@ function buildCreateTableSql(qualifiedTableName: string, table: StorageTable): s
   return `CREATE TABLE ${qualifiedTableName} (\n  ${allDefinitions.join(',\n  ')}\n)`;
 }
 
+/**
+ * Builds the column type SQL, handling autoincrement as a special case.
+ * For autoincrement on int4/int8, we use SERIAL/BIGSERIAL types.
+ */
+function buildColumnTypeSql(column: StorageColumn): string {
+  const columnDefault = column.default;
+
+  // For autoincrement, use SERIAL/BIGSERIAL types instead of int4/int8
+  if (columnDefault?.kind === 'function' && columnDefault.expression === 'autoincrement()') {
+    if (column.nativeType === 'int4' || column.nativeType === 'integer') {
+      return 'SERIAL';
+    }
+    if (column.nativeType === 'int8' || column.nativeType === 'bigint') {
+      return 'BIGSERIAL';
+    }
+    if (column.nativeType === 'int2' || column.nativeType === 'smallint') {
+      return 'SMALLSERIAL';
+    }
+  }
+
+  if (column.typeRef) {
+    return quoteIdentifier(column.nativeType);
+  }
+
+  return renderParameterizedTypeSql(column) ?? column.nativeType;
+}
+
+/**
+ * Renders parameterized type SQL for a column, returning null if no expansion is needed.
+ *
+ * Uses the shared expandParameterizedNativeType utility from the postgres adapter.
+ * Returns null when the column has no typeParams, allowing the caller to fall back
+ * to the base nativeType.
+ */
+function renderParameterizedTypeSql(column: StorageColumn): string | null {
+  if (!column.typeParams) {
+    return null;
+  }
+
+  const expanded = expandParameterizedNativeType({
+    nativeType: column.nativeType,
+    codecId: column.codecId,
+    typeParams: column.typeParams,
+  });
+
+  // If no expansion happened (returned the same base type), return null
+  // so caller can decide whether to use nativeType directly
+  return expanded !== column.nativeType ? expanded : null;
+}
+
+/**
+ * Builds the DEFAULT clause for a column definition.
+ * Returns empty string if no default is defined.
+ *
+ * Note: autoincrement is handled specially via SERIAL types, so we skip it here.
+ */
+function buildColumnDefaultSql(
+  columnDefault: PostgresColumnDefault | undefined,
+  column?: StorageColumn,
+): string {
+  if (!columnDefault) {
+    return '';
+  }
+
+  switch (columnDefault.kind) {
+    case 'literal':
+      return `DEFAULT ${renderDefaultLiteral(columnDefault.value, column)}`;
+    case 'function': {
+      // autoincrement is handled by SERIAL type, no explicit DEFAULT needed
+      if (columnDefault.expression === 'autoincrement()') {
+        return '';
+      }
+      return `DEFAULT ${columnDefault.expression}`;
+    }
+    case 'sequence':
+      // Sequence names use quoteIdentifier for safe identifier handling
+      return `DEFAULT nextval(${quoteIdentifier(columnDefault.name)}::regclass)`;
+  }
+}
+
+function renderDefaultLiteral(value: unknown, column?: StorageColumn): string {
+  const isJsonColumn = column?.nativeType === 'json' || column?.nativeType === 'jsonb';
+
+  if (value instanceof Date) {
+    return `'${escapeLiteral(value.toISOString())}'`;
+  }
+  if (!isJsonColumn && isTaggedBigInt(value)) {
+    if (!/^-?\d+$/.test(value.value)) {
+      throw new Error(`Invalid tagged bigint value: "${value.value}" is not a valid integer`);
+    }
+    return value.value;
+  }
+  if (typeof value === 'bigint') {
+    return value.toString();
+  }
+  if (typeof value === 'string') {
+    return `'${escapeLiteral(value)}'`;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  if (value === null) {
+    return 'NULL';
+  }
+  const json = JSON.stringify(value);
+  if (isJsonColumn) {
+    return `'${escapeLiteral(json)}'::${column.nativeType}`;
+  }
+  return `'${escapeLiteral(json)}'`;
+}
+
 function qualifyTableName(schema: string, table: string): string {
   return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
 }
@@ -660,16 +916,6 @@ function toRegclassLiteral(schema: string, name: string): string {
   return `'${escapeLiteral(regclass)}'`;
 }
 
-/** Escapes and quotes a SQL identifier (table, column, schema name). */
-function quoteIdentifier(identifier: string): string {
-  // TypeScript enforces string type - no runtime check needed for internal callers
-  return `"${identifier.replace(/"/g, '""')}"`;
-}
-
-function escapeLiteral(value: string): string {
-  return value.replace(/'/g, "''");
-}
-
 function sortedEntries<V>(record: Readonly<Record<string, V>>): Array<[string, V]> {
   return Object.entries(record).sort(([a], [b]) => a.localeCompare(b)) as Array<[string, V]>;
 }
@@ -741,9 +987,12 @@ function buildAddColumnSql(
   columnName: string,
   column: StorageColumn,
 ): string {
+  const typeSql = buildColumnTypeSql(column);
+  const defaultSql = buildColumnDefaultSql(column.default, column);
   const parts = [
     `ALTER TABLE ${qualifiedTableName}`,
-    `ADD COLUMN ${quoteIdentifier(columnName)} ${column.nativeType}`,
+    `ADD COLUMN ${quoteIdentifier(columnName)} ${typeSql}`,
+    defaultSql,
     column.nullable ? '' : 'NOT NULL',
   ].filter(Boolean);
   return parts.join(' ');
@@ -772,15 +1021,23 @@ function tableHasPrimaryKeyCheck(
 )`;
 }
 
+/**
+ * Checks if table has a unique constraint satisfied by the given columns.
+ * Uses shared semantic satisfaction predicate from verify-helpers.
+ */
 function hasUniqueConstraint(
   table: SqlSchemaIR['tables'][string],
   columns: readonly string[],
 ): boolean {
-  return table.uniques.some((unique) => arraysEqual(unique.columns, columns));
+  return isUniqueConstraintSatisfied(table.uniques, table.indexes, columns);
 }
 
+/**
+ * Checks if table has an index satisfied by the given columns.
+ * Uses shared semantic satisfaction predicate from verify-helpers.
+ */
 function hasIndex(table: SqlSchemaIR['tables'][string], columns: readonly string[]): boolean {
-  return table.indexes.some((index) => !index.unique && arraysEqual(index.columns, columns));
+  return isIndexSatisfied(table.indexes, table.uniques, columns);
 }
 
 function hasForeignKey(table: SqlSchemaIR['tables'][string], fk: ForeignKey): boolean {
@@ -794,6 +1051,8 @@ function hasForeignKey(table: SqlSchemaIR['tables'][string], fk: ForeignKey): bo
 
 function isAdditiveIssue(issue: SchemaIssue): boolean {
   switch (issue.kind) {
+    case 'type_missing':
+    case 'type_values_mismatch':
     case 'missing_table':
     case 'missing_column':
     case 'extension_missing':
@@ -860,3 +1119,42 @@ function compareStrings(a?: string, b?: string): number {
   }
   return a < b ? -1 : 1;
 }
+
+const REFERENTIAL_ACTION_SQL: Record<ReferentialAction, string> = {
+  noAction: 'NO ACTION',
+  restrict: 'RESTRICT',
+  cascade: 'CASCADE',
+  setNull: 'SET NULL',
+  setDefault: 'SET DEFAULT',
+};
+
+function buildForeignKeySql(
+  schemaName: string,
+  tableName: string,
+  fkName: string,
+  foreignKey: ForeignKey,
+): string {
+  let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
+ADD CONSTRAINT ${quoteIdentifier(fkName)}
+FOREIGN KEY (${foreignKey.columns.map(quoteIdentifier).join(', ')})
+REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${foreignKey.references.columns
+    .map(quoteIdentifier)
+    .join(', ')})`;
+
+  if (foreignKey.onDelete !== undefined) {
+    const action = REFERENTIAL_ACTION_SQL[foreignKey.onDelete];
+    if (!action) {
+      throw new Error(`Unknown referential action for onDelete: ${String(foreignKey.onDelete)}`);
+    }
+    sql += `\nON DELETE ${action}`;
+  }
+  if (foreignKey.onUpdate !== undefined) {
+    const action = REFERENTIAL_ACTION_SQL[foreignKey.onUpdate];
+    if (!action) {
+      throw new Error(`Unknown referential action for onUpdate: ${String(foreignKey.onUpdate)}`);
+    }
+    sql += `\nON UPDATE ${action}`;
+  }
+
+  return sql;
+}