@prisma-next/target-postgres 0.4.0-dev.9 → 0.4.2

package/dist/planner-identity-values-Dju-o5GF.mjs

@@ -0,0 +1,91 @@
+import { ifDefined } from "@prisma-next/utils/defined";
+
+//#region src/core/migrations/planner-identity-values.ts
+/**
+* Resolves the identity value (monoid neutral element) as a SQL literal for a column's type.
+* Checks codec hooks first (extensions can provide type-specific identity values),
+* then falls back to the built-in map.
+*/
+function resolveIdentityValue(column, codecHooks, storageTypes = {}) {
+	const referencedType = column.typeRef ? storageTypes[column.typeRef] : void 0;
+	const codecId = referencedType?.codecId ?? column.codecId;
+	const nativeType = referencedType?.nativeType ?? column.nativeType;
+	const typeParams = referencedType?.typeParams ?? column.typeParams;
+	if (codecId) {
+		const hookDefault = codecHooks.get(codecId)?.resolveIdentityValue?.({
+			nativeType,
+			codecId,
+			...ifDefined("typeParams", typeParams)
+		});
+		if (hookDefault !== void 0) return hookDefault;
+	}
+	return buildBuiltinIdentityValue(nativeType, typeParams);
+}
+/**
+* Returns the built-in identity value (monoid neutral element) as a SQL literal for the given
+* PostgreSQL native type — e.g. 0 for integers, '' for text, false for booleans.
+*
+* This is the planner's fallback when no codec hook provides a type-specific identity value.
+*
+* Returns null for unrecognized types (for example enums and extension-owned types without a
+* hook), which causes the planner to fall back to the empty-table precheck.
+*
+* @internal Exported for testing only.
+*/
+function buildBuiltinIdentityValue(nativeType, typeParams) {
+	const normalizedNativeType = normalizeIdentityValueNativeType(nativeType);
+	if (normalizedNativeType.endsWith("[]")) return "'{}'";
+	switch (normalizedNativeType) {
+		case "text":
+		case "character":
+		case "bpchar":
+		case "character varying":
+		case "varchar": return "''";
+		case "int2":
+		case "int4":
+		case "int8":
+		case "integer":
+		case "bigint":
+		case "smallint":
+		case "float4":
+		case "float8":
+		case "real":
+		case "double precision":
+		case "numeric":
+		case "decimal": return "0";
+		case "bool":
+		case "boolean": return "false";
+		case "uuid": return "'00000000-0000-0000-0000-000000000000'";
+		case "json": return "'{}'::json";
+		case "jsonb": return "'{}'::jsonb";
+		case "date":
+		case "timestamp":
+		case "timestamptz":
+		case "timestamp with time zone":
+		case "timestamp without time zone": return "'epoch'";
+		case "time":
+		case "time without time zone": return "'00:00:00'";
+		case "timetz":
+		case "time with time zone": return "'00:00:00+00'";
+		case "interval": return "'0'";
+		case "bytea": return "''::bytea";
+		case "tsvector": return "''::tsvector";
+		case "bit": return buildBitIdentityValue(typeParams);
+		case "bit varying":
+		case "varbit": return "B''";
+		default: return null;
+	}
+}
+function normalizeIdentityValueNativeType(nativeType) {
+	return nativeType.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function buildBitIdentityValue(typeParams) {
+	const length = typeParams?.["length"];
+	if (length === void 0) return "B'0'";
+	if (typeof length !== "number" || !Number.isInteger(length) || length <= 0) return null;
+	return `B'${"0".repeat(length)}'`;
+}
+
+//#endregion
+export { resolveIdentityValue as n, buildBuiltinIdentityValue as t };
+//# sourceMappingURL=planner-identity-values-Dju-o5GF.mjs.map

package/dist/planner-identity-values-Dju-o5GF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-identity-values-Dju-o5GF.mjs","names":[],"sources":["../src/core/migrations/planner-identity-values.ts"],"sourcesContent":["import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\n\n/**\n * Resolves the identity value (monoid neutral element) as a SQL literal for a column's type.\n * Checks codec hooks first (extensions can provide type-specific identity values),\n * then falls back to the built-in map.\n */\nexport function resolveIdentityValue(\n  column: StorageColumn,\n  codecHooks: Map<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance> = {},\n): string | null {\n  const referencedType = column.typeRef ? storageTypes[column.typeRef] : undefined;\n  const codecId = referencedType?.codecId ?? column.codecId;\n  const nativeType = referencedType?.nativeType ?? column.nativeType;\n  const typeParams = referencedType?.typeParams ?? column.typeParams;\n\n  if (codecId) {\n    const hookDefault = codecHooks.get(codecId)?.resolveIdentityValue?.({\n      nativeType,\n      codecId,\n      ...ifDefined('typeParams', typeParams),\n    });\n    if (hookDefault !== undefined) {\n      return hookDefault;\n    }\n  }\n\n  return buildBuiltinIdentityValue(nativeType, typeParams);\n}\n\n/**\n * Returns the built-in identity value (monoid neutral element) as a SQL literal for the given\n * PostgreSQL native type — e.g. 0 for integers, '' for text, false for booleans.\n *\n * This is the planner's fallback when no codec hook provides a type-specific identity value.\n *\n * Returns null for unrecognized types (for example enums and extension-owned types without a\n * hook), which causes the planner to fall back to the empty-table precheck.\n *\n * @internal Exported for testing only.\n */\nexport function buildBuiltinIdentityValue(\n  nativeType: string,\n  typeParams?: Record<string, unknown>,\n): string | null {\n  const normalizedNativeType = normalizeIdentityValueNativeType(nativeType);\n\n  if (normalizedNativeType.endsWith('[]')) {\n    return \"'{}'\";\n  }\n\n  switch (normalizedNativeType) {\n    case 'text':\n    case 'character':\n    case 'bpchar':\n    case 'character varying':\n    case 'varchar':\n      return \"''\";\n\n    case 'int2':\n    case 'int4':\n    case 'int8':\n    case 'integer':\n    case 'bigint':\n    case 'smallint':\n    case 'float4':\n    case 'float8':\n    case 'real':\n    case 'double precision':\n    case 'numeric':\n    case 'decimal':\n      return '0';\n\n    case 'bool':\n    case 'boolean':\n      return 'false';\n\n    case 'uuid':\n      return \"'00000000-0000-0000-0000-000000000000'\";\n\n    case 'json':\n      return \"'{}'::json\";\n    case 'jsonb':\n      return \"'{}'::jsonb\";\n\n    case 'date':\n    case 'timestamp':\n    case 'timestamptz':\n    case 'timestamp with time zone':\n    case 'timestamp without time zone':\n      return \"'epoch'\";\n\n    case 'time':\n    case 'time without time zone':\n      return \"'00:00:00'\";\n    case 'timetz':\n    case 'time with time zone':\n      return \"'00:00:00+00'\";\n\n    case 'interval':\n      return \"'0'\";\n\n    case 'bytea':\n      return \"''::bytea\";\n    case 'tsvector':\n      return \"''::tsvector\";\n\n    case 'bit':\n      return buildBitIdentityValue(typeParams);\n    case 'bit varying':\n    case 'varbit':\n      return \"B''\";\n\n    default:\n      return null;\n  }\n}\n\nfunction normalizeIdentityValueNativeType(nativeType: string): string {\n  return nativeType.trim().toLowerCase().replace(/\\s+/g, ' ');\n}\n\nfunction buildBitIdentityValue(typeParams?: Record<string, unknown>): string | null {\n  const length = typeParams?.['length'];\n  if (length === undefined) {\n    return \"B'0'\";\n  }\n  if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0) {\n    return null;\n  }\n  return `B'${'0'.repeat(length)}'`;\n}\n"],"mappings":";;;;;;;;AASA,SAAgB,qBACd,QACA,YACA,eAAoD,EAAE,EACvC;CACf,MAAM,iBAAiB,OAAO,UAAU,aAAa,OAAO,WAAW;CACvE,MAAM,UAAU,gBAAgB,WAAW,OAAO;CAClD,MAAM,aAAa,gBAAgB,cAAc,OAAO;CACxD,MAAM,aAAa,gBAAgB,cAAc,OAAO;AAExD,KAAI,SAAS;EACX,MAAM,cAAc,WAAW,IAAI,QAAQ,EAAE,uBAAuB;GAClE;GACA;GACA,GAAG,UAAU,cAAc,WAAW;GACvC,CAAC;AACF,MAAI,gBAAgB,OAClB,QAAO;;AAIX,QAAO,0BAA0B,YAAY,WAAW;;;;;;;;;;;;;AAc1D,SAAgB,0BACd,YACA,YACe;CACf,MAAM,uBAAuB,iCAAiC,WAAW;AAEzE,KAAI,qBAAqB,SAAS,KAAK,CACrC,QAAO;AAGT,SAAQ,sBAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,UACH,QAAO;EAET,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,UACH,QAAO;EAET,KAAK;EACL,KAAK,UACH,QAAO;EAET,KAAK,OACH,QAAO;EAET,KAAK,OACH,QAAO;EACT,KAAK,QACH,QAAO;EAET,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,8BACH,QAAO;EAET,KAAK;EACL,KAAK,yBACH,QAAO;EACT,KAAK;EACL,KAAK,sBACH,QAAO;EAET,KAAK,WACH,QAAO;EAET,KAAK,QACH,QAAO;EACT,KAAK,WACH,QAAO;EAET,KAAK,MACH,QAAO,sBAAsB,WAAW;EAC1C,KAAK;EACL,KAAK,SACH,QAAO;EAET,QACE,QAAO;;;AAIb,SAAS,iCAAiC,YAA4B;AACpE,QAAO,WAAW,MAAM,CAAC,aAAa,CAAC,QAAQ,QAAQ,IAAI;;AAG7D,SAAS,sBAAsB,YAAqD;CAClF,MAAM,SAAS,aAAa;AAC5B,KAAI,WAAW,OACb,QAAO;AAET,KAAI,OAAO,WAAW,YAAY,CAAC,OAAO,UAAU,OAAO,IAAI,UAAU,EACvE,QAAO;AAET,QAAO,KAAK,IAAI,OAAO,OAAO,CAAC"}

package/dist/planner-identity-values.d.mts

@@ -0,0 +1,20 @@
+import { CodecControlHooks } from "@prisma-next/family-sql/control";
+import { StorageColumn, StorageTypeInstance } from "@prisma-next/sql-contract/types";
+
+//#region src/core/migrations/planner-identity-values.d.ts
+
+/**
+ * Returns the built-in identity value (monoid neutral element) as a SQL literal for the given
+ * PostgreSQL native type — e.g. 0 for integers, '' for text, false for booleans.
+ *
+ * This is the planner's fallback when no codec hook provides a type-specific identity value.
+ *
+ * Returns null for unrecognized types (for example enums and extension-owned types without a
+ * hook), which causes the planner to fall back to the empty-table precheck.
+ *
+ * @internal Exported for testing only.
+ */
+declare function buildBuiltinIdentityValue(nativeType: string, typeParams?: Record<string, unknown>): string | null;
+//#endregion
+export { buildBuiltinIdentityValue };
+//# sourceMappingURL=planner-identity-values.d.mts.map

package/dist/planner-identity-values.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-identity-values.d.mts","names":[],"sources":["../src/core/migrations/planner-identity-values.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;iBA4CgB,yBAAA,kCAED"}

package/dist/planner-identity-values.mjs

@@ -0,0 +1,3 @@
+import { t as buildBuiltinIdentityValue } from "./planner-identity-values-Dju-o5GF.mjs";
+
+export { buildBuiltinIdentityValue };

package/dist/planner-produced-postgres-migration-CRRTno6Z.d.mts

@@ -0,0 +1,20 @@
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-DH-azLu-.mjs";
+import { b as PostgresOpFactoryCall } from "./op-factory-call-C3bWXKSP.mjs";
+import { t as PostgresMigration } from "./postgres-migration-BjA3Zmts.mjs";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+import { MigrationPlanWithAuthoringSurface } from "@prisma-next/framework-components/control";
+import { MigrationMeta } from "@prisma-next/migration-tools/migration";
+
+//#region src/core/migrations/planner-produced-postgres-migration.d.ts
+
+type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
+declare class TypeScriptRenderablePostgresMigration extends PostgresMigration implements MigrationPlanWithAuthoringSurface {
+  #private;
+  constructor(calls: readonly PostgresOpFactoryCall[], meta: MigrationMeta);
+  get operations(): readonly Op[];
+  describe(): MigrationMeta;
+  renderTypeScript(): string;
+}
+//#endregion
+export { TypeScriptRenderablePostgresMigration as t };
+//# sourceMappingURL=planner-produced-postgres-migration-CRRTno6Z.d.mts.map

package/dist/planner-produced-postgres-migration-CRRTno6Z.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-produced-postgres-migration-CRRTno6Z.d.mts","names":[],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;KAmCK,EAAA,GAAK,0BAA0B;cAEvB,qCAAA,SACH,iBAAA,YACG;;8BAKiB,+BAA+B;6BAMvB;cAIf"}

