@prisma-next/target-postgres 0.14.0-dev.8 → 0.14.0-dev.81

package/src/core/migrations/op-factory-call.ts

@@ -38,10 +38,22 @@ import { FunctionColumnDefault, LiteralColumnDefault } from '@prisma-next/sql-re
 import { type ImportRequirement, jsonToTsSource, TsExpression } from '@prisma-next/ts-render';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { columnExistsAst, tableExistsAst } from '../../contract-free/checks';
+import {
+  columnExistsAst,
+  nativeEnumTypeExistsAst,
+  nativeEnumValueExistsAst,
+  tableExistsAst,
+} from '../../contract-free/checks';
 import * as contractFreeDdl from '../../contract-free/ddl';
-import { escapeLiteral, quoteIdentifier } from '../sql-utils';
+import type { PostgresRlsPolicy } from '../postgres-rls-policy';
+import {
+  escapeLiteral,
+  quoteIdentifier,
+  quoteQualifiedName,
+  validateEnumValueLength,
+} from '../sql-utils';
 import type { PostgresColumnDefault } from '../types';
+import { boundSchema } from './bound-schema';
 import {
   addNotNullColumnDirect,
   alterColumnType,
@@ -61,6 +73,14 @@ import {
 } from './operations/constraints';
 import { createExtension } from './operations/dependencies';
 import { createIndex, dropIndex } from './operations/indexes';
+import { createNativeEnumType, dropNativeEnumType } from './operations/native-enum-types';
+import {
+  createRlsPolicy,
+  disableRowLevelSecurity,
+  dropRlsPolicy,
+  enableRowLevelSecurity,
+  renameRlsPolicy,
+} from './operations/rls';
 import type { ForeignKeySpec } from './operations/shared';
 import { step, targetDetails } from './operations/shared';
 import { dropTable } from './operations/tables';
@@ -83,10 +103,6 @@ type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 // transitive package on disk.
 const POSTGRES_MIGRATION_FACADE = '@prisma-next/postgres/migration';
 
-function boundSchema(schemaName: string): string | undefined {
-  return schemaName === UNBOUND_NAMESPACE_ID ? undefined : schemaName;
-}
-
 abstract class PostgresOpFactoryCallNode extends TsExpression implements FrameworkOpFactoryCall {
   abstract readonly factoryName: string;
   abstract readonly operationClass: MigrationOperationClass;
@@ -169,6 +185,8 @@ function renderDdlConstraintAsTsCall(constraint: DdlTableConstraint): string {
       const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : '';
       return `unique(${jsonToTsSource(constraint.columns)}${nameOpt})`;
     }
+    case 'check-expression':
+      return `checkExpression(${jsonToTsSource(constraint.name)}, ${jsonToTsSource(constraint.expression)})`;
   }
 }
 
@@ -183,6 +201,7 @@ function constraintImportSymbols(constraints: readonly DdlTableConstraint[] | un
     if (c.kind === 'primary-key') symbols.add('primaryKey');
     else if (c.kind === 'foreign-key') symbols.add('foreignKey');
     else if (c.kind === 'unique') symbols.add('unique');
+    else if (c.kind === 'check-expression') symbols.add('checkExpression');
   }
   return [...symbols];
 }
