@prisma-next/target-postgres 0.12.0-dev.3 → 0.12.0-dev.31

package/src/core/migrations/control-policy.ts

@@ -0,0 +1,235 @@
+import type { Contract } from '@prisma-next/contract/types';
+import type { ControlPolicySubject } from '@prisma-next/family-sql/control';
+import type { SchemaIssue } from '@prisma-next/framework-components/control';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import {
+  isPostgresEnumStorageEntry,
+  type SqlStorage,
+  storageTableAt,
+} from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { isPostgresSchema } from '../postgres-schema';
+import type { PostgresOpFactoryCall } from './op-factory-call';
+
+/**
+ * Factory calls that create a whole, previously-absent top-level storage
+ * object. Used to decide whether `tolerated` permits a call (it only allows
+ * creating absent objects, never modifying existing ones).
+ *
+ * Deliberately an explicit, closed set rather than a `factoryName`
+ * create/alter/drop classification: it answers exactly one yes/no question
+ * and is fail-closed. Any call not listed here — including future or
+ * extension-contributed factories — is treated as NOT object-creation, so it
+ * is suppressed under `tolerated` rather than permissively emitted.
+ */
+const OBJECT_CREATION_FACTORIES: ReadonlySet<string> = new Set<string>([
+  'createTable',
+  'createEnumType',
+  'createSchema',
+]);
+
+function createsNewTopLevelObject(call: PostgresOpFactoryCall): boolean {
+  return OBJECT_CREATION_FACTORIES.has(call.factoryName);
+}
+
+function ddlSchemaNameForNamespace(contract: Contract<SqlStorage>, namespaceId: string): string {
+  const namespace = contract.storage.namespaces[namespaceId];
+  return isPostgresSchema(namespace) ? namespace.ddlSchemaName(contract.storage) : namespaceId;
+}
+
+function resolveNamespaceIdForTable(
+  contract: Contract<SqlStorage>,
+  tableName: string,
+  ddlSchemaName: string | undefined,
+): string {
+  for (const namespaceId of Object.keys(contract.storage.namespaces)) {
+    const table = storageTableAt(contract.storage, namespaceId, tableName);
+    if (!table) continue;
+    if (
+      ddlSchemaName === undefined ||
+      ddlSchemaNameForNamespace(contract, namespaceId) === ddlSchemaName
+    ) {
+      return namespaceId;
+    }
+  }
+  return UNBOUND_NAMESPACE_ID;
+}
+
+function resolveNamespaceIdForDdlSchema(
+  contract: Contract<SqlStorage>,
+  ddlSchemaName: string,
+): string {
+  for (const namespaceId of Object.keys(contract.storage.namespaces)) {
+    const ns = contract.storage.namespaces[namespaceId];
+    if (isPostgresSchema(ns) && ns.ddlSchemaName(contract.storage) === ddlSchemaName) {
+      return namespaceId;
+    }
+    if (namespaceId === ddlSchemaName) {
+      return namespaceId;
+    }
+  }
+  return UNBOUND_NAMESPACE_ID;
+}
+
+interface PostgresCallFields {
+  readonly schemaName?: string;
+  readonly tableName?: string;
+  readonly columnName?: string;
+  readonly typeName?: string;
+}
+
+function postgresCallFields(call: PostgresOpFactoryCall): PostgresCallFields {
+  return {
+    ...ifDefined('schemaName', 'schemaName' in call ? call.schemaName : undefined),
+    ...ifDefined('tableName', 'tableName' in call ? call.tableName : undefined),
+    ...ifDefined('columnName', 'columnName' in call ? call.columnName : undefined),
+    ...ifDefined('typeName', 'typeName' in call ? call.typeName : undefined),
+  };
+}
+
+export function formatPostgresControlPolicySubjectLabel(
+  factoryName: string,
+  subject: ControlPolicySubject | undefined,
+  contract: Contract<SqlStorage>,
+): string {
+  if (subject?.table) {
+    const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);
+    return `${factoryName}(${ddlSchema}.${subject.table})`;
+  }
+  if (subject?.typeName) {
+    const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);
+    return `${factoryName}(${ddlSchema}.${subject.typeName})`;
+  }
+  return factoryName;
+}
+
+export function resolvePostgresCallControlPolicySubject(
+  call: PostgresOpFactoryCall,
+  contract: Contract<SqlStorage>,
+): ControlPolicySubject | undefined {
+  const callFields = postgresCallFields(call);
+  const createsNewObject = createsNewTopLevelObject(call);
+
+  if (call.factoryName === 'createSchema' && callFields.schemaName) {
+    return {
+      namespaceId: resolveNamespaceIdForDdlSchema(contract, callFields.schemaName),
+      createsNewObject,
+    };
+  }
+
+  if (callFields.typeName && call.factoryName !== 'addColumn') {
+    const namespaceId = callFields.schemaName
+      ? resolveNamespaceIdForDdlSchema(contract, callFields.schemaName)
+      : UNBOUND_NAMESPACE_ID;
+    const ns = contract.storage.namespaces[namespaceId];
+    const rawEnum =
+      ns && 'enum' in ns && ns.enum != null ? ns.enum[callFields.typeName] : undefined;
+    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
+    return {
+      namespaceId,
+      ...ifDefined('explicitNodeControlPolicy', controlPolicy),
+      typeName: callFields.typeName,
+      createsNewObject,
+    };
+  }
+
+  if (callFields.tableName) {
+    const namespaceId = resolveNamespaceIdForTable(
+      contract,
+      callFields.tableName,
+      callFields.schemaName,
+    );
+    const table = storageTableAt(contract.storage, namespaceId, callFields.tableName);
+    const tableControlPolicy = table?.control;
+    return {
+      namespaceId,
+      ...ifDefined('explicitNodeControlPolicy', tableControlPolicy),
+      table: callFields.tableName,
+      ...ifDefined('column', callFields.columnName),
+      createsNewObject,
+    };
+  }
+
+  if (callFields.schemaName) {
+    return {
+      namespaceId: resolveNamespaceIdForDdlSchema(contract, callFields.schemaName),
+      createsNewObject,
+    };
+  }
+
+  return undefined;
+}
+
+/**
+ * Issue kinds that describe the absence of a whole, top-level Postgres
+ * object — the same kinds `createsNewTopLevelObject` recognises for calls.
+ * Used by {@link resolvePostgresIssueCreationFactoryName} to decide whether
+ * a `tolerated` subject permits the issue to flow into the planner
+ * (create-if-absent) and to seed the suppressed-subject warning's
+ * `factoryName` when the planner is skipped.
+ */
+const POSTGRES_ISSUE_CREATION_FACTORY: Readonly<Record<string, string>> = Object.freeze({
+  missing_schema: 'createSchema',
+  missing_table: 'createTable',
+  type_missing: 'createEnumType',
+});
+
+export function resolvePostgresIssueCreationFactoryName(issue: SchemaIssue): string | undefined {
+  return POSTGRES_ISSUE_CREATION_FACTORY[issue.kind];
+}
+
+/**
+ * Resolve the control-policy subject coordinate for a single
+ * {@link SchemaIssue}. Mirrors the resolution `resolvePostgresCallControlPolicySubject`
+ * performs for a generated DDL call, but works *off the issue* — so the
+ * planner can partition issues by effective policy before the diff engine
+ * runs. `createsNewObject` is derived from the issue's kind: schema/table/
+ * type-missing issues describe a brand-new top-level object; everything else
+ * touches an existing object.
+ *
+ * An `extra_table` issue carries no contract namespace coordinate (the table
+ * isn't in any contract namespace), so the subject's `namespaceId` falls
+ * back to {@link UNBOUND_NAMESPACE_ID}; the call-side resolver does the same
+ * for the `DropTableCall` it produces.
+ */
+export function resolvePostgresIssueControlPolicySubject(
+  issue: SchemaIssue,
+  contract: Contract<SqlStorage>,
+): ControlPolicySubject | undefined {
+  const createsNewObject = POSTGRES_ISSUE_CREATION_FACTORY[issue.kind] !== undefined;
+
+  if (issue.kind === 'missing_schema' && issue.namespaceId) {
+    return { namespaceId: issue.namespaceId, createsNewObject };
+  }
+
+  if ('typeName' in issue && issue.typeName) {
+    const namespaceId =
+      'namespaceId' in issue && issue.namespaceId ? issue.namespaceId : UNBOUND_NAMESPACE_ID;
+    const ns = contract.storage.namespaces[namespaceId];
+    const rawEnum = ns && 'enum' in ns && ns.enum != null ? ns.enum[issue.typeName] : undefined;
+    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
+    return {
+      namespaceId,
+      ...ifDefined('explicitNodeControlPolicy', controlPolicy),
+      typeName: issue.typeName,
+      createsNewObject,
+    };
+  }
+
+  if ('table' in issue && issue.table) {
+    const namespaceId =
+      'namespaceId' in issue && issue.namespaceId
+        ? issue.namespaceId
+        : resolveNamespaceIdForTable(contract, issue.table, undefined);
+    const table = storageTableAt(contract.storage, namespaceId, issue.table);
+    return {
+      namespaceId,
+      ...ifDefined('explicitNodeControlPolicy', table?.control),
+      table: issue.table,
+      ...ifDefined('column', 'column' in issue ? issue.column : undefined),
+      createsNewObject,
+    };
+  }
+
+  return undefined;
+}