package/dist/planner-produced-postgres-migration-DSSPq8QS.mjs

@@ -0,0 +1,33 @@
+import { t as PostgresMigration } from "./postgres-migration-qtmtbONe.mjs";
+import { t as renderOps } from "./render-ops-D6_DHdOK.mjs";
+import { t as renderCallsToTypeScript } from "./render-typescript-1rF_SB4g.mjs";
+import { ifDefined } from "@prisma-next/utils/defined";
+
+//#region src/core/migrations/planner-produced-postgres-migration.ts
+var TypeScriptRenderablePostgresMigration = class extends PostgresMigration {
+	#calls;
+	#meta;
+	constructor(calls, meta) {
+		super();
+		this.#calls = calls;
+		this.#meta = meta;
+	}
+	get operations() {
+		return renderOps(this.#calls);
+	}
+	describe() {
+		return this.#meta;
+	}
+	renderTypeScript() {
+		return renderCallsToTypeScript(this.#calls, {
+			from: this.#meta.from,
+			to: this.#meta.to,
+			...ifDefined("kind", this.#meta.kind),
+			...ifDefined("labels", this.#meta.labels)
+		});
+	}
+};
+
+//#endregion
+export { TypeScriptRenderablePostgresMigration as t };
+//# sourceMappingURL=planner-produced-postgres-migration-DSSPq8QS.mjs.map

package/dist/planner-produced-postgres-migration-DSSPq8QS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-produced-postgres-migration-DSSPq8QS.mjs","names":["#calls","#meta"],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"sourcesContent":["/**\n * Planner-produced Postgres migration.\n *\n * Returned by `PostgresMigrationPlanner.plan(...)` and `emptyMigration(...)`.\n * Holds the migration IR (`PostgresOpFactoryCall[]`) alongside\n * `MigrationMeta` and exposes both the runtime-ops view (`get operations`)\n * and the TypeScript authoring view (`renderTypeScript()`). Satisfies\n * `MigrationPlanWithAuthoringSurface` so the CLI can uniformly serialize any\n * planner result back to `migration.ts`.\n *\n * Extends the family-level `SqlMigration` alias rather than the target-local\n * migration base directly — mirrors Mongo's `PlannerProducedMongoMigration`\n * shape and keeps CLI wiring one step removed from target internals.\n *\n * Placeholder-bearing plans: `renderTypeScript()` always succeeds and embeds\n * `() => placeholder(\"slot\")` at each stub. `operations`, in contrast, is\n * _not safe to enumerate_ on a stub-bearing plan — `DataTransformCall.toOp()`\n * throws `PN-MIG-2001` because a planner-stubbed closure cannot be lowered\n * to a runtime op. Callers that know a plan may carry stubs must render to\n * `migration.ts`, let the user fill the slots, and re-load the edited\n * migration before enumerating ops. The walk-schema planner does not emit\n * `DataTransformCall`s today, so this asymmetry is invisible until the\n * issue-planner integration lands in Phase 2.\n */\n\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { MigrationPlanWithAuthoringSurface } from '@prisma-next/framework-components/control';\nimport type { MigrationMeta } from '@prisma-next/migration-tools/migration';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\nimport { PostgresMigration } from './postgres-migration';\nimport { renderOps } from './render-ops';\nimport { renderCallsToTypeScript } from './render-typescript';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\nexport class TypeScriptRenderablePostgresMigration\n  extends PostgresMigration\n  implements MigrationPlanWithAuthoringSurface\n{\n  readonly #calls: readonly PostgresOpFactoryCall[];\n  readonly #meta: MigrationMeta;\n\n  constructor(calls: readonly PostgresOpFactoryCall[], meta: MigrationMeta) {\n    super();\n    this.#calls = calls;\n    this.#meta = meta;\n  }\n\n  override get operations(): readonly Op[] {\n    return renderOps(this.#calls);\n  }\n\n  override describe(): MigrationMeta {\n    return this.#meta;\n  }\n\n  renderTypeScript(): string {\n    return renderCallsToTypeScript(this.#calls, {\n      from: this.#meta.from,\n      to: this.#meta.to,\n      ...ifDefined('kind', this.#meta.kind),\n      ...ifDefined('labels', this.#meta.labels),\n    });\n  }\n}\n"],"mappings":";;;;;;AAqCA,IAAa,wCAAb,cACU,kBAEV;CACE,CAASA;CACT,CAASC;CAET,YAAY,OAAyC,MAAqB;AACxE,SAAO;AACP,QAAKD,QAAS;AACd,QAAKC,OAAQ;;CAGf,IAAa,aAA4B;AACvC,SAAO,UAAU,MAAKD,MAAO;;CAG/B,AAAS,WAA0B;AACjC,SAAO,MAAKC;;CAGd,mBAA2B;AACzB,SAAO,wBAAwB,MAAKD,OAAQ;GAC1C,MAAM,MAAKC,KAAM;GACjB,IAAI,MAAKA,KAAM;GACf,GAAG,UAAU,QAAQ,MAAKA,KAAM,KAAK;GACrC,GAAG,UAAU,UAAU,MAAKA,KAAM,OAAO;GAC1C,CAAC"}

package/dist/planner-produced-postgres-migration.d.mts

@@ -0,0 +1,5 @@
+import "./shared-Bxkt8pNO.mjs";
+import "./op-factory-call-C3bWXKSP.mjs";
+import "./postgres-migration-BjA3Zmts.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-CRRTno6Z.mjs";
+export { TypeScriptRenderablePostgresMigration };

package/dist/planner-produced-postgres-migration.mjs

@@ -0,0 +1,3 @@
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-DSSPq8QS.mjs";
+
+export { TypeScriptRenderablePostgresMigration };

package/dist/planner-schema-lookup-B7lkypwn.mjs

@@ -0,0 +1,29 @@
+//#region src/core/migrations/planner-schema-lookup.ts
+function buildSchemaLookupMap(schema) {
+	const map = /* @__PURE__ */ new Map();
+	for (const [tableName, table] of Object.entries(schema.tables)) map.set(tableName, buildSchemaTableLookup(table));
+	return map;
+}
+function buildSchemaTableLookup(table) {
+	return {
+		uniqueKeys: new Set(table.uniques.map((u) => u.columns.join(","))),
+		indexKeys: new Set(table.indexes.map((i) => i.columns.join(","))),
+		uniqueIndexKeys: new Set(table.indexes.filter((i) => i.unique).map((i) => i.columns.join(","))),
+		fkKeys: new Set(table.foreignKeys.map((fk) => `${fk.columns.join(",")}|${fk.referencedTable}|${fk.referencedColumns.join(",")}`))
+	};
+}
+function hasUniqueConstraint(lookup, columns) {
+	const key = columns.join(",");
+	return lookup.uniqueKeys.has(key) || lookup.uniqueIndexKeys.has(key);
+}
+function hasIndex(lookup, columns) {
+	const key = columns.join(",");
+	return lookup.indexKeys.has(key) || lookup.uniqueKeys.has(key);
+}
+function hasForeignKey(lookup, fk) {
+	return lookup.fkKeys.has(`${fk.columns.join(",")}|${fk.references.table}|${fk.references.columns.join(",")}`);
+}
+
+//#endregion
+export { hasUniqueConstraint as i, hasForeignKey as n, hasIndex as r, buildSchemaLookupMap as t };
+//# sourceMappingURL=planner-schema-lookup-B7lkypwn.mjs.map

package/dist/planner-schema-lookup-B7lkypwn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-schema-lookup-B7lkypwn.mjs","names":[],"sources":["../src/core/migrations/planner-schema-lookup.ts"],"sourcesContent":["import type { ForeignKey } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\n\n/**\n * Pre-computed lookup sets for a schema table's constraints.\n * Converts O(n*m) linear scans to O(1) Set lookups per constraint check.\n */\nexport interface SchemaTableLookup {\n  readonly uniqueKeys: Set<string>;\n  readonly indexKeys: Set<string>;\n  readonly uniqueIndexKeys: Set<string>;\n  readonly fkKeys: Set<string>;\n}\n\nexport function buildSchemaLookupMap(schema: SqlSchemaIR): ReadonlyMap<string, SchemaTableLookup> {\n  const map = new Map<string, SchemaTableLookup>();\n  for (const [tableName, table] of Object.entries(schema.tables)) {\n    map.set(tableName, buildSchemaTableLookup(table));\n  }\n  return map;\n}\n\nfunction buildSchemaTableLookup(table: SqlSchemaIR['tables'][string]): SchemaTableLookup {\n  const uniqueKeys = new Set(table.uniques.map((u) => u.columns.join(',')));\n  const indexKeys = new Set(table.indexes.map((i) => i.columns.join(',')));\n  const uniqueIndexKeys = new Set(\n    table.indexes.filter((i) => i.unique).map((i) => i.columns.join(',')),\n  );\n  const fkKeys = new Set(\n    table.foreignKeys.map(\n      (fk) => `${fk.columns.join(',')}|${fk.referencedTable}|${fk.referencedColumns.join(',')}`,\n    ),\n  );\n  return { uniqueKeys, indexKeys, uniqueIndexKeys, fkKeys };\n}\n\nexport function hasUniqueConstraint(\n  lookup: SchemaTableLookup,\n  columns: readonly string[],\n): boolean {\n  const key = columns.join(',');\n  return lookup.uniqueKeys.has(key) || lookup.uniqueIndexKeys.has(key);\n}\n\nexport function hasIndex(lookup: SchemaTableLookup, columns: readonly string[]): boolean {\n  const key = columns.join(',');\n  return lookup.indexKeys.has(key) || lookup.uniqueKeys.has(key);\n}\n\nexport function hasForeignKey(lookup: SchemaTableLookup, fk: ForeignKey): boolean {\n  return lookup.fkKeys.has(\n    `${fk.columns.join(',')}|${fk.references.table}|${fk.references.columns.join(',')}`,\n  );\n}\n"],"mappings":";AAcA,SAAgB,qBAAqB,QAA6D;CAChG,MAAM,sBAAM,IAAI,KAAgC;AAChD,MAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,OAAO,OAAO,CAC5D,KAAI,IAAI,WAAW,uBAAuB,MAAM,CAAC;AAEnD,QAAO;;AAGT,SAAS,uBAAuB,OAAyD;AAWvF,QAAO;EAAE,YAVU,IAAI,IAAI,MAAM,QAAQ,KAAK,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC,CAAC;EAUpD,WATH,IAAI,IAAI,MAAM,QAAQ,KAAK,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC,CAAC;EASxC,iBARR,IAAI,IAC1B,MAAM,QAAQ,QAAQ,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC,CACtE;EAMgD,QALlC,IAAI,IACjB,MAAM,YAAY,KACf,OAAO,GAAG,GAAG,QAAQ,KAAK,IAAI,CAAC,GAAG,GAAG,gBAAgB,GAAG,GAAG,kBAAkB,KAAK,IAAI,GACxF,CACF;EACwD;;AAG3D,SAAgB,oBACd,QACA,SACS;CACT,MAAM,MAAM,QAAQ,KAAK,IAAI;AAC7B,QAAO,OAAO,WAAW,IAAI,IAAI,IAAI,OAAO,gBAAgB,IAAI,IAAI;;AAGtE,SAAgB,SAAS,QAA2B,SAAqC;CACvF,MAAM,MAAM,QAAQ,KAAK,IAAI;AAC7B,QAAO,OAAO,UAAU,IAAI,IAAI,IAAI,OAAO,WAAW,IAAI,IAAI;;AAGhE,SAAgB,cAAc,QAA2B,IAAyB;AAChF,QAAO,OAAO,OAAO,IACnB,GAAG,GAAG,QAAQ,KAAK,IAAI,CAAC,GAAG,GAAG,WAAW,MAAM,GAAG,GAAG,WAAW,QAAQ,KAAK,IAAI,GAClF"}

package/dist/planner-schema-lookup.d.mts

@@ -0,0 +1,22 @@
+import { ForeignKey } from "@prisma-next/sql-contract/types";
+import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
+
+//#region src/core/migrations/planner-schema-lookup.d.ts
+
+/**
+ * Pre-computed lookup sets for a schema table's constraints.
+ * Converts O(n*m) linear scans to O(1) Set lookups per constraint check.
+ */
+interface SchemaTableLookup {
+  readonly uniqueKeys: Set<string>;
+  readonly indexKeys: Set<string>;
+  readonly uniqueIndexKeys: Set<string>;
+  readonly fkKeys: Set<string>;
+}
+declare function buildSchemaLookupMap(schema: SqlSchemaIR): ReadonlyMap<string, SchemaTableLookup>;
+declare function hasUniqueConstraint(lookup: SchemaTableLookup, columns: readonly string[]): boolean;
+declare function hasIndex(lookup: SchemaTableLookup, columns: readonly string[]): boolean;
+declare function hasForeignKey(lookup: SchemaTableLookup, fk: ForeignKey): boolean;
+//#endregion
+export { buildSchemaLookupMap, hasForeignKey, hasIndex, hasUniqueConstraint };
+//# sourceMappingURL=planner-schema-lookup.d.mts.map

package/dist/planner-schema-lookup.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-schema-lookup.d.mts","names":[],"sources":["../src/core/migrations/planner-schema-lookup.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;;AAEsB,UAFL,iBAAA,CAEK;EACM,SAAA,UAAA,EAFL,GAEK,CAAA,MAAA,CAAA;EACT,SAAA,SAAA,EAFG,GAEH,CAAA,MAAA,CAAA;EAAG,SAAA,eAAA,EADM,GACN,CAAA,MAAA,CAAA;EAGN,SAAA,MAAA,EAHG,GAGH,CAAA,MAAoB,CAAA;;AAA2C,iBAA/D,oBAAA,CAA+D,MAAA,EAAlC,WAAkC,CAAA,EAApB,WAAoB,CAAA,MAAA,EAAA,iBAAA,CAAA;AAApB,iBAsB3C,mBAAA,CAtB2C,MAAA,EAuBjD,iBAvBiD,EAAA,OAAA,EAAA,SAAA,MAAA,EAAA,CAAA,EAAA,OAAA;AAAW,iBA8BtD,QAAA,CA9BsD,MAAA,EA8BrC,iBA9BqC,EAAA,OAAA,EAAA,SAAA,MAAA,EAAA,CAAA,EAAA,OAAA;AAsBtD,iBAaA,aAAA,CAZN,MAAA,EAY4B,iBAZX,EAAA,EAAA,EAYkC,UAZlC,CAAA,EAAA,OAAA"}

package/dist/planner-schema-lookup.mjs

@@ -0,0 +1,3 @@
+import { i as hasUniqueConstraint, n as hasForeignKey, r as hasIndex, t as buildSchemaLookupMap } from "./planner-schema-lookup-B7lkypwn.mjs";
+
+export { buildSchemaLookupMap, hasForeignKey, hasIndex, hasUniqueConstraint };

package/dist/planner-sql-checks-7jkgm9TX.mjs

@@ -0,0 +1,241 @@
+import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-r-Lw535w.mjs";
+
+//#region src/core/migrations/planner-type-resolution.ts
+function resolveColumnTypeMetadata(column, storageTypes) {
+	if (!column.typeRef) return column;
+	const referencedType = storageTypes[column.typeRef];
+	if (!referencedType) return column;
+	return {
+		codecId: referencedType.codecId,
+		nativeType: referencedType.nativeType,
+		typeParams: referencedType.typeParams
+	};
+}
+
+//#endregion
+//#region src/core/migrations/planner-sql-checks.ts
+function qualifyTableName(schema, table) {
+	return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
+}
+function toRegclassLiteral(schema, name) {
+	return `'${escapeLiteral(`${quoteIdentifier(schema)}.${quoteIdentifier(name)}`)}'`;
+}
+/**
+* When `table` is omitted the check matches by name + schema across all tables.
+* Pass `table` to scope the check to a single table (prevents false matches on
+* identically-named constraints in different tables).
+*/
+function constraintExistsCheck({ constraintName, schema, table, exists = true }) {
+	const existsClause = exists ? "EXISTS" : "NOT EXISTS";
+	const tableFilter = table ? `AND c.conrelid = to_regclass(${toRegclassLiteral(schema, table)})` : "";
+	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)}'
+  ${tableFilter}
+)`;
+}
+function columnExistsCheck({ schema, table, column, exists = true }) {
+	return `SELECT ${exists ? "" : "NOT "}EXISTS (
+  SELECT 1
+  FROM information_schema.columns
+  WHERE table_schema = '${escapeLiteral(schema)}'
+    AND table_name = '${escapeLiteral(table)}'
+    AND column_name = '${escapeLiteral(column)}'
+)`;
+}
+function columnNullabilityCheck({ schema, table, column, nullable }) {
+	const expected = nullable ? "YES" : "NO";
+	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 = '${expected}'
+)`;
+}
+function tableIsEmptyCheck(qualifiedTableName) {
+	return `SELECT NOT EXISTS (SELECT 1 FROM ${qualifiedTableName} LIMIT 1)`;
+}
+function columnHasNoDefaultCheck(opts) {
+	return `SELECT NOT EXISTS (
+  SELECT 1
+  FROM information_schema.columns
+  WHERE table_schema = '${escapeLiteral(opts.schema)}'
+    AND table_name = '${escapeLiteral(opts.table)}'
+    AND column_name = '${escapeLiteral(opts.column)}'
+    AND column_default IS NOT NULL
+)`;
+}
+const FORMAT_TYPE_DISPLAY = new Map([
+	["int2", "smallint"],
+	["int4", "integer"],
+	["int8", "bigint"],
+	["float4", "real"],
+	["float8", "double precision"],
+	["bool", "boolean"],
+	["timestamp", "timestamp without time zone"],
+	["timestamptz", "timestamp with time zone"],
+	["time", "time without time zone"],
+	["timetz", "time with time zone"]
+]);
+const UNQUOTED_POSTGRES_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/;
+const POSTGRES_RESERVED_IDENTIFIER_WORDS = new Set([
+	"all",
+	"analyse",
+	"analyze",
+	"and",
+	"any",
+	"array",
+	"as",
+	"asc",
+	"asymmetric",
+	"authorization",
+	"between",
+	"binary",
+	"both",
+	"case",
+	"cast",
+	"check",
+	"collate",
+	"column",
+	"constraint",
+	"create",
+	"current_catalog",
+	"current_date",
+	"current_role",
+	"current_time",
+	"current_timestamp",
+	"current_user",
+	"default",
+	"deferrable",
+	"desc",
+	"distinct",
+	"do",
+	"else",
+	"end",
+	"except",
+	"false",
+	"fetch",
+	"for",
+	"foreign",
+	"freeze",
+	"from",
+	"full",
+	"grant",
+	"group",
+	"having",
+	"ilike",
+	"in",
+	"initially",
+	"inner",
+	"intersect",
+	"into",
+	"is",
+	"isnull",
+	"join",
+	"lateral",
+	"leading",
+	"left",
+	"like",
+	"limit",
+	"localtime",
+	"localtimestamp",
+	"natural",
+	"not",
+	"notnull",
+	"null",
+	"offset",
+	"on",
+	"only",
+	"or",
+	"order",
+	"outer",
+	"overlaps",
+	"placing",
+	"primary",
+	"references",
+	"right",
+	"select",
+	"session_user",
+	"similar",
+	"some",
+	"symmetric",
+	"table",
+	"then",
+	"to",
+	"trailing",
+	"true",
+	"union",
+	"unique",
+	"user",
+	"using",
+	"variadic",
+	"verbose",
+	"when",
+	"where",
+	"window",
+	"with"
+]);
+function formatUserDefinedTypeName(identifier) {
+	if (UNQUOTED_POSTGRES_IDENTIFIER_PATTERN.test(identifier) && !POSTGRES_RESERVED_IDENTIFIER_WORDS.has(identifier)) return identifier;
+	return quoteIdentifier(identifier);
+}
+function buildExpectedFormatType(column, codecHooks, storageTypes = {}) {
+	const resolved = resolveColumnTypeMetadata(column, storageTypes);
+	if (resolved.typeParams && resolved.codecId) {
+		const hooks = codecHooks.get(resolved.codecId);
+		if (hooks?.expandNativeType) return hooks.expandNativeType({
+			nativeType: resolved.nativeType,
+			codecId: resolved.codecId,
+			typeParams: resolved.typeParams
+		});
+	}
+	if (column.typeRef) return formatUserDefinedTypeName(resolved.nativeType);
+	return FORMAT_TYPE_DISPLAY.get(resolved.nativeType) ?? resolved.nativeType;
+}
+function columnTypeCheck({ schema, table, column, expectedType }) {
+	return `SELECT EXISTS (
+  SELECT 1
+  FROM pg_attribute a
+  JOIN pg_class c ON c.oid = a.attrelid
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+  WHERE n.nspname = '${escapeLiteral(schema)}'
+    AND c.relname = '${escapeLiteral(table)}'
+    AND a.attname = '${escapeLiteral(column)}'
+    AND format_type(a.atttypid, a.atttypmod) = '${escapeLiteral(expectedType)}'
+    AND NOT a.attisdropped
+)`;
+}
+function columnDefaultExistsCheck({ schema, table, column, exists = true }) {
+	const nullCheck = exists ? "IS NOT NULL" : "IS NULL";
+	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 column_default ${nullCheck}
+)`;
+}
+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}
+)`;
+}
+
+//#endregion
+export { columnNullabilityCheck as a, qualifyTableName as c, toRegclassLiteral as d, resolveColumnTypeMetadata as f, columnHasNoDefaultCheck as i, tableHasPrimaryKeyCheck as l, columnDefaultExistsCheck as n, columnTypeCheck as o, columnExistsCheck as r, constraintExistsCheck as s, buildExpectedFormatType as t, tableIsEmptyCheck as u };
+//# sourceMappingURL=planner-sql-checks-7jkgm9TX.mjs.map

