@prisma-next/target-postgres 0.12.0-dev.9 → 0.13.0-dev.1

package/dist/statement-builders-DVI5IVAa.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"statement-builders-DVI5IVAa.mjs","names":["APP_SPACE_ID"],"sources":["../src/core/migrations/statement-builders.ts"],"sourcesContent":["import { APP_SPACE_ID } from '@prisma-next/framework-components/control';\n\nexport { APP_SPACE_ID };\n\nexport interface SqlStatement {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n}\n\nexport const ensurePrismaContractSchemaStatement: SqlStatement = {\n  sql: 'create schema if not exists prisma_contract',\n  params: [],\n};\n\n/**\n * Schema for `prisma_contract.marker`. The `space text` primary key\n * supports one row per loaded contract space (`'app'`,\n * `'<extension-id>'`, …); on a brand-new database `CREATE TABLE IF NOT\n * EXISTS` produces this shape directly. The migration runner detects\n * pre-1.0 single-row markers (no `space` column) at boot and fails with\n * a structured `LEGACY_MARKER_SHAPE` error rather than auto-migrating —\n * see `specs/framework-mechanism.spec.md § 2`.\n */\nexport const ensureMarkerTableStatement: SqlStatement = {\n  sql: `create table if not exists prisma_contract.marker (\n    space text not null primary key default '${APP_SPACE_ID}',\n    core_hash text not null,\n    profile_hash text not null,\n    contract_json jsonb,\n    canonical_version int,\n    updated_at timestamptz not null default now(),\n    app_tag text,\n    meta jsonb not null default '{}',\n    invariants text[] not null default '{}'\n  )`,\n  params: [],\n};\n\nexport const ensureLedgerTableStatement: SqlStatement = {\n  sql: `create table if not exists prisma_contract.ledger (\n    id bigserial primary key,\n    created_at timestamptz not null default now(),\n    origin_core_hash text,\n    origin_profile_hash text,\n    destination_core_hash text not null,\n    destination_profile_hash text,\n    contract_json_before jsonb,\n    contract_json_after jsonb,\n    operations jsonb not null\n  )`,\n  params: [],\n};\n\nexport interface MergeMarkerInput {\n  /**\n   * Logical space identifier for this marker row. Required at every\n   * call site so the type system surfaces every place that needs to\n   * thread the value (rather than letting an `?? APP_SPACE_ID`\n   * fall-through silently collapse per-space markers onto the\n   * `'app'` row). App-plan callers pass {@link APP_SPACE_ID}\n   * (`'app'`); per-extension callers (planner / runner / verifier\n   * extensions over contract spaces) pass the extension's space id.\n   */\n  readonly space: string;\n  readonly storageHash: string;\n  readonly profileHash: string;\n  readonly contractJson?: unknown;\n  readonly canonicalVersion?: number | null;\n  readonly appTag?: string | null;\n  readonly meta?: Record<string, unknown>;\n  /**\n   * Invariants to merge into `marker.invariants`. INSERT writes them as\n   * the initial value (callers are expected to pass a sorted, deduped\n   * array). UPDATE merges them with the existing column server-side via\n   * a single atomic SQL expression.\n   */\n  readonly invariants: readonly string[];\n}\n\nexport function buildMergeMarkerStatements(input: MergeMarkerInput): {\n  readonly insert: SqlStatement;\n  readonly update: SqlStatement;\n} {\n  const params: readonly unknown[] = [\n    input.space,\n    input.storageHash,\n    input.profileHash,\n    jsonParam(input.contractJson),\n    input.canonicalVersion ?? null,\n    input.appTag ?? null,\n    jsonParam(input.meta ?? {}),\n    input.invariants,\n  ];\n\n  return {\n    insert: {\n      sql: `insert into prisma_contract.marker (\n        space,\n        core_hash,\n        profile_hash,\n        contract_json,\n        canonical_version,\n        updated_at,\n        app_tag,\n        meta,\n        invariants\n      ) values (\n        $1,\n        $2,\n        $3,\n        $4::jsonb,\n        $5,\n        now(),\n        $6,\n        $7::jsonb,\n        $8::text[]\n      )`,\n      params,\n    },\n    update: {\n      // `invariants = array(select distinct unnest(invariants || $8::text[]) order by 1)`\n      // reads the current column value under the UPDATE's row lock, unions\n      // with the incoming array, dedupes, and sorts ascending — single\n      // statement, atomic, no read-then-write window.\n      sql: `update prisma_contract.marker set\n        core_hash = $2,\n        profile_hash = $3,\n        contract_json = $4::jsonb,\n        canonical_version = $5,\n        updated_at = now(),\n        app_tag = $6,\n        meta = $7::jsonb,\n        invariants = array(select distinct unnest(invariants || $8::text[]) order by 1)\n      where space = $1`,\n      params,\n    },\n  };\n}\n\nexport interface LedgerInsertInput {\n  readonly originStorageHash?: string | null;\n  readonly originProfileHash?: string | null;\n  readonly destinationStorageHash: string;\n  readonly destinationProfileHash?: string | null;\n  readonly contractJsonBefore?: unknown;\n  readonly contractJsonAfter?: unknown;\n  readonly operations: unknown;\n}\n\nexport function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement {\n  return {\n    sql: `insert into prisma_contract.ledger (\n      origin_core_hash,\n      origin_profile_hash,\n      destination_core_hash,\n      destination_profile_hash,\n      contract_json_before,\n      contract_json_after,\n      operations\n    ) values (\n      $1,\n      $2,\n      $3,\n      $4,\n      $5::jsonb,\n      $6::jsonb,\n      $7::jsonb\n    )`,\n    params: [\n      input.originStorageHash ?? null,\n      input.originProfileHash ?? null,\n      input.destinationStorageHash,\n      input.destinationProfileHash ?? null,\n      jsonParam(input.contractJsonBefore),\n      jsonParam(input.contractJsonAfter),\n      jsonParam(input.operations),\n    ],\n  };\n}\n\nfunction jsonParam(value: unknown): string {\n  return JSON.stringify(value ?? null);\n}\n"],"mappings":";;AASA,MAAa,sCAAoD;CAC/D,KAAK;CACL,QAAQ,CAAC;AACX;;;;;;;;;;AAWA,MAAa,6BAA2C;CACtD,KAAK;+CACwCA,eAAa;;;;;;;;;;CAU1D,QAAQ,CAAC;AACX;AAEA,MAAa,6BAA2C;CACtD,KAAK;;;;;;;;;;;CAWL,QAAQ,CAAC;AACX;AA4BA,SAAgB,2BAA2B,OAGzC;CACA,MAAM,SAA6B;EACjC,MAAM;EACN,MAAM;EACN,MAAM;EACN,UAAU,MAAM,YAAY;EAC5B,MAAM,oBAAoB;EAC1B,MAAM,UAAU;EAChB,UAAU,MAAM,QAAQ,CAAC,CAAC;EAC1B,MAAM;CACR;CAEA,OAAO;EACL,QAAQ;GACN,KAAK;;;;;;;;;;;;;;;;;;;;;GAqBL;EACF;EACA,QAAQ;GAKN,KAAK;;;;;;;;;;GAUL;EACF;CACF;AACF;AAYA,SAAgB,2BAA2B,OAAwC;CACjF,OAAO;EACL,KAAK;;;;;;;;;;;;;;;;;EAiBL,QAAQ;GACN,MAAM,qBAAqB;GAC3B,MAAM,qBAAqB;GAC3B,MAAM;GACN,MAAM,0BAA0B;GAChC,UAAU,MAAM,kBAAkB;GAClC,UAAU,MAAM,iBAAiB;GACjC,UAAU,MAAM,UAAU;EAC5B;CACF;AACF;AAEA,SAAS,UAAU,OAAwB;CACzC,OAAO,KAAK,UAAU,SAAS,IAAI;AACrC"}

