@prisma/orm-family-sql 0.16.0-dev.36

package/dist/middleware-CMr4CHNz-DHIUdxlm.mjs

@@ -0,0 +1,80 @@
+import { t as collectOrderedParamRefs } from "./util-DQQgv2j1-D6INZaRG.mjs";
+//#region ../../../2-sql/4-lanes/relational-core/dist/middleware-CMr4CHNz.mjs
+/**
+* Build a {@link SqlParamRefMutatorInternal} for the given lowered plan.
+*
+* The mutator captures `plan.params` by reference and walks
+* `plan.ast` (via `collectOrderedParamRefs`) on demand to build
+* entries. Mutations write to a lazily-allocated working copy so the
+* fast path (no mutation) preserves bit-for-bit reference identity to
+* the original `plan.params`.
+*
+* Threading: `plan.ast` carries the canonical `ParamRef` ordering used
+* by every consumer (renderer's `$N` index map, encode-side metadata
+* walk, etc.). The mutator's `entries()` yields the same order so
+* middleware that filters by codec id sees ParamRefs in the order the
+* runtime will encode them.
+*/
+function createSqlParamRefMutator(plan) {
+	const originalParams = plan.params;
+	const refs = plan.ast ? collectOrderedParamRefs(plan.ast) : [];
+	let workingParams;
+	const indexOfRef = (handle) => {
+		return refs.indexOf(handle);
+	};
+	const ensureWorkingParams = () => {
+		if (!workingParams) workingParams = [...originalParams];
+		return workingParams;
+	};
+	const writeAt = (index, value) => {
+		const buffer = ensureWorkingParams();
+		buffer[index] = value;
+	};
+	function* entries() {
+		const view = workingParams ?? originalParams;
+		for (let i = 0; i < refs.length; i++) {
+			const ref = refs[i];
+			if (!ref) continue;
+			const handle = ref;
+			let value;
+			let codecId;
+			if (ref.kind === "param-ref") {
+				value = i < view.length ? view[i] : ref.value;
+				codecId = ref.codec?.codecId;
+			} else {
+				value = i < view.length ? view[i] : void 0;
+				codecId = ref.codec.codecId;
+			}
+			yield {
+				ref: handle,
+				value,
+				codecId
+			};
+		}
+	}
+	function replaceValue(handle, newValue) {
+		const index = indexOfRef(handle);
+		if (index < 0) return;
+		writeAt(index, newValue);
+	}
+	function replaceValues(updates) {
+		for (const { ref, newValue } of updates) {
+			const index = indexOfRef(ref);
+			if (index < 0) continue;
+			writeAt(index, newValue);
+		}
+	}
+	return {
+		entries,
+		replaceValue,
+		replaceValues,
+		currentParams() {
+			if (!workingParams) return originalParams;
+			return Object.freeze([...workingParams]);
+		}
+	};
+}
+//#endregion
+export { createSqlParamRefMutator as t };
+
+//# sourceMappingURL=middleware-CMr4CHNz-DHIUdxlm.mjs.map