package/dist/planner-sql-checks-7jkgm9TX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-sql-checks-7jkgm9TX.mjs","names":["FORMAT_TYPE_DISPLAY: ReadonlyMap<string, string>"],"sources":["../src/core/migrations/planner-type-resolution.ts","../src/core/migrations/planner-sql-checks.ts"],"sourcesContent":["import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';\n\nexport type ResolvedColumnTypeMetadata = Pick<\n  StorageColumn,\n  'nativeType' | 'codecId' | 'typeParams'\n>;\n\nexport function resolveColumnTypeMetadata(\n  column: StorageColumn,\n  storageTypes: Record<string, StorageTypeInstance>,\n): ResolvedColumnTypeMetadata {\n  if (!column.typeRef) {\n    return column;\n  }\n\n  const referencedType = storageTypes[column.typeRef];\n  if (!referencedType) {\n    return column;\n  }\n\n  return {\n    codecId: referencedType.codecId,\n    nativeType: referencedType.nativeType,\n    typeParams: referencedType.typeParams,\n  };\n}\n","import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport { escapeLiteral, quoteIdentifier } from '../sql-utils';\nimport { resolveColumnTypeMetadata } from './planner-type-resolution';\n\nexport function qualifyTableName(schema: string, table: string): string {\n  return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;\n}\n\nexport function toRegclassLiteral(schema: string, name: string): string {\n  const regclass = `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;\n  return `'${escapeLiteral(regclass)}'`;\n}\n\n/**\n * When `table` is omitted the check matches by name + schema across all tables.\n * Pass `table` to scope the check to a single table (prevents false matches on\n * identically-named constraints in different tables).\n */\nexport function constraintExistsCheck({\n  constraintName,\n  schema,\n  table,\n  exists = true,\n}: {\n  constraintName: string;\n  schema: string;\n  table?: string;\n  exists?: boolean;\n}): string {\n  const existsClause = exists ? 'EXISTS' : 'NOT EXISTS';\n  const tableFilter = table\n    ? `AND c.conrelid = to_regclass(${toRegclassLiteral(schema, table)})`\n    : '';\n  return `SELECT ${existsClause} (\n  SELECT 1 FROM pg_constraint c\n  JOIN pg_namespace n ON c.connamespace = n.oid\n  WHERE c.conname = '${escapeLiteral(constraintName)}'\n  AND n.nspname = '${escapeLiteral(schema)}'\n  ${tableFilter}\n)`;\n}\n\nexport function columnExistsCheck({\n  schema,\n  table,\n  column,\n  exists = true,\n}: {\n  schema: string;\n  table: string;\n  column: string;\n  exists?: boolean;\n}): string {\n  const existsClause = exists ? '' : 'NOT ';\n  return `SELECT ${existsClause}EXISTS (\n  SELECT 1\n  FROM information_schema.columns\n  WHERE table_schema = '${escapeLiteral(schema)}'\n    AND table_name = '${escapeLiteral(table)}'\n    AND column_name = '${escapeLiteral(column)}'\n)`;\n}\n\nexport function columnNullabilityCheck({\n  schema,\n  table,\n  column,\n  nullable,\n}: {\n  schema: string;\n  table: string;\n  column: string;\n  nullable: boolean;\n}): string {\n  const expected = nullable ? 'YES' : 'NO';\n  return `SELECT EXISTS (\n  SELECT 1\n  FROM information_schema.columns\n  WHERE table_schema = '${escapeLiteral(schema)}'\n    AND table_name = '${escapeLiteral(table)}'\n    AND column_name = '${escapeLiteral(column)}'\n    AND is_nullable = '${expected}'\n)`;\n}\n\nexport function tableIsEmptyCheck(qualifiedTableName: string): string {\n  return `SELECT NOT EXISTS (SELECT 1 FROM ${qualifiedTableName} LIMIT 1)`;\n}\n\nexport function columnHasNoDefaultCheck(opts: {\n  schema: string;\n  table: string;\n  column: string;\n}): string {\n  return `SELECT NOT EXISTS (\n  SELECT 1\n  FROM information_schema.columns\n  WHERE table_schema = '${escapeLiteral(opts.schema)}'\n    AND table_name = '${escapeLiteral(opts.table)}'\n    AND column_name = '${escapeLiteral(opts.column)}'\n    AND column_default IS NOT NULL\n)`;\n}\n\nconst FORMAT_TYPE_DISPLAY: ReadonlyMap<string, string> = new Map([\n  ['int2', 'smallint'],\n  ['int4', 'integer'],\n  ['int8', 'bigint'],\n  ['float4', 'real'],\n  ['float8', 'double precision'],\n  ['bool', 'boolean'],\n  ['timestamp', 'timestamp without time zone'],\n  ['timestamptz', 'timestamp with time zone'],\n  ['time', 'time without time zone'],\n  ['timetz', 'time with time zone'],\n]);\n\nconst UNQUOTED_POSTGRES_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/;\n\nconst POSTGRES_RESERVED_IDENTIFIER_WORDS = new Set([\n  'all',\n  'analyse',\n  'analyze',\n  'and',\n  'any',\n  'array',\n  'as',\n  'asc',\n  'asymmetric',\n  'authorization',\n  'between',\n  'binary',\n  'both',\n  'case',\n  'cast',\n  'check',\n  'collate',\n  'column',\n  'constraint',\n  'create',\n  'current_catalog',\n  'current_date',\n  'current_role',\n  'current_time',\n  'current_timestamp',\n  'current_user',\n  'default',\n  'deferrable',\n  'desc',\n  'distinct',\n  'do',\n  'else',\n  'end',\n  'except',\n  'false',\n  'fetch',\n  'for',\n  'foreign',\n  'freeze',\n  'from',\n  'full',\n  'grant',\n  'group',\n  'having',\n  'ilike',\n  'in',\n  'initially',\n  'inner',\n  'intersect',\n  'into',\n  'is',\n  'isnull',\n  'join',\n  'lateral',\n  'leading',\n  'left',\n  'like',\n  'limit',\n  'localtime',\n  'localtimestamp',\n  'natural',\n  'not',\n  'notnull',\n  'null',\n  'offset',\n  'on',\n  'only',\n  'or',\n  'order',\n  'outer',\n  'overlaps',\n  'placing',\n  'primary',\n  'references',\n  'right',\n  'select',\n  'session_user',\n  'similar',\n  'some',\n  'symmetric',\n  'table',\n  'then',\n  'to',\n  'trailing',\n  'true',\n  'union',\n  'unique',\n  'user',\n  'using',\n  'variadic',\n  'verbose',\n  'when',\n  'where',\n  'window',\n  'with',\n]);\n\nfunction formatUserDefinedTypeName(identifier: string): string {\n  if (\n    UNQUOTED_POSTGRES_IDENTIFIER_PATTERN.test(identifier) &&\n    !POSTGRES_RESERVED_IDENTIFIER_WORDS.has(identifier)\n  ) {\n    return identifier;\n  }\n\n  return quoteIdentifier(identifier);\n}\n\nexport function buildExpectedFormatType(\n  column: StorageColumn,\n  codecHooks: Map<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance> = {},\n): string {\n  const resolved = resolveColumnTypeMetadata(column, storageTypes);\n\n  if (resolved.typeParams && resolved.codecId) {\n    const hooks = codecHooks.get(resolved.codecId);\n    if (hooks?.expandNativeType) {\n      return hooks.expandNativeType({\n        nativeType: resolved.nativeType,\n        codecId: resolved.codecId,\n        typeParams: resolved.typeParams,\n      });\n    }\n  }\n\n  if (column.typeRef) {\n    return formatUserDefinedTypeName(resolved.nativeType);\n  }\n\n  return FORMAT_TYPE_DISPLAY.get(resolved.nativeType) ?? resolved.nativeType;\n}\n\nexport function columnTypeCheck({\n  schema,\n  table,\n  column,\n  expectedType,\n}: {\n  schema: string;\n  table: string;\n  column: string;\n  expectedType: string;\n}): string {\n  return `SELECT EXISTS (\n  SELECT 1\n  FROM pg_attribute a\n  JOIN pg_class c ON c.oid = a.attrelid\n  JOIN pg_namespace n ON n.oid = c.relnamespace\n  WHERE n.nspname = '${escapeLiteral(schema)}'\n    AND c.relname = '${escapeLiteral(table)}'\n    AND a.attname = '${escapeLiteral(column)}'\n    AND format_type(a.atttypid, a.atttypmod) = '${escapeLiteral(expectedType)}'\n    AND NOT a.attisdropped\n)`;\n}\n\nexport function columnDefaultExistsCheck({\n  schema,\n  table,\n  column,\n  exists = true,\n}: {\n  schema: string;\n  table: string;\n  column: string;\n  exists?: boolean;\n}): string {\n  const nullCheck = exists ? 'IS NOT NULL' : 'IS NULL';\n  return `SELECT EXISTS (\n  SELECT 1\n  FROM information_schema.columns\n  WHERE table_schema = '${escapeLiteral(schema)}'\n    AND table_name = '${escapeLiteral(table)}'\n    AND column_name = '${escapeLiteral(column)}'\n    AND column_default ${nullCheck}\n)`;\n}\n\nexport function tableHasPrimaryKeyCheck(\n  schema: string,\n  table: string,\n  exists: boolean,\n  constraintName?: string,\n): string {\n  const comparison = exists ? '' : 'NOT ';\n  const constraintFilter = constraintName\n    ? `AND c2.relname = '${escapeLiteral(constraintName)}'`\n    : '';\n  return `SELECT ${comparison}EXISTS (\n  SELECT 1\n  FROM pg_index i\n  JOIN pg_class c ON c.oid = i.indrelid\n  JOIN pg_namespace n ON n.oid = c.relnamespace\n  LEFT JOIN pg_class c2 ON c2.oid = i.indexrelid\n  WHERE n.nspname = '${escapeLiteral(schema)}'\n    AND c.relname = '${escapeLiteral(table)}'\n    AND i.indisprimary\n    ${constraintFilter}\n)`;\n}\n"],"mappings":"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"}

