@prisma/orm-family-sql 8.0.0-rc.14-dev.29 → 8.0.0-rc.14-dev.30

package/dist/data-type-CAPmGXg9.mjs

@@ -0,0 +1,297 @@
+import { t as contractError } from "./contract-errors-BCN6RVI5-5IHBF_lg.mjs";
+import { dataType, objectSchemaKeys } from "@prisma/orm-framework/components/codec";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { type } from "arktype";
+//#region ../../../2-sql/1-core/contract/dist/data-type.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) {
+	const escaped = text.replace(REGEXP_SPECIAL, "\\$&");
+	return new RegExp(`^${escaped.replace(/\\\{[A-Za-z][A-Za-z0-9]*\\\}/g, "(\\d+)")}$`);
+}
+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.claimsKind === void 0) {
+		if (spec.render !== void 0) refuseDeclaration(id, "render is allowed only together with claimsKind.");
+		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.");
+}
+const identity = (params) => params;
+function acceptsParams(type$1, params) {
+	return type$1.params === void 0 || !(type$1.params(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 (!acceptsParams(type, 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 { params: _untypedParams, ...declared } = dataType(id, spec);
+	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);
+	const type = {
+		...declared,
+		...ifDefined("params", spec.params),
+		sql: {
+			texts,
+			claimsKind: spec.claimsKind,
+			normalize: spec.normalize ?? identity,
+			render: spec.render,
+			fromReported: spec.fromReported
+		}
+	};
+	checkNormalFormsWritten(type);
+	return type;
+}
+/** 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;
+}
+/** The parameters of `typeParams` that `type` declares; codec-owned keys are dropped. */
+function dataTypeParams(type, typeParams) {
+	if (typeParams === void 0) return {};
+	const kept = {};
+	for (const key of paramKeysOf(type.id, type.params)) if (Object.hasOwn(typeParams, key)) kept[key] = typeParams[key];
+	return kept;
+}
+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 at fault. */
+function validateSqlTypeParams(type$2, params) {
+	if (type$2.params === void 0) return blindCast(params);
+	const result = type$2.params(params);
+	if (result instanceof type.errors) throw contractError("CONTRACT.TYPE_PARAMS_INVALID", `${type$2.id}: ${result.summary}`, { meta: {
+		dataType: type$2.id,
+		parameters: [...new Set(result.map((error) => error.path.map(String).join(".")))]
+	} });
+	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. */
+function sqlBaseName(type, params) {
+	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. It differs from {@link sqlBaseName} only for a
+* type that claims a kind: there it is the `typeName` parameter as written (`app.status`), where
+* `sqlBaseName` gives the quoted name `render` writes into SQL (`"app"."status"`).
+*/
+function unquotedSqlBaseName(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;
+}
+/** {@link unquotedSqlBaseName} of the data type the codec `codecId` represents. */
+function unquotedSqlBaseNameOfCodec(codecId, typeParams, lookups) {
+	const type = sqlDataTypeOfCodec(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.`);
+	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 match = patternOf(candidate.text).exec(text);
+		if (match === null) continue;
+		return resolvedWith(type, Object.fromEntries(placeholdersOf(candidate.text).map((name, index) => [name, Number.parseInt(match[index + 1] ?? "", 10)])));
+	}
+}
+function resolvedWith(type$3, params) {
+	if (type$3.params !== void 0 && type$3.params(params) instanceof type.errors) return void 0;
+	return {
+		dataType: type$3.id,
+		typeParams: type$3.sql.normalize(params)
+	};
+}
+//#endregion
+export { renderSqlTypeName as a, sqlDataType as c, unquotedSqlBaseNameOfCodec as d, validateSqlTypeParams as f, renderSqlCatalogText as i, sqlDataTypeOfCodec as l, findSqlDataTypeCollision as n, resolveReportedSqlType as o, isSqlDataType as r, sqlBaseName as s, dataTypeParams as t, unquotedSqlBaseName as u };
+
+//# sourceMappingURL=data-type-CAPmGXg9.mjs.map

package/dist/data-type-CAPmGXg9.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-CAPmGXg9.mjs","names":[],"sources":["../../../../2-sql/1-core/contract/dist/data-type.mjs"],"sourcesContent":["import { t as contractError } from \"./contract-errors-BCN6RVI5.mjs\";\nimport { t as numeralText } from \"./numeral-text-Cqu87pVe.mjs\";\nimport { dataType, objectSchemaKeys } from \"@internal/framework-components/codec\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { ifDefined } from \"@internal/utils/defined\";\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) {\n\tconst escaped = text.replace(REGEXP_SPECIAL, \"\\\\$&\");\n\treturn new RegExp(`^${escaped.replace(/\\\\\\{[A-Za-z][A-Za-z0-9]*\\\\\\}/g, \"(\\\\d+)\")}$`);\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.claimsKind === void 0) {\n\t\tif (spec.render !== void 0) refuseDeclaration(id, \"render is allowed only together with claimsKind.\");\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}\nconst identity = (params) => params;\nfunction acceptsParams(type$1, params) {\n\treturn type$1.params === void 0 || !(type$1.params(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 (!acceptsParams(type, 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 { params: _untypedParams, ...declared } = dataType(id, spec);\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\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\tnormalize: spec.normalize ?? identity,\n\t\t\trender: spec.render,\n\t\t\tfromReported: spec.fromReported\n\t\t}\n\t};\n\tcheckNormalFormsWritten(type);\n\treturn type;\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}\n/** The parameters of `typeParams` that `type` declares; codec-owned keys are dropped. */\nfunction dataTypeParams(type, typeParams) {\n\tif (typeParams === void 0) return {};\n\tconst kept = {};\n\tfor (const key of paramKeysOf(type.id, type.params)) if (Object.hasOwn(typeParams, key)) kept[key] = typeParams[key];\n\treturn kept;\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 at fault. */\nfunction validateSqlTypeParams(type$2, params) {\n\tif (type$2.params === void 0) return blindCast(params);\n\tconst result = type$2.params(params);\n\tif (result instanceof type.errors) throw contractError(\"CONTRACT.TYPE_PARAMS_INVALID\", `${type$2.id}: ${result.summary}`, { meta: {\n\t\tdataType: type$2.id,\n\t\tparameters: [...new Set(result.map((error) => error.path.map(String).join(\".\")))]\n\t} });\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/** The name of `type` with no parameters, for places where parameters must not appear. */\nfunction sqlBaseName(type, params) {\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. It differs from {@link sqlBaseName} only for a\n* type that claims a kind: there it is the `typeName` parameter as written (`app.status`), where\n* `sqlBaseName` gives the quoted name `render` writes into SQL (`\"app\".\"status\"`).\n*/\nfunction unquotedSqlBaseName(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/** {@link unquotedSqlBaseName} of the data type the codec `codecId` represents. */\nfunction unquotedSqlBaseNameOfCodec(codecId, typeParams, lookups) {\n\tconst type = sqlDataTypeOfCodec(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\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 match = patternOf(candidate.text).exec(text);\n\t\tif (match === null) continue;\n\t\treturn resolvedWith(type, Object.fromEntries(placeholdersOf(candidate.text).map((name, index) => [name, Number.parseInt(match[index + 1] ?? \"\", 10)])));\n\t}\n}\nfunction resolvedWith(type$3, params) {\n\tif (type$3.params !== void 0 && type$3.params(params) instanceof type.errors) return void 0;\n\treturn {\n\t\tdataType: type$3.id,\n\t\ttypeParams: type$3.sql.normalize(params)\n\t};\n}\n//#endregion\nexport { dataTypeParams, findSqlDataTypeCollision, isSqlDataType, numeralText, renderSqlCatalogText, renderSqlTypeName, resolveReportedSqlType, sqlBaseName, sqlDataType, sqlDataTypeOfCodec, unquotedSqlBaseName, unquotedSqlBaseNameOfCodec, validateSqlTypeParams };\n\n//# sourceMappingURL=data-type.mjs.map"],"mappings":"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"}

package/dist/data-type-CpqSDmR_.d.mts

@@ -0,0 +1,113 @@
+import { CodecLookupWithDescriptors, DataType, DataTypeId, DataTypeLookup, DataTypeSpec } from "@prisma/orm-framework/components/codec";
+import { Type } from "arktype";
+//#region ../../../2-sql/1-core/contract/dist/data-type.d.mts
+//#region src/numeral-text.d.ts
+/**
+ * A number as a contract source writes it: no exponent, because no schema language has that syntax,
+ * so the decimal point moves to where the exponent puts it. A non-finite number is its own word.
+ */
+declare function numeralText(value: number): string;
+//#endregion
+//#region src/sql-data-type.d.ts
+/** One way a database type is written or reported. */
+interface SqlTypeText {
+  /** Lower case with single spaces; `{name}` stands for the parameter `name`. */
+  readonly text: string;
+  /** A migration writes this text. */
+  readonly written?: true;
+  /** The database catalog prints this text. */
+  readonly catalog?: true;
+  /** The exact characters written and printed, when they differ from `text` in letter case only. */
+  readonly display?: string;
+}
+type SqlTypeParams = Readonly<Record<string, unknown>>;
+/** What introspection hands over about the element type of one column. */
+interface ReportedSqlType {
+  /** The catalog text of the element type. */
+  readonly text: string;
+  /** The target's word for the type's kind, such as `enum`; undefined for a base type. */
+  readonly kind: string | undefined;
+  readonly schema: string | undefined;
+  /** The type's name, unquoted. */
+  readonly name: string | undefined;
+}
+interface SqlDataTypeSpec<Params extends SqlTypeParams = SqlTypeParams> extends DataTypeSpec {
+  readonly params?: Type<Params>;
+  readonly texts?: readonly SqlTypeText[];
+  /** The kind of reported type this data type claims, instead of any text. */
+  readonly claimsKind?: string;
+  readonly normalize?: (params: Params) => Params;
+  readonly render?: (params: Params) => string;
+  readonly fromReported?: (reported: ReportedSqlType) => Params;
+}
+interface SqlDataTypeFacts<Params extends SqlTypeParams = SqlTypeParams> {
+  readonly texts: readonly SqlTypeText[];
+  readonly claimsKind: string | undefined;
+  readonly normalize: (params: Params) => Params;
+  readonly render: ((params: Params) => string) | undefined;
+  readonly fromReported: ((reported: ReportedSqlType) => Params) | undefined;
+}
+interface SqlDataType<Params extends SqlTypeParams = SqlTypeParams> extends DataType {
+  readonly params?: Type<Params>;
+  readonly sql: SqlDataTypeFacts<Params>;
+}
+interface ResolvedSqlType {
+  readonly dataType: DataTypeId;
+  readonly typeParams: SqlTypeParams;
+}
+/** Declare a SQL data type, refusing a declaration that breaks a rule of the module. */
+declare function sqlDataType<Params extends SqlTypeParams = SqlTypeParams>(id: string, spec: SqlDataTypeSpec<Params>): SqlDataType<Params>;
+/** Whether `type` is a data type a SQL column can have. `sql/expression` is the one data type no column has. */
+declare function isSqlDataType(type: DataType): type is SqlDataType;
+/** The parameters of `typeParams` that `type` declares; codec-owned keys are dropped. */
+declare function dataTypeParams(type: DataType, typeParams: SqlTypeParams | undefined): SqlTypeParams;
+/** The parameters, when `type` accepts them; otherwise `CONTRACT.TYPE_PARAMS_INVALID` naming each parameter at fault. */
+declare function validateSqlTypeParams<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): Params;
+/** The name of `type` with no parameters, for places where parameters must not appear. */
+declare function sqlBaseName<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): string;
+/**
+ * The base name of `type` with `params`, unquoted. It differs from {@link sqlBaseName} only for a
+ * type that claims a kind: there it is the `typeName` parameter as written (`app.status`), where
+ * `sqlBaseName` gives the quoted name `render` writes into SQL (`"app"."status"`).
+ */
+declare function unquotedSqlBaseName<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): string;
+/** The lookups that find the data type a codec represents. */
+interface SqlTypeLookups {
+  readonly codecLookup: Pick<CodecLookupWithDescriptors, 'descriptorFor'>;
+  readonly dataTypeLookup: Pick<DataTypeLookup, 'get'>;
+}
+/** The SQL data type the codec `codecId` represents. */
+declare function sqlDataTypeOfCodec(codecId: string, lookups: SqlTypeLookups): SqlDataType;
+/** {@link unquotedSqlBaseName} of the data type the codec `codecId` represents. */
+declare function unquotedSqlBaseNameOfCodec(codecId: string, typeParams: SqlTypeParams | undefined, lookups: SqlTypeLookups): string;
+/** The text a migration writes for `type` with the raw `params`. */
+declare function renderSqlTypeName<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): string;
+/** The text the database catalog prints for `type` with `params`, in their normal form. */
+declare function renderSqlCatalogText<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): string;
+/** Two SQL data types that would both recognise one reported type, and what each claims. */
+interface SqlDataTypeCollision {
+  readonly first: SqlDataType;
+  readonly second: SqlDataType;
+  readonly claims: {
+    readonly by: 'text';
+    readonly first: string;
+    readonly second: string;
+  } | {
+    readonly by: 'kind';
+    readonly kind: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function findSqlDataTypeCollision(types: readonly DataType[]): SqlDataTypeCollision | undefined;
+/**
+ * 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.
+ */
+declare function resolveReportedSqlType(reported: ReportedSqlType, dataTypes: readonly DataType[]): ResolvedSqlType | undefined;
+//#endregion
+export { validateSqlTypeParams as S, sqlBaseName as _, SqlDataTypeFacts as a, unquotedSqlBaseName as b, SqlTypeParams as c, findSqlDataTypeCollision as d, isSqlDataType as f, resolveReportedSqlType as g, renderSqlTypeName as h, SqlDataTypeCollision as i, SqlTypeText as l, renderSqlCatalogText as m, ResolvedSqlType as n, SqlDataTypeSpec as o, numeralText as p, SqlDataType as r, SqlTypeLookups as s, ReportedSqlType as t, dataTypeParams as u, sqlDataType as v, unquotedSqlBaseNameOfCodec as x, sqlDataTypeOfCodec as y };
+//# sourceMappingURL=data-type-CpqSDmR_.d.mts.map

package/dist/data-type-CpqSDmR_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-CpqSDmR_.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/data-type.d.mts"],"mappings":";;;;;;;;iBAOiB,YAAY;;;;UAInB;;WAEC;;WAEA;;WAEA;;WAEA;;KAEN,gBAAgB,SAAS;;UAEpB;;WAEC;;WAEA;WACA;;WAEA;;UAED,gBAAgB,eAAe,gBAAgB,uBAAuB;WACrE,SAAS,KAAK;WACd,iBAAiB;;WAEjB;WACA,aAAa,QAAQ,WAAW;WAChC,UAAU,QAAQ;WAClB,gBAAgB,UAAU,oBAAoB;;UAE/C,iBAAiB,eAAe,gBAAgB;WAC/C,gBAAgB;WAChB;WACA,YAAY,QAAQ,WAAW;WAC/B,UAAU,QAAQ;WAClB,gBAAgB,UAAU,oBAAoB;;UAE/C,YAAY,eAAe,gBAAgB,uBAAuB;WACjE,SAAS,KAAK;WACd,KAAK,iBAAiB;;UAEvB;WACC,UAAU;WACV,YAAY;;;iBAGN,YAAY,eAAe,gBAAgB,eAAe,YAAY,MAAM,gBAAgB,UAAU,YAAY;;iBAElH,cAAc,MAAM,WAAW,QAAQ;;iBAEvC,eAAe,MAAM,UAAU,YAAY,4BAA4B;;iBAEvE,sBAAsB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ,gBAAgB;;iBAEvG,YAAY,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;;;;;iBAM7E,oBAAoB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;UAE5F;WACC,aAAa,KAAK;WAClB,gBAAgB,KAAK;;;iBAGf,mBAAmB,iBAAiB,SAAS,iBAAiB;;iBAE9D,2BAA2B,iBAAiB,YAAY,2BAA2B,SAAS;;iBAE5F,kBAAkB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;iBAEnF,qBAAqB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;UAE7F;WACC,OAAO;WACP,QAAQ;WACR;aACE;aACA;aACA;;aAEA;aACA;;;;;;;;iBAQI,yBAAyB,gBAAgB,aAAa;;;;;iBAKtD,uBAAuB,UAAU,iBAAiB,oBAAoB,aAAa"}

package/dist/data-type-support-B_Dr1cxB.d.mts

@@ -0,0 +1,92 @@
+import { DataTypeId, ToCanonicalForm } from "@prisma/orm-framework/components/codec";
+import { JsonValue } from "@prisma/orm-framework/contract/types";
+//#region ../../../2-sql/1-core/contract/dist/data-type-support.d.mts
+//#region src/data-type-support.d.ts
+/** Whether `text` is a whole number or a decimal as a contract source writes one. */
+declare function isNumeralText(text: string): boolean;
+/**
+ * A written numeral as the contract stores it. Leading zeros and the sign of zero never change a
+ * number, so they go; trailing zeros stay, because a type without a scale keeps them.
+ */
+declare function canonicalNumeralText(text: string): string;
+/**
+ * The canonical form of a 64-bit integer type: digit text. A database reads an integer default back as a number when it is a safe integer, so a safe integer reads as its digit text too; any other number may already have lost digits and is refused.
+ */
+declare const integerTextCanonicalForm: ToCanonicalForm;
+/** A string as a contract source writes it, with the escapes its string reader resolves. */
+declare function escapePslString(value: string): string;
+/** Which data type a written number is, and whether that type stores it as a number or as text. */
+interface NumberClassification {
+  readonly type: DataTypeId;
+  readonly form: 'number' | 'text';
+}
+/** One integer type and the range of whole numbers it holds. */
+interface IntegerStep extends NumberClassification {
+  readonly min: bigint;
+  readonly max: bigint;
+}
+/** The range of a signed integer of `bits` bits. */
+declare function signedRange(bits: number): {
+  readonly min: bigint;
+  readonly max: bigint;
+};
+interface NumberClassifierSpec {
+  /** Tried in order; the first whose range holds the digits wins. */
+  readonly integers: readonly IntegerStep[];
+  /** A whole number no step holds. Absent means the target has no type for it. */
+  readonly largerWhole?: NumberClassification | undefined;
+  /** A number with a fraction. Absent means the target has no type for it. */
+  readonly fraction?: NumberClassification | undefined;
+  /** `NaN`, `Infinity` and `-Infinity`. Absent means the target has no type for them. */
+  readonly words?: NumberClassification | undefined;
+}
+/**
+ * The classifier one target's plain-number authoring entry carries: it reads the digits and says
+ * which of the target's types the value is, in that type's canonical form. `undefined` means no
+ * type of this target holds the number.
+ */
+declare function createNumberClassifier(spec: NumberClassifierSpec): (text: string) => {
+  readonly type: DataTypeId;
+  readonly value: JsonValue;
+} | undefined;
+/**
+ * Read a JSON body into the document it holds.
+ *
+ * `JSON.parse` reads a numeral too large for a double as `Infinity`, and `JSON.stringify` writes
+ * that back as `null`, so a document holding one would not be the document stored; it is refused
+ * here instead, naming where the number is.
+ */
+declare function parseJsonBody(text: string): JsonValue;
+/** Write a document as the body of a JSON literal. */
+declare function printJsonBody(value: JsonValue): string;
+//#endregion
+//#region src/date-time-canonical-form.d.ts
+/**
+ * The reader the SQL targets build the canonical form of each date and time type with; ADR 254
+ * states the forms and the text it reads.
+ */
+/** What a date or time type holds, which decides the text it reads and writes. */
+type DateTimeShape = 'date' | 'time' | 'timeWithOffset' | 'dateTime' | 'instant';
+interface CanonicalDateTimeOptions {
+  readonly shape: DateTimeShape;
+  /** The data type id, which messages name. */
+  readonly dataTypeId: string;
+  /** The largest UTC offset the type holds, in hours. Defaults to 23. */
+  readonly maxOffsetHours?: number;
+  /** The most digits after the decimal point the type holds. Defaults to 6, microseconds. */
+  readonly maxFractionDigits?: 3 | 6;
+  /** The earliest and latest values the type holds, each in canonical form. */
+  readonly range?: {
+    readonly earliest: string;
+    readonly latest: string;
+  };
+}
+/**
+ * The canonical form of written date or time text, or a refusal with a message that says what is
+ * wrong and shows text the type holds. `written` is the text as its author wrote it, which the
+ * message shows, when a target rewrote it into ISO 8601 before calling this.
+ */
+declare function canonicalDateTime(text: string, options: CanonicalDateTimeOptions, written?: string): string;
+//#endregion
+export { NumberClassifierSpec as a, createNumberClassifier as c, isNumeralText as d, parseJsonBody as f, NumberClassification as i, escapePslString as l, signedRange as m, DateTimeShape as n, canonicalDateTime as o, printJsonBody as p, IntegerStep as r, canonicalNumeralText as s, CanonicalDateTimeOptions as t, integerTextCanonicalForm as u };
+//# sourceMappingURL=data-type-support-B_Dr1cxB.d.mts.map

package/dist/data-type-support-B_Dr1cxB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-support-B_Dr1cxB.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/data-type-support.d.mts"],"mappings":";;;;;iBAIiB,cAAc;;;;;iBAKd,qBAAqB;;;;cAIxB,0BAA0B;;iBAEvB,gBAAgB;;UAEvB;WACC,MAAM;WACN;;;UAGD,oBAAoB;WACnB;WACA;;;iBAGM,YAAY;WAClB;WACA;;UAED;;WAEC,mBAAmB;;WAEnB,cAAc;;WAEd,WAAW;;WAEX,QAAQ;;;;;;;iBAOF,uBAAuB,MAAM,wBAAwB;WAC3D,MAAM;WACN,OAAO;;;;;;;;;iBASD,cAAc,eAAe;;iBAE7B,cAAc,OAAO;;;;;;;;KAQjC;UACK;WACC,OAAO;;WAEP;;WAEA;;WAEA;;WAEA;aACE;aACA;;;;;;;;iBAQI,kBAAkB,cAAc,SAAS,0BAA0B"}