@prisma-next/target-postgres 0.3.0-dev.6 → 0.3.0-dev.64

package/dist/exports/control.js

@@ -1,1255 +0,0 @@
-import {
-  postgresTargetDescriptorMeta
-} from "../chunk-RKEXRSSI.js";
-
-// src/core/migrations/planner.ts
-import {
-  createMigrationPlan,
-  plannerFailure,
-  plannerSuccess
-} from "@prisma-next/family-sql/control";
-import { arraysEqual, verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
-var DEFAULT_PLANNER_CONFIG = {
-  defaultSchema: "public"
-};
-function createPostgresMigrationPlanner(config = {}) {
-  return new PostgresMigrationPlanner({
-    ...DEFAULT_PLANNER_CONFIG,
-    ...config
-  });
-}
-var PostgresMigrationPlanner = class {
-  constructor(config) {
-    this.config = config;
-  }
-  plan(options) {
-    const schemaName = options.schemaName ?? this.config.defaultSchema;
-    const policyResult = this.ensureAdditivePolicy(options.policy);
-    if (policyResult) {
-      return policyResult;
-    }
-    const classification = this.classifySchema(options);
-    if (classification.kind === "conflict") {
-      return plannerFailure(classification.conflicts);
-    }
-    const operations = [];
-    operations.push(
-      ...this.buildDatabaseDependencyOperations(options),
-      ...this.buildTableOperations(options.contract.storage.tables, options.schema, schemaName),
-      ...this.buildColumnOperations(options.contract.storage.tables, options.schema, schemaName),
-      ...this.buildPrimaryKeyOperations(
-        options.contract.storage.tables,
-        options.schema,
-        schemaName
-      ),
-      ...this.buildUniqueOperations(options.contract.storage.tables, options.schema, schemaName),
-      ...this.buildIndexOperations(options.contract.storage.tables, options.schema, schemaName),
-      ...this.buildForeignKeyOperations(
-        options.contract.storage.tables,
-        options.schema,
-        schemaName
-      )
-    );
-    const plan = createMigrationPlan({
-      targetId: "postgres",
-      origin: null,
-      destination: {
-        coreHash: options.contract.coreHash,
-        ...options.contract.profileHash ? { profileHash: options.contract.profileHash } : {}
-      },
-      operations
-    });
-    return plannerSuccess(plan);
-  }
-  ensureAdditivePolicy(policy) {
-    if (!policy.allowedOperationClasses.includes("additive")) {
-      return plannerFailure([
-        {
-          kind: "unsupportedOperation",
-          summary: "Init planner requires additive operations be allowed",
-          why: 'The init planner only emits additive operations. Update the policy to include "additive".'
-        }
-      ]);
-    }
-    return null;
-  }
-  /**
-   * Builds migration operations from component-owned database dependencies.
-   * These operations install database-side persistence structures declared by components.
-   */
-  buildDatabaseDependencyOperations(options) {
-    const dependencies = this.collectDependencies(options);
-    const operations = [];
-    const seenDependencyIds = /* @__PURE__ */ new Set();
-    const seenOperationIds = /* @__PURE__ */ new Set();
-    for (const dependency of dependencies) {
-      if (seenDependencyIds.has(dependency.id)) {
-        continue;
-      }
-      seenDependencyIds.add(dependency.id);
-      const issues = dependency.verifyDatabaseDependencyInstalled(options.schema);
-      if (issues.length === 0) {
-        continue;
-      }
-      for (const installOp of dependency.install) {
-        if (seenOperationIds.has(installOp.id)) {
-          continue;
-        }
-        seenOperationIds.add(installOp.id);
-        operations.push(installOp);
-      }
-    }
-    return operations;
-  }
-  collectDependencies(options) {
-    const components = options.frameworkComponents;
-    if (components.length === 0) {
-      return [];
-    }
-    const deps = [];
-    for (const component of components) {
-      if (!isSqlDependencyProvider(component)) {
-        continue;
-      }
-      const initDeps = component.databaseDependencies?.init;
-      if (initDeps && initDeps.length > 0) {
-        deps.push(...initDeps);
-      }
-    }
-    return sortDependencies(deps);
-  }
-  buildTableOperations(tables, schema, schemaName) {
-    const operations = [];
-    for (const [tableName, table] of sortedEntries(tables)) {
-      if (schema.tables[tableName]) {
-        continue;
-      }
-      const qualified = qualifyTableName(schemaName, tableName);
-      operations.push({
-        id: `table.${tableName}`,
-        label: `Create table ${tableName}`,
-        summary: `Creates table ${tableName} with required columns`,
-        operationClass: "additive",
-        target: {
-          id: "postgres",
-          details: this.buildTargetDetails("table", tableName, schemaName)
-        },
-        precheck: [
-          {
-            description: `ensure table "${tableName}" does not exist`,
-            sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`
-          }
-        ],
-        execute: [
-          {
-            description: `create table "${tableName}"`,
-            sql: buildCreateTableSql(qualified, table)
-          }
-        ],
-        postcheck: [
-          {
-            description: `verify table "${tableName}" exists`,
-            sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`
-          }
-        ]
-      });
-    }
-    return operations;
-  }
-  buildColumnOperations(tables, schema, schemaName) {
-    const operations = [];
-    for (const [tableName, table] of sortedEntries(tables)) {
-      const schemaTable = schema.tables[tableName];
-      if (!schemaTable) {
-        continue;
-      }
-      for (const [columnName, column] of sortedEntries(table.columns)) {
-        if (schemaTable.columns[columnName]) {
-          continue;
-        }
-        operations.push(this.buildAddColumnOperation(schemaName, tableName, columnName, column));
-      }
-    }
-    return operations;
-  }
-  buildAddColumnOperation(schema, tableName, columnName, column) {
-    const qualified = qualifyTableName(schema, tableName);
-    const notNull = column.nullable === false;
-    const precheck = [
-      {
-        description: `ensure column "${columnName}" is missing`,
-        sql: columnExistsCheck({ schema, table: tableName, column: columnName, exists: false })
-      },
-      ...notNull ? [
-        {
-          description: `ensure table "${tableName}" is empty before adding NOT NULL column`,
-          sql: tableIsEmptyCheck(qualified)
-        }
-      ] : []
-    ];
-    const execute = [
-      {
-        description: `add column "${columnName}"`,
-        sql: buildAddColumnSql(qualified, columnName, column)
-      }
-    ];
-    const postcheck = [
-      {
-        description: `verify column "${columnName}" exists`,
-        sql: columnExistsCheck({ schema, table: tableName, column: columnName })
-      },
-      ...notNull ? [
-        {
-          description: `verify column "${columnName}" is NOT NULL`,
-          sql: columnIsNotNullCheck({ schema, table: tableName, column: columnName })
-        }
-      ] : []
-    ];
-    return {
-      id: `column.${tableName}.${columnName}`,
-      label: `Add column ${columnName} to ${tableName}`,
-      summary: `Adds column ${columnName} to table ${tableName}`,
-      operationClass: "additive",
-      target: {
-        id: "postgres",
-        details: this.buildTargetDetails("table", tableName, schema)
-      },
-      precheck,
-      execute,
-      postcheck
-    };
-  }
-  buildPrimaryKeyOperations(tables, schema, schemaName) {
-    const operations = [];
-    for (const [tableName, table] of sortedEntries(tables)) {
-      if (!table.primaryKey) {
-        continue;
-      }
-      const schemaTable = schema.tables[tableName];
-      if (!schemaTable || schemaTable.primaryKey) {
-        continue;
-      }
-      const constraintName = table.primaryKey.name ?? `${tableName}_pkey`;
-      operations.push({
-        id: `primaryKey.${tableName}.${constraintName}`,
-        label: `Add primary key ${constraintName} on ${tableName}`,
-        summary: `Adds primary key ${constraintName} on ${tableName}`,
-        operationClass: "additive",
-        target: {
-          id: "postgres",
-          details: this.buildTargetDetails("table", tableName, schemaName)
-        },
-        precheck: [
-          {
-            description: `ensure primary key does not exist on "${tableName}"`,
-            sql: tableHasPrimaryKeyCheck(schemaName, tableName, false)
-          }
-        ],
-        execute: [
-          {
-            description: `add primary key "${constraintName}"`,
-            sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
-ADD CONSTRAINT ${quoteIdentifier(constraintName)}
-PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(", ")})`
-          }
-        ],
-        postcheck: [
-          {
-            description: `verify primary key "${constraintName}" exists`,
-            sql: tableHasPrimaryKeyCheck(schemaName, tableName, true, constraintName)
-          }
-        ]
-      });
-    }
-    return operations;
-  }
-  buildUniqueOperations(tables, schema, schemaName) {
-    const operations = [];
-    for (const [tableName, table] of sortedEntries(tables)) {
-      const schemaTable = schema.tables[tableName];
-      for (const unique of table.uniques) {
-        if (schemaTable && hasUniqueConstraint(schemaTable, unique.columns)) {
-          continue;
-        }
-        const constraintName = unique.name ?? `${tableName}_${unique.columns.join("_")}_key`;
-        operations.push({
-          id: `unique.${tableName}.${constraintName}`,
-          label: `Add unique constraint ${constraintName} on ${tableName}`,
-          summary: `Adds unique constraint ${constraintName} on ${tableName}`,
-          operationClass: "additive",
-          target: {
-            id: "postgres",
-            details: this.buildTargetDetails("unique", constraintName, schemaName, tableName)
-          },
-          precheck: [
-            {
-              description: `ensure unique constraint "${constraintName}" is missing`,
-              sql: constraintExistsCheck({ constraintName, schema: schemaName, exists: false })
-            }
-          ],
-          execute: [
-            {
-              description: `add unique constraint "${constraintName}"`,
-              sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
-ADD CONSTRAINT ${quoteIdentifier(constraintName)}
-UNIQUE (${unique.columns.map(quoteIdentifier).join(", ")})`
-            }
-          ],
-          postcheck: [
-            {
-              description: `verify unique constraint "${constraintName}" exists`,
-              sql: constraintExistsCheck({ constraintName, schema: schemaName })
-            }
-          ]
-        });
-      }
-    }
-    return operations;
-  }
-  buildIndexOperations(tables, schema, schemaName) {
-    const operations = [];
-    for (const [tableName, table] of sortedEntries(tables)) {
-      const schemaTable = schema.tables[tableName];
-      for (const index of table.indexes) {
-        if (schemaTable && hasIndex(schemaTable, index.columns)) {
-          continue;
-        }
-        const indexName = index.name ?? `${tableName}_${index.columns.join("_")}_idx`;
-        operations.push({
-          id: `index.${tableName}.${indexName}`,
-          label: `Create index ${indexName} on ${tableName}`,
-          summary: `Creates index ${indexName} on ${tableName}`,
-          operationClass: "additive",
-          target: {
-            id: "postgres",
-            details: this.buildTargetDetails("index", indexName, schemaName, tableName)
-          },
-          precheck: [
-            {
-              description: `ensure index "${indexName}" is missing`,
-              sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`
-            }
-          ],
-          execute: [
-            {
-              description: `create index "${indexName}"`,
-              sql: `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualifyTableName(
-                schemaName,
-                tableName
-              )} (${index.columns.map(quoteIdentifier).join(", ")})`
-            }
-          ],
-          postcheck: [
-            {
-              description: `verify index "${indexName}" exists`,
-              sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`
-            }
-          ]
-        });
-      }
-    }
-    return operations;
-  }
-  buildForeignKeyOperations(tables, schema, schemaName) {
-    const operations = [];
-    for (const [tableName, table] of sortedEntries(tables)) {
-      const schemaTable = schema.tables[tableName];
-      for (const foreignKey of table.foreignKeys) {
-        if (schemaTable && hasForeignKey(schemaTable, foreignKey)) {
-          continue;
-        }
-        const fkName = foreignKey.name ?? `${tableName}_${foreignKey.columns.join("_")}_fkey`;
-        operations.push({
-          id: `foreignKey.${tableName}.${fkName}`,
-          label: `Add foreign key ${fkName} on ${tableName}`,
-          summary: `Adds foreign key ${fkName} referencing ${foreignKey.references.table}`,
-          operationClass: "additive",
-          target: {
-            id: "postgres",
-            details: this.buildTargetDetails("foreignKey", fkName, schemaName, tableName)
-          },
-          precheck: [
-            {
-              description: `ensure foreign key "${fkName}" is missing`,
-              sql: constraintExistsCheck({
-                constraintName: fkName,
-                schema: schemaName,
-                exists: false
-              })
-            }
-          ],
-          execute: [
-            {
-              description: `add foreign key "${fkName}"`,
-              sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
-ADD CONSTRAINT ${quoteIdentifier(fkName)}
-FOREIGN KEY (${foreignKey.columns.map(quoteIdentifier).join(", ")})
-REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${foreignKey.references.columns.map(quoteIdentifier).join(", ")})`
-            }
-          ],
-          postcheck: [
-            {
-              description: `verify foreign key "${fkName}" exists`,
-              sql: constraintExistsCheck({ constraintName: fkName, schema: schemaName })
-            }
-          ]
-        });
-      }
-    }
-    return operations;
-  }
-  buildTargetDetails(objectType, name, schema, table) {
-    return {
-      schema,
-      objectType,
-      name,
-      ...table ? { table } : {}
-    };
-  }
-  classifySchema(options) {
-    const verifyOptions = {
-      contract: options.contract,
-      schema: options.schema,
-      strict: false,
-      typeMetadataRegistry: /* @__PURE__ */ new Map(),
-      frameworkComponents: options.frameworkComponents
-    };
-    const verifyResult = verifySqlSchema(verifyOptions);
-    const conflicts = this.extractConflicts(verifyResult.schema.issues);
-    if (conflicts.length > 0) {
-      return { kind: "conflict", conflicts };
-    }
-    return { kind: "ok" };
-  }
-  extractConflicts(issues) {
-    const conflicts = [];
-    for (const issue of issues) {
-      if (isAdditiveIssue(issue)) {
-        continue;
-      }
-      const conflict = this.convertIssueToConflict(issue);
-      if (conflict) {
-        conflicts.push(conflict);
-      }
-    }
-    return conflicts.sort(conflictComparator);
-  }
-  convertIssueToConflict(issue) {
-    switch (issue.kind) {
-      case "type_mismatch":
-        return this.buildConflict("typeMismatch", issue);
-      case "nullability_mismatch":
-        return this.buildConflict("nullabilityConflict", issue);
-      case "primary_key_mismatch":
-        return this.buildConflict("indexIncompatible", issue);
-      case "unique_constraint_mismatch":
-        return this.buildConflict("indexIncompatible", issue);
-      case "index_mismatch":
-        return this.buildConflict("indexIncompatible", issue);
-      case "foreign_key_mismatch":
-        return this.buildConflict("foreignKeyConflict", issue);
-      default:
-        return null;
-    }
-  }
-  buildConflict(kind, issue) {
-    const location = buildConflictLocation(issue);
-    const meta = issue.expected || issue.actual ? Object.freeze({
-      ...issue.expected ? { expected: issue.expected } : {},
-      ...issue.actual ? { actual: issue.actual } : {}
-    }) : void 0;
-    return {
-      kind,
-      summary: issue.message,
-      ...location ? { location } : {},
-      ...meta ? { meta } : {}
-    };
-  }
-};
-function isSqlDependencyProvider(component) {
-  if (typeof component !== "object" || component === null) {
-    return false;
-  }
-  const record = component;
-  if (Object.hasOwn(record, "familyId") && record["familyId"] !== "sql") {
-    return false;
-  }
-  if (!Object.hasOwn(record, "databaseDependencies")) {
-    return false;
-  }
-  const deps = record["databaseDependencies"];
-  return deps === void 0 || typeof deps === "object" && deps !== null;
-}
-function sortDependencies(dependencies) {
-  if (dependencies.length <= 1) {
-    return dependencies;
-  }
-  return [...dependencies].sort((a, b) => a.id.localeCompare(b.id));
-}
-function buildCreateTableSql(qualifiedTableName, table) {
-  const columnDefinitions = Object.entries(table.columns).map(
-    ([columnName, column]) => {
-      const parts = [
-        quoteIdentifier(columnName),
-        column.nativeType,
-        column.nullable ? "" : "NOT NULL"
-      ].filter(Boolean);
-      return parts.join(" ");
-    }
-  );
-  const constraintDefinitions = [];
-  if (table.primaryKey) {
-    constraintDefinitions.push(
-      `PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(", ")})`
-    );
-  }
-  const allDefinitions = [...columnDefinitions, ...constraintDefinitions];
-  return `CREATE TABLE ${qualifiedTableName} (
-  ${allDefinitions.join(",\n  ")}
-)`;
-}
-function qualifyTableName(schema, table) {
-  return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
-}
-function toRegclassLiteral(schema, name) {
-  const regclass = `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;
-  return `'${escapeLiteral(regclass)}'`;
-}
-function quoteIdentifier(identifier) {
-  return `"${identifier.replace(/"/g, '""')}"`;
-}
-function escapeLiteral(value) {
-  return value.replace(/'/g, "''");
-}
-function sortedEntries(record) {
-  return Object.entries(record).sort(([a], [b]) => a.localeCompare(b));
-}
-function constraintExistsCheck({
-  constraintName,
-  schema,
-  exists = true
-}) {
-  const existsClause = exists ? "EXISTS" : "NOT EXISTS";
-  return `SELECT ${existsClause} (
-  SELECT 1 FROM pg_constraint c
-  JOIN pg_namespace n ON c.connamespace = n.oid
-  WHERE c.conname = '${escapeLiteral(constraintName)}'
-  AND n.nspname = '${escapeLiteral(schema)}'
-)`;
-}
-function columnExistsCheck({
-  schema,
-  table,
-  column,
-  exists = true
-}) {
-  const existsClause = exists ? "" : "NOT ";
-  return `SELECT ${existsClause}EXISTS (
-  SELECT 1
-  FROM information_schema.columns
-  WHERE table_schema = '${escapeLiteral(schema)}'
-    AND table_name = '${escapeLiteral(table)}'
-    AND column_name = '${escapeLiteral(column)}'
-)`;
-}
-function columnIsNotNullCheck({
-  schema,
-  table,
-  column
-}) {
-  return `SELECT EXISTS (
-  SELECT 1
-  FROM information_schema.columns
-  WHERE table_schema = '${escapeLiteral(schema)}'
-    AND table_name = '${escapeLiteral(table)}'
-    AND column_name = '${escapeLiteral(column)}'
-    AND is_nullable = 'NO'
-)`;
-}
-function tableIsEmptyCheck(qualifiedTableName) {
-  return `SELECT NOT EXISTS (SELECT 1 FROM ${qualifiedTableName} LIMIT 1)`;
-}
-function buildAddColumnSql(qualifiedTableName, columnName, column) {
-  const parts = [
-    `ALTER TABLE ${qualifiedTableName}`,
-    `ADD COLUMN ${quoteIdentifier(columnName)} ${column.nativeType}`,
-    column.nullable ? "" : "NOT NULL"
-  ].filter(Boolean);
-  return parts.join(" ");
-}
-function tableHasPrimaryKeyCheck(schema, table, exists, constraintName) {
-  const comparison = exists ? "" : "NOT ";
-  const constraintFilter = constraintName ? `AND c2.relname = '${escapeLiteral(constraintName)}'` : "";
-  return `SELECT ${comparison}EXISTS (
-  SELECT 1
-  FROM pg_index i
-  JOIN pg_class c ON c.oid = i.indrelid
-  JOIN pg_namespace n ON n.oid = c.relnamespace
-  LEFT JOIN pg_class c2 ON c2.oid = i.indexrelid
-  WHERE n.nspname = '${escapeLiteral(schema)}'
-    AND c.relname = '${escapeLiteral(table)}'
-    AND i.indisprimary
-    ${constraintFilter}
-)`;
-}
-function hasUniqueConstraint(table, columns) {
-  return table.uniques.some((unique) => arraysEqual(unique.columns, columns));
-}
-function hasIndex(table, columns) {
-  return table.indexes.some((index) => !index.unique && arraysEqual(index.columns, columns));
-}
-function hasForeignKey(table, fk) {
-  return table.foreignKeys.some(
-    (candidate) => arraysEqual(candidate.columns, fk.columns) && candidate.referencedTable === fk.references.table && arraysEqual(candidate.referencedColumns, fk.references.columns)
-  );
-}
-function isAdditiveIssue(issue) {
-  switch (issue.kind) {
-    case "missing_table":
-    case "missing_column":
-    case "extension_missing":
-      return true;
-    case "primary_key_mismatch":
-      return issue.actual === void 0;
-    case "unique_constraint_mismatch":
-    case "index_mismatch":
-    case "foreign_key_mismatch":
-      return issue.indexOrConstraint === void 0;
-    default:
-      return false;
-  }
-}
-function buildConflictLocation(issue) {
-  const location = {};
-  if (issue.table) {
-    location.table = issue.table;
-  }
-  if (issue.column) {
-    location.column = issue.column;
-  }
-  if (issue.indexOrConstraint) {
-    location.constraint = issue.indexOrConstraint;
-  }
-  return Object.keys(location).length > 0 ? location : void 0;
-}
-function conflictComparator(a, b) {
-  if (a.kind !== b.kind) {
-    return a.kind < b.kind ? -1 : 1;
-  }
-  const aLocation = a.location ?? {};
-  const bLocation = b.location ?? {};
-  const tableCompare = compareStrings(aLocation.table, bLocation.table);
-  if (tableCompare !== 0) {
-    return tableCompare;
-  }
-  const columnCompare = compareStrings(aLocation.column, bLocation.column);
-  if (columnCompare !== 0) {
-    return columnCompare;
-  }
-  const constraintCompare = compareStrings(aLocation.constraint, bLocation.constraint);
-  if (constraintCompare !== 0) {
-    return constraintCompare;
-  }
-  return compareStrings(a.summary, b.summary);
-}
-function compareStrings(a, b) {
-  if (a === b) {
-    return 0;
-  }
-  if (a === void 0) {
-    return -1;
-  }
-  if (b === void 0) {
-    return 1;
-  }
-  return a < b ? -1 : 1;
-}
-
-// src/core/migrations/runner.ts
-import { runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
-import { verifySqlSchema as verifySqlSchema2 } from "@prisma-next/family-sql/schema-verify";
-import { readMarker } from "@prisma-next/family-sql/verify";
-import { SqlQueryError } from "@prisma-next/sql-errors";
-import { ok, okVoid } from "@prisma-next/utils/result";
-
-// src/core/migrations/statement-builders.ts
-var ensurePrismaContractSchemaStatement = {
-  sql: "create schema if not exists prisma_contract",
-  params: []
-};
-var ensureMarkerTableStatement = {
-  sql: `create table if not exists prisma_contract.marker (
-    id smallint primary key default 1,
-    core_hash text not null,
-    profile_hash text not null,
-    contract_json jsonb,
-    canonical_version int,
-    updated_at timestamptz not null default now(),
-    app_tag text,
-    meta jsonb not null default '{}'
-  )`,
-  params: []
-};
-var ensureLedgerTableStatement = {
-  sql: `create table if not exists prisma_contract.ledger (
-    id bigserial primary key,
-    created_at timestamptz not null default now(),
-    origin_core_hash text,
-    origin_profile_hash text,
-    destination_core_hash text not null,
-    destination_profile_hash text,
-    contract_json_before jsonb,
-    contract_json_after jsonb,
-    operations jsonb not null
-  )`,
-  params: []
-};
-function buildWriteMarkerStatements(input) {
-  const params = [
-    1,
-    input.coreHash,
-    input.profileHash,
-    jsonParam(input.contractJson),
-    input.canonicalVersion ?? null,
-    input.appTag ?? null,
-    jsonParam(input.meta ?? {})
-  ];
-  return {
-    insert: {
-      sql: `insert into prisma_contract.marker (
-        id,
-        core_hash,
-        profile_hash,
-        contract_json,
-        canonical_version,
-        updated_at,
-        app_tag,
-        meta
-      ) values (
-        $1,
-        $2,
-        $3,
-        $4::jsonb,
-        $5,
-        now(),
-        $6,
-        $7::jsonb
-      )`,
-      params
-    },
-    update: {
-      sql: `update prisma_contract.marker set
-        core_hash = $2,
-        profile_hash = $3,
-        contract_json = $4::jsonb,
-        canonical_version = $5,
-        updated_at = now(),
-        app_tag = $6,
-        meta = $7::jsonb
-      where id = $1`,
-      params
-    }
-  };
-}
-function buildLedgerInsertStatement(input) {
-  return {
-    sql: `insert into prisma_contract.ledger (
-      origin_core_hash,
-      origin_profile_hash,
-      destination_core_hash,
-      destination_profile_hash,
-      contract_json_before,
-      contract_json_after,
-      operations
-    ) values (
-      $1,
-      $2,
-      $3,
-      $4,
-      $5::jsonb,
-      $6::jsonb,
-      $7::jsonb
-    )`,
-    params: [
-      input.originCoreHash ?? null,
-      input.originProfileHash ?? null,
-      input.destinationCoreHash,
-      input.destinationProfileHash ?? null,
-      jsonParam(input.contractJsonBefore),
-      jsonParam(input.contractJsonAfter),
-      jsonParam(input.operations)
-    ]
-  };
-}
-function jsonParam(value) {
-  return JSON.stringify(value ?? null);
-}
-
-// src/core/migrations/runner.ts
-var DEFAULT_CONFIG = {
-  defaultSchema: "public"
-};
-var LOCK_DOMAIN = "prisma_next.contract.marker";
-function cloneAndFreezeRecord(value) {
-  const cloned = {};
-  for (const [key, val] of Object.entries(value)) {
-    if (val === null || val === void 0) {
-      cloned[key] = val;
-    } else if (Array.isArray(val)) {
-      cloned[key] = Object.freeze([...val]);
-    } else if (typeof val === "object") {
-      cloned[key] = cloneAndFreezeRecord(val);
-    } else {
-      cloned[key] = val;
-    }
-  }
-  return Object.freeze(cloned);
-}
-function createPostgresMigrationRunner(family, config = {}) {
-  return new PostgresMigrationRunner(family, { ...DEFAULT_CONFIG, ...config });
-}
-var PostgresMigrationRunner = class {
-  constructor(family, config) {
-    this.family = family;
-    this.config = config;
-  }
-  async execute(options) {
-    const schema = options.schemaName ?? this.config.defaultSchema;
-    const driver = options.driver;
-    const lockKey = `${LOCK_DOMAIN}:${schema}`;
-    const destinationCheck = this.ensurePlanMatchesDestinationContract(
-      options.plan.destination,
-      options.destinationContract
-    );
-    if (!destinationCheck.ok) {
-      return destinationCheck;
-    }
-    const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);
-    if (!policyCheck.ok) {
-      return policyCheck;
-    }
-    await this.beginTransaction(driver);
-    let committed = false;
-    try {
-      await this.acquireLock(driver, lockKey);
-      await this.ensureControlTables(driver);
-      const existingMarker = await readMarker(driver);
-      const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
-      if (!markerCheck.ok) {
-        return markerCheck;
-      }
-      const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
-      let applyValue;
-      if (markerAtDestination) {
-        applyValue = { operationsExecuted: 0, executedOperations: [] };
-      } else {
-        const applyResult = await this.applyPlan(driver, options);
-        if (!applyResult.ok) {
-          return applyResult;
-        }
-        applyValue = applyResult.value;
-      }
-      const schemaIR = await this.family.introspect({
-        driver,
-        contractIR: options.destinationContract
-      });
-      const schemaVerifyResult = verifySqlSchema2({
-        contract: options.destinationContract,
-        schema: schemaIR,
-        strict: options.strictVerification ?? true,
-        context: options.context ?? {},
-        typeMetadataRegistry: this.family.typeMetadataRegistry,
-        frameworkComponents: options.frameworkComponents
-      });
-      if (!schemaVerifyResult.ok) {
-        return runnerFailure("SCHEMA_VERIFY_FAILED", schemaVerifyResult.summary, {
-          why: "The resulting database schema does not satisfy the destination contract.",
-          meta: {
-            issues: schemaVerifyResult.schema.issues
-          }
-        });
-      }
-      await this.upsertMarker(driver, options, existingMarker);
-      await this.recordLedgerEntry(driver, options, existingMarker, applyValue.executedOperations);
-      await this.commitTransaction(driver);
-      committed = true;
-      return runnerSuccess({
-        operationsPlanned: options.plan.operations.length,
-        operationsExecuted: applyValue.operationsExecuted
-      });
-    } finally {
-      if (!committed) {
-        await this.rollbackTransaction(driver);
-      }
-    }
-  }
-  async applyPlan(driver, options) {
-    const checks = options.executionChecks;
-    const runPrechecks = checks?.prechecks !== false;
-    const runPostchecks = checks?.postchecks !== false;
-    const runIdempotency = checks?.idempotencyChecks !== false;
-    let operationsExecuted = 0;
-    const executedOperations = [];
-    for (const operation of options.plan.operations) {
-      options.callbacks?.onOperationStart?.(operation);
-      try {
-        if (runPostchecks && runIdempotency) {
-          const postcheckAlreadySatisfied = await this.expectationsAreSatisfied(
-            driver,
-            operation.postcheck
-          );
-          if (postcheckAlreadySatisfied) {
-            executedOperations.push(this.createPostcheckPreSatisfiedSkipRecord(operation));
-            continue;
-          }
-        }
-        if (runPrechecks) {
-          const precheckResult = await this.runExpectationSteps(
-            driver,
-            operation.precheck,
-            operation,
-            "precheck"
-          );
-          if (!precheckResult.ok) {
-            return precheckResult;
-          }
-        }
-        const executeResult = await this.runExecuteSteps(driver, operation.execute, operation);
-        if (!executeResult.ok) {
-          return executeResult;
-        }
-        if (runPostchecks) {
-          const postcheckResult = await this.runExpectationSteps(
-            driver,
-            operation.postcheck,
-            operation,
-            "postcheck"
-          );
-          if (!postcheckResult.ok) {
-            return postcheckResult;
-          }
-        }
-        executedOperations.push(operation);
-        operationsExecuted += 1;
-      } finally {
-        options.callbacks?.onOperationComplete?.(operation);
-      }
-    }
-    return ok({ operationsExecuted, executedOperations });
-  }
-  async ensureControlTables(driver) {
-    await this.executeStatement(driver, ensurePrismaContractSchemaStatement);
-    await this.executeStatement(driver, ensureMarkerTableStatement);
-    await this.executeStatement(driver, ensureLedgerTableStatement);
-  }
-  async runExpectationSteps(driver, steps, operation, phase) {
-    for (const step of steps) {
-      const result = await driver.query(step.sql);
-      if (!this.stepResultIsTrue(result.rows)) {
-        const code = phase === "precheck" ? "PRECHECK_FAILED" : "POSTCHECK_FAILED";
-        return runnerFailure(
-          code,
-          `Operation ${operation.id} failed during ${phase}: ${step.description}`,
-          {
-            meta: {
-              operationId: operation.id,
-              phase,
-              stepDescription: step.description
-            }
-          }
-        );
-      }
-    }
-    return okVoid();
-  }
-  async runExecuteSteps(driver, steps, operation) {
-    for (const step of steps) {
-      try {
-        await driver.query(step.sql);
-      } catch (error) {
-        if (SqlQueryError.is(error)) {
-          return runnerFailure(
-            "EXECUTION_FAILED",
-            `Operation ${operation.id} failed during execution: ${step.description}`,
-            {
-              why: error.message,
-              meta: {
-                operationId: operation.id,
-                stepDescription: step.description,
-                sql: step.sql,
-                sqlState: error.sqlState,
-                constraint: error.constraint,
-                table: error.table,
-                column: error.column,
-                detail: error.detail
-              }
-            }
-          );
-        }
-        throw error;
-      }
-    }
-    return okVoid();
-  }
-  stepResultIsTrue(rows) {
-    if (!rows || rows.length === 0) {
-      return false;
-    }
-    const firstRow = rows[0];
-    const firstValue = firstRow ? Object.values(firstRow)[0] : void 0;
-    if (typeof firstValue === "boolean") {
-      return firstValue;
-    }
-    if (typeof firstValue === "number") {
-      return firstValue !== 0;
-    }
-    if (typeof firstValue === "string") {
-      const lower = firstValue.toLowerCase();
-      if (lower === "t" || lower === "true" || lower === "1") {
-        return true;
-      }
-      if (lower === "f" || lower === "false" || lower === "0") {
-        return false;
-      }
-      return firstValue.length > 0;
-    }
-    return Boolean(firstValue);
-  }
-  async expectationsAreSatisfied(driver, steps) {
-    if (steps.length === 0) {
-      return false;
-    }
-    for (const step of steps) {
-      const result = await driver.query(step.sql);
-      if (!this.stepResultIsTrue(result.rows)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  createPostcheckPreSatisfiedSkipRecord(operation) {
-    const clonedMeta = operation.meta ? cloneAndFreezeRecord(operation.meta) : void 0;
-    const runnerMeta = Object.freeze({
-      skipped: true,
-      reason: "postcheck_pre_satisfied"
-    });
-    const mergedMeta = Object.freeze({
-      ...clonedMeta ?? {},
-      runner: runnerMeta
-    });
-    const frozenPostcheck = Object.freeze([...operation.postcheck]);
-    return Object.freeze({
-      id: operation.id,
-      label: operation.label,
-      ...operation.summary ? { 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 } : {}
-    });
-  }
-  markerMatchesDestination(marker, plan) {
-    if (!marker) {
-      return false;
-    }
-    if (marker.coreHash !== plan.destination.coreHash) {
-      return false;
-    }
-    if (plan.destination.profileHash && marker.profileHash !== plan.destination.profileHash) {
-      return false;
-    }
-    return true;
-  }
-  enforcePolicyCompatibility(policy, operations) {
-    const allowedClasses = new Set(policy.allowedOperationClasses);
-    for (const operation of operations) {
-      if (!allowedClasses.has(operation.operationClass)) {
-        return runnerFailure(
-          "POLICY_VIOLATION",
-          `Operation ${operation.id} has class "${operation.operationClass}" which is not allowed by policy.`,
-          {
-            why: `Policy only allows: ${policy.allowedOperationClasses.join(", ")}.`,
-            meta: {
-              operationId: operation.id,
-              operationClass: operation.operationClass,
-              allowedClasses: policy.allowedOperationClasses
-            }
-          }
-        );
-      }
-    }
-    return okVoid();
-  }
-  ensureMarkerCompatibility(marker, plan) {
-    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
-          }
-        }
-      );
-    }
-    if (!marker) {
-      return runnerFailure(
-        "MARKER_ORIGIN_MISMATCH",
-        `Missing contract marker: expected origin core hash ${origin.coreHash}.`,
-        {
-          meta: {
-            expectedOriginCoreHash: origin.coreHash
-          }
-        }
-      );
-    }
-    if (marker.coreHash !== origin.coreHash) {
-      return runnerFailure(
-        "MARKER_ORIGIN_MISMATCH",
-        `Existing contract marker (${marker.coreHash}) does not match plan origin (${origin.coreHash}).`,
-        {
-          meta: {
-            markerCoreHash: marker.coreHash,
-            expectedOriginCoreHash: origin.coreHash
-          }
-        }
-      );
-    }
-    if (origin.profileHash && marker.profileHash !== origin.profileHash) {
-      return runnerFailure(
-        "MARKER_ORIGIN_MISMATCH",
-        `Existing contract marker profile hash (${marker.profileHash}) does not match plan origin profile hash (${origin.profileHash}).`,
-        {
-          meta: {
-            markerProfileHash: marker.profileHash,
-            expectedOriginProfileHash: origin.profileHash
-          }
-        }
-      );
-    }
-    return okVoid();
-  }
-  ensurePlanMatchesDestinationContract(destination, contract) {
-    if (destination.coreHash !== contract.coreHash) {
-      return runnerFailure(
-        "DESTINATION_CONTRACT_MISMATCH",
-        `Plan destination core hash (${destination.coreHash}) does not match provided contract core hash (${contract.coreHash}).`,
-        {
-          meta: {
-            planCoreHash: destination.coreHash,
-            contractCoreHash: contract.coreHash
-          }
-        }
-      );
-    }
-    if (destination.profileHash && contract.profileHash && destination.profileHash !== contract.profileHash) {
-      return runnerFailure(
-        "DESTINATION_CONTRACT_MISMATCH",
-        `Plan destination profile hash (${destination.profileHash}) does not match provided contract profile hash (${contract.profileHash}).`,
-        {
-          meta: {
-            planProfileHash: destination.profileHash,
-            contractProfileHash: contract.profileHash
-          }
-        }
-      );
-    }
-    return okVoid();
-  }
-  async upsertMarker(driver, options, existingMarker) {
-    const writeStatements = buildWriteMarkerStatements({
-      coreHash: options.plan.destination.coreHash,
-      profileHash: options.plan.destination.profileHash ?? options.destinationContract.profileHash ?? options.plan.destination.coreHash,
-      contractJson: options.destinationContract,
-      canonicalVersion: null,
-      meta: {}
-    });
-    const statement = existingMarker ? writeStatements.update : writeStatements.insert;
-    await this.executeStatement(driver, statement);
-  }
-  async recordLedgerEntry(driver, options, existingMarker, executedOperations) {
-    const ledgerStatement = buildLedgerInsertStatement({
-      originCoreHash: existingMarker?.coreHash ?? null,
-      originProfileHash: existingMarker?.profileHash ?? null,
-      destinationCoreHash: options.plan.destination.coreHash,
-      destinationProfileHash: options.plan.destination.profileHash ?? options.destinationContract.profileHash ?? options.plan.destination.coreHash,
-      contractJsonBefore: existingMarker?.contractJson ?? null,
-      contractJsonAfter: options.destinationContract,
-      operations: executedOperations
-    });
-    await this.executeStatement(driver, ledgerStatement);
-  }
-  async acquireLock(driver, key) {
-    await driver.query("select pg_advisory_xact_lock(hashtext($1))", [key]);
-  }
-  async beginTransaction(driver) {
-    await driver.query("BEGIN");
-  }
-  async commitTransaction(driver) {
-    await driver.query("COMMIT");
-  }
-  async rollbackTransaction(driver) {
-    await driver.query("ROLLBACK");
-  }
-  async executeStatement(driver, statement) {
-    if (statement.params.length > 0) {
-      await driver.query(statement.sql, statement.params);
-      return;
-    }
-    await driver.query(statement.sql);
-  }
-};
-
-// src/exports/control.ts
-var postgresTargetDescriptor = {
-  ...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) {
-      return createPostgresMigrationPlanner();
-    },
-    createRunner(family) {
-      return createPostgresMigrationRunner(family);
-    }
-  },
-  create() {
-    return {
-      familyId: "sql",
-      targetId: "postgres"
-    };
-  },
-  /**
-   * Direct method for SQL-specific usage.
-   * @deprecated Use migrations.createPlanner() for CLI compatibility.
-   */
-  createPlanner(_family) {
-    return createPostgresMigrationPlanner();
-  },
-  /**
-   * Direct method for SQL-specific usage.
-   * @deprecated Use migrations.createRunner() for CLI compatibility.
-   */
-  createRunner(family) {
-    return createPostgresMigrationRunner(family);
-  }
-};
-var control_default = postgresTargetDescriptor;
-export {
-  control_default as default
-};
-//# sourceMappingURL=control.js.map