package/dist/middleware-CMr4CHNz-DHIUdxlm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-CMr4CHNz-DHIUdxlm.mjs","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/middleware-CMr4CHNz.mjs"],"sourcesContent":["import { t as collectOrderedParamRefs } from \"./util-DQQgv2j1.mjs\";\n//#region src/middleware/param-ref-mutator.ts\n/**\n* Build a {@link SqlParamRefMutatorInternal} for the given lowered plan.\n*\n* The mutator captures `plan.params` by reference and walks\n* `plan.ast` (via `collectOrderedParamRefs`) on demand to build\n* entries. Mutations write to a lazily-allocated working copy so the\n* fast path (no mutation) preserves bit-for-bit reference identity to\n* the original `plan.params`.\n*\n* Threading: `plan.ast` carries the canonical `ParamRef` ordering used\n* by every consumer (renderer's `$N` index map, encode-side metadata\n* walk, etc.). The mutator's `entries()` yields the same order so\n* middleware that filters by codec id sees ParamRefs in the order the\n* runtime will encode them.\n*/\nfunction createSqlParamRefMutator(plan) {\n\tconst originalParams = plan.params;\n\tconst refs = plan.ast ? collectOrderedParamRefs(plan.ast) : [];\n\tlet workingParams;\n\tconst indexOfRef = (handle) => {\n\t\treturn refs.indexOf(handle);\n\t};\n\tconst ensureWorkingParams = () => {\n\t\tif (!workingParams) workingParams = [...originalParams];\n\t\treturn workingParams;\n\t};\n\tconst writeAt = (index, value) => {\n\t\tconst buffer = ensureWorkingParams();\n\t\tbuffer[index] = value;\n\t};\n\tfunction* entries() {\n\t\tconst view = workingParams ?? originalParams;\n\t\tfor (let i = 0; i < refs.length; i++) {\n\t\t\tconst ref = refs[i];\n\t\t\tif (!ref) continue;\n\t\t\tconst handle = ref;\n\t\t\tlet value;\n\t\t\tlet codecId;\n\t\t\tif (ref.kind === \"param-ref\") {\n\t\t\t\tvalue = i < view.length ? view[i] : ref.value;\n\t\t\t\tcodecId = ref.codec?.codecId;\n\t\t\t} else {\n\t\t\t\tvalue = i < view.length ? view[i] : void 0;\n\t\t\t\tcodecId = ref.codec.codecId;\n\t\t\t}\n\t\t\tyield {\n\t\t\t\tref: handle,\n\t\t\t\tvalue,\n\t\t\t\tcodecId\n\t\t\t};\n\t\t}\n\t}\n\tfunction replaceValue(handle, newValue) {\n\t\tconst index = indexOfRef(handle);\n\t\tif (index < 0) return;\n\t\twriteAt(index, newValue);\n\t}\n\tfunction replaceValues(updates) {\n\t\tfor (const { ref, newValue } of updates) {\n\t\t\tconst index = indexOfRef(ref);\n\t\t\tif (index < 0) continue;\n\t\t\twriteAt(index, newValue);\n\t\t}\n\t}\n\treturn {\n\t\tentries,\n\t\treplaceValue,\n\t\treplaceValues,\n\t\tcurrentParams() {\n\t\t\tif (!workingParams) return originalParams;\n\t\t\treturn Object.freeze([...workingParams]);\n\t\t}\n\t};\n}\n//#endregion\nexport { createSqlParamRefMutator as t };\n\n//# sourceMappingURL=middleware-CMr4CHNz.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,SAAS,yBAAyB,MAAM;CACvC,MAAM,iBAAiB,KAAK;CAC5B,MAAM,OAAO,KAAK,MAAM,wBAAwB,KAAK,GAAG,IAAI,CAAC;CAC7D,IAAI;CACJ,MAAM,cAAc,WAAW;EAC9B,OAAO,KAAK,QAAQ,MAAM;CAC3B;CACA,MAAM,4BAA4B;EACjC,IAAI,CAAC,eAAe,gBAAgB,CAAC,GAAG,cAAc;EACtD,OAAO;CACR;CACA,MAAM,WAAW,OAAO,UAAU;EACjC,MAAM,SAAS,oBAAoB;EACnC,OAAO,SAAS;CACjB;CACA,UAAU,UAAU;EACnB,MAAM,OAAO,iBAAiB;EAC9B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;GACrC,MAAM,MAAM,KAAK;GACjB,IAAI,CAAC,KAAK;GACV,MAAM,SAAS;GACf,IAAI;GACJ,IAAI;GACJ,IAAI,IAAI,SAAS,aAAa;IAC7B,QAAQ,IAAI,KAAK,SAAS,KAAK,KAAK,IAAI;IACxC,UAAU,IAAI,OAAO;GACtB,OAAO;IACN,QAAQ,IAAI,KAAK,SAAS,KAAK,KAAK,KAAK;IACzC,UAAU,IAAI,MAAM;GACrB;GACA,MAAM;IACL,KAAK;IACL;IACA;GACD;EACD;CACD;CACA,SAAS,aAAa,QAAQ,UAAU;EACvC,MAAM,QAAQ,WAAW,MAAM;EAC/B,IAAI,QAAQ,GAAG;EACf,QAAQ,OAAO,QAAQ;CACxB;CACA,SAAS,cAAc,SAAS;EAC/B,KAAK,MAAM,EAAE,KAAK,cAAc,SAAS;GACxC,MAAM,QAAQ,WAAW,GAAG;GAC5B,IAAI,QAAQ,GAAG;GACf,QAAQ,OAAO,QAAQ;EACxB;CACD;CACA,OAAO;EACN;EACA;EACA;EACA,gBAAgB;GACf,IAAI,CAAC,eAAe,OAAO;GAC3B,OAAO,OAAO,OAAO,CAAC,GAAG,aAAa,CAAC;EACxC;CACD;AACD"}

package/dist/migration-CK4oePIo.mjs

@@ -0,0 +1,44 @@
+import { deriveProvidedInvariants } from "@prisma/orm-toolchain/migration-tools/invariants";
+import { Migration } from "@prisma/orm-toolchain/migration-tools/migration";
+import { isThenable } from "@prisma/orm-framework/utils/promise";
+//#region ../../../2-sql/9-family/dist/migration.mjs
+/**
+* Family-owned base class for SQL migrations.
+*
+* Generic in `TDetails` (family plan target details, e.g. Postgres vs SQLite)
+* and in `TTargetId` (the literal target identifier, e.g. `'postgres'`).
+*
+* Adapters (Postgres, SQLite, …) extend this with a concrete `TDetails` and
+* a fixed `TTargetId` literal, so the public `Migration<TOp>` base sees the
+* fully concrete operation shape. Target-free code in SQL family / tooling
+* parameterises over `TDetails` (and usually `TTargetId = string`).
+*
+* The `Start` / `End` contract generics are forwarded to the framework
+* `Migration` base so the derived `describe()` and the per-target view getters
+* (`PostgresMigration` / `SqliteMigration`) carry each migration's precise
+* contract types. The view getters themselves live on the per-target bases
+* because the SQL ContractView shapes differ per target (SQLite unwraps its
+* sole namespace to the root; Postgres is schema-qualified).
+*
+* Keeps target-free contract/runtime features in the family layer while
+* letting adapters own target shape.
+*/
+var SqlMigration = class extends Migration {
+	/**
+	* Sorted, deduplicated invariant ids declared by this migration's
+	* data-transform ops. Derived from `this.operations` so the field remains
+	* consistent with the operation list — planner-built plans (`db init`,
+	* `db update`) yield `[]` because they emit no data-transform ops.
+	*
+	* Required by `SqlMigrationPlan.providedInvariants` (tightened from
+	* optional at the SQL-family layer); the framework-level
+	* `MigrationPlan.providedInvariants?` stays optional.
+	*/
+	get providedInvariants() {
+		return deriveProvidedInvariants(this.operations.filter((op) => !isThenable(op)));
+	}
+};
+//#endregion
+export { SqlMigration as t };
+
+//# sourceMappingURL=migration-CK4oePIo.mjs.map

