@prisma-next/target-postgres 0.13.0-dev.34 → 0.13.0-dev.36

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

@@ -1,7 +1,7 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
 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';
 
 /**
@@ -19,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'],
@@ -266,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}
-)`;
-}

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

@@ -43,6 +43,8 @@ import { isPostgresSchema } from '../postgres-schema';
 import {
   AddCheckConstraintCall,
   AddColumnCall,
+  AddNotNullColumnDirectCall,
+  AddNotNullColumnWithTempDefaultCall,
   AlterColumnTypeCall,
   DataTransformCall,
   DropCheckConstraintCall,
@@ -53,18 +55,8 @@ import {
 } from './op-factory-call';
 import { buildAddColumnSql, buildColumnTypeSql } from './planner-ddl-builders';
 import { resolveIdentityValue } from './planner-identity-values';
-import {
-  buildAddColumnOperationIdentity,
-  buildAddNotNullColumnWithTemporaryDefaultOperation,
-} from './planner-recipes';
 import { buildSchemaLookupMap, hasForeignKey, hasUniqueConstraint } from './planner-schema-lookup';
-import {
-  buildExpectedFormatType,
-  columnExistsCheck,
-  columnNullabilityCheck,
-  qualifyTableName,
-  tableIsEmptyCheck,
-} from './planner-sql-checks';
+import { buildExpectedFormatType, qualifyTableName } from './planner-sql-checks';
 import { buildTargetDetails, type PostgresPlanTargetDetails } from './planner-target-details';
 import { resolveColumnTypeMetadata } from './planner-type-resolution';
 
@@ -595,74 +587,34 @@ export const notNullAddColumnCallStrategy: CallMigrationStrategy = (issues, ctx)
 
     if (canUseSharedTempDefault && temporaryDefault !== null) {
       calls.push(
-        new RawSqlCall(
-          buildAddNotNullColumnWithTemporaryDefaultOperation({
-            schema: schemaForTable,
-            tableName: issue.table,
-            columnName: issue.column,
-            column,
-            codecHooks: mutableCodecHooks,
-            storageTypes: mutableStorageTypes,
-            temporaryDefault,
-          }),
-        ),
+        new AddNotNullColumnWithTempDefaultCall({
+          schemaName: schemaForTable,
+          tableName: issue.table,
+          columnName: issue.column,
+          column,
+          codecHooks: mutableCodecHooks,
+          storageTypes: mutableStorageTypes,
+          temporaryDefault,
+        }),
       );
       continue;
     }
 
     const qualified = qualifyTableName(schemaForTable, issue.table);
     calls.push(
-      new RawSqlCall({
-        ...buildAddColumnOperationIdentity(schemaForTable, issue.table, issue.column),
-        operationClass: 'additive',
-        precheck: [
-          {
-            description: `ensure column "${issue.column}" is missing`,
-            sql: columnExistsCheck({
-              schema: schemaForTable,
-              table: issue.table,
-              column: issue.column,
-              exists: false,
-            }),
-          },
-          {
-            description: `ensure table "${issue.table}" is empty before adding NOT NULL column without default`,
-            sql: tableIsEmptyCheck(qualified),
-          },
-        ],
-        execute: [
-          {
-            description: `add column "${issue.column}"`,
-            sql: buildAddColumnSql(
-              qualified,
-              issue.column,
-              column,
-              mutableCodecHooks,
-              undefined,
-              mutableStorageTypes,
-            ),
-          },
-        ],
-        postcheck: [
-          {
-            description: `verify column "${issue.column}" exists`,
-            sql: columnExistsCheck({
-              schema: schemaForTable,
-              table: issue.table,
-              column: issue.column,
-            }),
-          },
-          {
-            description: `verify column "${issue.column}" is NOT NULL`,
-            sql: columnNullabilityCheck({
-              schema: schemaForTable,
-              table: issue.table,
-              column: issue.column,
-              nullable: false,
-            }),
-          },
-        ],
-      }),
+      new AddNotNullColumnDirectCall(
+        schemaForTable,
+        issue.table,
+        issue.column,
+        buildAddColumnSql(
+          qualified,
+          issue.column,
+          column,
+          mutableCodecHooks,
+          undefined,
+          mutableStorageTypes,
+        ),
+      ),
     );
   }
 

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

@@ -3,12 +3,34 @@ import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control'
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import { Migration as SqlMigration } from '@prisma-next/family-sql/migration';
 import type { ControlStack } from '@prisma-next/framework-components/control';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
 import { errorPostgresMigrationStackMissing } from '../errors';
-import { AddColumnCall, CreateSchemaCall, CreateTableCall } from './op-factory-call';
+import {
+  AddCheckConstraintCall,
+  AddColumnCall,
+  AddForeignKeyCall,
+  AddPrimaryKeyCall,
+  AddUniqueCall,
+  AlterColumnTypeCall,
+  type AlterColumnTypeOptions,
+  CreateIndexCall,
+  CreateSchemaCall,
+  CreateTableCall,
+  DropCheckConstraintCall,
+  DropColumnCall,
+  DropConstraintCall,
+  DropDefaultCall,
+  DropIndexCall,
+  DropNotNullCall,
+  DropTableCall,
+  SetDefaultCall,
+  SetNotNullCall,
+} from './op-factory-call';
 import { type DataTransformOptions, dataTransform } from './operations/data-transform';
+import { installExtension } from './operations/dependencies';
+import type { CreateIndexExtras } from './operations/indexes';
+import type { ForeignKeySpec } from './operations/shared';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 /**
@@ -30,6 +52,13 @@ import type { PostgresPlanTargetDetails } from './planner-target-details';
  * instance method forwards to the free `dataTransform` factory with that
  * stored adapter, so user migrations can write `this.dataTransform(...)`
  * without threading the adapter through every call.
+ *
+ * Every method requires an explicit `schema`. Postgres migrations name their
+ * schema deliberately — there is no default and no `search_path`-relative
+ * option. A migration that left the schema unspecified would resolve against
+ * whatever `search_path` the connection happened to carry, and that ambiguity
+ * is an antipattern in a migration. (The unbound/unspecified namespace concept
+ * remains for SQLite, which has no schemas, and for Mongo's connection `db`.)
  */
 export abstract class PostgresMigration extends SqlMigration<
   PostgresPlanTargetDetails,
