@prisma-next/target-postgres 0.3.0-pr.99.5 → 0.3.0

package/src/core/migrations/runner.ts

@@ -1,3 +1,7 @@
+import {
+  normalizeSchemaNativeType,
+  parsePostgresDefault,
+} from '@prisma-next/adapter-postgres/control';
 import type { ContractMarkerRecord } from '@prisma-next/contract/types';
 import type {
   MigrationOperationPolicy,
@@ -13,10 +17,12 @@ import type {
 import { runnerFailure, runnerSuccess } from '@prisma-next/family-sql/control';
 import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import { readMarker } from '@prisma-next/family-sql/verify';
+import type { DataTransformOperation } from '@prisma-next/framework-components/control';
 import { SqlQueryError } from '@prisma-next/sql-errors';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { ok, okVoid } from '@prisma-next/utils/result';
-import type { PostgresPlanTargetDetails } from './planner';
+import type { PostgresPlanTargetDetails } from './planner-target-details';
 import {
   buildLedgerInsertStatement,
   buildWriteMarkerStatements,
@@ -41,6 +47,18 @@ const DEFAULT_CONFIG: RunnerConfig = {
 
 const LOCK_DOMAIN = 'prisma_next.contract.marker';
 
+function isDataTransformOperation(op: unknown): op is DataTransformOperation {
+  return (
+    typeof op === 'object' &&
+    op !== null &&
+    'operationClass' in op &&
+    (op as { operationClass: string }).operationClass === 'data' &&
+    'name' in op &&
+    'check' in op &&
+    'run' in op
+  );
+}
+
 /**
  * Deep clones and freezes a record object to prevent mutation.
  * Recursively clones nested objects and arrays to ensure complete isolation.
@@ -112,11 +130,12 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
         return markerCheck;
       }
 
-      // Apply plan operations or skip if marker already at destination
+      // db update (origin: null) always applies; migration-apply (origin set) skips if marker matches.
       const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
+      const skipOperations = markerAtDestination && options.plan.origin != null;
       let applyValue: ApplyPlanSuccessValue;
 
-      if (markerAtDestination) {
+      if (skipOperations) {
         applyValue = { operationsExecuted: 0, executedOperations: [] };
       } else {
         const applyResult = await this.applyPlan(driver, options);
@@ -130,7 +149,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
       // Step 1: Introspect live schema (DB I/O, family-owned)
       const schemaIR = await this.family.introspect({
         driver,
-        contractIR: options.destinationContract,
+        contract: options.destinationContract,
       });
 
       // Step 2: Pure verification (no DB I/O)
@@ -141,6 +160,8 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
         context: options.context ?? {},
         typeMetadataRegistry: this.family.typeMetadataRegistry,
         frameworkComponents: options.frameworkComponents,
+        normalizeDefault: parsePostgresDefault,
+        normalizeNativeType: normalizeSchemaNativeType,
       });
       if (!schemaVerifyResult.ok) {
         return runnerFailure('SCHEMA_VERIFY_FAILED', schemaVerifyResult.summary, {
@@ -182,6 +203,19 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     for (const operation of options.plan.operations) {
       options.callbacks?.onOperationStart?.(operation);
       try {
+        // Data transform operations have a different execution lifecycle
+        if (operation.operationClass === 'data' && isDataTransformOperation(operation)) {
+          const dtResult = await this.executeDataTransform(driver, operation, {
+            runIdempotency,
+          });
+          if (!dtResult.ok) {
+            return dtResult;
+          }
+          executedOperations.push(operation);
+          operationsExecuted += 1;
+          continue;
+        }
+
         // Idempotency probe: only run if both postchecks and idempotency checks are enabled
         if (runPostchecks && runIdempotency) {
           const postcheckAlreadySatisfied = await this.expectationsAreSatisfied(
@@ -234,6 +268,80 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     return ok({ operationsExecuted, executedOperations });
   }
 
+  /**
+   * Executes a data transform operation with the check → (skip or run) → check lifecycle.
+   *
+   * 1. If check is a query AST: render to SQL, execute. Empty result = already applied (skip).
+   * 2. If check is `true`: always skip. If `false`: always run.
+   * 3. Execute run ASTs (rendered to SQL) sequentially.
+   * 4. Re-execute check as post-run validation. If violations remain, fail.
+   */
+  private async executeDataTransform(
+    driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
+    op: DataTransformOperation,
+    options: { runIdempotency: boolean },
+  ): Promise<Result<void, SqlMigrationRunnerFailure>> {
+    // Step 1: Check (skip guard)
+    if (op.check === true) {
+      // Always skip, regardless of idempotency setting
+      return okVoid();
+    }
+    if (options.runIdempotency && op.check !== null && op.check !== false) {
+      const checkResult = await driver.query(op.check.sql, op.check.params);
+      if (checkResult.rows.length === 0) {
+        // No violations — already applied, skip
+        return okVoid();
+      }
+    }
+
+    // Step 2: Execute run steps
+    if (op.run) {
+      for (const plan of op.run) {
+        try {
+          await driver.query(plan.sql, plan.params);
+        } catch (error: unknown) {
+          if (SqlQueryError.is(error)) {
+            return runnerFailure(
+              'EXECUTION_FAILED',
+              `Data transform "${op.name}" failed: ${error.message}`,
+              {
+                why: error.message,
+                meta: {
+                  operationId: op.id,
+                  dataTransformName: op.name,
+                  sql: plan.sql,
+                  sqlState: error.sqlState,
+                },
+              },
+            );
+          }
+          throw error;
+        }
+      }
+    }
+
+    // Step 3: Post-run validation (check again)
+    if (op.check !== null && op.check !== false) {
+      const checkResult = await driver.query(op.check.sql, op.check.params);
+      if (checkResult.rows.length > 0) {
+        return runnerFailure(
+          'POSTCHECK_FAILED',
+          `Data transform "${op.name}" did not resolve all violations (${checkResult.rows.length} remaining)`,
+          {
+            why: `After executing the data transform, the check query still returns ${checkResult.rows.length} violation(s).`,
+            meta: {
+              operationId: op.id,
+              dataTransformName: op.name,
+              remainingViolations: checkResult.rows.length,
+            },
+          },
+        );
+      }
+    }
+
+    return okVoid();
+  }
+
   private async ensureControlTables(
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
   ): Promise<void> {
@@ -371,13 +479,13 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     return Object.freeze({
       id: operation.id,
       label: operation.label,
-      ...(operation.summary ? { summary: operation.summary } : {}),
+      ...ifDefined('summary', operation.summary),
       operationClass: operation.operationClass,
       target: operation.target, // Already frozen from plan creation
       precheck: Object.freeze([]),
       execute: Object.freeze([]),
       postcheck: frozenPostcheck,
-      ...(operation.meta || mergedMeta ? { meta: mergedMeta } : {}),
+      ...ifDefined('meta', operation.meta || mergedMeta ? mergedMeta : undefined),
     });
   }
 
@@ -388,7 +496,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     if (!marker) {
       return false;
     }
-    if (marker.coreHash !== plan.destination.coreHash) {
+    if (marker.storageHash !== plan.destination.storageHash) {
       return false;
     }
     if (plan.destination.profileHash && marker.profileHash !== plan.destination.profileHash) {
@@ -427,43 +535,31 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
   ): Result<void, SqlMigrationRunnerFailure> {
     const origin = plan.origin ?? null;
     if (!origin) {
-      if (!marker) {
-        return okVoid();
-      }
-      if (this.markerMatchesDestination(marker, plan)) {
-        return okVoid();
-      }
-      return runnerFailure(
-        'MARKER_ORIGIN_MISMATCH',
-        `Existing contract marker (${marker.coreHash}) does not match plan origin (no marker expected).`,
-        {
-          meta: {
-            markerCoreHash: marker.coreHash,
-            expectedOrigin: null,
-          },
-        },
-      );
+      // No origin assertion on the plan — the caller does not want origin validation.
+      // This is the case for `db update`, which introspects the live schema and does not
+      // rely on marker continuity. `db init` handles its own marker checks before the runner.
+      return okVoid();
     }
 
     if (!marker) {
       return runnerFailure(
         'MARKER_ORIGIN_MISMATCH',
-        `Missing contract marker: expected origin core hash ${origin.coreHash}.`,
+        `Missing contract marker: expected origin storage hash ${origin.storageHash}.`,
         {
           meta: {
-            expectedOriginCoreHash: origin.coreHash,
+            expectedOriginStorageHash: origin.storageHash,
           },
         },
       );
     }
-    if (marker.coreHash !== origin.coreHash) {
+    if (marker.storageHash !== origin.storageHash) {
       return runnerFailure(
         'MARKER_ORIGIN_MISMATCH',
-        `Existing contract marker (${marker.coreHash}) does not match plan origin (${origin.coreHash}).`,
+        `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`,
         {
           meta: {
-            markerCoreHash: marker.coreHash,
-            expectedOriginCoreHash: origin.coreHash,
+            markerStorageHash: marker.storageHash,
+            expectedOriginStorageHash: origin.storageHash,
           },
         },
       );
@@ -487,14 +583,14 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     destination: SqlMigrationPlanContractInfo,
     contract: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['destinationContract'],
   ): Result<void, SqlMigrationRunnerFailure> {
-    if (destination.coreHash !== contract.coreHash) {
+    if (destination.storageHash !== contract.storage.storageHash) {
       return runnerFailure(
         'DESTINATION_CONTRACT_MISMATCH',
-        `Plan destination core hash (${destination.coreHash}) does not match provided contract core hash (${contract.coreHash}).`,
+        `Plan destination storage hash (${destination.storageHash}) does not match provided contract storage hash (${contract.storage.storageHash}).`,
         {
           meta: {
-            planCoreHash: destination.coreHash,
-            contractCoreHash: contract.coreHash,
+            planStorageHash: destination.storageHash,
+            contractStorageHash: contract.storage.storageHash,
           },
         },
       );
@@ -524,11 +620,11 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     existingMarker: ContractMarkerRecord | null,
   ): Promise<void> {
     const writeStatements = buildWriteMarkerStatements({
-      coreHash: options.plan.destination.coreHash,
+      storageHash: options.plan.destination.storageHash,
       profileHash:
         options.plan.destination.profileHash ??
         options.destinationContract.profileHash ??
-        options.plan.destination.coreHash,
+        options.plan.destination.storageHash,
       contractJson: options.destinationContract,
       canonicalVersion: null,
       meta: {},
@@ -544,13 +640,13 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     executedOperations: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[],
   ): Promise<void> {
     const ledgerStatement = buildLedgerInsertStatement({
-      originCoreHash: existingMarker?.coreHash ?? null,
+      originStorageHash: existingMarker?.storageHash ?? null,
       originProfileHash: existingMarker?.profileHash ?? null,
-      destinationCoreHash: options.plan.destination.coreHash,
+      destinationStorageHash: options.plan.destination.storageHash,
       destinationProfileHash:
         options.plan.destination.profileHash ??
         options.destinationContract.profileHash ??
-        options.plan.destination.coreHash,
+        options.plan.destination.storageHash,
       contractJsonBefore: existingMarker?.contractJson ?? null,
       contractJsonAfter: options.destinationContract,
       operations: executedOperations,

package/src/core/migrations/statement-builders.ts

@@ -38,7 +38,7 @@ export const ensureLedgerTableStatement: SqlStatement = {
 };
 
 export interface WriteMarkerInput {
-  readonly coreHash: string;
+  readonly storageHash: string;
   readonly profileHash: string;
   readonly contractJson?: unknown;
   readonly canonicalVersion?: number | null;
@@ -52,7 +52,7 @@ export function buildWriteMarkerStatements(input: WriteMarkerInput): {
 } {
   const params: readonly unknown[] = [
     1,
-    input.coreHash,
+    input.storageHash,
     input.profileHash,
     jsonParam(input.contractJson),
     input.canonicalVersion ?? null,
@@ -99,9 +99,9 @@ export function buildWriteMarkerStatements(input: WriteMarkerInput): {
 }
 
 export interface LedgerInsertInput {
-  readonly originCoreHash?: string | null;
+  readonly originStorageHash?: string | null;
   readonly originProfileHash?: string | null;
-  readonly destinationCoreHash: string;
+  readonly destinationStorageHash: string;
   readonly destinationProfileHash?: string | null;
   readonly contractJsonBefore?: unknown;
   readonly contractJsonAfter?: unknown;
@@ -128,9 +128,9 @@ export function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStateme
       $7::jsonb
     )`,
     params: [
-      input.originCoreHash ?? null,
+      input.originStorageHash ?? null,
       input.originProfileHash ?? null,
-      input.destinationCoreHash,
+      input.destinationStorageHash,
       input.destinationProfileHash ?? null,
       jsonParam(input.contractJsonBefore),
       jsonParam(input.contractJsonAfter),

package/src/core/types.ts

@@ -0,0 +1,5 @@
+import type { ColumnDefault } from '@prisma-next/contract/types';
+
+export type PostgresColumnDefault =
+  | ColumnDefault
+  | { readonly kind: 'sequence'; readonly name: string };

package/src/exports/control.ts

@@ -1,28 +1,130 @@
-import type {
-  ControlTargetInstance,
-  MigrationPlanner,
-  MigrationRunner,
-} from '@prisma-next/core-control-plane/types';
+import {
+  normalizeSchemaNativeType,
+  parsePostgresDefault,
+} from '@prisma-next/adapter-postgres/control';
+import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
 import type {
   SqlControlFamilyInstance,
   SqlControlTargetDescriptor,
 } from '@prisma-next/family-sql/control';
+import {
+  collectInitDependencies,
+  contractToSchemaIR,
+  extractCodecControlHooks,
+} from '@prisma-next/family-sql/control';
+import { MigrationDescriptorArraySchema } from '@prisma-next/family-sql/operation-descriptors';
+import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type {
+  ControlTargetInstance,
+  MigrationPlanner,
+  MigrationRunner,
+  OperationDescriptor,
+} from '@prisma-next/framework-components/control';
+import { sql } from '@prisma-next/sql-builder/runtime';
+import type { SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
+import type { SqlOperationEntry } from '@prisma-next/sql-operations';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { type } from 'arktype';
 import { postgresTargetDescriptorMeta } from '../core/descriptor-meta';
-import type { PostgresPlanTargetDetails } from '../core/migrations/planner';
+import { planDescriptors } from '../core/migrations/descriptor-planner';
+import { resolveOperations } from '../core/migrations/operation-resolver';
 import { createPostgresMigrationPlanner } from '../core/migrations/planner';
+import { renderDefaultLiteral } from '../core/migrations/planner-ddl-builders';
+import type { PostgresPlanTargetDetails } from '../core/migrations/planner-target-details';
 import { createPostgresMigrationRunner } from '../core/migrations/runner';
 
+function parseDescriptors(descriptors: readonly OperationDescriptor[]) {
+  const result = MigrationDescriptorArraySchema([...descriptors]);
+  if (result instanceof type.errors) {
+    throw new Error(`Invalid migration descriptors:\n${result.summary}`);
+  }
+  return result;
+}
+
+function collectQueryOperationTypes(
+  frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', 'postgres'>>,
+): Readonly<Record<string, SqlOperationEntry>> {
+  const entries: Record<string, SqlOperationEntry> = {};
+  if (!frameworkComponents) return entries;
+  for (const component of frameworkComponents) {
+    const ops = (
+      component as {
+        queryOperations?: () => ReadonlyArray<{ method: string } & SqlOperationEntry>;
+      }
+    ).queryOperations?.();
+    if (!ops) continue;
+    for (const { method, ...entry } of ops) {
+      entries[method] = entry;
+    }
+  }
+  return entries;
+}
+
 /**
- * Postgres target descriptor for CLI config.
+ * Creates a SQL DSL client for migration authoring.
+ * Only the fields used by the builder are populated — operations, codecs,
+ * and types are unused by sql() and stubbed to satisfy the ExecutionContext type.
  */
+function createMigrationClient(
+  toContract: Contract<SqlStorage>,
+  frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', 'postgres'>>,
+) {
+  const queryOperationTypes = collectQueryOperationTypes(frameworkComponents);
+  // sql() only reads contract, queryOperations.entries(), and applyMutationDefaults
+  // from the context. The other fields are for runtime execution, not query building.
+  return sql({
+    context: {
+      contract: toContract,
+      queryOperations: { entries: () => queryOperationTypes },
+      applyMutationDefaults: () => [],
+    } as never,
+  });
+}
+
+function buildNativeTypeExpander(
+  frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', 'postgres'>>,
+) {
+  if (!frameworkComponents) {
+    return undefined;
+  }
+  const codecHooks = extractCodecControlHooks(frameworkComponents);
+  return (input: {
+    readonly nativeType: string;
+    readonly codecId?: string;
+    readonly typeParams?: Record<string, unknown>;
+  }) => {
+    if (!input.typeParams) return input.nativeType;
+
+    if (!input.codecId) {
+      throw new Error(
+        `Column declares typeParams for nativeType "${input.nativeType}" but has no codecId. ` +
+          'Ensure the column is associated with a codec.',
+      );
+    }
+
+    const hooks = codecHooks.get(input.codecId);
+    if (!hooks?.expandNativeType) {
+      throw new Error(
+        `Column declares typeParams for nativeType "${input.nativeType}" ` +
+          `but no expandNativeType hook is registered for codecId "${input.codecId}". ` +
+          'Ensure the extension providing this codec is included in extensionPacks.',
+      );
+    }
+    return hooks.expandNativeType(input);
+  };
+}
+
+export function postgresRenderDefault(def: ColumnDefault, column: StorageColumn): string {
+  if (def.kind === 'function') {
+    return def.expression;
+  }
+  return renderDefaultLiteral(def.value, column);
+}
+
 const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresPlanTargetDetails> =
   {
     ...postgresTargetDescriptorMeta,
-    /**
-     * Migrations capability for CLI to access planner/runner via core types.
-     * The SQL-specific planner/runner types are compatible with the generic
-     * MigrationPlanner/MigrationRunner interfaces at runtime.
-     */
     migrations: {
       createPlanner(_family: SqlControlFamilyInstance) {
         return createPostgresMigrationPlanner() as MigrationPlanner<'sql', 'postgres'>;
@@ -30,6 +132,74 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
       createRunner(family) {
         return createPostgresMigrationRunner(family) as MigrationRunner<'sql', 'postgres'>;
       },
+      contractToSchema(contract, frameworkComponents) {
+        const expander = buildNativeTypeExpander(frameworkComponents);
+        return contractToSchemaIR(contract as Contract<SqlStorage> | null, {
+          annotationNamespace: 'pg',
+          ...ifDefined('expandNativeType', expander),
+          renderDefault: postgresRenderDefault,
+          frameworkComponents: frameworkComponents ?? [],
+        });
+      },
+      planWithDescriptors(context) {
+        const toContract = context.toContract as Contract<SqlStorage>;
+        const fromContract = context.fromContract as Contract<SqlStorage> | null;
+
+        // Synthesize schema IR from the fromContract (same as contractToSchema flow)
+        const expander = buildNativeTypeExpander(context.frameworkComponents);
+        const fromSchemaIR = contractToSchemaIR(fromContract, {
+          annotationNamespace: 'pg',
+          ...ifDefined('expandNativeType', expander),
+          renderDefault: postgresRenderDefault,
+          frameworkComponents: context.frameworkComponents ?? [],
+        });
+
+        // Collect schema issues via verifier
+        const verifyResult = verifySqlSchema({
+          contract: toContract,
+          schema: fromSchemaIR,
+          strict: true,
+          typeMetadataRegistry: new Map(),
+          frameworkComponents: context.frameworkComponents ?? [],
+          normalizeDefault: parsePostgresDefault,
+          normalizeNativeType: normalizeSchemaNativeType,
+        });
+
+        // Run descriptor planner
+        const planResult = planDescriptors({
+          issues: verifyResult.schema.issues,
+          toContract,
+          fromContract,
+        });
+        if (!planResult.ok) {
+          return { ok: false as const, conflicts: planResult.failure };
+        }
+
+        return {
+          ok: true as const,
+          descriptors: planResult.value.descriptors,
+          needsDataMigration: planResult.value.needsDataMigration,
+        };
+      },
+
+      resolveDescriptors(descriptors, context) {
+        const validated = parseDescriptors(descriptors);
+        const codecHooks = context.frameworkComponents
+          ? extractCodecControlHooks(context.frameworkComponents)
+          : new Map();
+        const dependencies = context.frameworkComponents
+          ? collectInitDependencies(context.frameworkComponents)
+          : [];
+        const toContract = context.toContract as Contract<SqlStorage>;
+        const db = createMigrationClient(toContract, context.frameworkComponents);
+        return resolveOperations(validated, {
+          toContract,
+          schemaName: context.schemaName ?? 'public',
+          codecHooks,
+          dependencies,
+          db,
+        });
+      },
     },
     create(): ControlTargetInstance<'sql', 'postgres'> {
       return {

package/src/exports/migration-builders.ts

@@ -0,0 +1,56 @@
+// Re-export everything from the local operation-descriptors module,
+// which itself re-exports structural descriptors from sql-family
+// and adds postgres-specific data transform support.
+export {
+  type AddColumnDescriptor,
+  type AddEnumValuesDescriptor,
+  type AddForeignKeyDescriptor,
+  type AddPrimaryKeyDescriptor,
+  type AddUniqueDescriptor,
+  type AlterColumnTypeDescriptor,
+  addColumn,
+  addEnumValues,
+  addForeignKey,
+  addPrimaryKey,
+  addUnique,
+  alterColumnType,
+  type Buildable,
+  builders,
+  type CreateDependencyDescriptor,
+  type CreateEnumTypeDescriptor,
+  type CreateIndexDescriptor,
+  type CreateTableDescriptor,
+  createBuilders,
+  createDependency,
+  createEnumType,
+  createIndex,
+  createTable,
+  type DataTransformDescriptor,
+  type DropColumnDescriptor,
+  type DropConstraintDescriptor,
+  type DropDefaultDescriptor,
+  type DropEnumTypeDescriptor,
+  type DropIndexDescriptor,
+  type DropNotNullDescriptor,
+  type DropTableDescriptor,
+  dataTransform,
+  dropColumn,
+  dropConstraint,
+  dropDefault,
+  dropEnumType,
+  dropIndex,
+  dropNotNull,
+  dropTable,
+  type PostgresMigrationOpDescriptor,
+  type QueryPlanInput,
+  type RenameTypeDescriptor,
+  type RunInput,
+  renameType,
+  type SetDefaultDescriptor,
+  type SetNotNullDescriptor,
+  type SqlMigrationOpDescriptor,
+  setDefault,
+  setNotNull,
+  TODO,
+  type TodoMarker,
+} from '../core/migrations/operation-descriptors';

package/src/exports/pack.ts

@@ -1,6 +1,10 @@
-import type { TargetPackRef } from '@prisma-next/contract/framework-components';
+import type { CodecTypes } from '@prisma-next/adapter-postgres/codec-types';
+import type { TargetPackRef } from '@prisma-next/framework-components/components';
 import { postgresTargetDescriptorMeta } from '../core/descriptor-meta';
 
-const postgresPack: TargetPackRef<'sql', 'postgres'> = postgresTargetDescriptorMeta;
+const postgresPack = postgresTargetDescriptorMeta;
 
-export default postgresPack;
+export default postgresPack as typeof postgresTargetDescriptorMeta &
+  TargetPackRef<'sql', 'postgres'> & {
+    readonly __codecTypes?: CodecTypes;
+  };

package/src/exports/runtime.ts

@@ -1,23 +1,17 @@
-import type {
-  RuntimeTargetDescriptor,
-  RuntimeTargetInstance,
-} from '@prisma-next/core-execution-plane/types';
+import type { RuntimeTargetInstance } from '@prisma-next/framework-components/execution';
+import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
+import type { SqlRuntimeTargetDescriptor } from '@prisma-next/sql-runtime';
 import { postgresTargetDescriptorMeta } from '../core/descriptor-meta';
 
-/**
- * Postgres runtime target instance interface.
- */
 export interface PostgresRuntimeTargetInstance extends RuntimeTargetInstance<'sql', 'postgres'> {}
 
-/**
- * Postgres target descriptor for runtime plane.
- */
-const postgresRuntimeTargetDescriptor: RuntimeTargetDescriptor<
-  'sql',
+const postgresRuntimeTargetDescriptor: SqlRuntimeTargetDescriptor<
   'postgres',
   PostgresRuntimeTargetInstance
 > = {
   ...postgresTargetDescriptorMeta,
+  codecs: () => createCodecRegistry(),
+  parameterizedCodecs: () => [],
   create(): PostgresRuntimeTargetInstance {
     return {
       familyId: 'sql',

package/dist/chunk-RKEXRSSI.js

@@ -1,14 +0,0 @@
-// src/core/descriptor-meta.ts
-var postgresTargetDescriptorMeta = {
-  kind: "target",
-  familyId: "sql",
-  targetId: "postgres",
-  id: "postgres",
-  version: "0.0.1",
-  capabilities: {}
-};
-
-export {
-  postgresTargetDescriptorMeta
-};
-//# sourceMappingURL=chunk-RKEXRSSI.js.map