package/dist/migration-CK4oePIo.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-CK4oePIo.mjs","names":[],"sources":["../../../../2-sql/9-family/dist/migration.mjs"],"sourcesContent":["import { deriveProvidedInvariants } from \"@internal/migration-tools/invariants\";\nimport { Migration } from \"@internal/migration-tools/migration\";\nimport { isThenable } from \"@internal/utils/promise\";\n//#region src/core/sql-migration.ts\n/**\n* Family-owned base class for SQL migrations.\n*\n* Generic in `TDetails` (family plan target details, e.g. Postgres vs SQLite)\n* and in `TTargetId` (the literal target identifier, e.g. `'postgres'`).\n*\n* Adapters (Postgres, SQLite, …) extend this with a concrete `TDetails` and\n* a fixed `TTargetId` literal, so the public `Migration<TOp>` base sees the\n* fully concrete operation shape. Target-free code in SQL family / tooling\n* parameterises over `TDetails` (and usually `TTargetId = string`).\n*\n* The `Start` / `End` contract generics are forwarded to the framework\n* `Migration` base so the derived `describe()` and the per-target view getters\n* (`PostgresMigration` / `SqliteMigration`) carry each migration's precise\n* contract types. The view getters themselves live on the per-target bases\n* because the SQL ContractView shapes differ per target (SQLite unwraps its\n* sole namespace to the root; Postgres is schema-qualified).\n*\n* Keeps target-free contract/runtime features in the family layer while\n* letting adapters own target shape.\n*/\nvar SqlMigration = class extends Migration {\n\t/**\n\t* Sorted, deduplicated invariant ids declared by this migration's\n\t* data-transform ops. Derived from `this.operations` so the field remains\n\t* consistent with the operation list — planner-built plans (`db init`,\n\t* `db update`) yield `[]` because they emit no data-transform ops.\n\t*\n\t* Required by `SqlMigrationPlan.providedInvariants` (tightened from\n\t* optional at the SQL-family layer); the framework-level\n\t* `MigrationPlan.providedInvariants?` stays optional.\n\t*/\n\tget providedInvariants() {\n\t\treturn deriveProvidedInvariants(this.operations.filter((op) => !isThenable(op)));\n\t}\n};\n//#endregion\nexport { SqlMigration as Migration };\n\n//# sourceMappingURL=migration.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAI,eAAe,cAAc,UAAU;;;;;;;;;;;CAW1C,IAAI,qBAAqB;EACxB,OAAO,yBAAyB,KAAK,WAAW,QAAQ,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;CAChF;AACD"}

package/dist/migration-CW0ZJLxP.d.mts

@@ -0,0 +1,44 @@
+import { c as SqlStorage } from "./sql-storage-B0QwiTg6-B8DVctJm.mjs";
+import "./types-BchwQpmO.mjs";
+import { f as SqlMigrationPlanOperation, w as SqlPlanTargetDetails } from "./types-IqZMLrFC-DtdJNICr.mjs";
+import { Contract } from "@prisma/orm-framework/contract/types";
+import { Migration } from "@prisma/orm-toolchain/migration-tools/migration";
+//#region ../../../2-sql/9-family/dist/migration.d.mts
+//#region src/core/sql-migration.d.ts
+/**
+ * Family-owned base class for SQL migrations.
+ *
+ * Generic in `TDetails` (family plan target details, e.g. Postgres vs SQLite)
+ * and in `TTargetId` (the literal target identifier, e.g. `'postgres'`).
+ *
+ * Adapters (Postgres, SQLite, …) extend this with a concrete `TDetails` and
+ * a fixed `TTargetId` literal, so the public `Migration<TOp>` base sees the
+ * fully concrete operation shape. Target-free code in SQL family / tooling
+ * parameterises over `TDetails` (and usually `TTargetId = string`).
+ *
+ * The `Start` / `End` contract generics are forwarded to the framework
+ * `Migration` base so the derived `describe()` and the per-target view getters
+ * (`PostgresMigration` / `SqliteMigration`) carry each migration's precise
+ * contract types. The view getters themselves live on the per-target bases
+ * because the SQL ContractView shapes differ per target (SQLite unwraps its
+ * sole namespace to the root; Postgres is schema-qualified).
+ *
+ * Keeps target-free contract/runtime features in the family layer while
+ * letting adapters own target shape.
+ */
+declare abstract class SqlMigration<TDetails extends SqlPlanTargetDetails, TTargetId extends string = string, Start extends Contract<SqlStorage> = Contract<SqlStorage>, End extends Contract<SqlStorage> = Contract<SqlStorage>> extends Migration<SqlMigrationPlanOperation<TDetails>, 'sql', TTargetId, Start, End> {
+  /**
+   * Sorted, deduplicated invariant ids declared by this migration's
+   * data-transform ops. Derived from `this.operations` so the field remains
+   * consistent with the operation list — planner-built plans (`db init`,
+   * `db update`) yield `[]` because they emit no data-transform ops.
+   *
+   * Required by `SqlMigrationPlan.providedInvariants` (tightened from
+   * optional at the SQL-family layer); the framework-level
+   * `MigrationPlan.providedInvariants?` stays optional.
+   */
+  get providedInvariants(): readonly string[];
+}
+//#endregion
+export { SqlMigration as t };
+//# sourceMappingURL=migration-CW0ZJLxP.d.mts.map

package/dist/migration-CW0ZJLxP.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-CW0ZJLxP.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/migration.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0BuB,aAAa,iBAAiB,sBAAsB,mCAAmC,cAAc,SAAS,cAAc,SAAS,aAAa,YAAY,SAAS,cAAc,SAAS,qBAAqB,UAAU,0BAA0B,kBAAkB,WAAW,OAAO;;;;;;;;;;;MAW5S"}

package/dist/naming-BwqqVcZy-BgTObIQw.mjs