@@ -77,7 +106,7 @@ export abstract class PostgresMigration extends SqlMigration<
    * Throws if no adapter is present (i.e. migration instantiated without a stack).
    */
   protected createTable(options: {
-    readonly schema?: string;
+    readonly schema: string;
     readonly table: string;
     readonly ifNotExists?: boolean;
     readonly columns: readonly DdlColumn[];
@@ -87,7 +116,7 @@ export abstract class PostgresMigration extends SqlMigration<
       throw errorPostgresMigrationStackMissing();
     }
     return new CreateTableCall(
-      options.schema ?? UNBOUND_NAMESPACE_ID,
+      options.schema,
       options.table,
       options.columns,
       options.constraints,
@@ -110,17 +139,253 @@ export abstract class PostgresMigration extends SqlMigration<
   }
 
   protected addColumn(options: {
-    readonly schema?: string;
+    readonly schema: string;
     readonly table: string;
     readonly column: DdlColumn;
   }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
     if (!this.controlAdapter) {
       throw errorPostgresMigrationStackMissing();
     }
-    return new AddColumnCall(
-      options.schema ?? UNBOUND_NAMESPACE_ID,
+    return new AddColumnCall(options.schema, options.table, options.column).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected addPrimaryKey(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly columns: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AddPrimaryKeyCall(
+      options.schema,
+      options.table,
+      options.constraint,
+      options.columns,
+    ).toOp(this.controlAdapter);
+  }
+
+  protected addUnique(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly columns: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AddUniqueCall(
+      options.schema,
+      options.table,
+      options.constraint,
+      options.columns,
+    ).toOp(this.controlAdapter);
+  }
+
+  protected addForeignKey(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly foreignKey: ForeignKeySpec;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected addCheckConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly column: string;
+    readonly values: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AddCheckConstraintCall(
+      options.schema,
+      options.table,
+      options.constraint,
+      options.column,
+      options.values,
+    ).toOp(this.controlAdapter);
+  }
+
+  protected dropCheckConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected dropConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly kind?: 'foreignKey' | 'unique' | 'primaryKey';
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropConstraintCall(
+      options.schema,
+      options.table,
+      options.constraint,
+      options.kind ?? 'unique',
+    ).toOp(this.controlAdapter);
+  }
+
+  protected dropTable(options: {
+    readonly schema: string;
+    readonly table: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropTableCall(options.schema, options.table).toOp(this.controlAdapter);
+  }
+
+  protected dropColumn(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropColumnCall(options.schema, options.table, options.column).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected alterColumnType(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+    readonly options: AlterColumnTypeOptions;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AlterColumnTypeCall(
+      options.schema,
       options.table,
       options.column,
+      options.options,
     ).toOp(this.controlAdapter);
   }
+
+  protected setNotNull(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new SetNotNullCall(options.schema, options.table, options.column).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected dropNotNull(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropNotNullCall(options.schema, options.table, options.column).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected setDefault(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+    readonly defaultSql: string;
+    readonly operationClass?: 'additive' | 'widening';
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new SetDefaultCall(
+      options.schema,
+      options.table,
+      options.column,
+      options.defaultSql,
+      options.operationClass,
+    ).toOp(this.controlAdapter);
+  }
+
+  protected dropDefault(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropDefaultCall(options.schema, options.table, options.column).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected createIndex(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly index: string;
+    readonly columns: readonly string[];
+    readonly extras?: CreateIndexExtras;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new CreateIndexCall(
+      options.schema,
+      options.table,
+      options.index,
+      options.columns,
+      options.extras,
+    ).toOp(this.controlAdapter);
+  }
+
+  protected dropIndex(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly index: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropIndexCall(options.schema, options.table, options.index).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected installExtension(options: {
+    readonly extensionName: string;
+    readonly invariantId: string;
+    readonly id: string;
+    readonly label?: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return installExtension(options, this.controlAdapter);
+  }
 }

package/src/core/postgres-contract-serializer.ts

@@ -39,7 +39,7 @@ function isAuthoringEntityTypeFactoryOutput(
  * Walks a pack's entity-type namespace tree and emits hydration factories
  * keyed by the descriptor's `discriminator`. Used for `storage.types`
  * (codec-triple hydration). Namespace entries hydration dispatches by
- * entries key, not discriminator — handled by `hydrateEntriesKind`.
+ * entries key, not discriminator — handled by `hydrateNamespaceEntities`.
  */
 function collectStorageTypesHydrators(
   namespace: AuthoringEntityTypeNamespace,