@@ -684,10 +703,8 @@ export class DropDefaultCall extends PostgresOpFactoryCallNode {
 
 /**
  * Planner-internal call for adding a NOT NULL column (no contract default) to
- * a table that must be empty at migration time. Carries the raw ADD COLUMN SQL
- * (produced by `buildAddColumnSql` at plan time — deferred from slice-7 typed
- * DDL) plus the parameters needed to lower the typed pre/postchecks at render
- * time.
+ * a table that must be empty at migration time. Carries the typed `DdlColumn`
+ * and lowers it to an ADD COLUMN execute step via the adapter at `toOp` time.
  *
  * No authored `PostgresMigration` method: this call is only emitted by the
  * planner, never hand-written by migration authors.
@@ -698,15 +715,15 @@ export class AddNotNullColumnDirectCall extends PostgresOpFactoryCallNode {
   readonly schemaName: string;
   readonly tableName: string;
   readonly columnName: string;
-  readonly executeStepSql: string;
+  readonly column: DdlColumn;
   readonly label: string;
 
-  constructor(schemaName: string, tableName: string, columnName: string, executeStepSql: string) {
+  constructor(schemaName: string, tableName: string, columnName: string, column: DdlColumn) {
     super();
     this.schemaName = schemaName;
     this.tableName = tableName;
     this.columnName = columnName;
-    this.executeStepSql = executeStepSql;
+    this.column = column;
     this.label = `Add column ${columnName} to ${tableName}`;
     this.freeze();
   }
@@ -717,13 +734,7 @@ export class AddNotNullColumnDirectCall extends PostgresOpFactoryCallNode {
         `AddNotNullColumnDirectCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
       );
     }
-    return addNotNullColumnDirect(
-      this.schemaName,
-      this.tableName,
-      this.columnName,
-      this.executeStepSql,
-      lowerer,
-    );
+    return addNotNullColumnDirect(this.schemaName, this.tableName, this.column, lowerer);
   }
 
   renderTypeScript(): string {
@@ -738,9 +749,9 @@ export class AddNotNullColumnDirectCall extends PostgresOpFactoryCallNode {
 /**
  * Planner-internal call for adding a NOT NULL column (no contract default)
  * using a temporary default value for non-empty tables. Carries all parameters
- * needed for `buildAddNotNullColumnWithTemporaryDefaultOperation`; the typed
- * pre/postchecks are lowered at render time via `toOp(lowerer)`. The execute
- * SQL (`buildAddColumnSql`) is still raw per slice-7 deferral.
+ * needed for `buildAddNotNullColumnWithTemporaryDefaultOperation`; both the
+ * typed ADD COLUMN execute step and the pre/postchecks are lowered via the
+ * adapter at `toOp` time.
  *
  * No authored `PostgresMigration` method: this call is only emitted by the
  * planner, never hand-written by migration authors.
@@ -1318,6 +1329,184 @@ export class CreateSchemaCall extends PostgresOpFactoryCallNode {
   }
 }
 
+// ============================================================================
+// Native enum types
+// ============================================================================
+
+export class CreateNativeEnumTypeCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'createNativeEnumType' as const;
+  readonly operationClass = 'additive' as const;
+  readonly schemaName: string;
+  readonly typeName: string;
+  readonly members: readonly string[];
+  readonly label: string;
+
+  constructor(schemaName: string, typeName: string, members: readonly string[]) {
+    super();
+    this.schemaName = schemaName;
+    this.typeName = typeName;
+    this.members = Object.freeze([...members]);
+    this.label = `Create enum type "${typeName}"`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `CreateNativeEnumTypeCall.toOp: a DDL lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+      );
+    }
+    return createNativeEnumType(this.schemaName, this.typeName, this.members, lowerer);
+  }
+
+  renderTypeScript(): string {
+    const opts = [
+      `schema: ${jsonToTsSource(this.schemaName)}`,
+      `typeName: ${jsonToTsSource(this.typeName)}`,
+      `members: ${jsonToTsSource(this.members)}`,
+    ];
+    return `this.createNativeEnumType({ ${opts.join(', ')} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
+  }
+}
+
+export class DropNativeEnumTypeCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'dropNativeEnumType' as const;
+  readonly operationClass = 'destructive' as const;
+  readonly schemaName: string;
+  readonly typeName: string;
+  readonly label: string;
+
+  constructor(schemaName: string, typeName: string) {
+    super();
+    this.schemaName = schemaName;
+    this.typeName = typeName;
+    this.label = `Drop enum type "${typeName}"`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `DropNativeEnumTypeCall.toOp: a DDL lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+      );
+    }
+    return dropNativeEnumType(this.schemaName, this.typeName, lowerer);
+  }
+
+  renderTypeScript(): string {
+    const opts = [
+      `schema: ${jsonToTsSource(this.schemaName)}`,
+      `typeName: ${jsonToTsSource(this.typeName)}`,
+    ];
+    return `this.dropNativeEnumType({ ${opts.join(', ')} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
+  }
+}
+
+/** Schema-qualified, quoted enum type name — unqualified when `schemaName` is the unbound sentinel, matching `boundSchema`'s DDL-node convention. */
+function qualifiedNativeEnumTypeName(schemaName: string, typeName: string): string {
+  const bound = boundSchema(schemaName);
+  return quoteQualifiedName(bound === undefined ? typeName : `${bound}.${typeName}`);
+}
+
+const ADD_VALUE_TRANSACTION_CAVEAT =
+  'A newly added enum value cannot be used until the transaction that adds it commits, so a ' +
+  'migration that both appends a value and uses it in the same step will fail at apply.';
+
+/**
+ * `ALTER TYPE <qualified> ADD VALUE '<value>'` for a suffix-appended member on
+ * a managed native enum. Built directly as SQL text (qualified via
+ * `quoteQualifiedName`, the value escaped via `escapeLiteral`) rather than a
+ * typed DDL node — mirrors how `enableRowLevelSecurity` renders its execute
+ * step, since no DDL-AST node exists for this statement. Prechecks/postchecks
+ * are still typed catalog queries lowered through the control adapter.
+ * `validateEnumValueLength` runs at construction, so an over-length value
+ * fails before planning produces a call.
+ */
+export class AddNativeEnumValueCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'addNativeEnumValue' as const;
+  readonly operationClass = 'additive' as const;
+  readonly schemaName: string;
+  readonly typeName: string;
+  readonly value: string;
+  readonly label: string;
+  readonly summary: string;
+
+  constructor(schemaName: string, typeName: string, value: string) {
+    super();
+    validateEnumValueLength(value, typeName);
+    this.schemaName = schemaName;
+    this.typeName = typeName;
+    this.value = value;
+    this.label = `Add value "${value}" to enum type "${typeName}"`;
+    this.summary = `Adds value "${value}" to enum type "${typeName}". ${ADD_VALUE_TRANSACTION_CAVEAT}`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `AddNativeEnumValueCall.toOp: a lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+      );
+    }
+    const { schemaName, typeName, value } = this;
+    const typeChecks = nativeEnumTypeExistsAst(schemaName, typeName);
+    const valueChecks = nativeEnumValueExistsAst({ schema: schemaName, typeName, value });
+    const typePresent = await lowerer.lowerToExecuteRequest(typeChecks.typePresent());
+    const valueAbsent = await lowerer.lowerToExecuteRequest(valueChecks.valueAbsent());
+    const valuePresent = await lowerer.lowerToExecuteRequest(valueChecks.valuePresent());
+    const qualifiedType = qualifiedNativeEnumTypeName(schemaName, typeName);
+    return {
+      id: `addNativeEnumValue.${typeName}.${value}`,
+      label: this.label,
+      summary: this.summary,
+      operationClass: 'additive',
+      target: targetDetails('type', typeName, schemaName),
+      precheck: [
+        step(`ensure enum type "${typeName}" exists`, typePresent.sql, typePresent.params),
+        step(
+          `ensure value "${value}" is absent from enum type "${typeName}"`,
+          valueAbsent.sql,
+          valueAbsent.params,
+        ),
+      ],
+      execute: [
+        step(
+          `add value "${value}" to enum type "${typeName}"`,
+          `ALTER TYPE ${qualifiedType} ADD VALUE '${escapeLiteral(value)}'`,
+        ),
+      ],
+      postcheck: [
+        step(
+          `verify value "${value}" exists on enum type "${typeName}"`,
+          valuePresent.sql,
+          valuePresent.params,
+        ),
+      ],
+    };
+  }
+
+  renderTypeScript(): string {
+    const opts = [
+      `schema: ${jsonToTsSource(this.schemaName)}`,
+      `typeName: ${jsonToTsSource(this.typeName)}`,
+      `value: ${jsonToTsSource(this.value)}`,
+    ];
+    return `this.addNativeEnumValue({ ${opts.join(', ')} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
+  }
+}
+
 // ============================================================================
 // Data transform
 // ============================================================================
@@ -1376,6 +1565,169 @@ export class DataTransformCall extends PostgresOpFactoryCallNode {
   }
 }
 
+export class CreatePostgresRlsPolicyCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'createRlsPolicy' as const;
+  readonly operationClass = 'additive' as const;
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly policy: PostgresRlsPolicy;
+  readonly label: string;
+
+  constructor(schemaName: string, tableName: string, policy: PostgresRlsPolicy) {
+    super();
+    this.schemaName = schemaName;
+    this.tableName = tableName;
+    this.policy = policy;
+    this.label = `Create RLS policy "${policy.name}" on "${tableName}"`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `CreatePostgresRlsPolicyCall.toOp: a lowerer is required on the Postgres planner path (policy "${this.policy.name}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+      );
+    }
+    return createRlsPolicy(this.schemaName, this.tableName, this.policy, lowerer);
+  }
+
+  renderTypeScript(): string {
+    return `createRlsPolicy(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.policy)})`;
+  }
+}
+
+export class DropPostgresRlsPolicyCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'dropRlsPolicy' as const;
+  readonly operationClass = 'destructive' as const;
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly policyName: string;
+  readonly label: string;
+
+  constructor(schemaName: string, tableName: string, policyName: string) {
+    super();
+    this.schemaName = schemaName;
+    this.tableName = tableName;
+    this.policyName = policyName;
+    this.label = `Drop RLS policy "${policyName}" on "${tableName}"`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `DropPostgresRlsPolicyCall.toOp: a lowerer is required on the Postgres planner path (policy "${this.policyName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+      );
+    }
+    return dropRlsPolicy(this.schemaName, this.tableName, this.policyName, lowerer);
+  }
+
+  renderTypeScript(): string {
+    return `dropRlsPolicy(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.policyName)})`;
+  }
+}
+
+export class EnableRowLevelSecurityCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'enableRowLevelSecurity' as const;
+  readonly operationClass = 'additive' as const;
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly label: string;
+
+  constructor(schemaName: string, tableName: string) {
+    super();
+    this.schemaName = schemaName;
+    this.tableName = tableName;
+    this.label = `Enable row-level security on "${tableName}"`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `EnableRowLevelSecurityCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+      );
+    }
+    return enableRowLevelSecurity(this.schemaName, this.tableName, lowerer);
+  }
+
+  renderTypeScript(): string {
+    return `enableRowLevelSecurity(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)})`;
+  }
+}
+
+export class DisableRowLevelSecurityCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'disableRowLevelSecurity' as const;
+  readonly operationClass = 'destructive' as const;
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly label: string;
+
+  constructor(schemaName: string, tableName: string) {
+    super();
+    this.schemaName = schemaName;
+    this.tableName = tableName;
+    this.label = `Disable row-level security on "${tableName}"`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `DisableRowLevelSecurityCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+      );
+    }
+    return disableRowLevelSecurity(this.schemaName, this.tableName, lowerer);
+  }
+
+  renderTypeScript(): string {
+    return `disableRowLevelSecurity(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)})`;
+  }
+}
+
+export class RenamePostgresRlsPolicyCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'renameRlsPolicy' as const;
+  // `widening` is chosen so the rename plans under every allowance set except
+  // additive-only init — a rename is neither additive-creation nor
+  // destructive, and the class vocabulary has no neutral middle class. It is
+  // NOT that a rename widens anything; this is the accepted typology tradeoff.
+  readonly operationClass = 'widening' as const;
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly oldPolicyName: string;
+  readonly newPolicyName: string;
+  readonly label: string;
+
+  constructor(schemaName: string, tableName: string, oldPolicyName: string, newPolicyName: string) {
+    super();
+    this.schemaName = schemaName;
+    this.tableName = tableName;
+    this.oldPolicyName = oldPolicyName;
+    this.newPolicyName = newPolicyName;
+    this.label = `Rename RLS policy "${oldPolicyName}" to "${newPolicyName}" on "${tableName}"`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `RenamePostgresRlsPolicyCall.toOp: a lowerer is required on the Postgres planner path (policy "${this.oldPolicyName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+      );
+    }
+    return renameRlsPolicy(
+      this.schemaName,
+      this.tableName,
+      this.oldPolicyName,
+      this.newPolicyName,
+      lowerer,
+    );
+  }
+
+  renderTypeScript(): string {
+    return `renameRlsPolicy(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.oldPolicyName)}, ${jsonToTsSource(this.newPolicyName)})`;
+  }
+}
+
 export type PostgresOpFactoryCall =
   | CreateTableCall
   | DropTableCall
@@ -1399,4 +1751,12 @@ export type PostgresOpFactoryCall =
   | RawSqlCall
   | CreateExtensionCall
   | CreateSchemaCall
+  | CreateNativeEnumTypeCall
+  | DropNativeEnumTypeCall
+  | AddNativeEnumValueCall
+  | CreatePostgresRlsPolicyCall
+  | DropPostgresRlsPolicyCall
+  | EnableRowLevelSecurityCall
+  | DisableRowLevelSecurityCall
+  | RenamePostgresRlsPolicyCall
   | DataTransformCall;

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

@@ -1,4 +1,6 @@
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import type { DdlColumn } from '@prisma-next/sql-relational-core/ast';
+import { ifDefined } from '@prisma-next/utils/defined';
 import {
   columnDefaultAst,
   columnExistsAst,
@@ -7,7 +9,9 @@ import {
   noNullValuesAst,
   tableIsEmptyAst,
 } from '../../../contract-free/checks';
+import * as contractFreeDdl from '../../../contract-free/ddl';
 import { quoteIdentifier } from '../../sql-utils';
+import { boundSchema } from '../bound-schema';
 import { qualifyTableName } from '../planner-sql-checks';
 import { type Op, step, targetDetails } from './shared';
 
@@ -242,12 +246,18 @@ export async function dropDefault(
   columnName: string,
   lowerer: ExecuteRequestLowerer,
 ): Promise<Op> {
-  const qualified = qualifyTableName(schemaName, tableName);
   const { present } = await columnExistsSteps(lowerer, {
     schema: schemaName,
     table: tableName,
     column: columnName,
   });
+  const dropDefaultExec = await lowerer.lowerToExecuteRequest(
+    contractFreeDdl.alterTable({
+      ...ifDefined('schema', boundSchema(schemaName)),
+      table: tableName,
+      actions: [contractFreeDdl.dropDefaultAction(columnName)],
+    }),
+  );
   const noDefault = await lowerer.lowerToExecuteRequest(
     columnDefaultAst({ schema: schemaName, table: tableName, column: columnName }).defaultAbsent(),
   );
@@ -257,12 +267,7 @@ export async function dropDefault(
     operationClass: 'destructive',
     target: targetDetails('column', columnName, schemaName, tableName),
     precheck: [step(`ensure column "${columnName}" exists`, present.sql, present.params)],
-    execute: [
-      step(
-        `drop default on "${columnName}"`,
-        `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP DEFAULT`,
-      ),
-    ],
+    execute: [step(`drop default on "${columnName}"`, dropDefaultExec.sql)],
     postcheck: [
       step(`verify column "${columnName}" has no default`, noDefault.sql, noDefault.params),
     ],
@@ -272,16 +277,23 @@ export async function dropDefault(
 /**
  * Builds the op for adding a NOT NULL column (no contract default) to a
  * non-empty table. Prechecks assert the column is absent and the table is
- * empty; the execute step is the raw ADD COLUMN SQL passed by the caller
- * (slice-7 deferred); postchecks assert the column exists and is NOT NULL.
+ * empty; the execute step lowers the typed `AddColumn` DDL node through the
+ * adapter; postchecks assert the column exists and is NOT NULL.
  */
 export async function addNotNullColumnDirect(
   schemaName: string,
   tableName: string,
-  columnName: string,
-  executeStepSql: string,
+  column: DdlColumn,
   lowerer: ExecuteRequestLowerer,
 ): Promise<Op> {
+  const columnName = column.name;
+  const addColumn = await lowerer.lowerToExecuteRequest(
+    contractFreeDdl.alterTable({
+      ...ifDefined('schema', boundSchema(schemaName)),
+      table: tableName,
+      actions: [contractFreeDdl.addColumnAction(column)],
+    }),
+  );
   const absent = await lowerer.lowerToExecuteRequest(
     columnExistsAst({ schema: schemaName, table: tableName, column: columnName }).columnAbsent(),
   );
@@ -311,7 +323,7 @@ export async function addNotNullColumnDirect(
         tableEmpty.params,
       ),
     ],
-    execute: [step(`add column "${columnName}"`, executeStepSql)],
+    execute: [step(`add column "${columnName}"`, addColumn.sql)],
     postcheck: [
       step(`verify column "${columnName}" exists`, present.sql, present.params),
       step(`verify column "${columnName}" is NOT NULL`, notNullable.sql, notNullable.params),

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

@@ -196,7 +196,7 @@ export async function dropCheckConstraint(
  * `kind` feeds the operation's `target.details.objectType`. Descriptor-flow
  * does not carry kind information in its drop-constraint descriptor, so the
  * default is `'unique'`. The reconciliation planner passes the correct kind
- * (`'foreignKey'`, `'primaryKey'`, or `'unique'`) based on the `SchemaIssue`
+ * (`'foreignKey'`, `'primaryKey'`, or `'unique'`) based on the diff issue
  * that produced the drop.
  */
 export async function dropConstraint(

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

@@ -113,6 +113,12 @@ export async function dataTransform<TContract extends Contract<SqlStorage>>(
     runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name)),
   );
 
+  // Raw remnant: the factory lowered the user's `check` plan above before
+  // we get a chance to wrap it, so the EXISTS lifting only has text by the
+  // time it runs. The fix is to rewrite the factory to defer lowering until
+  // after wrapping — so `cfExpr.exists(checkPlan.ast)` can produce the
+  // EXISTS query, then lower once at the boundary — not to grow new AST
+  // substrate. Out of scope for the slice that introduced this comment.
   const precheck: readonly SqlMigrationPlanOperationStep[] = checkPlan
     ? [
         {

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

@@ -1,5 +1,6 @@
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import { extensionExistsAst } from '../../../contract-free/checks';
+import { DEFAULT_NAMESPACE_ID } from '../../namespace-ids';
 import { quoteIdentifier } from '../../sql-utils';
 import { type Op, step } from './shared';
 
@@ -55,7 +56,7 @@ export async function installExtension(
     invariantId,
     target: {
       id: 'postgres',
-      details: { schema: 'public', objectType: 'dependency', name: extensionName },
+      details: { schema: DEFAULT_NAMESPACE_ID, objectType: 'dependency', name: extensionName },
     },
     precheck: [
       step(`verify extension "${extensionName}" is not already enabled`, absent.sql, absent.params),

package/src/core/migrations/operations/native-enum-types.ts

@@ -0,0 +1,62 @@
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { createType, dropType } from '../../../contract-free/ddl';
+import { validateEnumValueLength } from '../../sql-utils';
+import { boundSchema } from '../bound-schema';
+import { type Op, step, targetDetails } from './shared';
+
+/**
+ * `CREATE TYPE <qualified> AS ENUM (…)` for a managed native enum, built as a
+ * typed DDL node and lowered by the control adapter (the type name is quoted,
+ * member values render as escaped string literals in declaration order —
+ * Postgres enum sort order is semantic). `boundSchema` maps the unbound sentinel
+ * to an absent schema so the type name renders unqualified and the connection's
+ * `search_path` resolves the schema at runtime.
+ */
+export async function createNativeEnumType(
+  schemaName: string,
+  typeName: string,
+  members: readonly string[],
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  for (const member of members) {
+    validateEnumValueLength(member, typeName);
+  }
+  const ddlNode = createType({
+    ...ifDefined('schema', boundSchema(schemaName)),
+    name: typeName,
+    values: members,
+  });
+  const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+  return {
+    id: `createNativeEnumType.${typeName}`,
+    label: `Create enum type "${typeName}"`,
+    operationClass: 'additive',
+    target: targetDetails('type', typeName, schemaName),
+    precheck: [],
+    execute: [step(`create enum type "${typeName}"`, statement.sql, statement.params)],
+    postcheck: [],
+  };
+}
+
+/** `DROP TYPE <qualified>` for an unclaimed managed native enum, via typed DDL. */
+export async function dropNativeEnumType(
+  schemaName: string,
+  typeName: string,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const ddlNode = dropType({
+    ...ifDefined('schema', boundSchema(schemaName)),
+    name: typeName,
+  });
+  const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+  return {
+    id: `dropNativeEnumType.${typeName}`,
+    label: `Drop enum type "${typeName}"`,
+    operationClass: 'destructive',
+    target: targetDetails('type', typeName, schemaName),
+    precheck: [],
+    execute: [step(`drop enum type "${typeName}"`, statement.sql, statement.params)],
+    postcheck: [],
+  };
+}