@prisma-next/target-postgres 0.16.0-dev.21 → 0.16.0-dev.23

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

@@ -38,6 +38,7 @@ 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 { assertNever } from '@prisma-next/utils/internal-error';
 import {
   columnExistsAst,
   nativeEnumTypeExistsAst,
@@ -45,6 +46,7 @@ import {
   tableExistsAst,
 } from '../../contract-free/checks';
 import * as contractFreeDdl from '../../contract-free/ddl';
+import { postgresError } from '../errors';
 import type { PostgresRlsPolicy, PostgresRlsPolicyInput } from '../postgres-rls-policy';
 import {
   escapeLiteral,
@@ -138,7 +140,8 @@ export function postgresDefaultToDdlColumnDefault(
       );
     default: {
       const exhaustive: never = columnDefault;
-      throw new Error(
+      return assertNever(
+        exhaustive,
         `postgresDefaultToDdlColumnDefault: unhandled kind "${blindCast<{ kind: string }, 'exhaustiveness: surface the unhandled default kind'>(exhaustive).kind}"`,
       );
     }
@@ -241,8 +244,10 @@ export class CreateTableCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `CreateTableCall.toOp: a DDL lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'CreateTableCall' } },
       );
     }
     const ddlNode = contractFreeDdl.createTable({
@@ -324,8 +329,10 @@ export class DropTableCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropTableCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropTableCall' } },
       );
     }
     return dropTable(this.schemaName, this.tableName, lowerer);
@@ -368,8 +375,10 @@ export class AddColumnCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddColumnCall.toOp: a DDL lowerer is required on the Postgres planner path (column "${this.column.name}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddColumnCall' } },
       );
     }
     const ddlNode = contractFreeDdl.alterTable({
@@ -435,8 +444,10 @@ export class DropColumnCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropColumnCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropColumnCall' } },
       );
     }
     return dropColumn(this.schemaName, this.tableName, this.columnName, lowerer);
@@ -490,8 +501,10 @@ export class AlterColumnTypeCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AlterColumnTypeCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AlterColumnTypeCall' } },
       );
     }
     return alterColumnType(this.schemaName, this.tableName, this.columnName, this.options, lowerer);
@@ -532,8 +545,10 @@ export class SetNotNullCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `SetNotNullCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'SetNotNullCall' } },
       );
     }
     return setNotNull(this.schemaName, this.tableName, this.columnName, lowerer);
@@ -573,8 +588,10 @@ export class DropNotNullCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropNotNullCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropNotNullCall' } },
       );
     }
     return dropNotNull(this.schemaName, this.tableName, this.columnName, lowerer);
@@ -623,8 +640,10 @@ export class SetDefaultCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `SetDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'SetDefaultCall' } },
       );
     }
     return setDefault(
@@ -675,8 +694,10 @@ export class DropDefaultCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropDefaultCall' } },
       );
     }
     return dropDefault(this.schemaName, this.tableName, this.columnName, lowerer);
@@ -730,8 +751,10 @@ export class AddNotNullColumnDirectCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddNotNullColumnDirectCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddNotNullColumnDirectCall' } },
       );
     }
     return addNotNullColumnDirect(this.schemaName, this.tableName, this.column, lowerer);
@@ -787,8 +810,10 @@ export class AddNotNullColumnWithTempDefaultCall extends PostgresOpFactoryCallNo
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddNotNullColumnWithTempDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddNotNullColumnWithTempDefaultCall' } },
       );
     }
     return buildAddNotNullColumnWithTemporaryDefaultOperation({
@@ -852,8 +877,10 @@ export class AddPrimaryKeyCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddPrimaryKeyCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddPrimaryKeyCall' } },
       );
     }
     return addPrimaryKey(
@@ -900,8 +927,10 @@ export class AddUniqueCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddUniqueCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddUniqueCall' } },
       );
     }
     return addUnique(this.schemaName, this.tableName, this.constraintName, this.columns, lowerer);
@@ -935,8 +964,10 @@ export class AddForeignKeyCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddForeignKeyCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.fk.name}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddForeignKeyCall' } },
       );
     }
     return addForeignKey(this.schemaName, this.tableName, this.fk, lowerer);
@@ -983,8 +1014,10 @@ export class DropConstraintCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropConstraintCall' } },
       );
     }
     return dropConstraint(this.schemaName, this.tableName, this.constraintName, lowerer, this.kind);
@@ -1032,8 +1065,10 @@ export class AddCheckConstraintCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddCheckConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddCheckConstraintCall' } },
       );
     }
     return addCheckConstraint(
@@ -1074,8 +1109,10 @@ export class DropCheckConstraintCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropCheckConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropCheckConstraintCall' } },
       );
     }
     return dropCheckConstraint(this.schemaName, this.tableName, this.constraintName, lowerer);
@@ -1127,8 +1164,10 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `CreateIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'CreateIndexCall' } },
       );
     }
     const extras: { type?: string; options?: Record<string, unknown> } = {};
