@prisma/orm-family-sql 8.0.0-rc.2-dev.2 → 8.0.0-rc.20

package/dist/sql-data-type-D7M-YTTY-D2vRqDxn.mjs

@@ -0,0 +1,400 @@
+import { t as contractError } from "./contract-errors-BCN6RVI5-DoH6b_KZ.mjs";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { assertDataTypeParams, dataType, dataTypeParams, objectSchemaKeys, schemaKeysAllowing } from "@prisma/orm-framework/components/codec";
+import { canonicalizeJson } from "@prisma/orm-framework/components/utils";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { type } from "arktype";
+//#region ../../../2-sql-family/1-core/contract/dist/sql-data-type-D7M-YTTY.mjs
+const PLACEHOLDER = /\{([A-Za-z][A-Za-z0-9]*)\}/g;
+const LITERAL_CHARACTERS = /^[a-z0-9_ (),.]*$/;
+const REGEXP_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+function paramKeysOf(id, schema) {
+	if (schema === void 0) return [];
+	const keys = objectSchemaKeys(schema);
+	if (keys === void 0) refuseDeclaration(id, "its parameter schema must be an arktype object schema.");
+	return keys;
+}
+function placeholdersOf(text) {
+	return [...text.matchAll(PLACEHOLDER)].map((match) => match[1] ?? "");
+}
+function placeholderSetOf(text) {
+	return [...placeholdersOf(text)].sort().join(",");
+}
+function patternOf(text, signedKeys = []) {
+	const placeholders = text.replace(REGEXP_SPECIAL, "\\$&").replace(/\\\{([A-Za-z][A-Za-z0-9]*)\\\}/g, (_, name) => signedKeys.includes(name) ? "(-?\\d+)" : "(\\d+)");
+	return new RegExp(`^${placeholders}$`);
+}
+function refuseDeclaration(id, why) {
+	throw new InternalError(`Data type ${id}: ${why}`);
+}
+function checkText(id, text, paramKeys) {
+	const quoted = JSON.stringify(text.text);
+	const refuse = (why) => refuseDeclaration(id, `the text ${quoted} ${why}.`);
+	if (text.text === "") refuse("is empty");
+	if (text.text !== text.text.trim()) refuse("starts or ends with a space");
+	if (text.text.includes("  ")) refuse("has two spaces in a row");
+	const literal = text.text.replace(PLACEHOLDER, "");
+	if (literal.includes("{") || literal.includes("}")) refuse("has a placeholder that is not written {name}");
+	if (!LITERAL_CHARACTERS.test(literal)) refuse("must be lower case and contain only letters, digits, spaces, brackets, commas, dots, underscores and placeholders");
+	for (const name of placeholdersOf(text.text)) if (!paramKeys.includes(name)) refuse(`names the parameter {${name}}, which the type does not declare`);
+	if (text.display === void 0) return;
+	const display = JSON.stringify(text.display);
+	if (text.display.toLowerCase() !== text.text.toLowerCase()) refuse(`has the display ${display}, which differs from it beyond letter case`);
+	if (placeholdersOf(text.display).join(",") !== placeholdersOf(text.text).join(",")) refuse(`has the display ${display}, which writes a placeholder differently`);
+}
+function checkMarks(id, texts) {
+	const marked = /* @__PURE__ */ new Map();
+	for (const text of texts) {
+		const key = placeholderSetOf(text.text);
+		const entry = marked.get(key) ?? {};
+		for (const mark of ["written", "catalog"]) {
+			if (text[mark] !== true) continue;
+			const other = entry[mark];
+			if (other !== void 0) refuseDeclaration(id, `the texts ${JSON.stringify(other)} and ${JSON.stringify(text.text)} have the same placeholders and are both ${mark}.`);
+			entry[mark] = text.text;
+		}
+		marked.set(key, entry);
+	}
+}
+function checkKindClaim(id, spec) {
+	if (spec.nameIsCatalogText === true) {
+		if (spec.render === void 0) refuseDeclaration(id, "a type whose name is its catalog text declares render.");
+		if (spec.texts !== void 0 || spec.claimsKind !== void 0) refuseDeclaration(id, "a type whose name is its catalog text declares no texts and claims no kind.");
+	}
+	if (spec.claimsKind === void 0) {
+		if (spec.render !== void 0 && spec.nameIsCatalogText !== true) refuseDeclaration(id, "render is allowed only together with claimsKind or nameIsCatalogText.");
+		if (spec.fromReported !== void 0) refuseDeclaration(id, "fromReported is allowed only together with claimsKind.");
+		return;
+	}
+	if (spec.texts !== void 0) refuseDeclaration(id, "a type that claims a kind declares no texts.");
+}
+function checkStoredAs(id, spec) {
+	if (spec.storedAs === void 0) return;
+	if (spec.texts !== void 0) refuseDeclaration(id, "a type stored as another declares no texts; its name is the name of the type it is stored as.");
+	if (spec.claimsKind !== void 0) refuseDeclaration(id, "a type stored as another claims no kind.");
+}
+const identity = (params) => params;
+function isParamsOf(schema, params) {
+	return schema === void 0 || !(schema(params) instanceof type.errors);
+}
+function checkNormalFormsWritten(type) {
+	const written = new Set(type.sql.texts.filter((text) => text.written === true).map((text) => placeholderSetOf(text.text)));
+	if (written.size === 0) return;
+	const probes = [{}, ...type.sql.texts.map((text) => Object.fromEntries(placeholdersOf(text.text).map((name) => [name, 1])))];
+	for (const probe of probes) {
+		if (!isParamsOf(type.params, probe)) continue;
+		const normalKeys = presentKeys(type.sql.normalize(probe));
+		if (!written.has([...normalKeys].sort().join(","))) refuseDeclaration(type.id, `the parameters ${formatKeys(Object.keys(probe))} have the normal form ${formatKeys(normalKeys)}, which no written text takes.`);
+	}
+}
+/** Declare a SQL data type, refusing a declaration that breaks a rule of the module. */
+function sqlDataType(id, spec) {
+	const declaredNormalize = spec.normalize ?? identity;
+	const normalize = (params) => isParamsOf(spec.params, params) ? declaredNormalize(params) : params;
+	const { params: _untypedParams, ...declared } = dataType(id, {
+		...spec,
+		normalize
+	});
+	const texts = spec.texts ?? [];
+	const paramKeys = paramKeysOf(declared.id, spec.params);
+	for (const text of texts) checkText(declared.id, text, paramKeys);
+	checkMarks(declared.id, texts);
+	checkKindClaim(declared.id, spec);
+	checkStoredAs(declared.id, spec);
+	const type = {
+		...declared,
+		...ifDefined("params", spec.params),
+		sql: {
+			texts,
+			claimsKind: spec.claimsKind,
+			storedAs: spec.storedAs,
+			normalize,
+			render: spec.render,
+			fromReported: spec.fromReported,
+			nameIsCatalogText: spec.nameIsCatalogText === true
+		}
+	};
+	checkNormalFormsWritten(type);
+	return type;
+}
+/** Whether the name of `type` is the text the database catalog prints, as declared by {@link SqlDataTypeSpec.nameIsCatalogText}. */
+function nameIsCatalogText(type) {
+	return type.sql.nameIsCatalogText;
+}
+/** Whether `type` is a data type a SQL column can have. `sql/expression` is the one data type no column has. */
+function isSqlDataType(type) {
+	return "sql" in type;
+}
+function presentKeys(params) {
+	return Object.keys(params).filter((key) => params[key] !== void 0);
+}
+function formatKeys(keys) {
+	return `[${[...keys].sort().join(", ")}]`;
+}
+/** The parameters, when `type` accepts them; otherwise `CONTRACT.TYPE_PARAMS_INVALID` naming each parameter it refuses. */
+function validateSqlTypeParams(type, params) {
+	assertDataTypeParams(type, params);
+	return blindCast(params);
+}
+function pickText(type, mark, keys) {
+	const candidates = type.sql.texts.filter((text) => text[mark] === true);
+	const wanted = [...keys].sort().join(",");
+	const found = candidates.find((text) => placeholderSetOf(text.text) === wanted);
+	if (found !== void 0) return found;
+	const verb = mark === "written" ? "written" : "reported";
+	const takes = candidates.length === 0 ? `it is never ${verb}` : `it is ${verb} with ${candidates.map((text) => formatKeys(placeholdersOf(text.text))).join(", ")}`;
+	throw contractError("CONTRACT.TYPE_PARAMS_INVALID", `${type.id} cannot be ${verb} with parameters ${formatKeys(keys)}; ${takes}`, { meta: {
+		dataType: type.id,
+		parameters: [...keys]
+	} });
+}
+function substitute(type, text, params) {
+	return (text.display ?? text.text).replace(PLACEHOLDER, (_, name) => {
+		const value = params[name];
+		if (!Number.isSafeInteger(value)) throw contractError("CONTRACT.TYPE_PARAMS_INVALID", `${type.id}: the parameter ${name} is written into the type name and must be an integer`, { meta: {
+			dataType: type.id,
+			parameters: [name]
+		} });
+		return String(value);
+	});
+}
+/**
+* The name of `type` with no parameters, for places where parameters must not appear, such as a
+* cast. A type whose name is its catalog text has none: its parameters cannot be separated from its
+* name, so it is refused.
+*/
+function sqlBaseName(type, params) {
+	if (type.sql.nameIsCatalogText) throw new InternalError(`Data type ${type.id} names its type by its catalog text, so it has no base name.`);
+	if (type.sql.render !== void 0) return type.sql.render(validateSqlTypeParams(type, params));
+	const fewest = type.sql.texts.filter((text) => text.written === true).reduce((best, text) => best === void 0 || placeholdersOf(text.text).length < placeholdersOf(best.text).length ? text : best, void 0);
+	if (fewest === void 0) throw new InternalError(`Data type ${type.id} has no written text and no render, so it has no base name.`);
+	const name = fewest.display ?? fewest.text;
+	if (placeholdersOf(fewest.text).length === 0) return name;
+	const bracket = name.indexOf("(");
+	return bracket === -1 ? name : name.slice(0, bracket);
+}
+/**
+* The base name of `type` with `params`, unquoted, for display. It differs from {@link sqlBaseName}
+* for a type that claims a kind, where it is the `typeName` parameter as written (`app.status`)
+* while `sqlBaseName` gives the quoted name `render` writes into SQL (`"app"."status"`), and for a
+* type whose name is its catalog text, where it is that whole text.
+*/
+function unquotedSqlBaseName(type, params) {
+	if (type.sql.nameIsCatalogText) return renderSqlTypeName(type, params);
+	if (type.sql.claimsKind === void 0) return sqlBaseName(type, params);
+	const { typeName } = validateSqlTypeParams(type, params);
+	if (typeof typeName !== "string") throw new InternalError(`Data type ${type.id} claims the kind "${type.sql.claimsKind}" but declares no string typeName parameter.`);
+	return typeName;
+}
+const ADD_THE_CODEC_PACK = "Add the pack that provides the codec, and so declares its data type, to the configuration: to `extensions` in prisma.config or in defineContract.";
+/** The SQL data type the codec `codecId` represents. */
+function sqlDataTypeOfCodec(codecId, lookups) {
+	const descriptor = lookups.codecLookup.descriptorFor(codecId);
+	if (descriptor === void 0) throw contractError("CONTRACT.CODEC_DESCRIPTOR_MISSING", `No codec "${codecId}" is registered, so its column type cannot be named.`, {
+		fix: ADD_THE_CODEC_PACK,
+		meta: { codecId }
+	});
+	const type = lookups.dataTypeLookup.get(descriptor.dataType);
+	if (type === void 0) throw contractError("CONTRACT.DATA_TYPE_UNREGISTERED", `Codec "${codecId}" represents data type "${descriptor.dataType}", which no component registers.`, {
+		fix: ADD_THE_CODEC_PACK,
+		meta: {
+			codecId,
+			dataType: descriptor.dataType
+		}
+	});
+	if (!isSqlDataType(type)) throw new InternalError(`Data type ${type.id} is not a SQL data type, so it has no type name.`);
+	return type;
+}
+/**
+* The length of a column of data type `type` with `typeParams`, in the type's normal form, as verify compares it: a bare Postgres `character` holds 1. `undefined` when the column has no length, or when its data type drops the length because the database does not limit it, as SQLite's text types do.
+*/
+function sqlColumnLength(type, typeParams) {
+	if (type === void 0 || !isSqlDataType(type)) return void 0;
+	const length = type.sql.normalize(dataTypeParams(type, typeParams ?? {}))["length"];
+	return typeof length === "number" ? length : void 0;
+}
+/** The length of a column of `codecId` in its data type's normal form, or `undefined` for a column with no length or one whose database does not limit it. */
+function sqlCodecColumnLength(dataTypes, codecId, typeParams) {
+	const dataTypeId = dataTypes.dataTypeOfCodec(codecId);
+	return sqlColumnLength(dataTypeId === void 0 ? void 0 : dataTypes.lookup.get(dataTypeId), typeParams);
+}
+/** The type a column of `type` is stored as, whose name DDL writes and the database reports: `type` itself unless it names another. */
+function sqlStorageType(type, lookup) {
+	if (type.sql.storedAs === void 0) return type;
+	const storage = lookup.get(type.sql.storedAs);
+	if (storage === void 0 || !isSqlDataType(storage)) throw contractError("CONTRACT.DATA_TYPE_UNREGISTERED", `Data type "${type.id}" is stored as "${type.sql.storedAs}", which no component registers as a SQL data type.`, { meta: {
+		dataType: type.sql.storedAs,
+		storedBy: type.id
+	} });
+	return storage;
+}
+/** The id of the type a column of the data type `dataTypeId` is stored as: {@link sqlStorageType} of it, which refuses a storage type the lookup does not register, or `dataTypeId` itself when the lookup does not know it as a SQL data type. */
+function sqlStorageTypeId(dataTypeId, lookup) {
+	const type = lookup.get(dataTypeId);
+	return type !== void 0 && isSqlDataType(type) ? sqlStorageType(type, lookup).id : dataTypeId;
+}
+/** The type a column is stored as, with its parameters in normal form, or the column's own id and parameters as written when the lookup does not know its data type as a SQL data type. */
+function storedColumnType(column, lookup) {
+	const type = lookup.get(column.dataType);
+	if (type === void 0 || !isSqlDataType(type)) return {
+		id: column.dataType,
+		params: column.typeParams ?? {}
+	};
+	const storage = sqlStorageType(type, lookup);
+	return {
+		id: storage.id,
+		params: storage.sql.normalize(dataTypeParams(storage, column.typeParams ?? {}))
+	};
+}
+/**
+* Whether two contract columns have the same type: the types their data types are stored as are one type, those types' parameters are equal in normal form, and both or neither are lists. ADR 254.
+*/
+function sameSqlColumnType(a, b, lookup) {
+	const isList = (column) => column.many !== void 0 && column.many !== false;
+	const left = storedColumnType(a, lookup);
+	const right = storedColumnType(b, lookup);
+	return left.id === right.id && canonicalizeJson(left.params) === canonicalizeJson(right.params) && isList(a) === isList(b);
+}
+/** The type a column of the codec `codecId` is stored as: {@link sqlStorageType} of the data type it represents. */
+function sqlStorageTypeOfCodec(codecId, lookups) {
+	return sqlStorageType(sqlDataTypeOfCodec(codecId, lookups), lookups.dataTypeLookup);
+}
+/** {@link unquotedSqlBaseName} of the type a column of the codec `codecId` is stored as. */
+function unquotedSqlBaseNameOfCodec(codecId, typeParams, lookups) {
+	const type = sqlStorageTypeOfCodec(codecId, lookups);
+	return unquotedSqlBaseName(type, dataTypeParams(type, typeParams));
+}
+/** The text a migration writes for `type` with the raw `params`. */
+function renderSqlTypeName(type, params) {
+	const validated = validateSqlTypeParams(type, params);
+	if (type.sql.render !== void 0) return type.sql.render(validated);
+	const normalized = type.sql.normalize(validated);
+	return substitute(type, pickText(type, "written", presentKeys(params).filter((key) => Object.hasOwn(normalized, key))), params);
+}
+/** The text the database catalog prints for `type` with `params`, in their normal form. */
+function renderSqlCatalogText(type, params) {
+	const validated = validateSqlTypeParams(type, params);
+	if (type.sql.claimsKind !== void 0) throw new InternalError(`Data type ${type.id} claims the kind "${type.sql.claimsKind}" and has no catalog text.`);
+	if (type.sql.render !== void 0) return type.sql.render(validated);
+	const normalized = type.sql.normalize(validated);
+	return substitute(type, pickText(type, "catalog", presentKeys(normalized)), normalized);
+}
+function prepareReportedText(text) {
+	let prepared = "";
+	let quoted = false;
+	let spacePending = false;
+	for (const character of text.trim()) {
+		if (!quoted && /\s/.test(character)) {
+			spacePending = true;
+			continue;
+		}
+		if (spacePending && !/[(,]$/.test(prepared) && character !== ")") prepared += " ";
+		spacePending = false;
+		if (character === "\"") quoted = !quoted;
+		prepared += quoted ? character : character.toLowerCase();
+	}
+	return prepared;
+}
+function claims(text) {
+	return text.catalog === true || text.written !== true;
+}
+function claimingTexts(type) {
+	return type.sql.texts.filter(claims).map((text) => text.text);
+}
+function textsCollide(a, b) {
+	const withOnes = (text) => text.replace(PLACEHOLDER, "1");
+	return patternOf(a).test(withOnes(b)) || patternOf(b).test(withOnes(a));
+}
+function collisionBetween(first, second) {
+	const kind = first.sql.claimsKind;
+	if (kind !== void 0 && kind === second.sql.claimsKind) return {
+		by: "kind",
+		kind
+	};
+	for (const a of claimingTexts(first)) {
+		const b = claimingTexts(second).find((text) => textsCollide(a, text));
+		if (b !== void 0) return {
+			by: "text",
+			first: a,
+			second: b
+		};
+	}
+}
+/**
+* The first two SQL data types in `types` that would both recognise one reported type: a claiming
+* text of each collides, or both claim the same kind. Two texts collide when either one's pattern
+* matches the other with each placeholder written as 1.
+*/
+function findSqlDataTypeCollision(types) {
+	const sqlTypes = types.filter(isSqlDataType);
+	for (const [index, first] of sqlTypes.entries()) for (const second of sqlTypes.slice(index + 1)) {
+		const claims = collisionBetween(first, second);
+		if (claims !== void 0) return {
+			first,
+			second,
+			claims
+		};
+	}
+}
+/**
+* The data type that claims a reported type, with its parameters in normal form, or undefined when
+* no type in `dataTypes` claims it or its parameters fail the type's schema.
+*/
+function resolveReportedSqlType(reported, dataTypes) {
+	const sqlTypes = dataTypes.filter(isSqlDataType);
+	if (reported.kind !== void 0) {
+		const claimant = sqlTypes.find((type) => type.sql.claimsKind === reported.kind);
+		if (claimant === void 0) return void 0;
+		return resolvedWith(claimant, claimant.sql.fromReported?.(reported) ?? {});
+	}
+	const text = prepareReportedText(reported.text);
+	for (const type of sqlTypes) for (const candidate of type.sql.texts) {
+		if (!claims(candidate)) continue;
+		const params = paramsMatching(type, candidate, text);
+		if (params !== void 0) return resolvedWith(type, params);
+	}
+}
+const signedParamKeysByType = /* @__PURE__ */ new WeakMap();
+/** The parameters of `type` that may be negative, whose placeholders read a leading minus. */
+function signedParamKeys(type) {
+	const known = signedParamKeysByType.get(type);
+	if (known !== void 0) return known;
+	const keys = schemaKeysAllowing(type.params, -1) ?? [];
+	signedParamKeysByType.set(type, keys);
+	return keys;
+}
+function paramsMatching(type, candidate, text) {
+	const match = patternOf(candidate.text, signedParamKeys(type)).exec(text);
+	if (match === null) return void 0;
+	return Object.fromEntries(placeholdersOf(candidate.text).map((name, index) => [name, Number.parseInt(match[index + 1] ?? "", 10)]));
+}
+/**
+* Every data type in `dataTypes` that reads `text` as a migration may write it, with its parameters
+* in normal form: any of a type's texts counts, whether written, printed by the catalog or only
+* claimed. Empty when no type reads it or its parameters fail the type's schema. A type that claims
+* a kind has no texts, so it never reads one.
+*/
+function resolveWrittenSqlTypes(text, dataTypes) {
+	const prepared = prepareReportedText(text);
+	return dataTypes.filter(isSqlDataType).flatMap((type) => {
+		for (const candidate of type.sql.texts) {
+			const params = paramsMatching(type, candidate, prepared);
+			if (params === void 0) continue;
+			const resolved = resolvedWith(type, params);
+			if (resolved !== void 0) return [resolved];
+		}
+		return [];
+	});
+}
+function resolvedWith(type$1, params) {
+	if (type$1.params !== void 0 && type$1.params(params) instanceof type.errors) return void 0;
+	return {
+		dataType: type$1,
+		typeParams: type$1.sql.normalize(params)
+	};
+}
+//#endregion
+export { unquotedSqlBaseName as _, renderSqlTypeName as a, sameSqlColumnType as c, sqlColumnLength as d, sqlDataType as f, sqlStorageTypeOfCodec as g, sqlStorageTypeId as h, renderSqlCatalogText as i, sqlBaseName as l, sqlStorageType as m, isSqlDataType as n, resolveReportedSqlType as o, sqlDataTypeOfCodec as p, nameIsCatalogText as r, resolveWrittenSqlTypes as s, findSqlDataTypeCollision as t, sqlCodecColumnLength as u, unquotedSqlBaseNameOfCodec as v, validateSqlTypeParams as y };
+
+//# sourceMappingURL=sql-data-type-D7M-YTTY-D2vRqDxn.mjs.map

package/dist/sql-data-type-D7M-YTTY-D2vRqDxn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-data-type-D7M-YTTY-D2vRqDxn.mjs","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/sql-data-type-D7M-YTTY.mjs"],"sourcesContent":["import { t as contractError } from \"./contract-errors-BCN6RVI5.mjs\";\nimport { ifDefined } from \"@internal/utils/defined\";\nimport { assertDataTypeParams, dataType, dataTypeParams, objectSchemaKeys, schemaKeysAllowing } from \"@internal/framework-components/codec\";\nimport { canonicalizeJson } from \"@internal/framework-components/utils\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { InternalError } from \"@internal/utils/internal-error\";\nimport { type } from \"arktype\";\n//#region src/sql-data-type.ts\nconst PLACEHOLDER = /\\{([A-Za-z][A-Za-z0-9]*)\\}/g;\nconst LITERAL_CHARACTERS = /^[a-z0-9_ (),.]*$/;\nconst REGEXP_SPECIAL = /[.*+?^${}()|[\\]\\\\]/g;\nfunction paramKeysOf(id, schema) {\n\tif (schema === void 0) return [];\n\tconst keys = objectSchemaKeys(schema);\n\tif (keys === void 0) refuseDeclaration(id, \"its parameter schema must be an arktype object schema.\");\n\treturn keys;\n}\nfunction placeholdersOf(text) {\n\treturn [...text.matchAll(PLACEHOLDER)].map((match) => match[1] ?? \"\");\n}\nfunction placeholderSetOf(text) {\n\treturn [...placeholdersOf(text)].sort().join(\",\");\n}\nfunction patternOf(text, signedKeys = []) {\n\tconst placeholders = text.replace(REGEXP_SPECIAL, \"\\\\$&\").replace(/\\\\\\{([A-Za-z][A-Za-z0-9]*)\\\\\\}/g, (_, name) => signedKeys.includes(name) ? \"(-?\\\\d+)\" : \"(\\\\d+)\");\n\treturn new RegExp(`^${placeholders}$`);\n}\nfunction refuseDeclaration(id, why) {\n\tthrow new InternalError(`Data type ${id}: ${why}`);\n}\nfunction checkText(id, text, paramKeys) {\n\tconst quoted = JSON.stringify(text.text);\n\tconst refuse = (why) => refuseDeclaration(id, `the text ${quoted} ${why}.`);\n\tif (text.text === \"\") refuse(\"is empty\");\n\tif (text.text !== text.text.trim()) refuse(\"starts or ends with a space\");\n\tif (text.text.includes(\"  \")) refuse(\"has two spaces in a row\");\n\tconst literal = text.text.replace(PLACEHOLDER, \"\");\n\tif (literal.includes(\"{\") || literal.includes(\"}\")) refuse(\"has a placeholder that is not written {name}\");\n\tif (!LITERAL_CHARACTERS.test(literal)) refuse(\"must be lower case and contain only letters, digits, spaces, brackets, commas, dots, underscores and placeholders\");\n\tfor (const name of placeholdersOf(text.text)) if (!paramKeys.includes(name)) refuse(`names the parameter {${name}}, which the type does not declare`);\n\tif (text.display === void 0) return;\n\tconst display = JSON.stringify(text.display);\n\tif (text.display.toLowerCase() !== text.text.toLowerCase()) refuse(`has the display ${display}, which differs from it beyond letter case`);\n\tif (placeholdersOf(text.display).join(\",\") !== placeholdersOf(text.text).join(\",\")) refuse(`has the display ${display}, which writes a placeholder differently`);\n}\nfunction checkMarks(id, texts) {\n\tconst marked = /* @__PURE__ */ new Map();\n\tfor (const text of texts) {\n\t\tconst key = placeholderSetOf(text.text);\n\t\tconst entry = marked.get(key) ?? {};\n\t\tfor (const mark of [\"written\", \"catalog\"]) {\n\t\t\tif (text[mark] !== true) continue;\n\t\t\tconst other = entry[mark];\n\t\t\tif (other !== void 0) refuseDeclaration(id, `the texts ${JSON.stringify(other)} and ${JSON.stringify(text.text)} have the same placeholders and are both ${mark}.`);\n\t\t\tentry[mark] = text.text;\n\t\t}\n\t\tmarked.set(key, entry);\n\t}\n}\nfunction checkKindClaim(id, spec) {\n\tif (spec.nameIsCatalogText === true) {\n\t\tif (spec.render === void 0) refuseDeclaration(id, \"a type whose name is its catalog text declares render.\");\n\t\tif (spec.texts !== void 0 || spec.claimsKind !== void 0) refuseDeclaration(id, \"a type whose name is its catalog text declares no texts and claims no kind.\");\n\t}\n\tif (spec.claimsKind === void 0) {\n\t\tif (spec.render !== void 0 && spec.nameIsCatalogText !== true) refuseDeclaration(id, \"render is allowed only together with claimsKind or nameIsCatalogText.\");\n\t\tif (spec.fromReported !== void 0) refuseDeclaration(id, \"fromReported is allowed only together with claimsKind.\");\n\t\treturn;\n\t}\n\tif (spec.texts !== void 0) refuseDeclaration(id, \"a type that claims a kind declares no texts.\");\n}\nfunction checkStoredAs(id, spec) {\n\tif (spec.storedAs === void 0) return;\n\tif (spec.texts !== void 0) refuseDeclaration(id, \"a type stored as another declares no texts; its name is the name of the type it is stored as.\");\n\tif (spec.claimsKind !== void 0) refuseDeclaration(id, \"a type stored as another claims no kind.\");\n}\nconst identity = (params) => params;\nfunction isParamsOf(schema, params) {\n\treturn schema === void 0 || !(schema(params) instanceof type.errors);\n}\nfunction checkNormalFormsWritten(type) {\n\tconst written = new Set(type.sql.texts.filter((text) => text.written === true).map((text) => placeholderSetOf(text.text)));\n\tif (written.size === 0) return;\n\tconst probes = [{}, ...type.sql.texts.map((text) => Object.fromEntries(placeholdersOf(text.text).map((name) => [name, 1])))];\n\tfor (const probe of probes) {\n\t\tif (!isParamsOf(type.params, probe)) continue;\n\t\tconst normalKeys = presentKeys(type.sql.normalize(probe));\n\t\tif (!written.has([...normalKeys].sort().join(\",\"))) refuseDeclaration(type.id, `the parameters ${formatKeys(Object.keys(probe))} have the normal form ${formatKeys(normalKeys)}, which no written text takes.`);\n\t}\n}\n/** Declare a SQL data type, refusing a declaration that breaks a rule of the module. */\nfunction sqlDataType(id, spec) {\n\tconst declaredNormalize = spec.normalize ?? identity;\n\tconst normalize = (params) => isParamsOf(spec.params, params) ? declaredNormalize(params) : params;\n\tconst { params: _untypedParams, ...declared } = dataType(id, {\n\t\t...spec,\n\t\tnormalize\n\t});\n\tconst texts = spec.texts ?? [];\n\tconst paramKeys = paramKeysOf(declared.id, spec.params);\n\tfor (const text of texts) checkText(declared.id, text, paramKeys);\n\tcheckMarks(declared.id, texts);\n\tcheckKindClaim(declared.id, spec);\n\tcheckStoredAs(declared.id, spec);\n\tconst type = {\n\t\t...declared,\n\t\t...ifDefined(\"params\", spec.params),\n\t\tsql: {\n\t\t\ttexts,\n\t\t\tclaimsKind: spec.claimsKind,\n\t\t\tstoredAs: spec.storedAs,\n\t\t\tnormalize,\n\t\t\trender: spec.render,\n\t\t\tfromReported: spec.fromReported,\n\t\t\tnameIsCatalogText: spec.nameIsCatalogText === true\n\t\t}\n\t};\n\tcheckNormalFormsWritten(type);\n\treturn type;\n}\n/** Whether the name of `type` is the text the database catalog prints, as declared by {@link SqlDataTypeSpec.nameIsCatalogText}. */\nfunction nameIsCatalogText(type) {\n\treturn type.sql.nameIsCatalogText;\n}\n/** Whether `type` is a data type a SQL column can have. `sql/expression` is the one data type no column has. */\nfunction isSqlDataType(type) {\n\treturn \"sql\" in type;\n}\nfunction presentKeys(params) {\n\treturn Object.keys(params).filter((key) => params[key] !== void 0);\n}\nfunction formatKeys(keys) {\n\treturn `[${[...keys].sort().join(\", \")}]`;\n}\n/** The parameters, when `type` accepts them; otherwise `CONTRACT.TYPE_PARAMS_INVALID` naming each parameter it refuses. */\nfunction validateSqlTypeParams(type, params) {\n\tassertDataTypeParams(type, params);\n\treturn blindCast(params);\n}\nfunction pickText(type, mark, keys) {\n\tconst candidates = type.sql.texts.filter((text) => text[mark] === true);\n\tconst wanted = [...keys].sort().join(\",\");\n\tconst found = candidates.find((text) => placeholderSetOf(text.text) === wanted);\n\tif (found !== void 0) return found;\n\tconst verb = mark === \"written\" ? \"written\" : \"reported\";\n\tconst takes = candidates.length === 0 ? `it is never ${verb}` : `it is ${verb} with ${candidates.map((text) => formatKeys(placeholdersOf(text.text))).join(\", \")}`;\n\tthrow contractError(\"CONTRACT.TYPE_PARAMS_INVALID\", `${type.id} cannot be ${verb} with parameters ${formatKeys(keys)}; ${takes}`, { meta: {\n\t\tdataType: type.id,\n\t\tparameters: [...keys]\n\t} });\n}\nfunction substitute(type, text, params) {\n\treturn (text.display ?? text.text).replace(PLACEHOLDER, (_, name) => {\n\t\tconst value = params[name];\n\t\tif (!Number.isSafeInteger(value)) throw contractError(\"CONTRACT.TYPE_PARAMS_INVALID\", `${type.id}: the parameter ${name} is written into the type name and must be an integer`, { meta: {\n\t\t\tdataType: type.id,\n\t\t\tparameters: [name]\n\t\t} });\n\t\treturn String(value);\n\t});\n}\n/**\n* The name of `type` with no parameters, for places where parameters must not appear, such as a\n* cast. A type whose name is its catalog text has none: its parameters cannot be separated from its\n* name, so it is refused.\n*/\nfunction sqlBaseName(type, params) {\n\tif (type.sql.nameIsCatalogText) throw new InternalError(`Data type ${type.id} names its type by its catalog text, so it has no base name.`);\n\tif (type.sql.render !== void 0) return type.sql.render(validateSqlTypeParams(type, params));\n\tconst fewest = type.sql.texts.filter((text) => text.written === true).reduce((best, text) => best === void 0 || placeholdersOf(text.text).length < placeholdersOf(best.text).length ? text : best, void 0);\n\tif (fewest === void 0) throw new InternalError(`Data type ${type.id} has no written text and no render, so it has no base name.`);\n\tconst name = fewest.display ?? fewest.text;\n\tif (placeholdersOf(fewest.text).length === 0) return name;\n\tconst bracket = name.indexOf(\"(\");\n\treturn bracket === -1 ? name : name.slice(0, bracket);\n}\n/**\n* The base name of `type` with `params`, unquoted, for display. It differs from {@link sqlBaseName}\n* for a type that claims a kind, where it is the `typeName` parameter as written (`app.status`)\n* while `sqlBaseName` gives the quoted name `render` writes into SQL (`\"app\".\"status\"`), and for a\n* type whose name is its catalog text, where it is that whole text.\n*/\nfunction unquotedSqlBaseName(type, params) {\n\tif (type.sql.nameIsCatalogText) return renderSqlTypeName(type, params);\n\tif (type.sql.claimsKind === void 0) return sqlBaseName(type, params);\n\tconst { typeName } = validateSqlTypeParams(type, params);\n\tif (typeof typeName !== \"string\") throw new InternalError(`Data type ${type.id} claims the kind \"${type.sql.claimsKind}\" but declares no string typeName parameter.`);\n\treturn typeName;\n}\nconst ADD_THE_CODEC_PACK = \"Add the pack that provides the codec, and so declares its data type, to the configuration: to `extensions` in prisma.config or in defineContract.\";\n/** The SQL data type the codec `codecId` represents. */\nfunction sqlDataTypeOfCodec(codecId, lookups) {\n\tconst descriptor = lookups.codecLookup.descriptorFor(codecId);\n\tif (descriptor === void 0) throw contractError(\"CONTRACT.CODEC_DESCRIPTOR_MISSING\", `No codec \"${codecId}\" is registered, so its column type cannot be named.`, {\n\t\tfix: ADD_THE_CODEC_PACK,\n\t\tmeta: { codecId }\n\t});\n\tconst type = lookups.dataTypeLookup.get(descriptor.dataType);\n\tif (type === void 0) throw contractError(\"CONTRACT.DATA_TYPE_UNREGISTERED\", `Codec \"${codecId}\" represents data type \"${descriptor.dataType}\", which no component registers.`, {\n\t\tfix: ADD_THE_CODEC_PACK,\n\t\tmeta: {\n\t\t\tcodecId,\n\t\t\tdataType: descriptor.dataType\n\t\t}\n\t});\n\tif (!isSqlDataType(type)) throw new InternalError(`Data type ${type.id} is not a SQL data type, so it has no type name.`);\n\treturn type;\n}\n/**\n* The length of a column of data type `type` with `typeParams`, in the type's normal form, as verify compares it: a bare Postgres `character` holds 1. `undefined` when the column has no length, or when its data type drops the length because the database does not limit it, as SQLite's text types do.\n*/\nfunction sqlColumnLength(type, typeParams) {\n\tif (type === void 0 || !isSqlDataType(type)) return void 0;\n\tconst length = type.sql.normalize(dataTypeParams(type, typeParams ?? {}))[\"length\"];\n\treturn typeof length === \"number\" ? length : void 0;\n}\n/** The length of a column of `codecId` in its data type's normal form, or `undefined` for a column with no length or one whose database does not limit it. */\nfunction sqlCodecColumnLength(dataTypes, codecId, typeParams) {\n\tconst dataTypeId = dataTypes.dataTypeOfCodec(codecId);\n\treturn sqlColumnLength(dataTypeId === void 0 ? void 0 : dataTypes.lookup.get(dataTypeId), typeParams);\n}\n/** The type a column of `type` is stored as, whose name DDL writes and the database reports: `type` itself unless it names another. */\nfunction sqlStorageType(type, lookup) {\n\tif (type.sql.storedAs === void 0) return type;\n\tconst storage = lookup.get(type.sql.storedAs);\n\tif (storage === void 0 || !isSqlDataType(storage)) throw contractError(\"CONTRACT.DATA_TYPE_UNREGISTERED\", `Data type \"${type.id}\" is stored as \"${type.sql.storedAs}\", which no component registers as a SQL data type.`, { meta: {\n\t\tdataType: type.sql.storedAs,\n\t\tstoredBy: type.id\n\t} });\n\treturn storage;\n}\n/** The id of the type a column of the data type `dataTypeId` is stored as: {@link sqlStorageType} of it, which refuses a storage type the lookup does not register, or `dataTypeId` itself when the lookup does not know it as a SQL data type. */\nfunction sqlStorageTypeId(dataTypeId, lookup) {\n\tconst type = lookup.get(dataTypeId);\n\treturn type !== void 0 && isSqlDataType(type) ? sqlStorageType(type, lookup).id : dataTypeId;\n}\n/** The type a column is stored as, with its parameters in normal form, or the column's own id and parameters as written when the lookup does not know its data type as a SQL data type. */\nfunction storedColumnType(column, lookup) {\n\tconst type = lookup.get(column.dataType);\n\tif (type === void 0 || !isSqlDataType(type)) return {\n\t\tid: column.dataType,\n\t\tparams: column.typeParams ?? {}\n\t};\n\tconst storage = sqlStorageType(type, lookup);\n\treturn {\n\t\tid: storage.id,\n\t\tparams: storage.sql.normalize(dataTypeParams(storage, column.typeParams ?? {}))\n\t};\n}\n/**\n* Whether two contract columns have the same type: the types their data types are stored as are one type, those types' parameters are equal in normal form, and both or neither are lists. ADR 254.\n*/\nfunction sameSqlColumnType(a, b, lookup) {\n\tconst isList = (column) => column.many !== void 0 && column.many !== false;\n\tconst left = storedColumnType(a, lookup);\n\tconst right = storedColumnType(b, lookup);\n\treturn left.id === right.id && canonicalizeJson(left.params) === canonicalizeJson(right.params) && isList(a) === isList(b);\n}\n/** The type a column of the codec `codecId` is stored as: {@link sqlStorageType} of the data type it represents. */\nfunction sqlStorageTypeOfCodec(codecId, lookups) {\n\treturn sqlStorageType(sqlDataTypeOfCodec(codecId, lookups), lookups.dataTypeLookup);\n}\n/** {@link unquotedSqlBaseName} of the type a column of the codec `codecId` is stored as. */\nfunction unquotedSqlBaseNameOfCodec(codecId, typeParams, lookups) {\n\tconst type = sqlStorageTypeOfCodec(codecId, lookups);\n\treturn unquotedSqlBaseName(type, dataTypeParams(type, typeParams));\n}\n/** The text a migration writes for `type` with the raw `params`. */\nfunction renderSqlTypeName(type, params) {\n\tconst validated = validateSqlTypeParams(type, params);\n\tif (type.sql.render !== void 0) return type.sql.render(validated);\n\tconst normalized = type.sql.normalize(validated);\n\treturn substitute(type, pickText(type, \"written\", presentKeys(params).filter((key) => Object.hasOwn(normalized, key))), params);\n}\n/** The text the database catalog prints for `type` with `params`, in their normal form. */\nfunction renderSqlCatalogText(type, params) {\n\tconst validated = validateSqlTypeParams(type, params);\n\tif (type.sql.claimsKind !== void 0) throw new InternalError(`Data type ${type.id} claims the kind \"${type.sql.claimsKind}\" and has no catalog text.`);\n\tif (type.sql.render !== void 0) return type.sql.render(validated);\n\tconst normalized = type.sql.normalize(validated);\n\treturn substitute(type, pickText(type, \"catalog\", presentKeys(normalized)), normalized);\n}\nfunction prepareReportedText(text) {\n\tlet prepared = \"\";\n\tlet quoted = false;\n\tlet spacePending = false;\n\tfor (const character of text.trim()) {\n\t\tif (!quoted && /\\s/.test(character)) {\n\t\t\tspacePending = true;\n\t\t\tcontinue;\n\t\t}\n\t\tif (spacePending && !/[(,]$/.test(prepared) && character !== \")\") prepared += \" \";\n\t\tspacePending = false;\n\t\tif (character === \"\\\"\") quoted = !quoted;\n\t\tprepared += quoted ? character : character.toLowerCase();\n\t}\n\treturn prepared;\n}\nfunction claims(text) {\n\treturn text.catalog === true || text.written !== true;\n}\nfunction claimingTexts(type) {\n\treturn type.sql.texts.filter(claims).map((text) => text.text);\n}\nfunction textsCollide(a, b) {\n\tconst withOnes = (text) => text.replace(PLACEHOLDER, \"1\");\n\treturn patternOf(a).test(withOnes(b)) || patternOf(b).test(withOnes(a));\n}\nfunction collisionBetween(first, second) {\n\tconst kind = first.sql.claimsKind;\n\tif (kind !== void 0 && kind === second.sql.claimsKind) return {\n\t\tby: \"kind\",\n\t\tkind\n\t};\n\tfor (const a of claimingTexts(first)) {\n\t\tconst b = claimingTexts(second).find((text) => textsCollide(a, text));\n\t\tif (b !== void 0) return {\n\t\t\tby: \"text\",\n\t\t\tfirst: a,\n\t\t\tsecond: b\n\t\t};\n\t}\n}\n/**\n* The first two SQL data types in `types` that would both recognise one reported type: a claiming\n* text of each collides, or both claim the same kind. Two texts collide when either one's pattern\n* matches the other with each placeholder written as 1.\n*/\nfunction findSqlDataTypeCollision(types) {\n\tconst sqlTypes = types.filter(isSqlDataType);\n\tfor (const [index, first] of sqlTypes.entries()) for (const second of sqlTypes.slice(index + 1)) {\n\t\tconst claims = collisionBetween(first, second);\n\t\tif (claims !== void 0) return {\n\t\t\tfirst,\n\t\t\tsecond,\n\t\t\tclaims\n\t\t};\n\t}\n}\n/**\n* The data type that claims a reported type, with its parameters in normal form, or undefined when\n* no type in `dataTypes` claims it or its parameters fail the type's schema.\n*/\nfunction resolveReportedSqlType(reported, dataTypes) {\n\tconst sqlTypes = dataTypes.filter(isSqlDataType);\n\tif (reported.kind !== void 0) {\n\t\tconst claimant = sqlTypes.find((type) => type.sql.claimsKind === reported.kind);\n\t\tif (claimant === void 0) return void 0;\n\t\treturn resolvedWith(claimant, claimant.sql.fromReported?.(reported) ?? {});\n\t}\n\tconst text = prepareReportedText(reported.text);\n\tfor (const type of sqlTypes) for (const candidate of type.sql.texts) {\n\t\tif (!claims(candidate)) continue;\n\t\tconst params = paramsMatching(type, candidate, text);\n\t\tif (params !== void 0) return resolvedWith(type, params);\n\t}\n}\nconst signedParamKeysByType = /* @__PURE__ */ new WeakMap();\n/** The parameters of `type` that may be negative, whose placeholders read a leading minus. */\nfunction signedParamKeys(type) {\n\tconst known = signedParamKeysByType.get(type);\n\tif (known !== void 0) return known;\n\tconst keys = schemaKeysAllowing(type.params, -1) ?? [];\n\tsignedParamKeysByType.set(type, keys);\n\treturn keys;\n}\nfunction paramsMatching(type, candidate, text) {\n\tconst match = patternOf(candidate.text, signedParamKeys(type)).exec(text);\n\tif (match === null) return void 0;\n\treturn Object.fromEntries(placeholdersOf(candidate.text).map((name, index) => [name, Number.parseInt(match[index + 1] ?? \"\", 10)]));\n}\n/**\n* Every data type in `dataTypes` that reads `text` as a migration may write it, with its parameters\n* in normal form: any of a type's texts counts, whether written, printed by the catalog or only\n* claimed. Empty when no type reads it or its parameters fail the type's schema. A type that claims\n* a kind has no texts, so it never reads one.\n*/\nfunction resolveWrittenSqlTypes(text, dataTypes) {\n\tconst prepared = prepareReportedText(text);\n\treturn dataTypes.filter(isSqlDataType).flatMap((type) => {\n\t\tfor (const candidate of type.sql.texts) {\n\t\t\tconst params = paramsMatching(type, candidate, prepared);\n\t\t\tif (params === void 0) continue;\n\t\t\tconst resolved = resolvedWith(type, params);\n\t\t\tif (resolved !== void 0) return [resolved];\n\t\t}\n\t\treturn [];\n\t});\n}\nfunction resolvedWith(type$1, params) {\n\tif (type$1.params !== void 0 && type$1.params(params) instanceof type.errors) return void 0;\n\treturn {\n\t\tdataType: type$1,\n\t\ttypeParams: type$1.sql.normalize(params)\n\t};\n}\n//#endregion\nexport { unquotedSqlBaseName as _, renderSqlTypeName as a, sameSqlColumnType as c, sqlColumnLength as d, sqlDataType as f, sqlStorageTypeOfCodec as g, sqlStorageTypeId as h, renderSqlCatalogText as i, sqlBaseName as l, sqlStorageType as m, isSqlDataType as n, resolveReportedSqlType as o, sqlDataTypeOfCodec as p, nameIsCatalogText as r, resolveWrittenSqlTypes as s, findSqlDataTypeCollision as t, sqlCodecColumnLength as u, unquotedSqlBaseNameOfCodec as v, validateSqlTypeParams as y };\n\n//# sourceMappingURL=sql-data-type-D7M-YTTY.mjs.map"],"mappings":"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"}