package/dist/planner-sql-checks.d.mts

@@ -0,0 +1,55 @@
+import { CodecControlHooks } from "@prisma-next/family-sql/control";
+import { StorageColumn, StorageTypeInstance } from "@prisma-next/sql-contract/types";
+
+//#region src/core/migrations/planner-sql-checks.d.ts
+declare function qualifyTableName(schema: string, table: string): string;
+declare function toRegclassLiteral(schema: string, name: string): string;
+/**
+ * When `table` is omitted the check matches by name + schema across all tables.
+ * Pass `table` to scope the check to a single table (prevents false matches on
+ * identically-named constraints in different tables).
+ */
+declare function constraintExistsCheck({
+  constraintName,
+  schema,
+  table,
+  exists
+}: {
+  constraintName: string;
+  schema: string;
+  table?: string;
+  exists?: boolean;
+}): string;
+declare function columnExistsCheck({
+  schema,
+  table,
+  column,
+  exists
+}: {
+  schema: string;
+  table: string;
+  column: string;
+  exists?: boolean;
+}): string;
+declare function columnNullabilityCheck({
+  schema,
+  table,
+  column,
+  nullable
+}: {
+  schema: string;
+  table: string;
+  column: string;
+  nullable: boolean;
+}): string;
+declare function tableIsEmptyCheck(qualifiedTableName: string): string;
+declare function columnHasNoDefaultCheck(opts: {
+  schema: string;
+  table: string;
+  column: string;
+}): string;
+declare function buildExpectedFormatType(column: StorageColumn, codecHooks: Map<string, CodecControlHooks>, storageTypes?: Record<string, StorageTypeInstance>): string;
+declare function tableHasPrimaryKeyCheck(schema: string, table: string, exists: boolean, constraintName?: string): string;
+//#endregion
+export { buildExpectedFormatType, columnExistsCheck, columnHasNoDefaultCheck, columnNullabilityCheck, constraintExistsCheck, qualifyTableName, tableHasPrimaryKeyCheck, tableIsEmptyCheck, toRegclassLiteral };
+//# sourceMappingURL=planner-sql-checks.d.mts.map