@@ -1185,8 +1224,10 @@ export class DropIndexCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropIndexCall' } },
       );
     }
     return dropIndex(this.schemaName, this.tableName, this.indexName, lowerer);
@@ -1288,8 +1329,10 @@ export class CreateSchemaCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `CreateSchemaCall.toOp: a DDL lowerer is required on the Postgres planner path (schema "${this.schemaName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'CreateSchemaCall' } },
       );
     }
     const ddlNode = contractFreeDdl.createSchema({ schema: this.schemaName, ifNotExists: true });
@@ -1344,8 +1387,10 @@ export class CreateNativeEnumTypeCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `CreateNativeEnumTypeCall.toOp: a DDL lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'CreateNativeEnumTypeCall' } },
       );
     }
     return createNativeEnumType(this.schemaName, this.typeName, this.members, lowerer);
@@ -1382,8 +1427,10 @@ export class DropNativeEnumTypeCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropNativeEnumTypeCall.toOp: a DDL lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropNativeEnumTypeCall' } },
       );
     }
     return dropNativeEnumType(this.schemaName, this.typeName, lowerer);
@@ -1444,8 +1491,10 @@ export class AddNativeEnumValueCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddNativeEnumValueCall.toOp: a lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddNativeEnumValueCall' } },
       );
     }
     const { schemaName, typeName, value } = this;
@@ -1571,8 +1620,10 @@ export class CreatePostgresRlsPolicyCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `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.`,
+        { meta: { factory: 'CreatePostgresRlsPolicyCall' } },
       );
     }
     return createRlsPolicy(this.schemaName, this.tableName, this.policy, lowerer);
@@ -1618,8 +1669,10 @@ export class DropPostgresRlsPolicyCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropPostgresRlsPolicyCall.toOp: a lowerer is required on the Postgres planner path (policy "${this.policyName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropPostgresRlsPolicyCall' } },
       );
     }
     return dropRlsPolicy(this.schemaName, this.tableName, this.policyName, lowerer);