package/dist/{sql-execution-plan--jKyLpe5-CMGhgO0M.d.mts → sql-execution-plan-3uxYjHyu-DLknM-Pj.d.mts}

@@ -1,6 +1,6 @@
-import { m as AnyQueryAst } from "./types-v3qxLLxo-DCeKv7yY.mjs";
+import { h as AnyQueryAst } from "./types-DriMIMNQ-BkbsW7w3.mjs";
 import { ExecutionPlan } from "@prisma/orm-framework/components/runtime";
-//#region ../../../2-sql/4-lanes/relational-core/dist/sql-execution-plan--jKyLpe5.d.mts
+//#region ../../../2-sql-family/4-lanes/relational-core/dist/sql-execution-plan-3uxYjHyu.d.mts
 //#region src/sql-execution-plan.d.ts
 /**
  * SQL-domain execution plan: a query lowered to the wire-level shape that a
@@ -28,4 +28,4 @@ interface SqlExecutionPlan<Row = unknown> extends ExecutionPlan<Row> {
 }
 //#endregion
 export { SqlExecutionPlan as t };
-//# sourceMappingURL=sql-execution-plan--jKyLpe5-CMGhgO0M.d.mts.map
+//# sourceMappingURL=sql-execution-plan-3uxYjHyu-DLknM-Pj.d.mts.map

package/dist/sql-execution-plan-3uxYjHyu-DLknM-Pj.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-execution-plan-3uxYjHyu-DLknM-Pj.d.mts","names":[],"sources":["../../../../2-sql-family/4-lanes/relational-core/dist/sql-execution-plan-3uxYjHyu.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;UAsBU,iBAAiB,uBAAuB,cAAc;WACrD;WACA;WACA,KAAK"}

package/dist/sql-expression-B4BrhGPi.d.mts

@@ -0,0 +1,62 @@
+import { DataTypeAuthoringEntry } from "@prisma/orm-framework/components/authoring";
+import { DataType, DataTypeId } from "@prisma/orm-framework/components/codec";
+import { JsonValue } from "@prisma/orm-framework/contract/types";
+//#region ../../../2-sql-family/1-core/contract/dist/sql-expression.d.mts
+//#region src/sql-expression.d.ts
+declare const SQL_EXPRESSION_DATA_TYPE_ID: DataTypeId;
+declare const SQL_EXPRESSION_TAG = "sql";
+/** The data type of a SQL expression in the target database's language. It declares no casts. The SQL family registers it. ADR 254. */
+declare const sqlExpressionDataType: DataType;
+/** PSL support for `sql/expression`. The SQL family registers it under `SQL_EXPRESSION_DATA_TYPE_ID`. */
+declare const sqlExpressionAuthoringEntry: DataTypeAuthoringEntry;
+interface SqlExpressionRegistration {
+  readonly dataTypes: readonly DataType[];
+  readonly authoring: {
+    readonly dataTypes: Readonly<Record<string, DataTypeAuthoringEntry>>;
+  };
+}
+/** The SQL family's registration of `sql/expression`, shaped as the family descriptor's `dataTypes` and `authoring.dataTypes`. */
+declare const sqlExpressionRegistration: SqlExpressionRegistration;
+/** The SQL text held by the stored form of a `sql/expression` value. */
+declare function sqlTextFromStored(value: JsonValue): string;
+/** The text a `sql` literal holding `text` reads back as, or `undefined` when `text` has a NUL character or is too large. */
+declare function storedSqlText(text: string): string | undefined;
+/**
+ * A `sql` literal holding `text`. Throws when the literal would read back as different text; check with `sqlTextsReadBack`
+ * first. The result of `storedSqlText` always reads back.
+ */
+declare function printSqlExpressionLiteral(text: string): string;
+/** Whether every present text reads back unchanged when printed as a `sql` literal. */
+declare function sqlTextsReadBack(texts: readonly (string | undefined)[]): boolean;
+/**
+ * Throws when a data type declares a cast or a list cast from `sql/expression`. A `sql` literal is
+ * SQL the database runs, so a cast would turn it into a value of another type with no diagnostic.
+ * ADR 254.
+ */
+declare function assertNothingCastsFromSqlExpression(declaredDataTypes: ReadonlyArray<{
+  readonly type: DataType;
+  readonly contributedBy: string;
+}>): void;
+declare const SQL_EXPRESSION_MARKER: unique symbol;
+/** A value of the data type `sql/expression` in TypeScript. Its text is always canonical. */
+declare class SqlExpression {
+  readonly [SQL_EXPRESSION_MARKER]: true;
+  readonly text: string;
+  /** Canonicalizes `text` as a PSL `sql` literal's text is canonicalized. Throws CONTRACT.SQL_EXPRESSION_INVALID on NUL or oversize text. */
+  constructor(text: string);
+}
+/** Whether `value` is a `sql` value, made by this copy of the package or by another one. */
+declare function isSqlExpression(value: unknown): value is SqlExpression;
+/**
+ * This copy's `SqlExpression` for `value`: the value itself when this copy made it, a new one built
+ * from the text of a `sql` value another copy made, so that text is canonicalized here too, or
+ * `undefined` for anything else.
+ */
+declare function readSqlExpression(value: unknown): SqlExpression | undefined;
+/** Raw SQL written as a template literal: `` sql`"userId" = auth.uid()` ``. Other `sql` values may be interpolated; each later line of one takes the indentation of the template line it sits on. */
+declare function sql(strings: TemplateStringsArray, ...values: readonly SqlExpression[]): SqlExpression;
+/** Reads `value` with `readSqlExpression`; throws for anything that is not a `sql` value. For callers that JavaScript cannot type-check. */
+declare function requireSqlExpression(value: unknown, what: string): SqlExpression;
+//#endregion
+export { assertNothingCastsFromSqlExpression as a, readSqlExpression as c, sqlExpressionAuthoringEntry as d, sqlExpressionDataType as f, storedSqlText as g, sqlTextsReadBack as h, SqlExpressionRegistration as i, requireSqlExpression as l, sqlTextFromStored as m, SQL_EXPRESSION_TAG as n, isSqlExpression as o, sqlExpressionRegistration as p, SqlExpression as r, printSqlExpressionLiteral as s, SQL_EXPRESSION_DATA_TYPE_ID as t, sql as u };
+//# sourceMappingURL=sql-expression-B4BrhGPi.d.mts.map

package/dist/sql-expression-B4BrhGPi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-expression-B4BrhGPi.d.mts","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/sql-expression.d.mts"],"mappings":";;;;;cAIc,6BAA6B;cAC7B;;cAEA,uBAAuB;;cAEvB,6BAA6B;UACjC;WACC,oBAAoB;WACpB;aACE,WAAW,SAAS,eAAe;;;;cAIlC,2BAA2B;;iBAExB,kBAAkB,OAAO;;iBAEzB,cAAc;;;;;iBAKd,0BAA0B;;iBAE1B,iBAAiB;;;;;;iBAMjB,oCAAoC,mBAAmB;WAC7D,MAAM;WACN;;cAEG;;cAEA;YACF;WACD;;EAET,YAAY;;;iBAGG,gBAAgB,iBAAiB,SAAS;;;;;;iBAM1C,kBAAkB,iBAAiB;;iBAEnC,IAAI,SAAS,yBAAyB,iBAAiB,kBAAkB;;iBAEzE,qBAAqB,gBAAgB,eAAe"}