package/dist/planner-sql-checks.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-sql-checks.d.mts","names":[],"sources":["../src/core/migrations/planner-sql-checks.ts"],"sourcesContent":[],"mappings":";;;;iBAKgB,gBAAA;iBAIA,iBAAA;AAJhB;AAIA;AAUA;;;AAGE,iBAHc,qBAAA,CAGd;EAAA,cAAA;EAAA,MAAA;EAAA,KAAA;EAAA;CAAA,EAAA;EACA,cAAA,EAAA,MAAA;EAAa,MAAA,EAAA,MAAA;EAoBC,KAAA,CAAA,EAAA,MAAA;EACd,MAAA,CAAA,EAAA,OAAA;CACA,CAAA,EAAA,MAAA;AACA,iBAHc,iBAAA,CAGd;EAAA,MAAA;EAAA,KAAA;EAAA,MAAA;EAAA;CAAA,EAAA;EACA,MAAA,EAAA,MAAA;EAAa,KAAA,EAAA,MAAA;EAiBC,MAAA,EAAA,MAAA;EACd,MAAA,CAAA,EAAA,OAAA;CACA,CAAA,EAAA,MAAA;AACA,iBAHc,sBAAA,CAGd;EAAA,MAAA;EAAA,KAAA;EAAA,MAAA;EAAA;AAkKF,CAlKE,EAAA;EACA,MAAA,EAAA,MAAA;EAAQ,KAAA,EAAA,MAAA;EAkBM,MAAA,EAAA,MAAA;EAIA,QAAA,EAAA,OAAA;AA2IhB,CAAA,CAAA,EAAgB,MAAA;AACN,iBAhJM,iBAAA,CAgJN,kBAAA,EAAA,MAAA,CAAA,EAAA,MAAA;AACgB,iBA7IV,uBAAA,CA6IU,IAAA,EAAA;EAAZ,MAAA,EAAA,MAAA;EACiB,KAAA,EAAA,MAAA;EAAf,MAAA,EAAA,MAAA;CAAM,CAAA,EAAA,MAAA;AAoEN,iBAvEA,uBAAA,CAuEuB,MAAA,EAtE7B,aAsE6B,EAAA,UAAA,EArEzB,GAqEyB,CAAA,MAAA,EArEb,iBAqEa,CAAA,EAAA,YAAA,CAAA,EApEvB,MAoEuB,CAAA,MAAA,EApER,mBAoEQ,CAAA,CAAA,EAAA,MAAA;iBAAvB,uBAAA"}

