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

package/src/core/migrations/planner.ts

@@ -1,5 +1,13 @@
+import {
+  escapeLiteral,
+  expandParameterizedNativeType,
+  normalizeSchemaNativeType,
+  parsePostgresDefault,
+  quoteIdentifier,
+} from '@prisma-next/adapter-postgres/control';
 import type { SchemaIssue } from '@prisma-next/core-control-plane/types';
 import type {
+  CodecControlHooks,
   MigrationOperationPolicy,
   SqlMigrationPlanner,
   SqlMigrationPlannerPlanOptions,
@@ -8,6 +16,7 @@ import type {
 } from '@prisma-next/family-sql/control';
 import {
   createMigrationPlan,
+  extractCodecControlHooks,
   plannerFailure,
   plannerSuccess,
 } from '@prisma-next/family-sql/control';
@@ -25,8 +34,10 @@ import type {
   StorageTable,
 } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+import { ifDefined } from '@prisma-next/utils/defined';
+import type { PostgresColumnDefault } from '../types';
 
-type OperationClass = 'extension' | 'table' | 'unique' | 'index' | 'foreignKey';
+type OperationClass = 'extension' | 'type' | 'table' | 'unique' | 'index' | 'foreignKey';
 
 type PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {
   readonly frameworkComponents: infer T;
@@ -88,11 +99,21 @@ class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTarget
       return plannerFailure(classification.conflicts);
     }
 
+    // Extract codec control hooks once at entry point for reuse across all operations.
+    // This avoids repeated iteration over frameworkComponents for each method that needs hooks.
+    const codecHooks = extractCodecControlHooks(options.frameworkComponents);
+
     const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
 
+    const storageTypePlan = this.buildStorageTypeOperations(options, schemaName, codecHooks);
+    if (storageTypePlan.conflicts.length > 0) {
+      return plannerFailure(storageTypePlan.conflicts);
+    }
+
     // Build extension operations from component-owned database dependencies
     operations.push(
       ...this.buildDatabaseDependencyOperations(options),
+      ...storageTypePlan.operations,
       ...this.buildTableOperations(options.contract.storage.tables, options.schema, schemaName),
       ...this.buildColumnOperations(options.contract.storage.tables, options.schema, schemaName),
       ...this.buildPrimaryKeyOperations(
@@ -113,8 +134,8 @@ class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTarget
       targetId: 'postgres',
       origin: null,
       destination: {
-        coreHash: options.contract.coreHash,
-        ...(options.contract.profileHash ? { profileHash: options.contract.profileHash } : {}),
+        storageHash: options.contract.storageHash,
+        ...ifDefined('profileHash', options.contract.profileHash),
       },
       operations,
     });
@@ -171,6 +192,55 @@ class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTarget
 
     return operations;
   }