@@ -0,0 +1,177 @@
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { ContractValidationError } from "@prisma/orm-framework/contract/contract-validation-error";
+import { createHash } from "node:crypto";
+//#region ../../../2-sql/1-core/schema-ir/dist/naming-BwqqVcZy.mjs
+function defaultIndexName(tableName, columns) {
+	return `${tableName}_${columns.join("_")}_idx`;
+}
+/** The flat name the union describes. Inverse of {@link namingOf}. */
+function nameOf(naming) {
+	return naming.kind === "wire" ? formatWireName(naming.prefix, naming.hash) : naming.name;
+}
+/**
+* The naming a name-identified node was built with, read back off the flat
+* pair it stores. Inverse of {@link nameOf}, and total for that
+* reason: the constructor derived `name` from the union, so the two agree.
+* Flat data arriving from outside the process goes through
+* {@link parseNaming} instead.
+*/
+function namingOf(name, prefix) {
+	if (prefix === void 0) return {
+		kind: "exact",
+		name
+	};
+	return {
+		kind: "wire",
+		prefix,
+		hash: name.slice(prefix.length + 1)
+	};
+}
+/**
+* Reads naming out of flat stored data — deserialized contract JSON and the
+* literals a user may hand-edit, the one place a name and a prefix can still
+* disagree. Throws when a declared prefix does not parse back out of the name.
+*/
+function parseNaming(name, prefix) {
+	if (prefix === void 0) return {
+		kind: "exact",
+		name
+	};
+	const parsed = parseWireName(name);
+	if (parsed === void 0 || parsed.prefix !== prefix) throw new ContractValidationError(`"${name}": prefix "${prefix}" does not match the wire name (expected "${formatWireName(prefix, "<8hex>")}").`, "storage");
+	return {
+		kind: "wire",
+		prefix: parsed.prefix,
+		hash: parsed.hash
+	};
+}
+/**
+* The naming an object read out of a live catalog has: a wire-shaped name
+* gets the wire arm so the rename pass can pair it by prefix, and every
+* other name is exact.
+*
+* The wire answer is a claim about the name's SHAPE only — the hash is
+* deliberately not recomputed from the object's content here. Nothing
+* downstream reads it as more than that: the differ always asks the
+* contract-derived side to choose the comparison, so a shape-only wire
+* claim on the introspected side never suppresses a body comparison, and
+* `contract infer` recomputes the hash independently before it will emit an
+* index as wire-named.
+*/
+function namingOfLiveName(name) {
+	const wire = parseWireName(name);
+	return wire === void 0 ? {
+		kind: "exact",
+		name
+	} : {
+		kind: "wire",
+		prefix: wire.prefix,
+		hash: wire.hash
+	};
+}
+const WIRE_NAME_PATTERN = /^(.+)_([0-9a-f]{8})$/;
+/**
+* Assembles a wire name from its user-supplied prefix and its 8-hex
+* content-hash suffix. This module owns the `<prefix>_<hash>` format on both
+* sides — construction here and parsing in {@link parseWireName} — so the two
+* never drift.
+*/
+function formatWireName(prefix, hash) {
+	return `${prefix}_${hash}`;
+}
+/**
+* Splits a wire name (`<prefix>_<8hex>`) into its prefix and content-hash
+* suffix. Returns `undefined` when the name does not follow the wire-name
+* shape (e.g. an object created outside the toolchain) — callers treat such
+* names as all-prefix. Consumed by introspection (prefix extraction) and by
+* rename pairing (same hash, different prefix).
+*/
+function parseWireName(name) {
+	const match = WIRE_NAME_PATTERN.exec(name);
+	const prefix = match?.[1];
+	const hash = match?.[2];
+	if (prefix === void 0 || hash === void 0) return void 0;
+	return {
+		prefix,
+		hash
+	};
+}
+/**
+* Stabilizes an authored SQL body (index expression, partial-index predicate,
+* RLS policy predicate) for hashing: trim, and collapse runs of internal
+* whitespace to a single space.
+*
+* This is deliberately minimal. The content hash is the equivalence relation
+* for a wire-named object, and the wire name (prefix + hash) is the only
+* thing ever compared — the hash is never recomputed from an introspected
+* body, so there is no need to match the database's reprinted form. Minimal
+* normalization also protects the no-collision property: aggressive rewriting
+* (lowercasing, paren-stripping, cast-alias folding) risks collapsing two
+* distinct bodies onto one hash.
+*
+* The normalizer is a stability commitment: any change re-suffixes all wire names.
+*/
+function normalizeSqlBody(sql) {
+	return sql.replace(/\s+/g, " ").trim();
+}
+/**
+* Returns the first 8 lowercase hex characters of the SHA-256 digest over the
+* canonical content tuple for an index:
+*
+*   [normalizeSqlBody(expression), normalizeSqlBody(where), columns, unique, type, sortedOptions]
+*
+* Columns hash in authored order — column order is semantic in an index.
+* Option values are `String()`-coerced (matching the loose option equality
+* used for diffing) so a hash computed from typed contract values agrees with
+* one recomputed from introspected reloptions strings. The prefix, schema,
+* and table are excluded (they are orthogonal to index equivalence).
+*
+* The tuple order and encoding are a stability commitment with the same
+* status as the RLS tuple: any change re-suffixes every wire name.
+*/
+/**
+* Canonicalizes one index option VALUE to the `on`/`off` boolean spelling:
+* JS booleans and the common catalog spellings (`pg_class.reloptions`
+* stores whatever spelling the DDL used, so a live index may carry
+* `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; everything
+* else via `String()` (fully specified for numbers, so no platform
+* variance). Shared by the wire-name hash tuple, the node's option
+* equality, and the DDL renderer, so an authored `{ fastupdate: true }`
+* agrees with a live index created under any boolean spelling.
+*/
+function normalizeIndexOptionValue(value) {
+	if (value === true || value === "true" || value === "on") return "on";
+	if (value === false || value === "false" || value === "off") return "off";
+	return String(value);
+}
+function computeIndexContentHash(parts) {
+	const sortedOptions = Object.entries(parts.options ?? {}).map(([key, value]) => [key, normalizeIndexOptionValue(value)]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	const tuple = JSON.stringify([
+		normalizeSqlBody(parts.expression ?? ""),
+		normalizeSqlBody(parts.where ?? ""),
+		parts.columns ?? [],
+		parts.unique,
+		parts.type ?? "",
+		sortedOptions
+	]);
+	return createHash("sha256").update(tuple).digest("hex").slice(0, 8);
+}
+/**
+* Postgres identifiers cap at 63 characters and the wire name appends a
+* 9-character `_<8hex>` suffix, so an authored prefix is bounded at 54.
+*/
+const WIRE_NAME_PREFIX_MAX_LENGTH = 54;
+/**
+* Rejects a wire-name prefix over {@link WIRE_NAME_PREFIX_MAX_LENGTH}.
+* `subject` opens the error message (e.g. `defineContract: policy prefix`).
+*/
+function assertWireNamePrefixLength(prefix, subject) {
+	if (prefix.length > 54) throw structuredError("CONTRACT.WIRE_NAME_PREFIX_TOO_LONG", `${subject} "${prefix}" exceeds the 54-character maximum (Postgres identifiers cap at 63 characters and the wire name appends a 9-character hash suffix).`, { meta: {
+		prefix,
+		maxLength: 54
+	} });
+}
+//#endregion
+export { formatWireName as a, namingOfLiveName as c, parseNaming as d, parseWireName as f, defaultIndexName as i, normalizeIndexOptionValue as l, assertWireNamePrefixLength as n, nameOf as o, computeIndexContentHash as r, namingOf as s, WIRE_NAME_PREFIX_MAX_LENGTH as t, normalizeSqlBody as u };
+
+//# sourceMappingURL=naming-BwqqVcZy-BgTObIQw.mjs.map

package/dist/naming-BwqqVcZy-BgTObIQw.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming-BwqqVcZy-BgTObIQw.mjs","names":[],"sources":["../../../../2-sql/1-core/schema-ir/dist/naming-BwqqVcZy.mjs"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { ContractValidationError } from \"@internal/contract/contract-validation-error\";\nimport { structuredError } from \"@internal/utils/structured-error\";\n//#region src/naming.ts\nfunction defaultIndexName(tableName, columns) {\n\treturn `${tableName}_${columns.join(\"_\")}_idx`;\n}\n/** The flat name the union describes. Inverse of {@link namingOf}. */\nfunction nameOf(naming) {\n\treturn naming.kind === \"wire\" ? formatWireName(naming.prefix, naming.hash) : naming.name;\n}\n/**\n* The naming a name-identified node was built with, read back off the flat\n* pair it stores. Inverse of {@link nameOf}, and total for that\n* reason: the constructor derived `name` from the union, so the two agree.\n* Flat data arriving from outside the process goes through\n* {@link parseNaming} instead.\n*/\nfunction namingOf(name, prefix) {\n\tif (prefix === void 0) return {\n\t\tkind: \"exact\",\n\t\tname\n\t};\n\treturn {\n\t\tkind: \"wire\",\n\t\tprefix,\n\t\thash: name.slice(prefix.length + 1)\n\t};\n}\n/**\n* Reads naming out of flat stored data — deserialized contract JSON and the\n* literals a user may hand-edit, the one place a name and a prefix can still\n* disagree. Throws when a declared prefix does not parse back out of the name.\n*/\nfunction parseNaming(name, prefix) {\n\tif (prefix === void 0) return {\n\t\tkind: \"exact\",\n\t\tname\n\t};\n\tconst parsed = parseWireName(name);\n\tif (parsed === void 0 || parsed.prefix !== prefix) throw new ContractValidationError(`\"${name}\": prefix \"${prefix}\" does not match the wire name (expected \"${formatWireName(prefix, \"<8hex>\")}\").`, \"storage\");\n\treturn {\n\t\tkind: \"wire\",\n\t\tprefix: parsed.prefix,\n\t\thash: parsed.hash\n\t};\n}\n/**\n* The naming an object read out of a live catalog has: a wire-shaped name\n* gets the wire arm so the rename pass can pair it by prefix, and every\n* other name is exact.\n*\n* The wire answer is a claim about the name's SHAPE only — the hash is\n* deliberately not recomputed from the object's content here. Nothing\n* downstream reads it as more than that: the differ always asks the\n* contract-derived side to choose the comparison, so a shape-only wire\n* claim on the introspected side never suppresses a body comparison, and\n* `contract infer` recomputes the hash independently before it will emit an\n* index as wire-named.\n*/\nfunction namingOfLiveName(name) {\n\tconst wire = parseWireName(name);\n\treturn wire === void 0 ? {\n\t\tkind: \"exact\",\n\t\tname\n\t} : {\n\t\tkind: \"wire\",\n\t\tprefix: wire.prefix,\n\t\thash: wire.hash\n\t};\n}\nconst WIRE_NAME_PATTERN = /^(.+)_([0-9a-f]{8})$/;\n/**\n* Assembles a wire name from its user-supplied prefix and its 8-hex\n* content-hash suffix. This module owns the `<prefix>_<hash>` format on both\n* sides — construction here and parsing in {@link parseWireName} — so the two\n* never drift.\n*/\nfunction formatWireName(prefix, hash) {\n\treturn `${prefix}_${hash}`;\n}\n/**\n* Splits a wire name (`<prefix>_<8hex>`) into its prefix and content-hash\n* suffix. Returns `undefined` when the name does not follow the wire-name\n* shape (e.g. an object created outside the toolchain) — callers treat such\n* names as all-prefix. Consumed by introspection (prefix extraction) and by\n* rename pairing (same hash, different prefix).\n*/\nfunction parseWireName(name) {\n\tconst match = WIRE_NAME_PATTERN.exec(name);\n\tconst prefix = match?.[1];\n\tconst hash = match?.[2];\n\tif (prefix === void 0 || hash === void 0) return void 0;\n\treturn {\n\t\tprefix,\n\t\thash\n\t};\n}\n/**\n* Stabilizes an authored SQL body (index expression, partial-index predicate,\n* RLS policy predicate) for hashing: trim, and collapse runs of internal\n* whitespace to a single space.\n*\n* This is deliberately minimal. The content hash is the equivalence relation\n* for a wire-named object, and the wire name (prefix + hash) is the only\n* thing ever compared — the hash is never recomputed from an introspected\n* body, so there is no need to match the database's reprinted form. Minimal\n* normalization also protects the no-collision property: aggressive rewriting\n* (lowercasing, paren-stripping, cast-alias folding) risks collapsing two\n* distinct bodies onto one hash.\n*\n* The normalizer is a stability commitment: any change re-suffixes all wire names.\n*/\nfunction normalizeSqlBody(sql) {\n\treturn sql.replace(/\\s+/g, \" \").trim();\n}\n/**\n* Returns the first 8 lowercase hex characters of the SHA-256 digest over the\n* canonical content tuple for an index:\n*\n*   [normalizeSqlBody(expression), normalizeSqlBody(where), columns, unique, type, sortedOptions]\n*\n* Columns hash in authored order — column order is semantic in an index.\n* Option values are `String()`-coerced (matching the loose option equality\n* used for diffing) so a hash computed from typed contract values agrees with\n* one recomputed from introspected reloptions strings. The prefix, schema,\n* and table are excluded (they are orthogonal to index equivalence).\n*\n* The tuple order and encoding are a stability commitment with the same\n* status as the RLS tuple: any change re-suffixes every wire name.\n*/\n/**\n* Canonicalizes one index option VALUE to the `on`/`off` boolean spelling:\n* JS booleans and the common catalog spellings (`pg_class.reloptions`\n* stores whatever spelling the DDL used, so a live index may carry\n* `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; everything\n* else via `String()` (fully specified for numbers, so no platform\n* variance). Shared by the wire-name hash tuple, the node's option\n* equality, and the DDL renderer, so an authored `{ fastupdate: true }`\n* agrees with a live index created under any boolean spelling.\n*/\nfunction normalizeIndexOptionValue(value) {\n\tif (value === true || value === \"true\" || value === \"on\") return \"on\";\n\tif (value === false || value === \"false\" || value === \"off\") return \"off\";\n\treturn String(value);\n}\nfunction computeIndexContentHash(parts) {\n\tconst sortedOptions = Object.entries(parts.options ?? {}).map(([key, value]) => [key, normalizeIndexOptionValue(value)]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);\n\tconst tuple = JSON.stringify([\n\t\tnormalizeSqlBody(parts.expression ?? \"\"),\n\t\tnormalizeSqlBody(parts.where ?? \"\"),\n\t\tparts.columns ?? [],\n\t\tparts.unique,\n\t\tparts.type ?? \"\",\n\t\tsortedOptions\n\t]);\n\treturn createHash(\"sha256\").update(tuple).digest(\"hex\").slice(0, 8);\n}\n/**\n* Postgres identifiers cap at 63 characters and the wire name appends a\n* 9-character `_<8hex>` suffix, so an authored prefix is bounded at 54.\n*/\nconst WIRE_NAME_PREFIX_MAX_LENGTH = 54;\n/**\n* Rejects a wire-name prefix over {@link WIRE_NAME_PREFIX_MAX_LENGTH}.\n* `subject` opens the error message (e.g. `defineContract: policy prefix`).\n*/\nfunction assertWireNamePrefixLength(prefix, subject) {\n\tif (prefix.length > 54) throw structuredError(\"CONTRACT.WIRE_NAME_PREFIX_TOO_LONG\", `${subject} \"${prefix}\" exceeds the 54-character maximum (Postgres identifiers cap at 63 characters and the wire name appends a 9-character hash suffix).`, { meta: {\n\t\tprefix,\n\t\tmaxLength: 54\n\t} });\n}\n//#endregion\nexport { formatWireName as a, namingOfLiveName as c, parseNaming as d, parseWireName as f, defaultIndexName as i, normalizeIndexOptionValue as l, assertWireNamePrefixLength as n, nameOf as o, computeIndexContentHash as r, namingOf as s, WIRE_NAME_PREFIX_MAX_LENGTH as t, normalizeSqlBody as u };\n\n//# sourceMappingURL=naming-BwqqVcZy.mjs.map"],"mappings":";;;;AAIA,SAAS,iBAAiB,WAAW,SAAS;CAC7C,OAAO,GAAG,UAAU,GAAG,QAAQ,KAAK,GAAG,EAAE;AAC1C;;AAEA,SAAS,OAAO,QAAQ;CACvB,OAAO,OAAO,SAAS,SAAS,eAAe,OAAO,QAAQ,OAAO,IAAI,IAAI,OAAO;AACrF;;;;;;;;AAQA,SAAS,SAAS,MAAM,QAAQ;CAC/B,IAAI,WAAW,KAAK,GAAG,OAAO;EAC7B,MAAM;EACN;CACD;CACA,OAAO;EACN,MAAM;EACN;EACA,MAAM,KAAK,MAAM,OAAO,SAAS,CAAC;CACnC;AACD;;;;;;AAMA,SAAS,YAAY,MAAM,QAAQ;CAClC,IAAI,WAAW,KAAK,GAAG,OAAO;EAC7B,MAAM;EACN;CACD;CACA,MAAM,SAAS,cAAc,IAAI;CACjC,IAAI,WAAW,KAAK,KAAK,OAAO,WAAW,QAAQ,MAAM,IAAI,wBAAwB,IAAI,KAAK,aAAa,OAAO,4CAA4C,eAAe,QAAQ,QAAQ,EAAE,MAAM,SAAS;CAC9M,OAAO;EACN,MAAM;EACN,QAAQ,OAAO;EACf,MAAM,OAAO;CACd;AACD;;;;;;;;;;;;;;AAcA,SAAS,iBAAiB,MAAM;CAC/B,MAAM,OAAO,cAAc,IAAI;CAC/B,OAAO,SAAS,KAAK,IAAI;EACxB,MAAM;EACN;CACD,IAAI;EACH,MAAM;EACN,QAAQ,KAAK;EACb,MAAM,KAAK;CACZ;AACD;AACA,MAAM,oBAAoB;;;;;;;AAO1B,SAAS,eAAe,QAAQ,MAAM;CACrC,OAAO,GAAG,OAAO,GAAG;AACrB;;;;;;;;AAQA,SAAS,cAAc,MAAM;CAC5B,MAAM,QAAQ,kBAAkB,KAAK,IAAI;CACzC,MAAM,SAAS,QAAQ;CACvB,MAAM,OAAO,QAAQ;CACrB,IAAI,WAAW,KAAK,KAAK,SAAS,KAAK,GAAG,OAAO,KAAK;CACtD,OAAO;EACN;EACA;CACD;AACD;;;;;;;;;;;;;;;;AAgBA,SAAS,iBAAiB,KAAK;CAC9B,OAAO,IAAI,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK;AACtC;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAS,0BAA0B,OAAO;CACzC,IAAI,UAAU,QAAQ,UAAU,UAAU,UAAU,MAAM,OAAO;CACjE,IAAI,UAAU,SAAS,UAAU,WAAW,UAAU,OAAO,OAAO;CACpE,OAAO,OAAO,KAAK;AACpB;AACA,SAAS,wBAAwB,OAAO;CACvC,MAAM,gBAAgB,OAAO,QAAQ,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CAAC,KAAK,0BAA0B,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC;CACtK,MAAM,QAAQ,KAAK,UAAU;EAC5B,iBAAiB,MAAM,cAAc,EAAE;EACvC,iBAAiB,MAAM,SAAS,EAAE;EAClC,MAAM,WAAW,CAAC;EAClB,MAAM;EACN,MAAM,QAAQ;EACd;CACD,CAAC;CACD,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC;AACnE;;;;;AAKA,MAAM,8BAA8B;;;;;AAKpC,SAAS,2BAA2B,QAAQ,SAAS;CACpD,IAAI,OAAO,SAAS,IAAI,MAAM,gBAAgB,sCAAsC,GAAG,QAAQ,IAAI,OAAO,sIAAsI,EAAE,MAAM;EACvP;EACA,WAAW;CACZ,EAAE,CAAC;AACJ"}