package/src/core/migrations/planner.ts

@@ -2,10 +2,13 @@ import type { Contract } from '@prisma-next/contract/types';
 import type {
   MigrationOperationPolicy,
   SqlMigrationPlannerPlanOptions,
+  SqlPlannerConflict,
   SqlPlannerFailureResult,
 } from '@prisma-next/family-sql/control';
 import {
   extractCodecControlHooks,
+  partitionCallsByControlPolicy,
+  partitionIssuesByControlPolicy,
   planFieldEventOperations,
   plannerFailure,
 } from '@prisma-next/family-sql/control';
@@ -18,10 +21,19 @@ import type {
   SchemaIssue,
 } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import { blindCast } from '@prisma-next/utils/casts';
+import { postgresColumnsCompatible } from '../column-type-compatibility';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
+import {
+  formatPostgresControlPolicySubjectLabel,
+  resolvePostgresCallControlPolicySubject,
+  resolvePostgresIssueControlPolicySubject,
+  resolvePostgresIssueCreationFactoryName,
+} from './control-policy';
 import { createResolveExistingEnumValues } from './enum-planning';
 import { planIssues } from './issue-planner';
+import type { PostgresOpFactoryCall } from './op-factory-call';
 import { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';
 import { postgresPlannerStrategies } from './planner-strategies';
 import { verifyPostgresNamespacePresence } from './verify-postgres-namespaces';
@@ -52,7 +64,11 @@ export function createPostgresMigrationPlanner(): PostgresMigrationPlanner {
  * uniformly.
  */
 export type PostgresPlanResult =
-  | { readonly kind: 'success'; readonly plan: TypeScriptRenderablePostgresMigration }
+  | {
+      readonly kind: 'success';
+      readonly plan: TypeScriptRenderablePostgresMigration;
+      readonly warnings?: readonly SqlPlannerConflict[];
+    }
   | SqlPlannerFailureResult;
 
 /**
@@ -131,8 +147,25 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     const codecHooks = extractCodecControlHooks(options.frameworkComponents);
     const storageTypes = options.contract.storage.types ?? {};
 
-    const result = planIssues({
+    // Input-side control-policy partition. `external` / `observed` subjects
+    // — and non-creation issues for `tolerated` subjects — are dropped from
+    // the planner's input entirely; the planner never observes them, never
+    // diffs them, never generates DDL for them. Suppression warnings are
+    // built directly from the suppressed partition (one per subject), so the
+    // user-visible message survives even when the planner would have failed
+    // to model the subject's live shape.
+    const issuePartition = partitionIssuesByControlPolicy({
       issues: schemaIssues,
+      contract: options.contract,
+      resolveControlPolicySubject: (issue) =>
+        resolvePostgresIssueControlPolicySubject(issue, options.contract),
+      resolveCreationFactoryName: resolvePostgresIssueCreationFactoryName,
+      formatSubjectLabel: (factoryName, subject) =>
+        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),
+    });
+
+    const result = planIssues({
+      issues: issuePartition.plannable,
       toContract: options.contract,
       // `fromContract` is only supplied by `migration plan`. It is `null` for
       // `db update` / `db init`, which means data-safety strategies needing
@@ -163,10 +196,26 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       newContract: options.contract,
       codecHooks,
     });
-    // Codec-emitted calls already conform to `OpFactoryCall` — render +
-    // toOp + importRequirements ride directly through the same emit path
-    // as structural ops, no `RawSqlCall` wrap.
-    const calls = [...result.value.calls, ...fieldEventOps];
+    // Codec hook ops are target-agnostic `OpFactoryCall`; Postgres planning
+    // lifts them at this integration boundary (see field-event-planner JSDoc).
+    const fieldEventPostgresCalls = blindCast<
+      readonly PostgresOpFactoryCall[],
+      'Codec hook ops conform to PostgresOpFactoryCall at the app emitter boundary'
+    >(fieldEventOps);
+    const fieldEventPartition = partitionCallsByControlPolicy({
+      calls: fieldEventPostgresCalls,
+      contract: options.contract,
+      resolveControlPolicySubject: (call) =>
+        resolvePostgresCallControlPolicySubject(call, options.contract),
+      resolveFactoryName: (call) => call.factoryName,
+      formatSubjectLabel: (factoryName, subject) =>
+        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),
+    });
+    const calls = [...result.value.calls, ...fieldEventPartition.kept];
+    const warnings: SqlPlannerConflict[] = [
+      ...issuePartition.warnings,
+      ...fieldEventPartition.warnings,
+    ];
 
     return Object.freeze({
       kind: 'success' as const,
@@ -178,6 +227,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
         },
         options.spaceId,
       ),
+      ...(warnings.length > 0 ? { warnings: Object.freeze(warnings) } : {}),
     });
   }
 
@@ -208,6 +258,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       frameworkComponents: options.frameworkComponents,
       normalizeDefault: parsePostgresDefault,
       normalizeNativeType: normalizeSchemaNativeType,
+      columnsCompatible: postgresColumnsCompatible,
       resolveExistingEnumValues: createResolveExistingEnumValues(options.contract.storage),
     };
     const verifyResult = verifySqlSchema(verifyOptions);

package/src/core/migrations/runner.ts

@@ -1,4 +1,4 @@
-import type { ContractMarkerRecord } from '@prisma-next/contract/types';
+import type { Contract, ContractMarkerRecord } from '@prisma-next/contract/types';
 import type {
   MigrationOperationPolicy,
   SqlControlFamilyInstance,
@@ -19,10 +19,12 @@ import type {
 } from '@prisma-next/framework-components/control';
 import { APP_SPACE_ID } 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 { SqlQueryError } from '@prisma-next/sql-errors';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok, okVoid } from '@prisma-next/utils/result';
+import { postgresColumnsCompatible } from '../column-type-compatibility';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
 import { createResolveExistingEnumValues } from './enum-planning';
@@ -30,9 +32,6 @@ import type { PostgresPlanTargetDetails } from './planner-target-details';
 import {
   buildLedgerInsertStatement,
   buildMergeMarkerStatements,
-  ensureLedgerTableStatement,
-  ensureMarkerTableStatement,
-  ensurePrismaContractSchemaStatement,
   type SqlStatement,
 } from './statement-builders';
 
@@ -107,7 +106,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     if (!policyCheck.ok) return policyCheck;
 
     await this.acquireLock(driver, lockKey);
-    const ensureResult = await this.ensureControlTables(driver);
+    const ensureResult = await this.ensureControlTables(driver, options.destinationContract);
     if (!ensureResult.ok) return ensureResult;
     const existingMarker = await this.family.readMarker({ driver, space });
 
@@ -146,6 +145,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
         frameworkComponents: options.frameworkComponents,
         normalizeDefault: parsePostgresDefault,
         normalizeNativeType: normalizeSchemaNativeType,
+        columnsCompatible: postgresColumnsCompatible,
         resolveExistingEnumValues: createResolveExistingEnumValues(
           options.destinationContract.storage,
         ),
@@ -166,7 +166,12 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
 
     if (!isSelfEdgeNoOp) {
       await this.upsertMarker(driver, options, existingMarker, space);
-      await this.recordLedgerEntry(driver, options, existingMarker, applyValue.executedOperations);
+      await this.recordLedgerEntries(
+        driver,
+        options,
+        existingMarker,
+        applyValue.executedOperations,
+      );
     }
 
     return runnerSuccess({
@@ -282,18 +287,22 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
 
   private async ensureControlTables(
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
+    contract: Contract<SqlStorage>,
   ): Promise<Result<void, SqlMigrationRunnerFailure>> {
-    await this.executeStatement(driver, ensurePrismaContractSchemaStatement);
-    // Pre-1.0 zero-range guardrail: detect a pre-cleanup single-row
-    // marker table (no `space` column) and surface a structured failure
-    // rather than silently auto-migrating it to the per-space shape.
-    // See `specs/framework-mechanism.spec.md § 2`.
+    const lowererContext = { contract };
+    const bootstrapQueries = this.family.bootstrapControlTableQueries();
+    const [schemaQuery, ...tableQueries] = bootstrapQueries;
+    if (schemaQuery === undefined) {
+      throw new Error('Postgres control-table bootstrap must include CREATE SCHEMA');
+    }
+    await this.executeStatement(driver, this.family.lowerAst(schemaQuery, lowererContext));
     const legacyDetection = await this.detectLegacyMarkerShape(driver);
     if (!legacyDetection.ok) {
       return legacyDetection;
     }
-    await this.executeStatement(driver, ensureMarkerTableStatement);
-    await this.executeStatement(driver, ensureLedgerTableStatement);
+    for (const query of tableQueries) {
+      await this.executeStatement(driver, this.family.lowerAst(query, lowererContext));
+    }
     return okVoid();
   }
 
@@ -612,25 +621,55 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     await this.executeStatement(driver, statement);
   }
 
-  private async recordLedgerEntry(
+  private async recordLedgerEntries(
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
     options: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,
     existingMarker: ContractMarkerRecord | null,
     executedOperations: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[],
   ): Promise<void> {
-    const ledgerStatement = buildLedgerInsertStatement({
-      originStorageHash: existingMarker?.storageHash ?? null,
-      originProfileHash: existingMarker?.profileHash ?? null,
-      destinationStorageHash: options.plan.destination.storageHash,
-      destinationProfileHash:
-        options.plan.destination.profileHash ??
-        options.destinationContract.profileHash ??
-        options.plan.destination.storageHash,
-      contractJsonBefore: existingMarker?.contractJson ?? null,
-      contractJsonAfter: options.destinationContract,
-      operations: executedOperations,
-    });
-    await this.executeStatement(driver, ledgerStatement);
+    const plan = options.plan;
+    const space = plan.spaceId;
+    const destinationProfileHash =
+      plan.destination.profileHash ??
+      options.destinationContract.profileHash ??
+      plan.destination.storageHash;
+    const edges = options.migrationEdges;
+    const totalEdgeOps = edges.reduce((sum, edge) => sum + edge.operationCount, 0);
+    if (totalEdgeOps !== plan.operations.length) {
+      throw new Error(
+        `Ledger write: plan.operations length (${plan.operations.length}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`,
+      );
+    }
+    // The ledger records the operations as executed — idempotency-skipped ops
+    // are substituted with skip records (empty `execute`) by `applyPlan`, so the
+    // journal reflects what actually ran rather than the raw plan.
+    let offset = 0;
+    const lastIndex = edges.length - 1;
+    for (const [i, edge] of edges.entries()) {
+      const edgeOps = executedOperations.slice(offset, offset + edge.operationCount);
+      offset += edge.operationCount;
+      const isFirst = i === 0;
+      const isLast = i === lastIndex;
+      await this.executeStatement(
+        driver,
+        buildLedgerInsertStatement({
+          space,
+          migrationName: edge.dirName,
+          migrationHash: edge.migrationHash,
+          originStorageHash: edge.from === '' ? null : edge.from,
+          originProfileHash:
+            isFirst && existingMarker?.storageHash === edge.from
+              ? (existingMarker.profileHash ?? null)
+              : null,
+          destinationStorageHash: edge.to,
+          destinationProfileHash:
+            isLast && edge.to === plan.destination.storageHash ? destinationProfileHash : null,
+          contractJsonBefore: isFirst ? (existingMarker?.contractJson ?? null) : null,
+          contractJsonAfter: isLast ? options.destinationContract : null,
+          operations: edgeOps,
+        }),
+      );
+    }
   }
 
   private async acquireLock(

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

@@ -40,6 +40,9 @@ export const ensureLedgerTableStatement: SqlStatement = {
   sql: `create table if not exists prisma_contract.ledger (
     id bigserial primary key,
     created_at timestamptz not null default now(),
+    space text not null,
+    migration_name text not null,
+    migration_hash text not null,
     origin_core_hash text,
     origin_profile_hash text,
     destination_core_hash text not null,
@@ -138,6 +141,9 @@ export function buildMergeMarkerStatements(input: MergeMarkerInput): {
 }
 
 export interface LedgerInsertInput {
+  readonly space: string;
+  readonly migrationName: string;
+  readonly migrationHash: string;
   readonly originStorageHash?: string | null;
   readonly originProfileHash?: string | null;
   readonly destinationStorageHash: string;
@@ -150,6 +156,9 @@ export interface LedgerInsertInput {
 export function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement {
   return {
     sql: `insert into prisma_contract.ledger (
+      space,
+      migration_name,
+      migration_hash,
       origin_core_hash,
       origin_profile_hash,
       destination_core_hash,
@@ -162,11 +171,17 @@ export function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStateme
       $2,
       $3,
       $4,
-      $5::jsonb,
-      $6::jsonb,
-      $7::jsonb
+      $5,
+      $6,
+      $7,
+      $8::jsonb,
+      $9::jsonb,
+      $10::jsonb
     )`,
     params: [
+      input.space,
+      input.migrationName,
+      input.migrationHash,
       input.originStorageHash ?? null,
       input.originProfileHash ?? null,
       input.destinationStorageHash,

package/src/exports/column-type-compatibility.ts

@@ -0,0 +1 @@
+export { postgresColumnsCompatible } from '../core/column-type-compatibility';

package/src/exports/contract-free.ts

@@ -0,0 +1,5 @@
+export {
+  buildControlTableBootstrapQueries,
+  buildSignMarkerBootstrapQueries,
+} from '../contract-free/control-bootstrap';
+export { createSchema, createTable } from '../contract-free/ddl';

package/src/exports/ddl.ts

@@ -0,0 +1,7 @@
+export {
+  type AnyPostgresDdlNode,
+  PostgresCreateSchema,
+  PostgresCreateTable,
+  PostgresDdlNode,
+  type PostgresDdlVisitor,
+} from '../core/ddl/nodes';

package/dist/descriptor-meta-Uu8QaClr.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-Uu8QaClr.mjs","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["import type { CodecTypes } from '../exports/codec-types';\nimport {\n  postgresAuthoringEntityTypes,\n  postgresAuthoringFieldPresets,\n  postgresAuthoringTypes,\n} from './authoring';\nimport { postgresTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';\n\nconst postgresTargetDescriptorMetaBase = {\n  ...postgresTargetDescriptorMetaRuntime,\n  authoring: {\n    type: postgresAuthoringTypes,\n    field: postgresAuthoringFieldPresets,\n    entityTypes: postgresAuthoringEntityTypes,\n  },\n} as const;\n\nexport const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaBase;\n"],"mappings":";AAiBA,MAAa,+BAET;CAVF,GAAG;CACH,WAAW;EACT,MAAM;EACN,OAAO;EACP,aAAa;CACf;AAKE"}