+
+  private buildStorageTypeOperations(
+    options: PlannerOptionsWithComponents,
+    schemaName: string,
+    codecHooks: Map<string, CodecControlHooks>,
+  ): {
+    readonly operations: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[];
+    readonly conflicts: readonly SqlPlannerConflict[];
+  } {
+    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
+    const conflicts: SqlPlannerConflict[] = [];
+    const storageTypes = options.contract.storage.types ?? {};
+
+    for (const [typeName, typeInstance] of sortedEntries(storageTypes)) {
+      const hook = codecHooks.get(typeInstance.codecId);
+      const planResult = hook?.planTypeOperations?.({
+        typeName,
+        typeInstance,
+        contract: options.contract,
+        schema: options.schema,
+        schemaName,
+        policy: options.policy,
+      });
+      if (!planResult) {
+        continue;
+      }
+      for (const operation of planResult.operations) {
+        if (!options.policy.allowedOperationClasses.includes(operation.operationClass)) {
+          conflicts.push({
+            kind: 'missingButNonAdditive',
+            summary: `Storage type "${typeName}" requires "${operation.operationClass}" operation "${operation.id}"`,
+            location: {
+              type: typeName,
+            },
+          });
+          continue;
+        }
+        operations.push({
+          ...operation,
+          target: {
+            id: operation.target.id,
+            details: this.buildTargetDetails('type', typeName, schemaName),
+          },
+        });
+      }
+    }
+
+    return { operations, conflicts };
+  }
   private collectDependencies(
     options: PlannerOptionsWithComponents,
   ): ReadonlyArray<PlannerDatabaseDependency> {
@@ -263,15 +333,20 @@ class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTarget
   ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
     const qualified = qualifyTableName(schema, tableName);
     const notNull = column.nullable === false;
+    const hasDefault = column.default !== undefined;
+    // Only require empty table for NOT NULL columns WITHOUT defaults.
+    // PostgreSQL allows adding NOT NULL columns with defaults to non-empty tables
+    // because the default value is applied to existing rows.
+    const requiresEmptyTable = notNull && !hasDefault;
     const precheck = [
       {
         description: `ensure column "${columnName}" is missing`,
         sql: columnExistsCheck({ schema, table: tableName, column: columnName, exists: false }),
       },
-      ...(notNull
+      ...(requiresEmptyTable
         ? [
             {
-              description: `ensure table "${tableName}" is empty before adding NOT NULL column`,
+              description: `ensure table "${tableName}" is empty before adding NOT NULL column without default`,
               sql: tableIsEmptyCheck(qualified),
             },
           ]
@@ -524,7 +599,7 @@ REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${forei
       schema,
       objectType,
       name,
-      ...(table ? { table } : {}),
+      ...ifDefined('table', table),
     };
   }
 
@@ -540,6 +615,8 @@ REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${forei
       strict: false,
       typeMetadataRegistry: new Map(),
       frameworkComponents: options.frameworkComponents,
+      normalizeDefault: parsePostgresDefault,
+      normalizeNativeType: normalizeSchemaNativeType,
     };
     const verifyResult = verifySqlSchema(verifyOptions);
 
@@ -588,16 +665,16 @@ REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${forei
     const meta =
       issue.expected || issue.actual
         ? Object.freeze({
-            ...(issue.expected ? { expected: issue.expected } : {}),
-            ...(issue.actual ? { actual: issue.actual } : {}),
+            ...ifDefined('expected', issue.expected),
+            ...ifDefined('actual', issue.actual),
           })
         : undefined;
 
     return {
       kind,
       summary: issue.message,
-      ...(location ? { location } : {}),
-      ...(meta ? { meta } : {}),
+      ...ifDefined('location', location),
+      ...ifDefined('meta', meta),
     };
   }
 }
@@ -638,7 +715,8 @@ function buildCreateTableSql(qualifiedTableName: string, table: StorageTable): s
     ([columnName, column]: [string, StorageColumn]) => {
       const parts = [
         quoteIdentifier(columnName),
-        column.nativeType,
+        buildColumnTypeSql(column),
+        buildColumnDefaultSql(column.default),
         column.nullable ? '' : 'NOT NULL',
       ].filter(Boolean);
       return parts.join(' ');
@@ -656,6 +734,83 @@ function buildCreateTableSql(qualifiedTableName: string, table: StorageTable): s
   return `CREATE TABLE ${qualifiedTableName} (\n  ${allDefinitions.join(',\n  ')}\n)`;
 }
 
+/**
+ * Builds the column type SQL, handling autoincrement as a special case.
+ * For autoincrement on int4/int8, we use SERIAL/BIGSERIAL types.
+ */
+function buildColumnTypeSql(column: StorageColumn): string {
+  const columnDefault = column.default;
+
+  // For autoincrement, use SERIAL/BIGSERIAL types instead of int4/int8
+  if (columnDefault?.kind === 'function' && columnDefault.expression === 'autoincrement()') {
+    if (column.nativeType === 'int4' || column.nativeType === 'integer') {
+      return 'SERIAL';
+    }
+    if (column.nativeType === 'int8' || column.nativeType === 'bigint') {
+      return 'BIGSERIAL';
+    }
+    if (column.nativeType === 'int2' || column.nativeType === 'smallint') {
+      return 'SMALLSERIAL';
+    }
+  }
+
+  if (column.typeRef) {
+    return quoteIdentifier(column.nativeType);
+  }
+
+  return renderParameterizedTypeSql(column) ?? column.nativeType;
+}
+
+/**
+ * Renders parameterized type SQL for a column, returning null if no expansion is needed.
+ *
+ * Uses the shared expandParameterizedNativeType utility from the postgres adapter.
+ * Returns null when the column has no typeParams, allowing the caller to fall back
+ * to the base nativeType.
+ */
+function renderParameterizedTypeSql(column: StorageColumn): string | null {
+  if (!column.typeParams) {
+    return null;
+  }
+
+  const expanded = expandParameterizedNativeType({
+    nativeType: column.nativeType,
+    codecId: column.codecId,
+    typeParams: column.typeParams,
+  });
+
+  // If no expansion happened (returned the same base type), return null
+  // so caller can decide whether to use nativeType directly
+  return expanded !== column.nativeType ? expanded : null;
+}
+
+/**
+ * Builds the DEFAULT clause for a column definition.
+ * Returns empty string if no default is defined.
+ *
+ * Note: autoincrement is handled specially via SERIAL types, so we skip it here.
+ */
+function buildColumnDefaultSql(columnDefault: PostgresColumnDefault | undefined): string {
+  if (!columnDefault) {
+    return '';
+  }
+
+  switch (columnDefault.kind) {
+    case 'literal':
+      return `DEFAULT ${columnDefault.expression}`;
+    case 'function': {
+      // autoincrement is handled by SERIAL type, no explicit DEFAULT needed
+      if (columnDefault.expression === 'autoincrement()') {
+        return '';
+      }
+      return `DEFAULT ${columnDefault.expression}`;
+    }
+    case 'sequence':
+      // Sequence names use quoteIdentifier for safe identifier handling
+      return `DEFAULT nextval(${quoteIdentifier(columnDefault.name)}::regclass)`;
+  }
+}
+
 function qualifyTableName(schema: string, table: string): string {
   return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
 }
@@ -665,16 +820,6 @@ function toRegclassLiteral(schema: string, name: string): string {
   return `'${escapeLiteral(regclass)}'`;
 }
 
-/** Escapes and quotes a SQL identifier (table, column, schema name). */
-function quoteIdentifier(identifier: string): string {
-  // TypeScript enforces string type - no runtime check needed for internal callers
-  return `"${identifier.replace(/"/g, '""')}"`;
-}
-
-function escapeLiteral(value: string): string {
-  return value.replace(/'/g, "''");
-}
-
 function sortedEntries<V>(record: Readonly<Record<string, V>>): Array<[string, V]> {
   return Object.entries(record).sort(([a], [b]) => a.localeCompare(b)) as Array<[string, V]>;
 }
@@ -746,9 +891,12 @@ function buildAddColumnSql(
   columnName: string,
   column: StorageColumn,
 ): string {
+  const typeSql = buildColumnTypeSql(column);
+  const defaultSql = buildColumnDefaultSql(column.default);
   const parts = [
     `ALTER TABLE ${qualifiedTableName}`,
-    `ADD COLUMN ${quoteIdentifier(columnName)} ${column.nativeType}`,
+    `ADD COLUMN ${quoteIdentifier(columnName)} ${typeSql}`,
+    defaultSql,
     column.nullable ? '' : 'NOT NULL',
   ].filter(Boolean);
   return parts.join(' ');
@@ -807,6 +955,8 @@ function hasForeignKey(table: SqlSchemaIR['tables'][string], fk: ForeignKey): bo
 
 function isAdditiveIssue(issue: SchemaIssue): boolean {
   switch (issue.kind) {
+    case 'type_missing':
+    case 'type_values_mismatch':
     case 'missing_table':
     case 'missing_column':
     case 'extension_missing':

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,
@@ -14,6 +18,7 @@ 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 { 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';
@@ -141,6 +146,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, {
@@ -371,13 +378,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 +395,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) {
@@ -435,10 +442,10 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
       }
       return runnerFailure(
         'MARKER_ORIGIN_MISMATCH',
-        `Existing contract marker (${marker.coreHash}) does not match plan origin (no marker expected).`,
+        `Existing contract marker (${marker.storageHash}) does not match plan origin (no marker expected).`,
         {
           meta: {
-            markerCoreHash: marker.coreHash,
+            markerStorageHash: marker.storageHash,
             expectedOrigin: null,
           },
         },
@@ -448,22 +455,22 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     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 +494,14 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     destination: SqlMigrationPlanContractInfo,
     contract: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['destinationContract'],
   ): Result<void, SqlMigrationRunnerFailure> {
-    if (destination.coreHash !== contract.coreHash) {
+    if (destination.storageHash !== contract.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.storageHash}).`,
         {
           meta: {
-            planCoreHash: destination.coreHash,
-            contractCoreHash: contract.coreHash,
+            planStorageHash: destination.storageHash,
+            contractStorageHash: contract.storageHash,
           },
         },
       );
@@ -524,11 +531,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 +551,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

@@ -12,12 +12,10 @@ import type { PostgresPlanTargetDetails } from '../core/migrations/planner';
 import { createPostgresMigrationPlanner } from '../core/migrations/planner';
 import { createPostgresMigrationRunner } from '../core/migrations/runner';
 
-/**
- * Postgres target descriptor for CLI config.
- */
 const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresPlanTargetDetails> =
   {
     ...postgresTargetDescriptorMeta,
+    operationSignatures: () => [],
     /**
      * Migrations capability for CLI to access planner/runner via core types.
      * The SQL-specific planner/runner types are compatible with the generic

package/src/exports/runtime.ts

@@ -1,23 +1,18 @@
-import type {
-  RuntimeTargetDescriptor,
-  RuntimeTargetInstance,
-} from '@prisma-next/core-execution-plane/types';
+import type { RuntimeTargetInstance } from '@prisma-next/core-execution-plane/types';
+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(),
+  operationSignatures: () => [],
+  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

package/dist/chunk-RKEXRSSI.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["export const postgresTargetDescriptorMeta = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n} as const;\n"],"mappings":";AAAO,IAAM,+BAA+B;AAAA,EAC1C,MAAM;AAAA,EACN,UAAU;AAAA,EACV,UAAU;AAAA,EACV,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,cAAc,CAAC;AACjB;","names":[]}

package/dist/core/descriptor-meta.d.ts

@@ -1,9 +0,0 @@
-export declare const postgresTargetDescriptorMeta: {
-    readonly kind: "target";
-    readonly familyId: "sql";
-    readonly targetId: "postgres";
-    readonly id: "postgres";
-    readonly version: "0.0.1";
-    readonly capabilities: {};
-};
-//# sourceMappingURL=descriptor-meta.d.ts.map

package/dist/core/descriptor-meta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta.d.ts","sourceRoot":"","sources":["../../src/core/descriptor-meta.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B;;;;;;;CAO/B,CAAC"}

package/dist/core/migrations/planner.d.ts

@@ -1,14 +0,0 @@
-import type { SqlMigrationPlanner } from '@prisma-next/family-sql/control';
-type OperationClass = 'extension' | 'table' | 'unique' | 'index' | 'foreignKey';
-export interface PostgresPlanTargetDetails {
-    readonly schema: string;
-    readonly objectType: OperationClass;
-    readonly name: string;
-    readonly table?: string;
-}
-interface PlannerConfig {
-    readonly defaultSchema: string;
-}
-export declare function createPostgresMigrationPlanner(config?: Partial<PlannerConfig>): SqlMigrationPlanner<PostgresPlanTargetDetails>;
-export {};
-//# sourceMappingURL=planner.d.ts.map

package/dist/core/migrations/planner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../../src/core/migrations/planner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,mBAAmB,EAIpB,MAAM,iCAAiC,CAAC;AAqBzC,KAAK,cAAc,GAAG,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,YAAY,CAAC;AAuBhF,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,aAAa;IACrB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAMD,wBAAgB,8BAA8B,CAC5C,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM,GAClC,mBAAmB,CAAC,yBAAyB,CAAC,CAKhD"}

package/dist/core/migrations/runner.d.ts

@@ -1,8 +0,0 @@
-import type { SqlControlFamilyInstance, SqlMigrationRunner } from '@prisma-next/family-sql/control';
-import type { PostgresPlanTargetDetails } from './planner';
-interface RunnerConfig {
-    readonly defaultSchema: string;
-}
-export declare function createPostgresMigrationRunner(family: SqlControlFamilyInstance, config?: Partial<RunnerConfig>): SqlMigrationRunner<PostgresPlanTargetDetails>;
-export {};
-//# sourceMappingURL=runner.d.ts.map

package/dist/core/migrations/runner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/core/migrations/runner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,wBAAwB,EAIxB,kBAAkB,EAInB,MAAM,iCAAiC,CAAC;AAOzC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAU3D,UAAU,YAAY;IACpB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAoCD,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,wBAAwB,EAChC,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM,GACjC,kBAAkB,CAAC,yBAAyB,CAAC,CAE/C"}

package/dist/core/migrations/statement-builders.d.ts

@@ -1,30 +0,0 @@
-export interface SqlStatement {
-    readonly sql: string;
-    readonly params: readonly unknown[];
-}
-export declare const ensurePrismaContractSchemaStatement: SqlStatement;
-export declare const ensureMarkerTableStatement: SqlStatement;
-export declare const ensureLedgerTableStatement: SqlStatement;
-export interface WriteMarkerInput {
-    readonly coreHash: string;
-    readonly profileHash: string;
-    readonly contractJson?: unknown;
-    readonly canonicalVersion?: number | null;
-    readonly appTag?: string | null;
-    readonly meta?: Record<string, unknown>;
-}
-export declare function buildWriteMarkerStatements(input: WriteMarkerInput): {
-    readonly insert: SqlStatement;
-    readonly update: SqlStatement;
-};
-export interface LedgerInsertInput {
-    readonly originCoreHash?: string | null;
-    readonly originProfileHash?: string | null;
-    readonly destinationCoreHash: string;
-    readonly destinationProfileHash?: string | null;
-    readonly contractJsonBefore?: unknown;
-    readonly contractJsonAfter?: unknown;
-    readonly operations: unknown;
-}
-export declare function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement;
-//# sourceMappingURL=statement-builders.d.ts.map

package/dist/core/migrations/statement-builders.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"statement-builders.d.ts","sourceRoot":"","sources":["../../../src/core/migrations/statement-builders.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;CACrC;AAED,eAAO,MAAM,mCAAmC,EAAE,YAGjD,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,YAYxC,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,YAaxC,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,gBAAgB,GAAG;IACnE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B,CA+CA;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,CA6BjF"}

package/dist/exports/control.d.ts

@@ -1,8 +0,0 @@
-import type { SqlControlTargetDescriptor } from '@prisma-next/family-sql/control';
-import type { PostgresPlanTargetDetails } from '../core/migrations/planner';
-/**
- * Postgres target descriptor for CLI config.
- */
-declare const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresPlanTargetDetails>;
-export default postgresTargetDescriptor;
-//# sourceMappingURL=control.d.ts.map

package/dist/exports/control.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../src/exports/control.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,0BAA0B,EAC3B,MAAM,iCAAiC,CAAC;AAEzC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAI5E;;GAEG;AACH,QAAA,MAAM,wBAAwB,EAAE,0BAA0B,CAAC,UAAU,EAAE,yBAAyB,CAoC7F,CAAC;AAEJ,eAAe,wBAAwB,CAAC"}