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

package/src/core/migrations/planner-identity-values.ts

@@ -1,12 +1,6 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
-import {
-  isPostgresEnumStorageEntry,
-  type PostgresEnumStorageEntry,
-  type StorageColumn,
-  type StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
-import type { PostgresEnumType } from '../postgres-enum-type';
 
 /**
  * Resolves the identity value (monoid neutral element) as a SQL literal for a column's type.
@@ -16,30 +10,12 @@ import type { PostgresEnumType } from '../postgres-enum-type';
 export function resolveIdentityValue(
   column: StorageColumn,
   codecHooks: Map<string, CodecControlHooks>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
 ): string | null {
   const referencedType = column.typeRef ? storageTypes[column.typeRef] : undefined;
-  const referencedIsEnum =
-    referencedType !== undefined && isPostgresEnumStorageEntry(referencedType);
-  const referencedBinding = referencedIsEnum
-    ? ((referencedType as PostgresEnumType).codecBinding ?? {
-        codecId: (referencedType as PostgresEnumStorageEntry).codecId,
-        typeParams: { values: (referencedType as PostgresEnumStorageEntry).values },
-      })
-    : undefined;
-  const codecId =
-    referencedBinding?.codecId ??
-    (referencedType && !referencedIsEnum
-      ? (referencedType as StorageTypeInstance).codecId
-      : undefined) ??
-    column.codecId;
+  const codecId = referencedType?.codecId ?? column.codecId;
   const nativeType = referencedType?.nativeType ?? column.nativeType;
-  const typeParams =
-    (referencedBinding?.typeParams as Record<string, unknown> | undefined) ??
-    (referencedType && !referencedIsEnum
-      ? (referencedType as StorageTypeInstance).typeParams
-      : undefined) ??
-    column.typeParams;
+  const typeParams = referencedType?.typeParams ?? column.typeParams;
 
   if (codecId) {
     const hookDefault = codecHooks.get(codecId)?.resolveIdentityValue?.({

package/src/core/migrations/planner-produced-postgres-migration.ts

@@ -24,7 +24,7 @@
  */
 
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
-import type { Lowerer } from '@prisma-next/family-sql/control-adapter';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import type {
   MigrationPlanWithAuthoringSurface,
   OpFactoryCall,
@@ -35,8 +35,6 @@ import { PostgresMigration } from './postgres-migration';
 import { renderOps } from './render-ops';
 import { renderCallsToTypeScript } from './render-typescript';
 
-type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
-
 export class TypeScriptRenderablePostgresMigration
   extends PostgresMigration
   implements MigrationPlanWithAuthoringSurface
@@ -44,13 +42,19 @@ export class TypeScriptRenderablePostgresMigration
   readonly #calls: readonly OpFactoryCall[];
   readonly #meta: MigrationMeta;
   readonly #spaceId: string;
-  readonly #lowerer: Lowerer | undefined;
+  readonly #lowerer: ExecuteRequestLowerer | undefined;
+  #operationsCache:
+    | readonly (
+        | SqlMigrationPlanOperation<PostgresPlanTargetDetails>
+        | Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>
+      )[]
+    | undefined;
 
   constructor(
     calls: readonly OpFactoryCall[],
     meta: MigrationMeta,
     spaceId: string,
-    lowerer?: Lowerer,
+    lowerer?: ExecuteRequestLowerer,
   ) {
     super();
     this.#calls = calls;
@@ -59,8 +63,12 @@ export class TypeScriptRenderablePostgresMigration
     this.#lowerer = lowerer;
   }
 
-  override get operations(): readonly Op[] {
-    return renderOps(this.#calls, this.#lowerer);
+  override get operations(): readonly (
+    | SqlMigrationPlanOperation<PostgresPlanTargetDetails>
+    | Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>
+  )[] {
+    this.#operationsCache ??= renderOps(this.#calls, this.#lowerer);
+    return this.#operationsCache;
   }
 
   override describe(): MigrationMeta {

package/src/core/migrations/planner-recipes.ts

@@ -1,17 +1,15 @@
 import type { CodecControlHooks, SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
-import type {
-  PostgresEnumStorageEntry,
-  StorageColumn,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import {
+  columnDefaultAst,
+  columnExistsAst,
+  columnNullabilityAst,
+} from '../../contract-free/checks';
 import { quoteIdentifier } from '../sql-utils';
+import { step } from './operations/shared';
 import { buildAddColumnSql } from './planner-ddl-builders';
-import {
-  columnExistsCheck,
-  columnHasNoDefaultCheck,
-  columnNullabilityCheck,
-  qualifyTableName,
-} from './planner-sql-checks';
+import { qualifyTableName } from './planner-sql-checks';
 import { buildTargetDetails, type PostgresPlanTargetDetails } from './planner-target-details';
 
 export function buildAddColumnOperationIdentity(
@@ -33,28 +31,45 @@ export function buildAddColumnOperationIdentity(
   };
 }
 
-export function buildAddNotNullColumnWithTemporaryDefaultOperation(options: {
+export async function buildAddNotNullColumnWithTemporaryDefaultOperation(options: {
   readonly schema: string;
   readonly tableName: string;
   readonly columnName: string;
   readonly column: StorageColumn;
   readonly codecHooks: Map<string, CodecControlHooks>;
-  readonly storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+  readonly storageTypes: Record<string, StorageTypeInstance>;
   readonly temporaryDefault: string;
-}): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
-  const { schema, tableName, columnName, column, codecHooks, storageTypes, temporaryDefault } =
-    options;
+  readonly lowerer: ExecuteRequestLowerer;
+}): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+  const {
+    schema,
+    tableName,
+    columnName,
+    column,
+    codecHooks,
+    storageTypes,
+    temporaryDefault,
+    lowerer,
+  } = options;
   const qualified = qualifyTableName(schema, tableName);
 
+  const absent = await lowerer.lowerToExecuteRequest(
+    columnExistsAst({ schema, table: tableName, column: columnName }).columnAbsent(),
+  );
+  const present = await lowerer.lowerToExecuteRequest(
+    columnExistsAst({ schema, table: tableName, column: columnName }).columnPresent(),
+  );
+  const notNullable = await lowerer.lowerToExecuteRequest(
+    columnNullabilityAst({ schema, table: tableName, column: columnName, nullable: false }),
+  );
+  const noDefault = await lowerer.lowerToExecuteRequest(
+    columnDefaultAst({ schema, table: tableName, column: columnName }).noDefault(),
+  );
+
   return {
     ...buildAddColumnOperationIdentity(schema, tableName, columnName),
     operationClass: 'additive',
-    precheck: [
-      {
-        description: `ensure column "${columnName}" is missing`,
-        sql: columnExistsCheck({ schema, table: tableName, column: columnName, exists: false }),
-      },
-    ],
+    precheck: [step(`ensure column "${columnName}" is missing`, absent.sql, absent.params)],
     execute: [
       {
         description: `add column "${columnName}"`,
@@ -73,23 +88,13 @@ export function buildAddNotNullColumnWithTemporaryDefaultOperation(options: {
       },
     ],
     postcheck: [
-      {
-        description: `verify column "${columnName}" exists`,
-        sql: columnExistsCheck({ schema, table: tableName, column: columnName }),
-      },
-      {
-        description: `verify column "${columnName}" is NOT NULL`,
-        sql: columnNullabilityCheck({
-          schema,
-          table: tableName,
-          column: columnName,
-          nullable: false,
-        }),
-      },
-      {
-        description: `verify column "${columnName}" has no default after temporary default removal`,
-        sql: columnHasNoDefaultCheck({ schema, table: tableName, column: columnName }),
-      },
+      step(`verify column "${columnName}" exists`, present.sql, present.params),
+      step(`verify column "${columnName}" is NOT NULL`, notNullable.sql, notNullable.params),
+      step(
+        `verify column "${columnName}" has no default after temporary default removal`,
+        noDefault.sql,
+        noDefault.params,
+      ),
     ],
   };
 }

package/src/core/migrations/planner-sql-checks.ts

@@ -1,11 +1,7 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
-import type {
-  PostgresEnumStorageEntry,
-  StorageColumn,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { postgresCreateNamespace } from '../postgres-schema';
-import { escapeLiteral, quoteIdentifier } from '../sql-utils';
+import { quoteIdentifier } from '../sql-utils';
 import { resolveColumnTypeMetadata } from './planner-type-resolution';
 
 /**
@@ -23,105 +19,6 @@ export function qualifyTableName(schema: string, table: string): string {
   return postgresCreateNamespace({ id: schema, entries: { table: {} } }).qualifyTable(table);
 }
 
-export function toRegclassLiteral(schema: string, name: string): string {
-  return postgresCreateNamespace({ id: schema, entries: { table: {} } }).regclassLiteral(name);
-}
-
-/**
- * When `table` is omitted the check matches by name + schema across all tables.
- * Pass `table` to scope the check to a single table (prevents false matches on
- * identically-named constraints in different tables).
- */
-export function constraintExistsCheck({
-  constraintName,
-  schema,
-  table,
-  exists = true,
-}: {
-  constraintName: string;
-  schema: string;
-  table?: string;
-  exists?: boolean;
-}): string {
-  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
-  const existsClause = exists ? 'EXISTS' : 'NOT EXISTS';
-  const tableFilter = table
-    ? `AND c.conrelid = to_regclass(${namespace.regclassLiteral(table)})`
-    : '';
-  return `SELECT ${existsClause} (
-  SELECT 1 FROM pg_constraint c
-  JOIN pg_namespace n ON c.connamespace = n.oid
-  WHERE c.conname = '${escapeLiteral(constraintName)}'
-  AND n.nspname = ${namespace.schemaSqlExpression()}
-  ${tableFilter}
-)`;
-}
-
-export function columnExistsCheck({
-  schema,
-  table,
-  column,
-  exists = true,
-}: {
-  schema: string;
-  table: string;
-  column: string;
-  exists?: boolean;
-}): string {
-  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
-  const existsClause = exists ? '' : 'NOT ';
-  return `SELECT ${existsClause}EXISTS (
-  SELECT 1
-  FROM information_schema.columns
-  WHERE table_schema = ${namespace.schemaSqlExpression()}
-    AND table_name = '${escapeLiteral(table)}'
-    AND column_name = '${escapeLiteral(column)}'
-)`;
-}
-
-export function columnNullabilityCheck({
-  schema,
-  table,
-  column,
-  nullable,
-}: {
-  schema: string;
-  table: string;
-  column: string;
-  nullable: boolean;
-}): string {
-  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
-  const expected = nullable ? 'YES' : 'NO';
-  return `SELECT EXISTS (
-  SELECT 1
-  FROM information_schema.columns
-  WHERE table_schema = ${namespace.schemaSqlExpression()}
-    AND table_name = '${escapeLiteral(table)}'
-    AND column_name = '${escapeLiteral(column)}'
-    AND is_nullable = '${expected}'
-)`;
-}
-
-export function tableIsEmptyCheck(qualifiedTableName: string): string {
-  return `SELECT NOT EXISTS (SELECT 1 FROM ${qualifiedTableName} LIMIT 1)`;
-}
-
-export function columnHasNoDefaultCheck(opts: {
-  schema: string;
-  table: string;
-  column: string;
-}): string {
-  const namespace = postgresCreateNamespace({ id: opts.schema, entries: { table: {} } });
-  return `SELECT NOT EXISTS (
-  SELECT 1
-  FROM information_schema.columns
-  WHERE table_schema = ${namespace.schemaSqlExpression()}
-    AND table_name = '${escapeLiteral(opts.table)}'
-    AND column_name = '${escapeLiteral(opts.column)}'
-    AND column_default IS NOT NULL
-)`;
-}
-
 const FORMAT_TYPE_DISPLAY: ReadonlyMap<string, string> = new Map([
   ['int2', 'smallint'],
   ['int4', 'integer'],
@@ -249,7 +146,7 @@ function formatUserDefinedTypeName(identifier: string): string {
 export function buildExpectedFormatType(
   column: StorageColumn,
   codecHooks: Map<string, CodecControlHooks>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
 ): string {
   const resolved = resolveColumnTypeMetadata(column, storageTypes);
 
@@ -270,75 +167,3 @@ export function buildExpectedFormatType(
 
   return FORMAT_TYPE_DISPLAY.get(resolved.nativeType) ?? resolved.nativeType;
 }
-
-export function columnTypeCheck({
-  schema,
-  table,
-  column,
-  expectedType,
-}: {
-  schema: string;
-  table: string;
-  column: string;
-  expectedType: string;
-}): string {
-  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
-  return `SELECT EXISTS (
-  SELECT 1
-  FROM pg_attribute a
-  JOIN pg_class c ON c.oid = a.attrelid
-  JOIN pg_namespace n ON n.oid = c.relnamespace
-  WHERE n.nspname = ${namespace.schemaSqlExpression()}
-    AND c.relname = '${escapeLiteral(table)}'
-    AND a.attname = '${escapeLiteral(column)}'
-    AND format_type(a.atttypid, a.atttypmod) = '${escapeLiteral(expectedType)}'
-    AND NOT a.attisdropped
-)`;
-}
-
-export function columnDefaultExistsCheck({
-  schema,
-  table,
-  column,
-  exists = true,
-}: {
-  schema: string;
-  table: string;
-  column: string;
-  exists?: boolean;
-}): string {
-  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
-  const nullCheck = exists ? 'IS NOT NULL' : 'IS NULL';
-  return `SELECT EXISTS (
-  SELECT 1
-  FROM information_schema.columns
-  WHERE table_schema = ${namespace.schemaSqlExpression()}
-    AND table_name = '${escapeLiteral(table)}'
-    AND column_name = '${escapeLiteral(column)}'
-    AND column_default ${nullCheck}
-)`;
-}
-
-export function tableHasPrimaryKeyCheck(
-  schema: string,
-  table: string,
-  exists: boolean,
-  constraintName?: string,
-): string {
-  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
-  const comparison = exists ? '' : 'NOT ';
-  const constraintFilter = constraintName
-    ? `AND c2.relname = '${escapeLiteral(constraintName)}'`
-    : '';
-  return `SELECT ${comparison}EXISTS (
-  SELECT 1
-  FROM pg_index i
-  JOIN pg_class c ON c.oid = i.indrelid
-  JOIN pg_namespace n ON n.oid = c.relnamespace
-  LEFT JOIN pg_class c2 ON c2.oid = i.indexrelid
-  WHERE n.nspname = ${namespace.schemaSqlExpression()}
-    AND c.relname = '${escapeLiteral(table)}'
-    AND i.indisprimary
-    ${constraintFilter}
-)`;
-}