@@ -1651,8 +1704,10 @@ export class EnableRowLevelSecurityCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `EnableRowLevelSecurityCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'EnableRowLevelSecurityCall' } },
       );
     }
     return enableRowLevelSecurity(this.schemaName, this.tableName, lowerer);
@@ -1684,8 +1739,10 @@ export class DisableRowLevelSecurityCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DisableRowLevelSecurityCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DisableRowLevelSecurityCall' } },
       );
     }
     return disableRowLevelSecurity(this.schemaName, this.tableName, lowerer);
@@ -1725,8 +1782,10 @@ export class RenamePostgresRlsPolicyCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `RenamePostgresRlsPolicyCall.toOp: a lowerer is required on the Postgres planner path (policy "${this.oldPolicyName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'RenamePostgresRlsPolicyCall' } },
       );
     }
     return renameRlsPolicy(

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

@@ -1,5 +1,6 @@
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
+import { InternalError } from '@prisma-next/utils/internal-error';
 import { constraintExistsAst } from '../../../contract-free/checks';
 import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
 import { qualifyTableName } from '../planner-sql-checks';
@@ -29,14 +30,14 @@ REFERENCES ${qualifyTableName(fk.references.schema, fk.references.table)} (${fk.
   if (fk.onDelete !== undefined) {
     const action = REFERENTIAL_ACTION_SQL[fk.onDelete];
     if (!action) {
-      throw new Error(`Unknown referential action for onDelete: ${String(fk.onDelete)}`);
+      throw new InternalError(`Unknown referential action for onDelete: ${String(fk.onDelete)}`);
     }
     sql += `\nON DELETE ${action}`;
   }
   if (fk.onUpdate !== undefined) {
     const action = REFERENTIAL_ACTION_SQL[fk.onUpdate];
     if (!action) {
-      throw new Error(`Unknown referential action for onUpdate: ${String(fk.onUpdate)}`);
+      throw new InternalError(`Unknown referential action for onUpdate: ${String(fk.onUpdate)}`);
     }
     sql += `\nON UPDATE ${action}`;
   }

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

@@ -1,5 +1,6 @@
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import { indexExistsAst } from '../../../contract-free/checks';
+import { postgresError } from '../../errors';
 import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
 import { qualifyTableName } from '../planner-sql-checks';
 import { type Op, step, targetDetails } from './shared';
@@ -26,8 +27,10 @@ function renderIndexOptionValue(key: string, value: unknown): string {
   if (typeof value === 'string') return `'${escapeLiteral(value)}'`;
   if (typeof value === 'number' && Number.isFinite(value)) return String(value);
   if (typeof value === 'boolean') return value ? 'true' : 'false';
-  throw new Error(
+  throw postgresError(
+    'CONTRACT.INDEX_INVALID',
     `Index option "${key}" must be a string, finite number, or boolean; got ${typeof value}`,
+    { meta: { key, valueType: typeof value } },
   );
 }
 

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

@@ -7,6 +7,7 @@ import {
   disableRowLevelSecurity as disableRowLevelSecurityDdl,
   dropPolicy,
 } from '../../../contract-free/ddl';
+import { postgresError } from '../../errors';
 import type { PostgresRlsPolicy } from '../../postgres-rls-policy';
 import { qualifyTableName } from '../planner-sql-checks';
 import { type Op, step, targetDetails } from './shared';
@@ -15,8 +16,10 @@ const PLAIN_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_$]*$/;
 
 function validateRoleName(role: string): string {
   if (!PLAIN_IDENTIFIER.test(role)) {
-    throw new Error(
+    throw postgresError(
+      'CONTRACT.ROLE_INVALID',
       `Invalid role name ${JSON.stringify(role)}: role names must be plain SQL identifiers matching ^[A-Za-z_][A-Za-z0-9_$]*$`,
+      { meta: { role, reason: 'not-a-plain-identifier' } },
     );
   }
   return role;

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

@@ -2,6 +2,7 @@ import type { CodecControlHooks } from '@prisma-next/family-sql/control';
 import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { isPgEnumParams } from '../codecs';
+import { postgresError } from '../errors';
 import { escapeLiteral, quoteIdentifier, quoteQualifiedName } from '../sql-utils';
 import type { PostgresColumnDefault } from '../types';
 import { resolveColumnTypeMetadata } from './planner-type-resolution';
@@ -15,9 +16,11 @@ const SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*(\[\])?$/;
 
 function assertSafeNativeType(nativeType: string): void {
   if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) {
-    throw new Error(
+    throw postgresError(
+      'CONTRACT.NATIVE_TYPE_INVALID',
       `Unsafe native type name in contract: "${nativeType}". ` +
         'Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*(\\[\\])?$/',
+      { meta: { nativeType } },
     );
   }
 }
@@ -29,9 +32,11 @@ function assertSafeNativeType(nativeType: string): void {
  */
 function assertSafeDefaultExpression(expression: string): void {
   if (expression.includes(';') || /--|\/\*|\$\$|\bSELECT\b/i.test(expression)) {
-    throw new Error(
+    throw postgresError(
+      'CONTRACT.DEFAULT_INVALID',
       `Unsafe default expression in contract: "${expression}". ` +
         'Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.',
+      { meta: { expression } },
     );
   }
 }
@@ -99,9 +104,11 @@ function expandParameterizedTypeSql(
   }
 
   if (!column.codecId) {
-    throw new Error(
+    throw postgresError(
+      'CONTRACT.CODEC_DESCRIPTOR_MISSING',
       `Column declares typeParams for nativeType "${column.nativeType}" but has no codecId. ` +
         'Ensure the column is associated with a codec.',
+      { meta: { nativeType: column.nativeType } },
     );
   }
 
@@ -110,10 +117,12 @@ function expandParameterizedTypeSql(
     if (hooks?.planTypeOperations) {
       return null;
     }
-    throw new Error(
+    throw postgresError(
+      'CONTRACT.PACK_CONTRIBUTION_INVALID',
       `Column declares typeParams for nativeType "${column.nativeType}" ` +
         `but no expandNativeType hook is registered for codecId "${column.codecId}". ` +
         'Ensure the extension providing this codec is included in extensions.',
+      { meta: { codecId: column.codecId, nativeType: column.nativeType } },
     );
   }
 

package/src/core/migrations/render-ops.ts

@@ -6,6 +6,7 @@ import type {
 } from '@prisma-next/framework-components/control';
 import { blindCast } from '@prisma-next/utils/casts';
 import { isThenable } from '@prisma-next/utils/promise';
+import { postgresError } from '../errors';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
@@ -23,8 +24,10 @@ function assertPostgresOp(op: MigrationPlanOperation, callFactoryName: string):
     'op.target is present on concrete SqlMigrationPlanOperation but absent on the framework MigrationPlanOperation base'
   >(op).target?.id;
   if (targetId !== 'postgres') {
-    throw new Error(
+    throw postgresError(
+      'MIGRATION.TARGET_MISMATCH',
       `renderOps: expected postgres op but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${callFactoryName}"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,
+      { meta: { opId: op.id, targetId: String(targetId), factoryName: callFactoryName } },
     );
   }
 }

package/src/core/migrations/runner.ts

@@ -20,8 +20,10 @@ import { SqlQueryError } from '@prisma-next/sql-errors';
 import type { SqlExecuteRequest } from '@prisma-next/sql-relational-core/ast';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { InternalError } from '@prisma-next/utils/internal-error';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok, okVoid } from '@prisma-next/utils/result';
+import { postgresError } from '../errors';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 interface ApplyPlanSuccessValue {
@@ -76,8 +78,10 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
       UNBOUND_NAMESPACE_ID;
     const driver = options.driver;
     if (options.space !== undefined && options.space !== options.plan.spaceId) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.CONTRACT_SPACE_VIOLATION',
         `SqlMigrationRunner: options.space (${options.space}) does not match plan.spaceId (${options.plan.spaceId})`,
+        { meta: { space: options.space, planSpaceId: options.plan.spaceId } },
       );
     }
     const space = options.plan.spaceId;
@@ -283,7 +287,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     const bootstrapQueries = this.family.bootstrapControlTableQueries();
     const [schemaQuery, ...tableQueries] = bootstrapQueries;
     if (schemaQuery === undefined) {
-      throw new Error('Postgres control-table bootstrap must include CREATE SCHEMA');
+      throw new InternalError('Postgres control-table bootstrap must include CREATE SCHEMA');
     }
     await this.executeStatement(driver, await this.family.lowerAst(schemaQuery, lowererContext));
     const legacyDetection = await this.detectLegacyMarkerShape(driver);
@@ -640,7 +644,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     const edges = options.migrationEdges;
     const totalEdgeOps = edges.reduce((sum, edge) => sum + edge.operationCount, 0);
     if (totalEdgeOps !== planOpsLength) {
-      throw new Error(
+      throw new InternalError(
         `Ledger write: plan.operations length (${planOpsLength}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`,
       );
     }

package/src/core/psl-infer/infer-psl-contract.ts

@@ -46,6 +46,8 @@ import type { SqlColumnIR, SqlForeignKeyIR } from '@prisma-next/sql-schema-ir/ty
 import { SqlSchemaIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { InternalError } from '@prisma-next/utils/internal-error';
+import { postgresError } from '../errors';
 import type { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
 import { createPostgresDefaultMapping } from './postgres-default-mapping';
 import { createPostgresTypeMap } from './postgres-type-map';
@@ -224,11 +226,13 @@ function resolveForeignKeys(
         if (owner !== undefined) {
           const target = resolveCrossSpaceTarget(owner, fk.referencedSchema, fk.referencedTable);
           if (target === undefined) {
-            throw new Error(
+            throw postgresError(
+              'CONTRACT.PACK_CONTRIBUTION_INVALID',
               `contract infer: described contract space "${owner.spaceId}" owns storage ` +
                 `coordinate "${fk.referencedSchema}.${fk.referencedTable}" but declares no ` +
                 'domain model mapped to it. A pack that describes a table must also declare the ' +
                 'domain model it maps to; this pack is malformed.',
+              { meta: { spaceId: owner.spaceId, tableName: fk.referencedTable } },
             );
           }
 
@@ -384,22 +388,26 @@ export function inferPostgresPslContract(
         continue;
       }
       if (tables[tableName] !== undefined) {
-        throw new Error(
+        throw postgresError(
+          'CONTRACT.INFER_UNSUPPORTED',
           `contract infer: duplicate table name "${tableName}" across schemas is not yet supported ` +
             '(single-namespace PSL inference emits one flat bucket; multi-namespace `namespace { … }` ' +
             'output is a later slice).',
+          { meta: { tableName } },
         );
       }
       if (ownedEnumTypes !== undefined) {
         for (const column of Object.values(table.columns)) {
           const owningSpaceId = ownedEnumTypes.get(column.nativeType);
           if (owningSpaceId !== undefined) {
-            throw new Error(
+            throw postgresError(
+              'CONTRACT.INFER_UNSUPPORTED',
               `contract infer: column "${tableName}"."${column.name}" is typed by native enum ` +
                 `type "${column.nativeType}", which extension pack space "${owningSpaceId}" ` +
                 'already describes. A cross-space enum-typed column has no authorable PSL form ' +
                 "yet; describe the table in that pack's contract or retype the column before " +
                 're-running contract infer.',
+              { meta: { tableName, columnName: column.name } },
             );
           }
         }
@@ -418,12 +426,14 @@ export function inferPostgresPslContract(
   if (enumDefinitions.size > 0) {
     const contentNamespaces = new Set([...enumNamespaceNames, ...tableNamespaceNames]);
     if (contentNamespaces.size > 1) {
-      throw new Error(
+      throw postgresError(
+        'CONTRACT.INFER_UNSUPPORTED',
         'contract infer: native enum adoption with content across multiple schemas is not yet ' +
           'supported (single-namespace PSL inference emits one `namespace { … }` block; ' +
           `multi-namespace output is a later slice). Schemas: ${[...contentNamespaces]
             .sort()
             .join(', ')}.`,
+        { meta: { schemas: [...contentNamespaces].sort() } },
       );
     }
     wrapNamespaceName = [...contentNamespaces][0];
@@ -1222,7 +1232,11 @@ function buildTopLevelNameMap(
           .map((source) => `"${source}"`)
           .join(', ')}`,
     );
-    throw new Error(`PSL ${kind} name collisions detected:\n${details.join('\n')}`);
+    throw postgresError(
+      'CONTRACT.NAME_DUPLICATE',
+      `PSL ${kind} name collisions detected:\n${details.join('\n')}`,
+      { meta: { kind, names: duplicates.map(([normalizedName]) => normalizedName) } },
+    );
   }
 
   return results;
@@ -1331,7 +1345,9 @@ function resolveNamedTypeName(
     return existing.name;
   }
 
-  throw new Error(`Named type registry was not seeded for native type "${resolution.nativeType}"`);
+  throw new InternalError(
+    `Named type registry was not seeded for native type "${resolution.nativeType}"`,
+  );
 }
 
 function createNamedTypeSignatureKey(resolution: {