package/dist/naming-jLgdauLi-C84G_UHi.d.mts

@@ -0,0 +1,133 @@
+//#region ../../../2-sql/1-core/schema-ir/dist/naming-jLgdauLi.d.mts
+//#region src/naming.d.ts
+declare function defaultIndexName(tableName: string, columns: readonly string[]): string;
+interface WireName {
+  /** The user-supplied part before the `_<8hex>` suffix. */
+  readonly prefix: string;
+  /** The 8-lowercase-hex content-hash suffix. */
+  readonly hash: string;
+}
+/**
+ * Where a name-identified object's name comes from: `wire` means the
+ * toolchain derives it as `formatWireName(prefix, hash)`; `exact` means the
+ * author owns it verbatim. Because the wire arm carries only the prefix
+ * and the hash, a name that disagrees with its prefix is unrepresentable.
+ *
+ * Storage and JSON stay flat (`name` plus an optional `prefix`);
+ * {@link parseNaming} is the way back in.
+ */
+type SqlObjectNaming = {
+  readonly kind: 'exact';
+  readonly name: string;
+} | ({
+  readonly kind: 'wire';
+} & WireName);
+/** The flat name the union describes. Inverse of {@link namingOf}. */
+declare function nameOf(naming: SqlObjectNaming): string;
+/**
+ * The naming a name-identified node was built with, read back off the flat
+ * pair it stores. Inverse of {@link nameOf}, and total for that
+ * reason: the constructor derived `name` from the union, so the two agree.
+ * Flat data arriving from outside the process goes through
+ * {@link parseNaming} instead.
+ */
+declare function namingOf(name: string, prefix: string | undefined): SqlObjectNaming;
+/**
+ * Reads naming out of flat stored data — deserialized contract JSON and the
+ * literals a user may hand-edit, the one place a name and a prefix can still
+ * disagree. Throws when a declared prefix does not parse back out of the name.
+ */
+declare function parseNaming(name: string, prefix: string | undefined): SqlObjectNaming;
+/**
+ * The naming an object read out of a live catalog has: a wire-shaped name
+ * gets the wire arm so the rename pass can pair it by prefix, and every
+ * other name is exact.
+ *
+ * The wire answer is a claim about the name's SHAPE only — the hash is
+ * deliberately not recomputed from the object's content here. Nothing
+ * downstream reads it as more than that: the differ always asks the
+ * contract-derived side to choose the comparison, so a shape-only wire
+ * claim on the introspected side never suppresses a body comparison, and
+ * `contract infer` recomputes the hash independently before it will emit an
+ * index as wire-named.
+ */
+declare function namingOfLiveName(name: string): SqlObjectNaming;
+/**
+ * Assembles a wire name from its user-supplied prefix and its 8-hex
+ * content-hash suffix. This module owns the `<prefix>_<hash>` format on both
+ * sides — construction here and parsing in {@link parseWireName} — so the two
+ * never drift.
+ */
+declare function formatWireName(prefix: string, hash: string): string;
+/**
+ * Splits a wire name (`<prefix>_<8hex>`) into its prefix and content-hash
+ * suffix. Returns `undefined` when the name does not follow the wire-name
+ * shape (e.g. an object created outside the toolchain) — callers treat such
+ * names as all-prefix. Consumed by introspection (prefix extraction) and by
+ * rename pairing (same hash, different prefix).
+ */
+declare function parseWireName(name: string): WireName | undefined;
+/**
+ * Stabilizes an authored SQL body (index expression, partial-index predicate,
+ * RLS policy predicate) for hashing: trim, and collapse runs of internal
+ * whitespace to a single space.
+ *
+ * This is deliberately minimal. The content hash is the equivalence relation
+ * for a wire-named object, and the wire name (prefix + hash) is the only
+ * thing ever compared — the hash is never recomputed from an introspected
+ * body, so there is no need to match the database's reprinted form. Minimal
+ * normalization also protects the no-collision property: aggressive rewriting
+ * (lowercasing, paren-stripping, cast-alias folding) risks collapsing two
+ * distinct bodies onto one hash.
+ *
+ * The normalizer is a stability commitment: any change re-suffixes all wire names.
+ */
+declare function normalizeSqlBody(sql: string): string;
+interface IndexContentHashParts {
+  readonly expression?: string;
+  readonly where?: string;
+  readonly columns?: readonly string[];
+  readonly unique: boolean;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+}
+/**
+ * Returns the first 8 lowercase hex characters of the SHA-256 digest over the
+ * canonical content tuple for an index:
+ *
+ *   [normalizeSqlBody(expression), normalizeSqlBody(where), columns, unique, type, sortedOptions]
+ *
+ * Columns hash in authored order — column order is semantic in an index.
+ * Option values are `String()`-coerced (matching the loose option equality
+ * used for diffing) so a hash computed from typed contract values agrees with
+ * one recomputed from introspected reloptions strings. The prefix, schema,
+ * and table are excluded (they are orthogonal to index equivalence).
+ *
+ * The tuple order and encoding are a stability commitment with the same
+ * status as the RLS tuple: any change re-suffixes every wire name.
+ */
+/**
+ * Canonicalizes one index option VALUE to the `on`/`off` boolean spelling:
+ * JS booleans and the common catalog spellings (`pg_class.reloptions`
+ * stores whatever spelling the DDL used, so a live index may carry
+ * `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; everything
+ * else via `String()` (fully specified for numbers, so no platform
+ * variance). Shared by the wire-name hash tuple, the node's option
+ * equality, and the DDL renderer, so an authored `{ fastupdate: true }`
+ * agrees with a live index created under any boolean spelling.
+ */
+declare function normalizeIndexOptionValue(value: unknown): string;
+declare function computeIndexContentHash(parts: IndexContentHashParts): string;
+/**
+ * Postgres identifiers cap at 63 characters and the wire name appends a
+ * 9-character `_<8hex>` suffix, so an authored prefix is bounded at 54.
+ */
+declare const WIRE_NAME_PREFIX_MAX_LENGTH = 54;
+/**
+ * Rejects a wire-name prefix over {@link WIRE_NAME_PREFIX_MAX_LENGTH}.
+ * `subject` opens the error message (e.g. `defineContract: policy prefix`).
+ */
+declare function assertWireNamePrefixLength(prefix: string, subject: string): void;
+//#endregion
+export { assertWireNamePrefixLength as a, formatWireName as c, namingOfLiveName as d, normalizeIndexOptionValue as f, parseWireName as h, WireName as i, nameOf as l, parseNaming as m, SqlObjectNaming as n, computeIndexContentHash as o, normalizeSqlBody as p, WIRE_NAME_PREFIX_MAX_LENGTH as r, defaultIndexName as s, IndexContentHashParts as t, namingOf as u };
+//# sourceMappingURL=naming-jLgdauLi-C84G_UHi.d.mts.map

