@prisma-next/target-postgres 0.13.0 → 0.14.0-dev.2

package/src/core/migrations/operations/constraints.ts

@@ -1,8 +1,23 @@
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
+import { constraintExistsAst } from '../../../contract-free/checks';
 import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
-import { constraintExistsCheck, qualifyTableName } from '../planner-sql-checks';
+import { qualifyTableName } from '../planner-sql-checks';
 import { type ForeignKeySpec, type Op, step, targetDetails } from './shared';
 
+async function constraintCheckSteps(
+  lowerer: ExecuteRequestLowerer,
+  options: { constraintName: string; schema: string; table: string },
+): Promise<{
+  absent: { sql: string; params?: readonly unknown[] };
+  present: { sql: string; params?: readonly unknown[] };
+}> {
+  const checks = constraintExistsAst(options);
+  const absent = await lowerer.lowerToExecuteRequest(checks.constraintAbsent());
+  const present = await lowerer.lowerToExecuteRequest(checks.constraintPresent());
+  return { absent, present };
+}
+
 function renderForeignKeySql(schemaName: string, tableName: string, fk: ForeignKeySpec): string {
   let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
 ADD CONSTRAINT ${quoteIdentifier(fk.name)}
@@ -28,29 +43,27 @@ REFERENCES ${qualifyTableName(fk.references.schema, fk.references.table)} (${fk.
   return sql;
 }
 
-export function addPrimaryKey(
+export async function addPrimaryKey(
   schemaName: string,
   tableName: string,
   constraintName: string,
   columns: readonly string[],
-): Op {
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
   const columnList = columns.map(quoteIdentifier).join(', ');
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `primaryKey.${tableName}.${constraintName}`,
     label: `Add primary key on "${tableName}"`,
     operationClass: 'additive',
     target: targetDetails('primaryKey', constraintName, schemaName, tableName),
     precheck: [
-      step(
-        `ensure primary key "${constraintName}" does not exist`,
-        constraintExistsCheck({
-          constraintName,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
+      step(`ensure primary key "${constraintName}" does not exist`, absent.sql, absent.params),
     ],
     execute: [
       step(
@@ -58,38 +71,31 @@ export function addPrimaryKey(
         `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} PRIMARY KEY (${columnList})`,
       ),
     ],
-    postcheck: [
-      step(
-        `verify primary key "${constraintName}" exists`,
-        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
-      ),
-    ],
+    postcheck: [step(`verify primary key "${constraintName}" exists`, present.sql, present.params)],
   };
 }
 
-export function addUnique(
+export async function addUnique(
   schemaName: string,
   tableName: string,
   constraintName: string,
   columns: readonly string[],
-): Op {
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
   const columnList = columns.map(quoteIdentifier).join(', ');
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `unique.${tableName}.${constraintName}`,
     label: `Add unique constraint on "${tableName}" (${columns.join(', ')})`,
     operationClass: 'additive',
     target: targetDetails('unique', constraintName, schemaName, tableName),
     precheck: [
-      step(
-        `ensure constraint "${constraintName}" does not exist`,
-        constraintExistsCheck({
-          constraintName,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
+      step(`ensure constraint "${constraintName}" does not exist`, absent.sql, absent.params),
     ],
     execute: [
       step(
@@ -97,70 +103,54 @@ export function addUnique(
         `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} UNIQUE (${columnList})`,
       ),
     ],
-    postcheck: [
-      step(
-        `verify constraint "${constraintName}" exists`,
-        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
-      ),
-    ],
+    postcheck: [step(`verify constraint "${constraintName}" exists`, present.sql, present.params)],
   };
 }
 
-export function addForeignKey(schemaName: string, tableName: string, fk: ForeignKeySpec): Op {
+export async function addForeignKey(
+  schemaName: string,
+  tableName: string,
+  fk: ForeignKeySpec,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName: fk.name,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `foreignKey.${tableName}.${fk.name}`,
     label: `Add foreign key "${fk.name}" on "${tableName}"`,
     operationClass: 'additive',
     target: targetDetails('foreignKey', fk.name, schemaName, tableName),
-    precheck: [
-      step(
-        `ensure FK "${fk.name}" does not exist`,
-        constraintExistsCheck({
-          constraintName: fk.name,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
-    ],
+    precheck: [step(`ensure FK "${fk.name}" does not exist`, absent.sql, absent.params)],
     execute: [step(`add FK "${fk.name}"`, renderForeignKeySql(schemaName, tableName, fk))],
-    postcheck: [
-      step(
-        `verify FK "${fk.name}" exists`,
-        constraintExistsCheck({
-          constraintName: fk.name,
-          schema: schemaName,
-          table: tableName,
-        }),
-      ),
-    ],
+    postcheck: [step(`verify FK "${fk.name}" exists`, present.sql, present.params)],
   };
 }
 
-export function addCheckConstraint(
+export async function addCheckConstraint(
   schemaName: string,
   tableName: string,
   constraintName: string,
   column: string,
   values: readonly string[],
-): Op {
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
   const valueList = values.map((v) => `'${escapeLiteral(v)}'`).join(', ');
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `checkConstraint.${tableName}.${constraintName}`,
     label: `Add check constraint "${constraintName}" on "${tableName}"."${column}"`,
     operationClass: 'additive',
     target: targetDetails('checkConstraint', constraintName, schemaName, tableName),
     precheck: [
-      step(
-        `ensure constraint "${constraintName}" does not exist`,
-        constraintExistsCheck({
-          constraintName,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
+      step(`ensure constraint "${constraintName}" does not exist`, absent.sql, absent.params),
     ],
     execute: [
       step(
@@ -168,32 +158,28 @@ export function addCheckConstraint(
         `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} CHECK (${quoteIdentifier(column)} IN (${valueList}))`,
       ),
     ],
-    postcheck: [
-      step(
-        `verify constraint "${constraintName}" exists`,
-        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
-      ),
-    ],
+    postcheck: [step(`verify constraint "${constraintName}" exists`, present.sql, present.params)],
   };
 }
 
-export function dropCheckConstraint(
+export async function dropCheckConstraint(
   schemaName: string,
   tableName: string,
   constraintName: string,
-): Op {
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `dropCheckConstraint.${tableName}.${constraintName}`,
     label: `Drop check constraint "${constraintName}" on "${tableName}"`,
     operationClass: 'destructive',
     target: targetDetails('checkConstraint', constraintName, schemaName, tableName),
-    precheck: [
-      step(
-        `ensure constraint "${constraintName}" exists`,
-        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
-      ),
-    ],
+    precheck: [step(`ensure constraint "${constraintName}" exists`, present.sql, present.params)],
     execute: [
       step(
         `drop check constraint "${constraintName}"`,
@@ -201,15 +187,7 @@ export function dropCheckConstraint(
       ),
     ],
     postcheck: [
-      step(
-        `verify constraint "${constraintName}" does not exist`,
-        constraintExistsCheck({
-          constraintName,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
+      step(`verify constraint "${constraintName}" does not exist`, absent.sql, absent.params),
     ],
   };
 }
@@ -221,24 +199,25 @@ export function dropCheckConstraint(
  * (`'foreignKey'`, `'primaryKey'`, or `'unique'`) based on the `SchemaIssue`
  * that produced the drop.
  */
-export function dropConstraint(
+export async function dropConstraint(
   schemaName: string,
   tableName: string,
   constraintName: string,
+  lowerer: ExecuteRequestLowerer,
   kind: 'foreignKey' | 'unique' | 'primaryKey' = 'unique',
-): Op {
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
+  const { absent, present } = await constraintCheckSteps(lowerer, {
+    constraintName,
+    schema: schemaName,
+    table: tableName,
+  });
   return {
     id: `dropConstraint.${tableName}.${constraintName}`,
     label: `Drop constraint "${constraintName}" on "${tableName}"`,
     operationClass: 'destructive',
     target: targetDetails(kind, constraintName, schemaName, tableName),
-    precheck: [
-      step(
-        `ensure constraint "${constraintName}" exists`,
-        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
-      ),
-    ],
+    precheck: [step(`ensure constraint "${constraintName}" exists`, present.sql, present.params)],
     execute: [
       step(
         `drop constraint "${constraintName}"`,
@@ -246,15 +225,7 @@ export function dropConstraint(
       ),
     ],
     postcheck: [
-      step(
-        `verify constraint "${constraintName}" does not exist`,
-        constraintExistsCheck({
-          constraintName,
-          schema: schemaName,
-          table: tableName,
-          exists: false,
-        }),
-      ),
+      step(`verify constraint "${constraintName}" does not exist`, absent.sql, absent.params),
     ],
   };
 }

package/src/core/migrations/operations/data-transform.ts

@@ -61,8 +61,8 @@ import type {
   SqlMigrationPlanOperationStep,
 } from '@prisma-next/family-sql/control';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
-import type { SerializedQueryPlan } from '@prisma-next/framework-components/control';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import type { SqlExecuteRequest } from '@prisma-next/sql-relational-core/ast';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { PostgresPlanTargetDetails } from '../planner-target-details';
@@ -96,25 +96,29 @@ export interface DataTransformOptions {
   readonly run: DataTransformClosure | readonly DataTransformClosure[];
 }
 
-export function dataTransform<TContract extends Contract<SqlStorage>>(
+export async function dataTransform<TContract extends Contract<SqlStorage>>(
   contract: TContract,
   name: string,
   options: DataTransformOptions,
   adapter: SqlControlAdapter<'postgres'>,
-): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
   const runClosures: readonly DataTransformClosure[] = Array.isArray(options.run)
     ? options.run
     : [options.run as DataTransformClosure];
 
-  const checkPlan = options.check ? invokeAndLower(options.check, contract, adapter, name) : null;
-  const runPlans = runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name));
+  const checkPlan = options.check
+    ? await invokeAndLower(options.check, contract, adapter, name)
+    : null;
+  const runPlans = await Promise.all(
+    runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name)),
+  );
 
   const precheck: readonly SqlMigrationPlanOperationStep[] = checkPlan
     ? [
         {
           description: `Check ${name} has work to do`,
           sql: `SELECT EXISTS (${checkPlan.sql}) AS ok`,
-          params: checkPlan.params,
+          params: checkPlan.params ?? [],
         },
       ]
     : [];
@@ -122,7 +126,7 @@ export function dataTransform<TContract extends Contract<SqlStorage>>(
   const execute: readonly SqlMigrationPlanOperationStep[] = runPlans.map((plan) => ({
     description: `Run ${name}`,
     sql: plan.sql,
-    params: plan.params,
+    params: plan.params ?? [],
   }));
 
   const postcheck: readonly SqlMigrationPlanOperationStep[] = checkPlan
@@ -130,7 +134,7 @@ export function dataTransform<TContract extends Contract<SqlStorage>>(
         {
           description: `Verify ${name} resolved all violations`,
           sql: `SELECT NOT EXISTS (${checkPlan.sql}) AS ok`,
-          params: checkPlan.params,
+          params: checkPlan.params ?? [],
         },
       ]
     : [];
@@ -147,23 +151,16 @@ export function dataTransform<TContract extends Contract<SqlStorage>>(
   };
 }
 
-function invokeAndLower(
+async function invokeAndLower(
   closure: DataTransformClosure,
   contract: Contract<SqlStorage>,
   adapter: SqlControlAdapter<'postgres'>,
   name: string,
-): SerializedQueryPlan {
+): Promise<SqlExecuteRequest> {
   const result = closure();
   const plan = isBuildable(result) ? result.build() : result;
   assertContractMatches(plan, contract, name);
-  const lowered = adapter.lower(plan.ast, { contract });
-  const params = lowered.params.map((slot) => {
-    if (slot.kind === 'literal') return slot.value;
-    throw new Error(
-      `data-transform: bind-site slot '${slot.name}' is not allowed in migration plans`,
-    );
-  });
-  return { sql: lowered.sql, params };
+  return adapter.lowerToExecuteRequest(plan.ast, { contract });
 }
 
 function isBuildable(value: unknown): value is Buildable {

package/src/core/migrations/operations/dependencies.ts

@@ -1,3 +1,5 @@
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { extensionExistsAst } from '../../../contract-free/checks';
 import { quoteIdentifier } from '../../sql-utils';
 import { type Op, step } from './shared';
 
@@ -32,14 +34,20 @@ export function createExtension(extensionName: string): Op {
  * use the bare {@link createExtension} for planner-emitted ops where the
  * caller already controls idempotency through the surrounding plan.
  */
-export function installExtension(options: {
-  readonly extensionName: string;
-  readonly invariantId: string;
-  readonly id: string;
-  readonly label?: string;
-}): Op {
+export async function installExtension(
+  options: {
+    readonly extensionName: string;
+    readonly invariantId: string;
+    readonly id: string;
+    readonly label?: string;
+  },
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const { extensionName, invariantId, id } = options;
   const label = options.label ?? `Enable extension "${extensionName}"`;
+  const checks = extensionExistsAst(extensionName);
+  const absent = await lowerer.lowerToExecuteRequest(checks.extensionAbsent());
+  const present = await lowerer.lowerToExecuteRequest(checks.extensionPresent());
   return {
     id,
     label,
@@ -50,10 +58,7 @@ export function installExtension(options: {
       details: { schema: 'public', objectType: 'dependency', name: extensionName },
     },
     precheck: [
-      step(
-        `verify extension "${extensionName}" is not already enabled`,
-        `SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`,
-      ),
+      step(`verify extension "${extensionName}" is not already enabled`, absent.sql, absent.params),
     ],
     execute: [
       step(
@@ -62,10 +67,7 @@ export function installExtension(options: {
       ),
     ],
     postcheck: [
-      step(
-        `confirm extension "${extensionName}" is enabled`,
-        `SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`,
-      ),
+      step(`confirm extension "${extensionName}" is enabled`, present.sql, present.params),
     ],
   };
 }

package/src/core/migrations/operations/indexes.ts

@@ -1,7 +1,22 @@
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { indexExistsAst } from '../../../contract-free/checks';
 import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
-import { qualifyTableName, toRegclassLiteral } from '../planner-sql-checks';
+import { qualifyTableName } from '../planner-sql-checks';
 import { type Op, step, targetDetails } from './shared';
 
+type CheckStep = { sql: string; params?: readonly unknown[] };
+
+async function indexExistsSteps(
+  lowerer: ExecuteRequestLowerer,
+  schemaName: string,
+  indexName: string,
+): Promise<{ present: CheckStep; absent: CheckStep }> {
+  const checks = indexExistsAst(schemaName, indexName);
+  const present = await lowerer.lowerToExecuteRequest(checks.indexPresent());
+  const absent = await lowerer.lowerToExecuteRequest(checks.indexAbsent());
+  return { present, absent };
+}
+
 export interface CreateIndexExtras {
   readonly type?: string;
   readonly options?: Record<string, unknown>;
@@ -22,65 +37,53 @@ function renderIndexOptions(options: Record<string, unknown>): string {
     .join(', ');
 }
 
-export function createIndex(
+export async function createIndex(
   schemaName: string,
   tableName: string,
   indexName: string,
   columns: readonly string[],
+  lowerer: ExecuteRequestLowerer,
   extras?: CreateIndexExtras,
-): Op {
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
   const columnList = columns.map(quoteIdentifier).join(', ');
   const using = extras?.type ? ` USING ${quoteIdentifier(extras.type)}` : '';
   const options = extras?.options;
   const withClause =
     options && Object.keys(options).length > 0 ? ` WITH (${renderIndexOptions(options)})` : '';
+  const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
   return {
     id: `index.${tableName}.${indexName}`,
     label: `Create index "${indexName}" on "${tableName}"`,
     operationClass: 'additive',
     target: targetDetails('index', indexName, schemaName, tableName),
-    precheck: [
-      step(
-        `ensure index "${indexName}" does not exist`,
-        `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`,
-      ),
-    ],
+    precheck: [step(`ensure index "${indexName}" does not exist`, absent.sql, absent.params)],
     execute: [
       step(
         `create index "${indexName}"`,
         `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified}${using} (${columnList})${withClause}`,
       ),
     ],
-    postcheck: [
-      step(
-        `verify index "${indexName}" exists`,
-        `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`,
-      ),
-    ],
+    postcheck: [step(`verify index "${indexName}" exists`, present.sql, present.params)],
   };
 }
 
-export function dropIndex(schemaName: string, tableName: string, indexName: string): Op {
+export async function dropIndex(
+  schemaName: string,
+  tableName: string,
+  indexName: string,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
   return {
     id: `dropIndex.${tableName}.${indexName}`,
     label: `Drop index "${indexName}"`,
     operationClass: 'destructive',
     target: targetDetails('index', indexName, schemaName, tableName),
-    precheck: [
-      step(
-        `ensure index "${indexName}" exists`,
-        `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`,
-      ),
-    ],
+    precheck: [step(`ensure index "${indexName}" exists`, present.sql, present.params)],
     execute: [
       step(`drop index "${indexName}"`, `DROP INDEX ${qualifyTableName(schemaName, indexName)}`),
     ],
-    postcheck: [
-      step(
-        `verify index "${indexName}" does not exist`,
-        `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`,
-      ),
-    ],
+    postcheck: [step(`verify index "${indexName}" does not exist`, absent.sql, absent.params)],
   };
 }

package/src/core/migrations/operations/shared.ts

@@ -42,8 +42,8 @@ export interface ForeignKeySpec {
   readonly onUpdate?: ReferentialAction;
 }
 
-export function step(description: string, sql: string) {
-  return { description, sql };
+export function step(description: string, sql: string, params?: readonly unknown[]) {
+  return { description, sql, ...ifDefined('params', params) };
 }
 
 export function targetDetails(

package/src/core/migrations/operations/tables.ts

@@ -1,25 +1,24 @@
-import { qualifyTableName, toRegclassLiteral } from '../planner-sql-checks';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { tableExistsAst } from '../../../contract-free/checks';
+import { qualifyTableName } from '../planner-sql-checks';
 import { type Op, step, targetDetails } from './shared';
 
-export function dropTable(schemaName: string, tableName: string): Op {
+export async function dropTable(
+  schemaName: string,
+  tableName: string,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const qualified = qualifyTableName(schemaName, tableName);
+  const checks = tableExistsAst(schemaName, tableName);
+  const present = await lowerer.lowerToExecuteRequest(checks.tablePresent());
+  const absent = await lowerer.lowerToExecuteRequest(checks.tableAbsent());
   return {
     id: `dropTable.${tableName}`,
     label: `Drop table "${tableName}"`,
     operationClass: 'destructive',
     target: targetDetails('table', tableName, schemaName),
-    precheck: [
-      step(
-        `ensure table "${tableName}" exists`,
-        `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`,
-      ),
-    ],
+    precheck: [step(`ensure table "${tableName}" exists`, present.sql, present.params)],
     execute: [step(`drop table "${tableName}"`, `DROP TABLE ${qualified}`)],
-    postcheck: [
-      step(
-        `verify table "${tableName}" does not exist`,
-        `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`,
-      ),
-    ],
+    postcheck: [step(`verify table "${tableName}" does not exist`, absent.sql, absent.params)],
   };
 }

package/src/core/migrations/planner-ddl-builders.ts

@@ -1,6 +1,5 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
 import type {
-  PostgresEnumStorageEntry,
   StorageColumn,
   StorageTable,
   StorageTypeInstance,
@@ -14,7 +13,7 @@ export function buildCreateTableSql(
   qualifiedTableName: string,
   table: StorageTable,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
 ): string {
   const columnDefinitions = Object.entries(table.columns).map(
     ([columnName, column]: [string, StorageColumn]) => {
@@ -79,7 +78,7 @@ function assertSafeDefaultExpression(expression: string): void {
 export function buildColumnTypeSql(
   column: StorageColumn,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
   allowPseudoTypes = true,
 ): string {
   const resolved = resolveColumnTypeMetadata(column, storageTypes);
@@ -200,7 +199,7 @@ export function buildAddColumnSql(
   column: StorageColumn,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
   temporaryDefault?: string | null,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
 ): string {
   const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
   const defaultSql =