package/dist/statement-builders.d.mts

@@ -1,51 +0,0 @@
-import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
-
-//#region src/core/migrations/statement-builders.d.ts
-interface SqlStatement {
-  readonly sql: string;
-  readonly params: readonly unknown[];
-}
-declare const ensurePrismaContractSchemaStatement: SqlStatement;
-/**
- * Schema for `prisma_contract.marker`. The `space text` primary key
- * supports one row per loaded contract space (`'app'`,
- * `'<extension-id>'`, …); on a brand-new database `CREATE TABLE IF NOT
- * EXISTS` produces this shape directly. The migration runner detects
- * pre-1.0 single-row markers (no `space` column) at boot and fails with
- * a structured `LEGACY_MARKER_SHAPE` error rather than auto-migrating —
- * see `specs/framework-mechanism.spec.md § 2`.
- */
-declare const ensureMarkerTableStatement: SqlStatement;
-declare const ensureLedgerTableStatement: SqlStatement;
-interface MergeMarkerInput {
-  /**
-   * Logical space identifier for this marker row. Required at every
-   * call site so the type system surfaces every place that needs to
-   * thread the value (rather than letting an `?? APP_SPACE_ID`
-   * fall-through silently collapse per-space markers onto the
-   * `'app'` row). App-plan callers pass {@link APP_SPACE_ID}
-   * (`'app'`); per-extension callers (planner / runner / verifier
-   * extensions over contract spaces) pass the extension's space id.
-   */
-  readonly space: string;
-  readonly storageHash: string;
-  readonly profileHash: string;
-  readonly contractJson?: unknown;
-  readonly canonicalVersion?: number | null;
-  readonly appTag?: string | null;
-  readonly meta?: Record<string, unknown>;
-  /**
-   * Invariants to merge into `marker.invariants`. INSERT writes them as
-   * the initial value (callers are expected to pass a sorted, deduped
-   * array). UPDATE merges them with the existing column server-side via
-   * a single atomic SQL expression.
-   */
-  readonly invariants: readonly string[];
-}
-declare function buildMergeMarkerStatements(input: MergeMarkerInput): {
-  readonly insert: SqlStatement;
-  readonly update: SqlStatement;
-};
-//#endregion
-export { APP_SPACE_ID, type SqlStatement, buildMergeMarkerStatements, ensureLedgerTableStatement, ensureMarkerTableStatement, ensurePrismaContractSchemaStatement };
-//# sourceMappingURL=statement-builders.d.mts.map