package/dist/planner-sql-checks.mjs

@@ -0,0 +1,3 @@
+import { a as columnNullabilityCheck, c as qualifyTableName, d as toRegclassLiteral, i as columnHasNoDefaultCheck, l as tableHasPrimaryKeyCheck, r as columnExistsCheck, s as constraintExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-7jkgm9TX.mjs";
+
+export { buildExpectedFormatType, columnExistsCheck, columnHasNoDefaultCheck, columnNullabilityCheck, constraintExistsCheck, qualifyTableName, tableHasPrimaryKeyCheck, tableIsEmptyCheck, toRegclassLiteral };

package/dist/planner-target-details-DH-azLu-.d.mts

@@ -0,0 +1,11 @@
+//#region src/core/migrations/planner-target-details.d.ts
+type OperationClass = 'dependency' | 'type' | 'table' | 'column' | 'primaryKey' | 'unique' | 'index' | 'foreignKey';
+interface PostgresPlanTargetDetails {
+  readonly schema: string;
+  readonly objectType: OperationClass;
+  readonly name: string;
+  readonly table?: string;
+}
+//#endregion
+export { PostgresPlanTargetDetails as t };
+//# sourceMappingURL=planner-target-details-DH-azLu-.d.mts.map

package/dist/planner-target-details-DH-azLu-.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-target-details-DH-azLu-.d.mts","names":[],"sources":["../src/core/migrations/planner-target-details.ts"],"sourcesContent":[],"mappings":";KAEY,cAAA;AAAA,UAUK,yBAAA,CAVS;EAUT,SAAA,MAAA,EAAA,MAAA;uBAEM"}

package/dist/planner-target-details.d.mts

@@ -0,0 +1,2 @@
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-DH-azLu-.mjs";
+export { type PostgresPlanTargetDetails };

package/dist/planner-target-details.mjs

@@ -0,0 +1 @@
+export {  };