package/dist/naming-jLgdauLi-C84G_UHi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming-jLgdauLi-C84G_UHi.d.mts","names":[],"sources":["../../../../2-sql/1-core/schema-ir/dist/naming-jLgdauLi.d.mts"],"mappings":";;iBACiB,iBAAiB,mBAAmB;UAC3C;;WAEC;;WAEA;;;;;;;;;;;KAWN;WACM;WACA;;WAEA;IACP;;iBAEa,OAAO,QAAQ;;;;;;;;iBAQf,SAAS,cAAc,6BAA6B;;;;;;iBAMpD,YAAY,cAAc,6BAA6B;;;;;;;;;;;;;;iBAcvD,iBAAiB,eAAe;;;;;;;iBAOhC,eAAe,gBAAgB;;;;;;;;iBAQ/B,cAAc,eAAe;;;;;;;;;;;;;;;;iBAgB7B,iBAAiB;UACxB;WACC;WACA;WACA;WACA;WACA;WACA,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BJ,0BAA0B;iBAC1B,wBAAwB,OAAO;;;;;cAKlC;;;;;iBAKG,2BAA2B,gBAAgB"}

package/dist/operations.d.mts

@@ -0,0 +1,2 @@
+import { a as SqlOperationRegistry, i as SqlOperationEntry, n as SqlOperationDescriptor, o as createSqlOperationRegistry, r as SqlOperationDescriptors, t as SqlLoweringSpec } from "./index-BgaTJRxj.mjs";
+export { SqlLoweringSpec, SqlOperationDescriptor, SqlOperationDescriptors, SqlOperationEntry, SqlOperationRegistry, createSqlOperationRegistry };

package/dist/operations.mjs

@@ -0,0 +1,2 @@
+import { t as createSqlOperationRegistry } from "./dist-C_q1_QR9.mjs";
+export { createSqlOperationRegistry };