package/dist/statement-builders.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"statement-builders.d.mts","names":[],"sources":["../src/core/migrations/statement-builders.ts"],"mappings":";;;UAIiB,YAAA;EAAA,SACN,GAAA;EAAA,SACA,MAAM;AAAA;AAAA,cAGJ,mCAAA,EAAqC,YAGjD;AANgB;AAGjB;;;;AAGC;AAWD;;;AAjBiB,cAiBJ,0BAAA,EAA4B,YAaxC;AAAA,cAEY,0BAAA,EAA4B,YAaxC;AAAA,UAEgB,gBAAA;EAFhB;;;AAAA;AAED;;;;;EAFC,SAYU,KAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA;EAAA,SACA,YAAA;EAAA,SACA,gBAAA;EAAA,SACA,MAAA;EAAA,SACA,IAAA,GAAO,MAAM;EAOb;;AAAU;AAGrB;;;EAHW,SAAA,UAAA;AAAA;AAAA,iBAGK,0BAAA,CAA2B,KAAA,EAAO,gBAAA;EAAA,SACvC,MAAA,EAAQ,YAAA;EAAA,SACR,MAAA,EAAQ,YAAA;AAAA"}

package/dist/statement-builders.mjs

@@ -1,2 +0,0 @@
-import { a as ensureMarkerTableStatement, i as ensureLedgerTableStatement, o as ensurePrismaContractSchemaStatement, r as buildMergeMarkerStatements, t as APP_SPACE_ID } from "./statement-builders-DVI5IVAa.mjs";
-export { APP_SPACE_ID, buildMergeMarkerStatements, ensureLedgerTableStatement, ensureMarkerTableStatement, ensurePrismaContractSchemaStatement };

package/dist/tables-DoA39Yqo.mjs

@@ -1,516 +0,0 @@
-import { i as quoteIdentifier, n as escapeLiteral, r as qualifyName } from "./sql-utils-CggjWNij.mjs";
-import { a as columnNullabilityCheck, c as qualifyTableName, d as toRegclassLiteral, n as columnDefaultExistsCheck, o as columnTypeCheck, r as columnExistsCheck, s as constraintExistsCheck } from "./planner-sql-checks-CfEiTXoQ.mjs";
-import { ifDefined } from "@prisma-next/utils/defined";
-//#region src/core/migrations/operations/shared.ts
-function step(description, sql) {
-	return {
-		description,
-		sql
-	};
-}
-function targetDetails(objectType, name, schema, table) {
-	return {
-		id: "postgres",
-		details: {
-			schema,
-			objectType,
-			name,
-			...ifDefined("table", table)
-		}
-	};
-}
-function renderColumnDefinition(column) {
-	return [
-		quoteIdentifier(column.name),
-		column.typeSql,
-		column.defaultSql,
-		column.nullable ? "" : "NOT NULL"
-	].filter(Boolean).join(" ");
-}
-//#endregion
-//#region src/core/migrations/operations/columns.ts
-function addColumn(schemaName, tableName, column) {
-	const addSql = [
-		`ALTER TABLE ${qualifyTableName(schemaName, tableName)}`,
-		`ADD COLUMN ${quoteIdentifier(column.name)} ${column.typeSql}`,
-		column.defaultSql,
-		column.nullable ? "" : "NOT NULL"
-	].filter(Boolean).join(" ");
-	return {
-		id: `column.${tableName}.${column.name}`,
-		label: `Add column "${column.name}" to "${tableName}"`,
-		operationClass: "additive",
-		target: targetDetails("column", column.name, schemaName, tableName),
-		precheck: [step(`ensure column "${column.name}" is missing`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: column.name,
-			exists: false
-		}))],
-		execute: [step(`add column "${column.name}"`, addSql)],
-		postcheck: [step(`verify column "${column.name}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: column.name
-		}))]
-	};
-}
-function dropColumn(schemaName, tableName, columnName) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `dropColumn.${tableName}.${columnName}`,
-		label: `Drop column "${columnName}" from "${tableName}"`,
-		operationClass: "destructive",
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
-		execute: [step(`drop column "${columnName}"`, `ALTER TABLE ${qualified} DROP COLUMN ${quoteIdentifier(columnName)}`)],
-		postcheck: [step(`verify column "${columnName}" does not exist`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			exists: false
-		}))]
-	};
-}
-/**
-* `qualifiedTargetType` is the new column type as it appears in the
-* `ALTER COLUMN TYPE` clause (schema-qualified for user-defined types, raw
-* native name for built-ins). `formatTypeExpected` is the unqualified
-* `format_type` form used in the postcheck. `rawTargetTypeForLabel` is the
-* string appearing in the human-readable label (typically `toType` when
-* explicit, else the column's native type).
-*/
-function alterColumnType(schemaName, tableName, columnName, options) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	const usingClause = options.using ? ` USING ${options.using}` : ` USING ${quoteIdentifier(columnName)}::${options.qualifiedTargetType}`;
-	return {
-		id: `alterType.${tableName}.${columnName}`,
-		label: `Alter type of "${tableName}"."${columnName}" to ${options.rawTargetTypeForLabel}`,
-		operationClass: "destructive",
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
-		execute: [step(`alter type of "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} TYPE ${options.qualifiedTargetType}${usingClause}`)],
-		postcheck: [step(`verify column "${columnName}" has type "${options.formatTypeExpected}"`, columnTypeCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			expectedType: options.formatTypeExpected
-		}))],
-		meta: { warning: "TABLE_REWRITE" }
-	};
-}
-function setNotNull(schemaName, tableName, columnName) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `alterNullability.setNotNull.${tableName}.${columnName}`,
-		label: `Set NOT NULL on "${tableName}"."${columnName}"`,
-		operationClass: "destructive",
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		})), step(`ensure no NULL values in "${columnName}"`, `SELECT NOT EXISTS (SELECT 1 FROM ${qualified} WHERE ${quoteIdentifier(columnName)} IS NULL)`)],
-		execute: [step(`set NOT NULL on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} SET NOT NULL`)],
-		postcheck: [step(`verify column "${columnName}" is NOT NULL`, columnNullabilityCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			nullable: false
-		}))]
-	};
-}
-function dropNotNull(schemaName, tableName, columnName) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `alterNullability.dropNotNull.${tableName}.${columnName}`,
-		label: `Drop NOT NULL on "${tableName}"."${columnName}"`,
-		operationClass: "widening",
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
-		execute: [step(`drop NOT NULL on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP NOT NULL`)],
-		postcheck: [step(`verify column "${columnName}" is nullable`, columnNullabilityCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			nullable: true
-		}))]
-	};
-}
-/**
-* `defaultSql` is the full `DEFAULT …` clause as produced by
-* `buildColumnDefaultSql` — e.g. `"DEFAULT 42"`,
-* `"DEFAULT (CURRENT_TIMESTAMP)"`, or `"DEFAULT nextval('seq'::regclass)"`.
-*
-* `operationClass` defaults to `'additive'` (setting a default on a column
-* that currently has none). The reconciliation planner passes `'widening'`
-* when the column already has a different default — policy enforcement
-* treats that as a widening change rather than an additive one.
-*/
-function setDefault(schemaName, tableName, columnName, defaultSql, operationClass = "additive") {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `setDefault.${tableName}.${columnName}`,
-		label: `Set default on "${tableName}"."${columnName}"`,
-		operationClass,
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
-		execute: [step(`set default on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} SET ${defaultSql}`)],
-		postcheck: [step(`verify column "${columnName}" has a default`, columnDefaultExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			exists: true
-		}))]
-	};
-}
-function dropDefault(schemaName, tableName, columnName) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `dropDefault.${tableName}.${columnName}`,
-		label: `Drop default on "${tableName}"."${columnName}"`,
-		operationClass: "destructive",
-		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName
-		}))],
-		execute: [step(`drop default on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP DEFAULT`)],
-		postcheck: [step(`verify column "${columnName}" has no default`, columnDefaultExistsCheck({
-			schema: schemaName,
-			table: tableName,
-			column: columnName,
-			exists: false
-		}))]
-	};
-}
-//#endregion
-//#region src/core/migrations/operations/constraints.ts
-const REFERENTIAL_ACTION_SQL = {
-	noAction: "NO ACTION",
-	restrict: "RESTRICT",
-	cascade: "CASCADE",
-	setNull: "SET NULL",
-	setDefault: "SET DEFAULT"
-};
-function renderForeignKeySql(schemaName, tableName, fk) {
-	let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
-ADD CONSTRAINT ${quoteIdentifier(fk.name)}
-FOREIGN KEY (${fk.columns.map(quoteIdentifier).join(", ")})
-REFERENCES ${qualifyTableName(fk.references.schema, fk.references.table)} (${fk.references.columns.map(quoteIdentifier).join(", ")})`;
-	if (fk.onDelete !== void 0) {
-		const action = REFERENTIAL_ACTION_SQL[fk.onDelete];
-		if (!action) throw new Error(`Unknown referential action for onDelete: ${String(fk.onDelete)}`);
-		sql += `\nON DELETE ${action}`;
-	}
-	if (fk.onUpdate !== void 0) {
-		const action = REFERENTIAL_ACTION_SQL[fk.onUpdate];
-		if (!action) throw new Error(`Unknown referential action for onUpdate: ${String(fk.onUpdate)}`);
-		sql += `\nON UPDATE ${action}`;
-	}
-	return sql;
-}
-function addPrimaryKey(schemaName, tableName, constraintName, columns) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	const columnList = columns.map(quoteIdentifier).join(", ");
-	return {
-		id: `primaryKey.${tableName}.${constraintName}`,
-		label: `Add primary key on "${tableName}"`,
-		operationClass: "additive",
-		target: targetDetails("primaryKey", constraintName, schemaName, tableName),
-		precheck: [step(`ensure primary key "${constraintName}" does not exist`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))],
-		execute: [step(`add primary key "${constraintName}"`, `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} PRIMARY KEY (${columnList})`)],
-		postcheck: [step(`verify primary key "${constraintName}" exists`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName
-		}))]
-	};
-}
-function addUnique(schemaName, tableName, constraintName, columns) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	const columnList = columns.map(quoteIdentifier).join(", ");
-	return {
-		id: `unique.${tableName}.${constraintName}`,
-		label: `Add unique constraint on "${tableName}" (${columns.join(", ")})`,
-		operationClass: "additive",
-		target: targetDetails("unique", constraintName, schemaName, tableName),
-		precheck: [step(`ensure constraint "${constraintName}" does not exist`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))],
-		execute: [step(`add unique constraint "${constraintName}"`, `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} UNIQUE (${columnList})`)],
-		postcheck: [step(`verify constraint "${constraintName}" exists`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName
-		}))]
-	};
-}
-function addForeignKey(schemaName, tableName, fk) {
-	return {
-		id: `foreignKey.${tableName}.${fk.name}`,
-		label: `Add foreign key "${fk.name}" on "${tableName}"`,
-		operationClass: "additive",
-		target: targetDetails("foreignKey", fk.name, schemaName, tableName),
-		precheck: [step(`ensure FK "${fk.name}" does not exist`, constraintExistsCheck({
-			constraintName: fk.name,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))],
-		execute: [step(`add FK "${fk.name}"`, renderForeignKeySql(schemaName, tableName, fk))],
-		postcheck: [step(`verify FK "${fk.name}" exists`, constraintExistsCheck({
-			constraintName: fk.name,
-			schema: schemaName,
-			table: tableName
-		}))]
-	};
-}
-/**
-* `kind` feeds the operation's `target.details.objectType`. Descriptor-flow
-* does not carry kind information in its drop-constraint descriptor, so the
-* default is `'unique'`. The reconciliation planner passes the correct kind
-* (`'foreignKey'`, `'primaryKey'`, or `'unique'`) based on the `SchemaIssue`
-* that produced the drop.
-*/
-function dropConstraint(schemaName, tableName, constraintName, kind = "unique") {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `dropConstraint.${tableName}.${constraintName}`,
-		label: `Drop constraint "${constraintName}" on "${tableName}"`,
-		operationClass: "destructive",
-		target: targetDetails(kind, constraintName, schemaName, tableName),
-		precheck: [step(`ensure constraint "${constraintName}" exists`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName
-		}))],
-		execute: [step(`drop constraint "${constraintName}"`, `ALTER TABLE ${qualified} DROP CONSTRAINT ${quoteIdentifier(constraintName)}`)],
-		postcheck: [step(`verify constraint "${constraintName}" does not exist`, constraintExistsCheck({
-			constraintName,
-			schema: schemaName,
-			table: tableName,
-			exists: false
-		}))]
-	};
-}
-//#endregion
-//#region src/core/migrations/operations/dependencies.ts
-function createExtension(extensionName) {
-	return {
-		id: `extension.${extensionName}`,
-		label: `Create extension "${extensionName}"`,
-		operationClass: "additive",
-		target: { id: "postgres" },
-		precheck: [],
-		execute: [step(`Create extension "${extensionName}"`, `CREATE EXTENSION IF NOT EXISTS ${quoteIdentifier(extensionName)}`)],
-		postcheck: []
-	};
-}
-/**
-* Install a Postgres extension as the baseline op for an extension-pack
-* contract space. Layered on top of {@link createExtension}: stamps an
-* `invariantId` (required so the per-space marker records the install),
-* scopes the op `id` under a caller-chosen namespace (e.g. `pgvector.`),
-* and emits pre- and postcheck SQL probing `pg_extension`. The richer
-* shape lets the runner's idempotency probe skip the install on re-run
-* (postcheck-pre-satisfied) without firing the precheck.
-*
-* Use this for hand-rolled baseline migrations in contract-space
-* extension packages (e.g. `extension-pgvector`, `extension-paradedb`);
-* use the bare {@link createExtension} for planner-emitted ops where the
-* caller already controls idempotency through the surrounding plan.
-*/
-function installExtension(options) {
-	const { extensionName, invariantId, id } = options;
-	return {
-		id,
-		label: options.label ?? `Enable extension "${extensionName}"`,
-		operationClass: "additive",
-		invariantId,
-		target: {
-			id: "postgres",
-			details: {
-				schema: "public",
-				objectType: "dependency",
-				name: extensionName
-			}
-		},
-		precheck: [step(`verify extension "${extensionName}" is not already enabled`, `SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`)],
-		execute: [step(`create extension "${extensionName}"`, `CREATE EXTENSION IF NOT EXISTS ${extensionName}`)],
-		postcheck: [step(`confirm extension "${extensionName}" is enabled`, `SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`)]
-	};
-}
-function createSchema(schemaName) {
-	return {
-		id: `schema.${schemaName}`,
-		label: `Create schema "${schemaName}"`,
-		operationClass: "additive",
-		target: { id: "postgres" },
-		precheck: [],
-		execute: [step(`Create schema "${schemaName}"`, `CREATE SCHEMA IF NOT EXISTS ${quoteIdentifier(schemaName)}`)],
-		postcheck: []
-	};
-}
-//#endregion
-//#region src/core/migrations/operations/enums.ts
-function enumTypeExistsCheck(schemaName, nativeType, exists = true) {
-	return `SELECT ${exists ? "EXISTS" : "NOT EXISTS"} (
-  SELECT 1
-  FROM pg_type t
-  JOIN pg_namespace n ON t.typnamespace = n.oid
-  WHERE n.nspname = '${escapeLiteral(schemaName)}'
-    AND t.typname = '${escapeLiteral(nativeType)}'
-)`;
-}
-function createEnumType(schemaName, typeName, values, nativeType = typeName) {
-	const qualifiedType = qualifyName(schemaName, nativeType);
-	const literalValues = values.map((v) => `'${escapeLiteral(v)}'`).join(", ");
-	return {
-		id: `type.${typeName}`,
-		label: `Create enum type "${typeName}"`,
-		operationClass: "additive",
-		target: targetDetails("type", typeName, schemaName),
-		precheck: [step(`ensure type "${nativeType}" does not exist`, enumTypeExistsCheck(schemaName, nativeType, false))],
-		execute: [step(`create enum type "${typeName}"`, `CREATE TYPE ${qualifiedType} AS ENUM (${literalValues})`)],
-		postcheck: [step(`verify type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType))]
-	};
-}
-/**
-* `typeName` is the contract-facing type name (used for id/label).
-* `nativeType` is the Postgres type name to mutate (may differ for external types).
-*/
-function addEnumValues(schemaName, typeName, nativeType, values) {
-	const qualifiedType = qualifyName(schemaName, nativeType);
-	return {
-		id: `type.${typeName}.addValues`,
-		label: `Add values to enum type "${typeName}": ${values.join(", ")}`,
-		operationClass: "additive",
-		target: targetDetails("type", typeName, schemaName),
-		precheck: [step(`ensure type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType))],
-		execute: values.map((value) => step(`add value '${value}' to enum "${nativeType}"`, `ALTER TYPE ${qualifiedType} ADD VALUE '${escapeLiteral(value)}'`)),
-		postcheck: [step(`verify type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType))]
-	};
-}
-function dropEnumType(schemaName, typeName) {
-	const qualified = qualifyName(schemaName, typeName);
-	return {
-		id: `type.${typeName}.drop`,
-		label: `Drop enum type "${typeName}"`,
-		operationClass: "destructive",
-		target: targetDetails("type", typeName, schemaName),
-		precheck: [step(`ensure type "${typeName}" exists`, enumTypeExistsCheck(schemaName, typeName))],
-		execute: [step(`drop enum type "${typeName}"`, `DROP TYPE ${qualified}`)],
-		postcheck: [step(`verify type "${typeName}" removed`, enumTypeExistsCheck(schemaName, typeName, false))]
-	};
-}
-function renameType(schemaName, fromName, toName) {
-	const qualifiedFrom = qualifyName(schemaName, fromName);
-	return {
-		id: `type.${fromName}.rename`,
-		label: `Rename type "${fromName}" to "${toName}"`,
-		operationClass: "destructive",
-		target: targetDetails("type", fromName, schemaName),
-		precheck: [step(`ensure type "${fromName}" exists`, enumTypeExistsCheck(schemaName, fromName)), step(`ensure type "${toName}" does not already exist`, enumTypeExistsCheck(schemaName, toName, false))],
-		execute: [step(`rename type "${fromName}" to "${toName}"`, `ALTER TYPE ${qualifiedFrom} RENAME TO ${quoteIdentifier(toName)}`)],
-		postcheck: [step(`verify type "${toName}" exists`, enumTypeExistsCheck(schemaName, toName))]
-	};
-}
-//#endregion
-//#region src/core/migrations/operations/indexes.ts
-function renderIndexOptionValue(key, value) {
-	if (typeof value === "string") return `'${escapeLiteral(value)}'`;
-	if (typeof value === "number" && Number.isFinite(value)) return String(value);
-	if (typeof value === "boolean") return value ? "true" : "false";
-	throw new Error(`Index option "${key}" must be a string, finite number, or boolean; got ${typeof value}`);
-}
-function renderIndexOptions(options) {
-	return Object.entries(options).map(([key, value]) => `${quoteIdentifier(key)} = ${renderIndexOptionValue(key, value)}`).join(", ");
-}
-function createIndex(schemaName, tableName, indexName, columns, extras) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	const columnList = columns.map(quoteIdentifier).join(", ");
-	const using = extras?.type ? ` USING ${quoteIdentifier(extras.type)}` : "";
-	const options = extras?.options;
-	const withClause = options && Object.keys(options).length > 0 ? ` WITH (${renderIndexOptions(options)})` : "";
-	return {
-		id: `index.${tableName}.${indexName}`,
-		label: `Create index "${indexName}" on "${tableName}"`,
-		operationClass: "additive",
-		target: targetDetails("index", indexName, schemaName, tableName),
-		precheck: [step(`ensure index "${indexName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`)],
-		execute: [step(`create index "${indexName}"`, `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified}${using} (${columnList})${withClause}`)],
-		postcheck: [step(`verify index "${indexName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`)]
-	};
-}
-function dropIndex(schemaName, tableName, indexName) {
-	return {
-		id: `dropIndex.${tableName}.${indexName}`,
-		label: `Drop index "${indexName}"`,
-		operationClass: "destructive",
-		target: targetDetails("index", indexName, schemaName, tableName),
-		precheck: [step(`ensure index "${indexName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`)],
-		execute: [step(`drop index "${indexName}"`, `DROP INDEX ${qualifyTableName(schemaName, indexName)}`)],
-		postcheck: [step(`verify index "${indexName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`)]
-	};
-}
-//#endregion
-//#region src/core/migrations/operations/tables.ts
-function createTable(schemaName, tableName, columns, primaryKey) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	const columnDefs = columns.map(renderColumnDefinition);
-	const constraintDefs = [];
-	if (primaryKey) constraintDefs.push(`PRIMARY KEY (${primaryKey.columns.map(quoteIdentifier).join(", ")})`);
-	const createSql = `CREATE TABLE ${qualified} (\n  ${[...columnDefs, ...constraintDefs].join(",\n  ")}\n)`;
-	return {
-		id: `table.${tableName}`,
-		label: `Create table "${tableName}"`,
-		summary: `Creates table "${tableName}"`,
-		operationClass: "additive",
-		target: targetDetails("table", tableName, schemaName),
-		precheck: [step(`ensure table "${tableName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`)],
-		execute: [step(`create table "${tableName}"`, createSql)],
-		postcheck: [step(`verify table "${tableName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`)]
-	};
-}
-function dropTable(schemaName, tableName) {
-	const qualified = qualifyTableName(schemaName, tableName);
-	return {
-		id: `dropTable.${tableName}`,
-		label: `Drop table "${tableName}"`,
-		operationClass: "destructive",
-		target: targetDetails("table", tableName, schemaName),
-		precheck: [step(`ensure table "${tableName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`)],
-		execute: [step(`drop table "${tableName}"`, `DROP TABLE ${qualified}`)],
-		postcheck: [step(`verify table "${tableName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`)]
-	};
-}
-//#endregion
-export { setNotNull as S, alterColumnType as _, addEnumValues as a, dropNotNull as b, renameType as c, installExtension as d, addForeignKey as f, addColumn as g, dropConstraint as h, dropIndex as i, createExtension as l, addUnique as m, dropTable as n, createEnumType as o, addPrimaryKey as p, createIndex as r, dropEnumType as s, createTable as t, createSchema as u, dropColumn as v, setDefault as x, dropDefault as y };
-
-//# sourceMappingURL=tables-DoA39Yqo.mjs.map