@prisma/orm-family-sql 8.0.0-rc.21-dev.6 → 8.0.0-rc.21-dev.8

package/dist/psl-build-BA0Ndi1v.mjs

@@ -0,0 +1,268 @@
+import { n as isSqlDataType, o as resolveReportedSqlType } from "./sql-data-type-LVBldu1a-Bq203xWX.mjs";
+import "./sql-expression-CKgKznXS.mjs";
+import { t as sqlFamilyError } from "./errors-B5g0xWro-C8plbqga.mjs";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { authoringTypeConstructorArguments, authoringTypeConstructors, findAuthoringTypeChoiceCall, getAuthoringTypeChoice, getAuthoringTypeConstructor, instantiateAuthoringTypeConstructor, isAuthoringTypeChoiceOption, printTaggedLiteral, writeDataTypeValue, writeTypedLiteral, writtenTypeArguments } from "@prisma/orm-framework/components/authoring";
+import { dataTypeId, dataTypeParams } from "@prisma/orm-framework/components/codec";
+import { canonicalizeJson } from "@prisma/orm-framework/components/utils";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { InternalError, isInternalError } from "@prisma/orm-framework/utils/internal-error";
+//#region ../../../2-sql-family/9-family/dist/psl-build.mjs
+/** Every constructor of `authoringTypes` marked `inferred`, by the data type its codec represents. */
+function inferredTypeConstructors(input) {
+	const found = /* @__PURE__ */ new Map();
+	for (const { path, descriptor } of authoringTypeConstructors(input.authoringTypes)) {
+		if (descriptor.inferred !== true) continue;
+		const dataTypeId = input.codecLookup.descriptorFor(descriptor.output.codecId)?.dataType;
+		const dataType = dataTypeId === void 0 ? void 0 : input.dataTypeLookup.get(dataTypeId);
+		if (dataType === void 0 || !isSqlDataType(dataType)) continue;
+		found.set(dataType.id, {
+			path,
+			descriptor,
+			dataType
+		});
+	}
+	return found;
+}
+function normalParams(marked, args) {
+	try {
+		const { typeParams } = instantiateAuthoringTypeConstructor(marked.descriptor, args);
+		const params = dataTypeParams(marked.dataType, typeParams);
+		return canonicalizeJson(marked.dataType.sql.normalize(params));
+	} catch (error) {
+		if (isInternalError(error)) throw error;
+		return;
+	}
+}
+/**
+* The call to `marked` with the fewest arguments that produces `params`, the normal form of a
+* column's data type parameters: arguments are dropped from the end while the normal form of what
+* the call produces stays `params`. Undefined when the constructor cannot produce them, such as one
+* whose argument names another entity.
+*/
+function fewestArgumentsCall(marked, params) {
+	const all = authoringTypeConstructorArguments(marked.descriptor, {
+		codecId: marked.descriptor.output.codecId,
+		typeParams: params
+	});
+	if (all === void 0) return void 0;
+	const wanted = canonicalizeJson(params);
+	const args = [...all];
+	while (args.length > 0 && normalParams(marked, args.slice(0, -1)) === wanted) args.pop();
+	return {
+		path: marked.path,
+		args
+	};
+}
+/**
+* Whether two outputs have the same codec and the same parameters in the normal form of `dataType`, which the codecs represent: how `db verify` and the planner compare a column with the database.
+*/
+function sameInNormalForm(dataType) {
+	const normal = (output) => canonicalizeJson(dataType.sql.normalize(dataTypeParams(dataType, output.typeParams ?? {})));
+	return (produced, wanted) => produced.codecId === wanted.codecId && normal(produced) === normal(wanted);
+}
+/**
+* The type choice call that becomes the type constructor call `call`, written by name with only the arguments that differ from the defaults (ADR 279). `sameOutput` decides when it becomes the same type; by default the codec and type parameters must be exactly equal. `undefined` when no type choice call becomes it or an argument has no literal that reads back as it.
+*/
+function writtenTypeChoiceCall(input) {
+	const found = findAuthoringTypeChoiceCall({
+		namespace: input.authoringTypes,
+		call: input.call,
+		...ifDefined("sameOutput", input.sameOutput)
+	});
+	const choice = found && getAuthoringTypeChoice({ type: input.authoringTypes }, found.path);
+	if (found === void 0 || choice === void 0) return void 0;
+	const args = [];
+	for (const { name, value } of found.args) {
+		const argument = choice.descriptor.args.find((candidate) => candidate.name === name);
+		const text = argument === void 0 ? void 0 : isAuthoringTypeChoiceOption(argument) ? String(value) : writeDataTypeValue(blindCast(value), dataTypeId(argument.dataType), input.dataTypes);
+		if (text === void 0) return void 0;
+		args.push({
+			name,
+			text
+		});
+	}
+	return {
+		path: found.path,
+		args,
+		becomes: found.becomes
+	};
+}
+/** The type the database reported for `column`, which introspection always records. */
+function reportedTypeOf(column, tableName) {
+	if (column.reportedType === void 0) throw new InternalError(`contract infer read column "${tableName}"."${column.name}" without the type the database reported for it.`);
+	return column.reportedType;
+}
+/** The call to the type choice that becomes `marked` with every parameter in `params`, compared in the normal form, as `db verify` compares the column, with the explicit call it becomes. */
+function convenienceCall(marked, params, authoringTypes, support) {
+	const values = authoringTypeConstructorArguments(marked.descriptor, {
+		codecId: marked.descriptor.output.codecId,
+		typeParams: params
+	});
+	const written = values && writtenTypeChoiceCall({
+		authoringTypes,
+		call: {
+			path: marked.path,
+			args: values
+		},
+		dataTypes: support,
+		sameOutput: sameInNormalForm(marked.dataType)
+	});
+	return written && {
+		path: written.path,
+		args: written.args,
+		explicit: {
+			path: written.becomes.path,
+			values: written.becomes.args
+		}
+	};
+}
+/**
+* The first call to a row of the type choice `written` names whose type constructor represents the same data type, with the same parameters, and whose codec reads the column default.
+*/
+async function rowReadingDefault(written, marked, params, authoringTypes, support, readsDefault) {
+	const choice = getAuthoringTypeChoice({ type: authoringTypes }, written.path);
+	for (const row of choice?.descriptor.choices ?? []) {
+		const path = [...written.path.slice(0, -1), row.type];
+		const descriptor = getAuthoringTypeConstructor({ type: authoringTypes }, path);
+		const call = descriptor !== void 0 && support.dataTypeOfCodec(descriptor.output.codecId) === marked.dataType.id ? convenienceCall({
+			...marked,
+			path,
+			descriptor
+		}, params, authoringTypes, support) : void 0;
+		if (call !== void 0 && await readsDefault(call)) return call;
+	}
+}
+async function writtenCall(constructors, dataTypes, authoringTypes, support, reported, readsDefault) {
+	const resolved = resolveReportedSqlType(reported, dataTypes);
+	const marked = resolved && constructors.get(resolved.dataType.id);
+	if (resolved === void 0 || marked === void 0) return void 0;
+	const convenience = convenienceCall(marked, resolved.typeParams, authoringTypes, support);
+	if (convenience !== void 0) {
+		if (await readsDefault(convenience)) return convenience;
+		return await rowReadingDefault(convenience, marked, resolved.typeParams, authoringTypes, support, readsDefault) ?? convenience;
+	}
+	const call = fewestArgumentsCall(marked, resolved.typeParams);
+	const args = call && writtenTypeArguments(marked.descriptor, call.args, support);
+	return call && args && {
+		path: call.path,
+		args: args.map((text) => ({
+			name: void 0,
+			text
+		})),
+		explicit: {
+			path: call.path,
+			values: call.args
+		}
+	};
+}
+/**
+* The type of every column of `tables` that `isEnumColumn` does not claim, through the constructor marked `inferred` for the data type that claims the column's reported type: the type choice call that becomes it, with only the arguments that differ from the defaults, or else the call to it with the fewest arguments. When the codec of that type choice call cannot read the column default as a row, the first row of the same type choice whose codec can is written instead. When any column has no such call, throws `CONTRACT.INFER_COLUMN_TYPE_UNCLAIMED` listing every one of them.
+*/
+async function inferColumnTypes(input) {
+	const dataTypes = [...input.constructors.values()].map((marked) => marked.dataType);
+	const types = /* @__PURE__ */ new Map();
+	const unclaimed = [];
+	for (const { schemaName, tableName, columns } of input.tables) for (const column of columns) {
+		if (input.isEnumColumn(column)) continue;
+		const reported = reportedTypeOf(column, tableName);
+		const readsDefault = input.readsDefault;
+		const call = await writtenCall(input.constructors, dataTypes, input.authoringTypes, input.dataTypes, reported, async (type) => readsDefault === void 0 ? true : readsDefault(tableName, column, type));
+		if (call === void 0) {
+			unclaimed.push(`${schemaName}.${tableName}.${column.name}: ${reported.text}${column.many === true ? "[]" : ""}`);
+			continue;
+		}
+		types.set(JSON.stringify([tableName, column.name]), call);
+	}
+	if (unclaimed.length > 0) {
+		const columns = unclaimed.sort();
+		throw sqlFamilyError("CONTRACT.INFER_COLUMN_TYPE_UNCLAIMED", ["contract infer: Prisma 8 cannot write these column types with the configured stack:", ...columns.map((line) => `  ${line}`)].join("\n"), {
+			why: "Prisma 8 reads a column type only through a data type that the target or an extension pack declares.",
+			fix: `No configured pack has a type for these columns. If a type comes from a database extension that has a Prisma 8 pack, add the pack to extensions in prisma.config.ts. Otherwise, to keep such a column, write the schema by hand and declare its field as Raw(sql\`<type>\`) with the type as listed, or change the column's type or remove the column from the database.`,
+			meta: { columns }
+		});
+	}
+	return (tableName, columnName) => {
+		const type = types.get(JSON.stringify([tableName, columnName]));
+		if (type === void 0) throw new InternalError(`contract infer resolved no type for "${tableName}"."${columnName}".`);
+		return type;
+	};
+}
+const DEFAULT_FUNCTION_ATTRIBUTES = {
+	"autoincrement()": "@default(autoincrement())",
+	"now()": "@default(now())"
+};
+/**
+* The attribute a stored default prints as: a named function, a literal the column takes, or any
+* other expression as a `sql` literal. `undefined` when a literal has no written form. An expression
+* prints even when the literal would read back as different text: default expressions are compared
+* with case and whitespace ignored (`SqlColumnDefaultIR.isEqualTo`), and canonicalization changes only
+* whitespace (ADR 129).
+*/
+function mapDefault(columnDefault, options) {
+	switch (columnDefault.kind) {
+		case "literal": {
+			const text = writeTypedLiteral(columnDefault.value, {
+				dataTypes: options?.dataTypes,
+				dataType: options?.columnCodec?.dataType,
+				typeParams: options?.typeParams,
+				...ifDefined("list", options?.list)
+			});
+			return text === void 0 ? void 0 : { attribute: `@default(${text})` };
+		}
+		case "function": return { attribute: options?.functionAttributes?.[columnDefault.expression] ?? DEFAULT_FUNCTION_ATTRIBUTES[columnDefault.expression] ?? `@default(${printTaggedLiteral("sql", columnDefault.expression)})` };
+	}
+}
+const GENERATOR_PHASES = ["onCreate", "onUpdate"];
+/**
+* The generator function call that writes each phase of a column's generators, as `@onCreate(...)` and `@onUpdate(...)` take it. A call must resolve back to the stored generator, so a list column, a generator no function writes for the codec, and a call that reads back differently are refused.
+*/
+function generatorCallsFor(input) {
+	const { executionDefault, field, list, generatorFunctions } = input;
+	const calls = [];
+	for (const phase of GENERATOR_PHASES) {
+		const generator = executionDefault[phase];
+		if (generator === void 0) continue;
+		if (list) return {
+			ok: false,
+			refusal: {
+				kind: "on-list",
+				phase,
+				generator
+			}
+		};
+		const printed = generatorFunctions.callFor(generator, field);
+		if (printed === void 0) return {
+			ok: false,
+			refusal: {
+				kind: "no-function",
+				phase,
+				generator
+			}
+		};
+		const readBack = generatorFunctions.resolve(printed.call, field);
+		if (!readBack.ok || canonicalizeJson(readBack.generator) !== canonicalizeJson(generator)) return {
+			ok: false,
+			refusal: {
+				kind: "reads-back-differently",
+				phase,
+				generator,
+				text: printed.text,
+				readBack: readBack.ok ? readBack.generator : void 0,
+				refusedBecause: !readBack.ok && readBack.reason === "refused" ? readBack.message : void 0
+			}
+		};
+		calls.push({
+			phase,
+			text: printed.text
+		});
+	}
+	return {
+		ok: true,
+		calls
+	};
+}
+//#endregion
+export { mapDefault as a, inferredTypeConstructors as i, generatorCallsFor as n, sameInNormalForm as o, inferColumnTypes as r, writtenTypeChoiceCall as s, fewestArgumentsCall as t };
+
+//# sourceMappingURL=psl-build-BA0Ndi1v.mjs.map

package/dist/psl-build-BA0Ndi1v.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-build-BA0Ndi1v.mjs","names":[],"sources":["../../../../2-sql-family/9-family/dist/psl-build.mjs"],"sourcesContent":["import { t as sqlFamilyError } from \"./errors-B5g0xWro.mjs\";\nimport { s as toEnumMemberName } from \"./psl-names-C3cwe0rg.mjs\";\nimport { isSqlDataType, resolveReportedSqlType } from \"@internal/sql-contract/data-type\";\nimport { SQL_EXPRESSION_TAG } from \"@internal/sql-contract/sql-expression\";\nimport { authoringTypeConstructorArguments, authoringTypeConstructors, findAuthoringTypeChoiceCall, getAuthoringTypeChoice, getAuthoringTypeConstructor, instantiateAuthoringTypeConstructor, isAuthoringTypeChoiceOption, printTaggedLiteral, writeDataTypeValue, writeTypedLiteral, writtenTypeArguments } from \"@internal/framework-components/authoring\";\nimport { dataTypeId, dataTypeParams } from \"@internal/framework-components/codec\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { ifDefined } from \"@internal/utils/defined\";\nimport { InternalError, isInternalError } from \"@internal/utils/internal-error\";\nimport { canonicalizeJson } from \"@internal/framework-components/utils\";\n//#region src/core/psl-build/inferred-type-constructors.ts\n/** Every constructor of `authoringTypes` marked `inferred`, by the data type its codec represents. */\nfunction inferredTypeConstructors(input) {\n\tconst found = /* @__PURE__ */ new Map();\n\tfor (const { path, descriptor } of authoringTypeConstructors(input.authoringTypes)) {\n\t\tif (descriptor.inferred !== true) continue;\n\t\tconst dataTypeId = input.codecLookup.descriptorFor(descriptor.output.codecId)?.dataType;\n\t\tconst dataType = dataTypeId === void 0 ? void 0 : input.dataTypeLookup.get(dataTypeId);\n\t\tif (dataType === void 0 || !isSqlDataType(dataType)) continue;\n\t\tfound.set(dataType.id, {\n\t\t\tpath,\n\t\t\tdescriptor,\n\t\t\tdataType\n\t\t});\n\t}\n\treturn found;\n}\nfunction normalParams(marked, args) {\n\ttry {\n\t\tconst { typeParams } = instantiateAuthoringTypeConstructor(marked.descriptor, args);\n\t\tconst params = dataTypeParams(marked.dataType, typeParams);\n\t\treturn canonicalizeJson(marked.dataType.sql.normalize(params));\n\t} catch (error) {\n\t\tif (isInternalError(error)) throw error;\n\t\treturn;\n\t}\n}\n/**\n* The call to `marked` with the fewest arguments that produces `params`, the normal form of a\n* column's data type parameters: arguments are dropped from the end while the normal form of what\n* the call produces stays `params`. Undefined when the constructor cannot produce them, such as one\n* whose argument names another entity.\n*/\nfunction fewestArgumentsCall(marked, params) {\n\tconst all = authoringTypeConstructorArguments(marked.descriptor, {\n\t\tcodecId: marked.descriptor.output.codecId,\n\t\ttypeParams: params\n\t});\n\tif (all === void 0) return void 0;\n\tconst wanted = canonicalizeJson(params);\n\tconst args = [...all];\n\twhile (args.length > 0 && normalParams(marked, args.slice(0, -1)) === wanted) args.pop();\n\treturn {\n\t\tpath: marked.path,\n\t\targs\n\t};\n}\n/**\n* Whether two outputs have the same codec and the same parameters in the normal form of `dataType`, which the codecs represent: how `db verify` and the planner compare a column with the database.\n*/\nfunction sameInNormalForm(dataType) {\n\tconst normal = (output) => canonicalizeJson(dataType.sql.normalize(dataTypeParams(dataType, output.typeParams ?? {})));\n\treturn (produced, wanted) => produced.codecId === wanted.codecId && normal(produced) === normal(wanted);\n}\n/**\n* The type choice call that becomes the type constructor call `call`, written by name with only the arguments that differ from the defaults (ADR 279). `sameOutput` decides when it becomes the same type; by default the codec and type parameters must be exactly equal. `undefined` when no type choice call becomes it or an argument has no literal that reads back as it.\n*/\nfunction writtenTypeChoiceCall(input) {\n\tconst found = findAuthoringTypeChoiceCall({\n\t\tnamespace: input.authoringTypes,\n\t\tcall: input.call,\n\t\t...ifDefined(\"sameOutput\", input.sameOutput)\n\t});\n\tconst choice = found && getAuthoringTypeChoice({ type: input.authoringTypes }, found.path);\n\tif (found === void 0 || choice === void 0) return void 0;\n\tconst args = [];\n\tfor (const { name, value } of found.args) {\n\t\tconst argument = choice.descriptor.args.find((candidate) => candidate.name === name);\n\t\tconst text = argument === void 0 ? void 0 : isAuthoringTypeChoiceOption(argument) ? String(value) : writeDataTypeValue(blindCast(value), dataTypeId(argument.dataType), input.dataTypes);\n\t\tif (text === void 0) return void 0;\n\t\targs.push({\n\t\t\tname,\n\t\t\ttext\n\t\t});\n\t}\n\treturn {\n\t\tpath: found.path,\n\t\targs,\n\t\tbecomes: found.becomes\n\t};\n}\n//#endregion\n//#region src/core/psl-build/column-types.ts\n/** The type the database reported for `column`, which introspection always records. */\nfunction reportedTypeOf(column, tableName) {\n\tif (column.reportedType === void 0) throw new InternalError(`contract infer read column \"${tableName}\".\"${column.name}\" without the type the database reported for it.`);\n\treturn column.reportedType;\n}\n/** The call to the type choice that becomes `marked` with every parameter in `params`, compared in the normal form, as `db verify` compares the column, with the explicit call it becomes. */\nfunction convenienceCall(marked, params, authoringTypes, support) {\n\tconst values = authoringTypeConstructorArguments(marked.descriptor, {\n\t\tcodecId: marked.descriptor.output.codecId,\n\t\ttypeParams: params\n\t});\n\tconst written = values && writtenTypeChoiceCall({\n\t\tauthoringTypes,\n\t\tcall: {\n\t\t\tpath: marked.path,\n\t\t\targs: values\n\t\t},\n\t\tdataTypes: support,\n\t\tsameOutput: sameInNormalForm(marked.dataType)\n\t});\n\treturn written && {\n\t\tpath: written.path,\n\t\targs: written.args,\n\t\texplicit: {\n\t\t\tpath: written.becomes.path,\n\t\t\tvalues: written.becomes.args\n\t\t}\n\t};\n}\n/**\n* The first call to a row of the type choice `written` names whose type constructor represents the same data type, with the same parameters, and whose codec reads the column default.\n*/\nasync function rowReadingDefault(written, marked, params, authoringTypes, support, readsDefault) {\n\tconst choice = getAuthoringTypeChoice({ type: authoringTypes }, written.path);\n\tfor (const row of choice?.descriptor.choices ?? []) {\n\t\tconst path = [...written.path.slice(0, -1), row.type];\n\t\tconst descriptor = getAuthoringTypeConstructor({ type: authoringTypes }, path);\n\t\tconst call = descriptor !== void 0 && support.dataTypeOfCodec(descriptor.output.codecId) === marked.dataType.id ? convenienceCall({\n\t\t\t...marked,\n\t\t\tpath,\n\t\t\tdescriptor\n\t\t}, params, authoringTypes, support) : void 0;\n\t\tif (call !== void 0 && await readsDefault(call)) return call;\n\t}\n}\nasync function writtenCall(constructors, dataTypes, authoringTypes, support, reported, readsDefault) {\n\tconst resolved = resolveReportedSqlType(reported, dataTypes);\n\tconst marked = resolved && constructors.get(resolved.dataType.id);\n\tif (resolved === void 0 || marked === void 0) return void 0;\n\tconst convenience = convenienceCall(marked, resolved.typeParams, authoringTypes, support);\n\tif (convenience !== void 0) {\n\t\tif (await readsDefault(convenience)) return convenience;\n\t\treturn await rowReadingDefault(convenience, marked, resolved.typeParams, authoringTypes, support, readsDefault) ?? convenience;\n\t}\n\tconst call = fewestArgumentsCall(marked, resolved.typeParams);\n\tconst args = call && writtenTypeArguments(marked.descriptor, call.args, support);\n\treturn call && args && {\n\t\tpath: call.path,\n\t\targs: args.map((text) => ({\n\t\t\tname: void 0,\n\t\t\ttext\n\t\t})),\n\t\texplicit: {\n\t\t\tpath: call.path,\n\t\t\tvalues: call.args\n\t\t}\n\t};\n}\n/**\n* The type of every column of `tables` that `isEnumColumn` does not claim, through the constructor marked `inferred` for the data type that claims the column's reported type: the type choice call that becomes it, with only the arguments that differ from the defaults, or else the call to it with the fewest arguments. When the codec of that type choice call cannot read the column default as a row, the first row of the same type choice whose codec can is written instead. When any column has no such call, throws `CONTRACT.INFER_COLUMN_TYPE_UNCLAIMED` listing every one of them.\n*/\nasync function inferColumnTypes(input) {\n\tconst dataTypes = [...input.constructors.values()].map((marked) => marked.dataType);\n\tconst types = /* @__PURE__ */ new Map();\n\tconst unclaimed = [];\n\tfor (const { schemaName, tableName, columns } of input.tables) for (const column of columns) {\n\t\tif (input.isEnumColumn(column)) continue;\n\t\tconst reported = reportedTypeOf(column, tableName);\n\t\tconst readsDefault = input.readsDefault;\n\t\tconst call = await writtenCall(input.constructors, dataTypes, input.authoringTypes, input.dataTypes, reported, async (type) => readsDefault === void 0 ? true : readsDefault(tableName, column, type));\n\t\tif (call === void 0) {\n\t\t\tunclaimed.push(`${schemaName}.${tableName}.${column.name}: ${reported.text}${column.many === true ? \"[]\" : \"\"}`);\n\t\t\tcontinue;\n\t\t}\n\t\ttypes.set(JSON.stringify([tableName, column.name]), call);\n\t}\n\tif (unclaimed.length > 0) {\n\t\tconst columns = unclaimed.sort();\n\t\tthrow sqlFamilyError(\"CONTRACT.INFER_COLUMN_TYPE_UNCLAIMED\", [\"contract infer: Prisma 8 cannot write these column types with the configured stack:\", ...columns.map((line) => `  ${line}`)].join(\"\\n\"), {\n\t\t\twhy: \"Prisma 8 reads a column type only through a data type that the target or an extension pack declares.\",\n\t\t\tfix: `No configured pack has a type for these columns. If a type comes from a database extension that has a Prisma 8 pack, add the pack to extensions in prisma.config.ts. Otherwise, to keep such a column, write the schema by hand and declare its field as Raw(sql\\`<type>\\`) with the type as listed, or change the column's type or remove the column from the database.`,\n\t\t\tmeta: { columns }\n\t\t});\n\t}\n\treturn (tableName, columnName) => {\n\t\tconst type = types.get(JSON.stringify([tableName, columnName]));\n\t\tif (type === void 0) throw new InternalError(`contract infer resolved no type for \"${tableName}\".\"${columnName}\".`);\n\t\treturn type;\n\t};\n}\n//#endregion\n//#region src/core/psl-build/default-mapping.ts\nconst DEFAULT_FUNCTION_ATTRIBUTES = {\n\t\"autoincrement()\": \"@default(autoincrement())\",\n\t\"now()\": \"@default(now())\"\n};\n/**\n* The attribute a stored default prints as: a named function, a literal the column takes, or any\n* other expression as a `sql` literal. `undefined` when a literal has no written form. An expression\n* prints even when the literal would read back as different text: default expressions are compared\n* with case and whitespace ignored (`SqlColumnDefaultIR.isEqualTo`), and canonicalization changes only\n* whitespace (ADR 129).\n*/\nfunction mapDefault(columnDefault, options) {\n\tswitch (columnDefault.kind) {\n\t\tcase \"literal\": {\n\t\t\tconst text = writeTypedLiteral(columnDefault.value, {\n\t\t\t\tdataTypes: options?.dataTypes,\n\t\t\t\tdataType: options?.columnCodec?.dataType,\n\t\t\t\ttypeParams: options?.typeParams,\n\t\t\t\t...ifDefined(\"list\", options?.list)\n\t\t\t});\n\t\t\treturn text === void 0 ? void 0 : { attribute: `@default(${text})` };\n\t\t}\n\t\tcase \"function\": return { attribute: options?.functionAttributes?.[columnDefault.expression] ?? DEFAULT_FUNCTION_ATTRIBUTES[columnDefault.expression] ?? `@default(${printTaggedLiteral(SQL_EXPRESSION_TAG, columnDefault.expression)})` };\n\t}\n}\n//#endregion\n//#region src/core/psl-build/generator-calls.ts\nconst GENERATOR_PHASES = [\"onCreate\", \"onUpdate\"];\n/**\n* The generator function call that writes each phase of a column's generators, as `@onCreate(...)` and `@onUpdate(...)` take it. A call must resolve back to the stored generator, so a list column, a generator no function writes for the codec, and a call that reads back differently are refused.\n*/\nfunction generatorCallsFor(input) {\n\tconst { executionDefault, field, list, generatorFunctions } = input;\n\tconst calls = [];\n\tfor (const phase of GENERATOR_PHASES) {\n\t\tconst generator = executionDefault[phase];\n\t\tif (generator === void 0) continue;\n\t\tif (list) return {\n\t\t\tok: false,\n\t\t\trefusal: {\n\t\t\t\tkind: \"on-list\",\n\t\t\t\tphase,\n\t\t\t\tgenerator\n\t\t\t}\n\t\t};\n\t\tconst printed = generatorFunctions.callFor(generator, field);\n\t\tif (printed === void 0) return {\n\t\t\tok: false,\n\t\t\trefusal: {\n\t\t\t\tkind: \"no-function\",\n\t\t\t\tphase,\n\t\t\t\tgenerator\n\t\t\t}\n\t\t};\n\t\tconst readBack = generatorFunctions.resolve(printed.call, field);\n\t\tif (!readBack.ok || canonicalizeJson(readBack.generator) !== canonicalizeJson(generator)) return {\n\t\t\tok: false,\n\t\t\trefusal: {\n\t\t\t\tkind: \"reads-back-differently\",\n\t\t\t\tphase,\n\t\t\t\tgenerator,\n\t\t\t\ttext: printed.text,\n\t\t\t\treadBack: readBack.ok ? readBack.generator : void 0,\n\t\t\t\trefusedBecause: !readBack.ok && readBack.reason === \"refused\" ? readBack.message : void 0\n\t\t\t}\n\t\t};\n\t\tcalls.push({\n\t\t\tphase,\n\t\t\ttext: printed.text\n\t\t});\n\t}\n\treturn {\n\t\tok: true,\n\t\tcalls\n\t};\n}\n//#endregion\nexport { fewestArgumentsCall, generatorCallsFor, inferColumnTypes, inferredTypeConstructors, mapDefault, sameInNormalForm, toEnumMemberName, writtenTypeChoiceCall };\n\n//# sourceMappingURL=psl-build.mjs.map"],"mappings":";;;;;;;;;;;AAYA,SAAS,yBAAyB,OAAO;CACxC,MAAM,wBAAwB,IAAI,IAAI;CACtC,KAAK,MAAM,EAAE,MAAM,gBAAgB,0BAA0B,MAAM,cAAc,GAAG;EACnF,IAAI,WAAW,aAAa,MAAM;EAClC,MAAM,aAAa,MAAM,YAAY,cAAc,WAAW,OAAO,OAAO,CAAC,EAAE;EAC/E,MAAM,WAAW,eAAe,KAAK,IAAI,KAAK,IAAI,MAAM,eAAe,IAAI,UAAU;EACrF,IAAI,aAAa,KAAK,KAAK,CAAC,cAAc,QAAQ,GAAG;EACrD,MAAM,IAAI,SAAS,IAAI;GACtB;GACA;GACA;EACD,CAAC;CACF;CACA,OAAO;AACR;AACA,SAAS,aAAa,QAAQ,MAAM;CACnC,IAAI;EACH,MAAM,EAAE,eAAe,oCAAoC,OAAO,YAAY,IAAI;EAClF,MAAM,SAAS,eAAe,OAAO,UAAU,UAAU;EACzD,OAAO,iBAAiB,OAAO,SAAS,IAAI,UAAU,MAAM,CAAC;CAC9D,SAAS,OAAO;EACf,IAAI,gBAAgB,KAAK,GAAG,MAAM;EAClC;CACD;AACD;;;;;;;AAOA,SAAS,oBAAoB,QAAQ,QAAQ;CAC5C,MAAM,MAAM,kCAAkC,OAAO,YAAY;EAChE,SAAS,OAAO,WAAW,OAAO;EAClC,YAAY;CACb,CAAC;CACD,IAAI,QAAQ,KAAK,GAAG,OAAO,KAAK;CAChC,MAAM,SAAS,iBAAiB,MAAM;CACtC,MAAM,OAAO,CAAC,GAAG,GAAG;CACpB,OAAO,KAAK,SAAS,KAAK,aAAa,QAAQ,KAAK,MAAM,GAAG,EAAE,CAAC,MAAM,QAAQ,KAAK,IAAI;CACvF,OAAO;EACN,MAAM,OAAO;EACb;CACD;AACD;;;;AAIA,SAAS,iBAAiB,UAAU;CACnC,MAAM,UAAU,WAAW,iBAAiB,SAAS,IAAI,UAAU,eAAe,UAAU,OAAO,cAAc,CAAC,CAAC,CAAC,CAAC;CACrH,QAAQ,UAAU,WAAW,SAAS,YAAY,OAAO,WAAW,OAAO,QAAQ,MAAM,OAAO,MAAM;AACvG;;;;AAIA,SAAS,sBAAsB,OAAO;CACrC,MAAM,QAAQ,4BAA4B;EACzC,WAAW,MAAM;EACjB,MAAM,MAAM;EACZ,GAAG,UAAU,cAAc,MAAM,UAAU;CAC5C,CAAC;CACD,MAAM,SAAS,SAAS,uBAAuB,EAAE,MAAM,MAAM,eAAe,GAAG,MAAM,IAAI;CACzF,IAAI,UAAU,KAAK,KAAK,WAAW,KAAK,GAAG,OAAO,KAAK;CACvD,MAAM,OAAO,CAAC;CACd,KAAK,MAAM,EAAE,MAAM,WAAW,MAAM,MAAM;EACzC,MAAM,WAAW,OAAO,WAAW,KAAK,MAAM,cAAc,UAAU,SAAS,IAAI;EACnF,MAAM,OAAO,aAAa,KAAK,IAAI,KAAK,IAAI,4BAA4B,QAAQ,IAAI,OAAO,KAAK,IAAI,mBAAmB,UAAU,KAAK,GAAG,WAAW,SAAS,QAAQ,GAAG,MAAM,SAAS;EACvL,IAAI,SAAS,KAAK,GAAG,OAAO,KAAK;EACjC,KAAK,KAAK;GACT;GACA;EACD,CAAC;CACF;CACA,OAAO;EACN,MAAM,MAAM;EACZ;EACA,SAAS,MAAM;CAChB;AACD;;AAIA,SAAS,eAAe,QAAQ,WAAW;CAC1C,IAAI,OAAO,iBAAiB,KAAK,GAAG,MAAM,IAAI,cAAc,+BAA+B,UAAU,KAAK,OAAO,KAAK,iDAAiD;CACvK,OAAO,OAAO;AACf;;AAEA,SAAS,gBAAgB,QAAQ,QAAQ,gBAAgB,SAAS;CACjE,MAAM,SAAS,kCAAkC,OAAO,YAAY;EACnE,SAAS,OAAO,WAAW,OAAO;EAClC,YAAY;CACb,CAAC;CACD,MAAM,UAAU,UAAU,sBAAsB;EAC/C;EACA,MAAM;GACL,MAAM,OAAO;GACb,MAAM;EACP;EACA,WAAW;EACX,YAAY,iBAAiB,OAAO,QAAQ;CAC7C,CAAC;CACD,OAAO,WAAW;EACjB,MAAM,QAAQ;EACd,MAAM,QAAQ;EACd,UAAU;GACT,MAAM,QAAQ,QAAQ;GACtB,QAAQ,QAAQ,QAAQ;EACzB;CACD;AACD;;;;AAIA,eAAe,kBAAkB,SAAS,QAAQ,QAAQ,gBAAgB,SAAS,cAAc;CAChG,MAAM,SAAS,uBAAuB,EAAE,MAAM,eAAe,GAAG,QAAQ,IAAI;CAC5E,KAAK,MAAM,OAAO,QAAQ,WAAW,WAAW,CAAC,GAAG;EACnD,MAAM,OAAO,CAAC,GAAG,QAAQ,KAAK,MAAM,GAAG,EAAE,GAAG,IAAI,IAAI;EACpD,MAAM,aAAa,4BAA4B,EAAE,MAAM,eAAe,GAAG,IAAI;EAC7E,MAAM,OAAO,eAAe,KAAK,KAAK,QAAQ,gBAAgB,WAAW,OAAO,OAAO,MAAM,OAAO,SAAS,KAAK,gBAAgB;GACjI,GAAG;GACH;GACA;EACD,GAAG,QAAQ,gBAAgB,OAAO,IAAI,KAAK;EAC3C,IAAI,SAAS,KAAK,KAAK,MAAM,aAAa,IAAI,GAAG,OAAO;CACzD;AACD;AACA,eAAe,YAAY,cAAc,WAAW,gBAAgB,SAAS,UAAU,cAAc;CACpG,MAAM,WAAW,uBAAuB,UAAU,SAAS;CAC3D,MAAM,SAAS,YAAY,aAAa,IAAI,SAAS,SAAS,EAAE;CAChE,IAAI,aAAa,KAAK,KAAK,WAAW,KAAK,GAAG,OAAO,KAAK;CAC1D,MAAM,cAAc,gBAAgB,QAAQ,SAAS,YAAY,gBAAgB,OAAO;CACxF,IAAI,gBAAgB,KAAK,GAAG;EAC3B,IAAI,MAAM,aAAa,WAAW,GAAG,OAAO;EAC5C,OAAO,MAAM,kBAAkB,aAAa,QAAQ,SAAS,YAAY,gBAAgB,SAAS,YAAY,KAAK;CACpH;CACA,MAAM,OAAO,oBAAoB,QAAQ,SAAS,UAAU;CAC5D,MAAM,OAAO,QAAQ,qBAAqB,OAAO,YAAY,KAAK,MAAM,OAAO;CAC/E,OAAO,QAAQ,QAAQ;EACtB,MAAM,KAAK;EACX,MAAM,KAAK,KAAK,UAAU;GACzB,MAAM,KAAK;GACX;EACD,EAAE;EACF,UAAU;GACT,MAAM,KAAK;GACX,QAAQ,KAAK;EACd;CACD;AACD;;;;AAIA,eAAe,iBAAiB,OAAO;CACtC,MAAM,YAAY,CAAC,GAAG,MAAM,aAAa,OAAO,CAAC,CAAC,CAAC,KAAK,WAAW,OAAO,QAAQ;CAClF,MAAM,wBAAwB,IAAI,IAAI;CACtC,MAAM,YAAY,CAAC;CACnB,KAAK,MAAM,EAAE,YAAY,WAAW,aAAa,MAAM,QAAQ,KAAK,MAAM,UAAU,SAAS;EAC5F,IAAI,MAAM,aAAa,MAAM,GAAG;EAChC,MAAM,WAAW,eAAe,QAAQ,SAAS;EACjD,MAAM,eAAe,MAAM;EAC3B,MAAM,OAAO,MAAM,YAAY,MAAM,cAAc,WAAW,MAAM,gBAAgB,MAAM,WAAW,UAAU,OAAO,SAAS,iBAAiB,KAAK,IAAI,OAAO,aAAa,WAAW,QAAQ,IAAI,CAAC;EACrM,IAAI,SAAS,KAAK,GAAG;GACpB,UAAU,KAAK,GAAG,WAAW,GAAG,UAAU,GAAG,OAAO,KAAK,IAAI,SAAS,OAAO,OAAO,SAAS,OAAO,OAAO,IAAI;GAC/G;EACD;EACA,MAAM,IAAI,KAAK,UAAU,CAAC,WAAW,OAAO,IAAI,CAAC,GAAG,IAAI;CACzD;CACA,IAAI,UAAU,SAAS,GAAG;EACzB,MAAM,UAAU,UAAU,KAAK;EAC/B,MAAM,eAAe,wCAAwC,CAAC,uFAAuF,GAAG,QAAQ,KAAK,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG;GACvM,KAAK;GACL,KAAK;GACL,MAAM,EAAE,QAAQ;EACjB,CAAC;CACF;CACA,QAAQ,WAAW,eAAe;EACjC,MAAM,OAAO,MAAM,IAAI,KAAK,UAAU,CAAC,WAAW,UAAU,CAAC,CAAC;EAC9D,IAAI,SAAS,KAAK,GAAG,MAAM,IAAI,cAAc,wCAAwC,UAAU,KAAK,WAAW,GAAG;EAClH,OAAO;CACR;AACD;AAGA,MAAM,8BAA8B;CACnC,mBAAmB;CACnB,SAAS;AACV;;;;;;;;AAQA,SAAS,WAAW,eAAe,SAAS;CAC3C,QAAQ,cAAc,MAAtB;EACC,KAAK,WAAW;GACf,MAAM,OAAO,kBAAkB,cAAc,OAAO;IACnD,WAAW,SAAS;IACpB,UAAU,SAAS,aAAa;IAChC,YAAY,SAAS;IACrB,GAAG,UAAU,QAAQ,SAAS,IAAI;GACnC,CAAC;GACD,OAAO,SAAS,KAAK,IAAI,KAAK,IAAI,EAAE,WAAW,YAAY,KAAK,GAAG;EACpE;EACA,KAAK,YAAY,OAAO,EAAE,WAAW,SAAS,qBAAqB,cAAc,eAAe,4BAA4B,cAAc,eAAe,YAAY,mBAAA,OAAuC,cAAc,UAAU,EAAE,GAAG;CAC1O;AACD;AAGA,MAAM,mBAAmB,CAAC,YAAY,UAAU;;;;AAIhD,SAAS,kBAAkB,OAAO;CACjC,MAAM,EAAE,kBAAkB,OAAO,MAAM,uBAAuB;CAC9D,MAAM,QAAQ,CAAC;CACf,KAAK,MAAM,SAAS,kBAAkB;EACrC,MAAM,YAAY,iBAAiB;EACnC,IAAI,cAAc,KAAK,GAAG;EAC1B,IAAI,MAAM,OAAO;GAChB,IAAI;GACJ,SAAS;IACR,MAAM;IACN;IACA;GACD;EACD;EACA,MAAM,UAAU,mBAAmB,QAAQ,WAAW,KAAK;EAC3D,IAAI,YAAY,KAAK,GAAG,OAAO;GAC9B,IAAI;GACJ,SAAS;IACR,MAAM;IACN;IACA;GACD;EACD;EACA,MAAM,WAAW,mBAAmB,QAAQ,QAAQ,MAAM,KAAK;EAC/D,IAAI,CAAC,SAAS,MAAM,iBAAiB,SAAS,SAAS,MAAM,iBAAiB,SAAS,GAAG,OAAO;GAChG,IAAI;GACJ,SAAS;IACR,MAAM;IACN;IACA;IACA,MAAM,QAAQ;IACd,UAAU,SAAS,KAAK,SAAS,YAAY,KAAK;IAClD,gBAAgB,CAAC,SAAS,MAAM,SAAS,WAAW,YAAY,SAAS,UAAU,KAAK;GACzF;EACD;EACA,MAAM,KAAK;GACV;GACA,MAAM,QAAQ;EACf,CAAC;CACF;CACA,OAAO;EACN,IAAI;EACJ;CACD;AACD"}

package/dist/{psl-build-CNncjpsa.d.mts → psl-build-DCZaF5g4.d.mts}

@@ -1,8 +1,8 @@
 import { u as SqlColumnIR } from "./types-fmtEmvj3-B0fQaVes.mjs";
 import "./types-B-dwfOwQ.mjs";
-import { i as SqlDataType, l as SqlTypeParams } from "./data-type-CR0gi2GQ.mjs";
-import "./default-mapping-CAOONlKQ-CIg7JCfF.mjs";
-import { AuthoringTypeConstructorCall, AuthoringTypeConstructorDescriptor, AuthoringTypeNamespace, DataTypeSupport } from "@prisma/orm-framework/components/authoring";
+import { a as SqlDataType, u as SqlTypeParams } from "./data-type-B-Do6RMA.mjs";
+import "./default-mapping-CEISdj2g-B50Ag_F_.mjs";
+import { AuthoringTypeConstructorCall, AuthoringTypeConstructorDescriptor, AuthoringTypeConstructorOutput, AuthoringTypeNamespace, DataTypeSupport } from "@prisma/orm-framework/components/authoring";
 import { ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue } from "@prisma/orm-framework/contract/types";
 import { CodecLookupWithDescriptors, DataTypeLookup } from "@prisma/orm-framework/components/codec";
 import { GeneratorFunctionField, GeneratorFunctionRegistry, GeneratorPhase } from "@prisma/orm-framework/components/components";
@@ -29,20 +29,48 @@ declare function inferredTypeConstructors(input: {
  * whose argument names another entity.
  */
 declare function fewestArgumentsCall(marked: InferredTypeConstructor, params: SqlTypeParams): AuthoringTypeConstructorCall | undefined;
+/** An argument of a type call as PSL writes it: by name, or by position when `name` is undefined. */
+interface PslTypeArgument {
+  readonly name: string | undefined;
+  readonly text: string;
+}
+/** A call to a type constructor or type choice as PSL writes it. */
+interface WrittenPslTypeCall {
+  readonly path: readonly string[];
+  readonly args: readonly PslTypeArgument[];
+}
+/** A type choice call as PSL writes it, and the type constructor call it becomes. */
+interface WrittenTypeChoiceCall extends WrittenPslTypeCall {
+  readonly becomes: AuthoringTypeConstructorCall;
+}
 /**
- * Each argument of a call to `descriptor` as PSL writes it: a value argument as a literal of its data type that reads back as the same value. `undefined` when an argument is not a value argument or no literal reads back as it.
+ * Whether two outputs have the same codec and the same parameters in the normal form of `dataType`, which the codecs represent: how `db verify` and the planner compare a column with the database.
  */
-declare function writtenTypeArguments(descriptor: AuthoringTypeConstructorDescriptor, args: readonly unknown[], dataTypes: DataTypeSupport): readonly string[] | undefined;
+declare function sameInNormalForm(dataType: SqlDataType): (produced: AuthoringTypeConstructorOutput, wanted: AuthoringTypeConstructorOutput) => boolean;
+/**
+ * The type choice call that becomes the type constructor call `call`, written by name with only the arguments that differ from the defaults (ADR 279). `sameOutput` decides when it becomes the same type; by default the codec and type parameters must be exactly equal. `undefined` when no type choice call becomes it or an argument has no literal that reads back as it.
+ */
+declare function writtenTypeChoiceCall(input: {
+  readonly authoringTypes: AuthoringTypeNamespace;
+  readonly call: AuthoringTypeConstructorCall;
+  readonly dataTypes: DataTypeSupport;
+  readonly sameOutput: ((produced: AuthoringTypeConstructorOutput, wanted: AuthoringTypeConstructorOutput) => boolean) | undefined;
+}): WrittenTypeChoiceCall | undefined;
 //#endregion
 //#region src/core/psl-build/column-types.d.ts
-/** A call to a type constructor as PSL writes it: the constructor's path, its arguments' text, and the value each argument gives the constructor. */
+/** A type call as PSL writes it, and the explicit type constructor it becomes, with the value of each of its arguments. */
 interface PslTypeCall {
   readonly path: readonly string[];
-  readonly args: readonly string[];
-  readonly values: readonly unknown[];
+  readonly args: readonly PslTypeArgument[];
+  readonly explicit: {
+    readonly path: readonly string[];
+    readonly values: readonly unknown[];
+  };
 }
 /** The PSL type `contract infer` writes for a column that is not an enum, by table and column name. */
 type ColumnTypeOf = (tableName: string, columnName: string) => PslTypeCall;
+/** Whether the codec of `type` reads the default the database reports for `column` as a row value. */
+type ColumnTypeReadsDefault = (tableName: string, column: SqlColumnIR, type: PslTypeCall) => Promise<boolean>;
 /** One introspected table, with the schema it was read from. */
 interface IntrospectedTable {
   readonly schemaName: string;
@@ -50,18 +78,19 @@ interface IntrospectedTable {
   readonly columns: readonly SqlColumnIR[];
 }
 /**
- * The type of every column of `tables` that `isEnumColumn` does not claim: the call, with the
- * fewest arguments, to the constructor marked `inferred` for the data type that claims the
- * column's reported type. When any column has no such call, throws
- * `CONTRACT.INFER_COLUMN_TYPE_UNCLAIMED` listing every one of them.
+ * The type of every column of `tables` that `isEnumColumn` does not claim, through the constructor marked `inferred` for the data type that claims the column's reported type: the type choice call that becomes it, with only the arguments that differ from the defaults, or else the call to it with the fewest arguments. When the codec of that type choice call cannot read the column default as a row, the first row of the same type choice whose codec can is written instead. When any column has no such call, throws `CONTRACT.INFER_COLUMN_TYPE_UNCLAIMED` listing every one of them.
  */
 declare function inferColumnTypes(input: {
   readonly tables: readonly IntrospectedTable[];
   readonly constructors: InferredTypeConstructors;
+  /** The stack's type namespace, whose type choices infer writes where one becomes a marked constructor. */
+  readonly authoringTypes: AuthoringTypeNamespace;
   /** The stack's data types, whose literals write each argument. */
   readonly dataTypes: DataTypeSupport;
   readonly isEnumColumn: (column: SqlColumnIR) => boolean;
-}): ColumnTypeOf;
+  /** Whether a type's codec reads the column default; every type does when `undefined`. */
+  readonly readsDefault: ColumnTypeReadsDefault | undefined;
+}): Promise<ColumnTypeOf>;
 //#endregion
 //#region src/core/psl-build/generator-calls.d.ts
 /** The call text that writes one phase of a column's generators. */
@@ -108,5 +137,5 @@ declare function generatorCallsFor(input: {
  */
 declare function toEnumMemberName(value: string): string;
 //#endregion
-export { InferredTypeConstructors as a, PslTypeCall as c, inferColumnTypes as d, inferredTypeConstructors as f, InferredTypeConstructor as i, fewestArgumentsCall as l, writtenTypeArguments as m, GeneratorCallRefusal as n, IntrospectedTable as o, toEnumMemberName as p, GeneratorCallsResult as r, PhaseCallText as s, ColumnTypeOf as t, generatorCallsFor as u };
-//# sourceMappingURL=psl-build-CNncjpsa.d.mts.map
+export { sameInNormalForm as _, InferredTypeConstructor as a, PhaseCallText as c, WrittenPslTypeCall as d, WrittenTypeChoiceCall as f, inferredTypeConstructors as g, inferColumnTypes as h, GeneratorCallsResult as i, PslTypeArgument as l, generatorCallsFor as m, ColumnTypeReadsDefault as n, InferredTypeConstructors as o, fewestArgumentsCall as p, GeneratorCallRefusal as r, IntrospectedTable as s, ColumnTypeOf as t, PslTypeCall as u, toEnumMemberName as v, writtenTypeChoiceCall as y };
+//# sourceMappingURL=psl-build-DCZaF5g4.d.mts.map

package/dist/psl-build-DCZaF5g4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-build-DCZaF5g4.d.mts","names":[],"sources":["../../../../2-sql-family/9-family/dist/psl-build.d.mts"],"mappings":";;;;;;;;;;;UASU;WACC;WACA,YAAY;WACZ,UAAU;;;KAGhB,2BAA2B,oBAAoB;;iBAEnC,yBAAyB;WAC/B,gBAAgB;WAChB,aAAa,KAAK;WAClB,gBAAgB;IACvB;;;;;;;iBAOa,oBAAoB,QAAQ,yBAAyB,QAAQ,gBAAgB;;UAEpF;WACC;WACA;;;UAGD;WACC;WACA,eAAe;;;UAGhB,8BAA8B;WAC7B,SAAS;;;;;iBAKH,iBAAiB,UAAU,eAAe,UAAU,gCAAgC,QAAQ;;;;iBAI5F,sBAAsB;WAC5B,gBAAgB;WAChB,MAAM;WACN,WAAW;WACX,cAAc,UAAU,gCAAgC,QAAQ;IACvE;;;;UAIM;WACC;WACA,eAAe;WACf;aACE;aACA;;;;KAIR,gBAAgB,mBAAmB,uBAAuB;;KAE1D,0BAA0B,mBAAmB,QAAQ,aAAa,MAAM,gBAAgB;;UAEnF;WACC;WACA;WACA,kBAAkB;;;;;iBAKZ,iBAAiB;WACvB,iBAAiB;WACjB,cAAc;;WAEd,gBAAgB;;WAEhB,WAAW;WACX,eAAe,QAAQ;;WAEvB,cAAc;IACrB,QAAQ;;;;UAIF;WACC,OAAO;WACP;;KAEN;WACM;WACA,OAAO;WACP,WAAW;;WAEX;WACA,OAAO;WACP,WAAW;WACX;WACA,UAAU;;WAEV;;KAEN;WACM;WACA,gBAAgB;;WAEhB;WACA,SAAS;;;;;iBAKH,kBAAkB;WACxB,kBAAkB;WAClB,OAAO;WACP;WACA,oBAAoB;IAC3B;;;;;;;;;iBASa,iBAAiB"}

package/dist/{psl-column-resolution-djGEITmJ-DfEOkjPf.d.mts → psl-column-resolution-djGEITmJ-C0LSpwl4.d.mts}

@@ -1,4 +1,4 @@
-import "./contract-builder-B8oDZ4aU.mjs";
+import "./contract-builder-D6JuOGA6.mjs";
 import { AuthoringTypeConstructorDescriptor, DataTypeSupport } from "@prisma/orm-framework/components/authoring";
 import { ValueSetRef } from "@prisma/orm-framework/contract/types";
 import { CodecLookupWithDescriptors } from "@prisma/orm-framework/components/codec";
@@ -21,4 +21,4 @@ type ColumnDescriptor = {
 };
 //#endregion
 export { ColumnDescriptor as t };
-//# sourceMappingURL=psl-column-resolution-djGEITmJ-DfEOkjPf.d.mts.map
+//# sourceMappingURL=psl-column-resolution-djGEITmJ-C0LSpwl4.d.mts.map

package/dist/{psl-column-resolution-djGEITmJ-DfEOkjPf.d.mts.map → psl-column-resolution-djGEITmJ-C0LSpwl4.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"psl-column-resolution-djGEITmJ-DfEOkjPf.d.mts","names":[],"sources":["../../../../2-sql-family/2-authoring/contract-psl/dist/psl-column-resolution-djGEITmJ.d.mts"],"mappings":";;;;;;;;KASK;WACM;WACA,aAAa;;;;;;;;;WASb,WAAW"}
+{"version":3,"file":"psl-column-resolution-djGEITmJ-C0LSpwl4.d.mts","names":[],"sources":["../../../../2-sql-family/2-authoring/contract-psl/dist/psl-column-resolution-djGEITmJ.d.mts"],"mappings":";;;;;;;;KASK;WACM;WACA,aAAa;;;;;;;;;WASb,WAAW"}

package/dist/{psl-field-resolution-Bvhx79fP-CuyYFk8z.mjs → psl-field-resolution-BW2_FOb9-DxqR43fo.mjs}

@@ -1,7 +1,7 @@
-import { u as sqlCodecColumnLength } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
+import { u as sqlCodecColumnLength } from "./sql-data-type-LVBldu1a-Bq203xWX.mjs";
 import { p as sqlTextFromStored, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-CKgKznXS.mjs";
-import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-CnQqLEIi.mjs";
-import { i as isValueObjectMember, o as storedAsListColumn } from "./derived-checks-BuTkSE9l-gyx0d0dX.mjs";
+import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-qcQteqs2.mjs";
+import { i as isValueObjectMember, o as storedAsListColumn } from "./derived-checks-D__agoFB-Boa1MHcA.mjs";
 import { n as getAttribute, o as storageName, t as formatDbAttributeMigrationMessage } from "./psl-attribute-parsing-BCsFWsSp-BJ-wGlY6.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
@@ -13,9 +13,9 @@ import { InternalError, isInternalError } from "@prisma/orm-framework/utils/inte
 import { FunctionCallAst } from "@prisma/orm-framework/psl-parser/syntax";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
 import { describeTaggedLiteralFailure as describeTaggedLiteralFailure$1 } from "@prisma/orm-framework/components/control";
-import { bool, contributedTypeCodecId, contributedTypeOf, dataTypeValue, diagnosticSource, entityRef, fieldAttribute, fieldRef, funcCall, generatorAttributeSpec, identifier, interpretAttribute, leafDiagnostic, list, mapArg, modelAttribute, nodePslSpan, nodeSourceText, numLiteral, oneOf, optional, record, referencedFieldRef, refuseRepeatedTypeAliasAttributes, str, taggedLiteral, typeAttribute, typeAttributeSpecContextOfField, typeAttributeSubjectLabel, typeGeneratorAttributeSpec, typeReferenceNode, writtenList, writtenScalar } from "@prisma/orm-framework/psl-parser";
-import { isBareTypeConstructor, mapPslHelperArgs, reportTypeConstructorNotCalled } from "@prisma/orm-framework/psl-parser/interpret";
-//#region ../../../2-sql-family/2-authoring/contract-psl/dist/psl-field-resolution-Bvhx79fP.mjs
+import { bool, contributedTypeCodecId, contributedTypeOf, dataTypeValue, diagnosticSource, entityRef, fieldAttribute, fieldRef, funcCall, generatorAttributeSpec, identifier, interpretAttribute, isContributedTypeChoice, leafDiagnostic, list, mapArg, modelAttribute, nodePslSpan, nodeSourceText, numLiteral, oneOf, optional, record, referencedFieldRef, refuseRepeatedTypeAliasAttributes, str, taggedLiteral, typeAttribute, typeAttributeSpecContextOfField, typeAttributeSubjectLabel, typeGeneratorAttributeSpec, typeReferenceNode, writtenList, writtenScalar } from "@prisma/orm-framework/psl-parser";
+import { argumentIndexOf, argumentSpan, instantiatePslTypeChoice, isBareTypeConstructor, mapPslHelperArgs, reportTypeConstructorNotCalled } from "@prisma/orm-framework/psl-parser/interpret";
+//#region ../../../2-sql-family/2-authoring/contract-psl/dist/psl-field-resolution-BW2_FOb9.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -62,11 +62,9 @@ function storedValueReader(input) {
 	const suggestedTypes = [descriptor.dataType];
 	const params = dataTypeParams(codec.dataType, input.column.typeParams);
 	const read = (written, elementIndex) => {
-		let stored;
+		let value;
 		try {
-			const value = codec.dataType.valueFrom(written, params);
-			codec.fromDataTypeValue(value);
-			stored = codec.dataType.toContract(value);
+			value = codec.dataType.valueFrom(written, params);
 		} catch (error) {
 			if (isInternalError(error)) throw error;
 			return {
@@ -80,6 +78,23 @@ function storedValueReader(input) {
 				suggestedTypes
 			};
 		}
+		const stored = codec.dataType.toContract(value);
+		try {
+			codec.fromDataTypeValue(value);
+		} catch (error) {
+			if (isInternalError(error)) throw error;
+			return {
+				ok: false,
+				refusal: {
+					kind: "refused-by-codec",
+					codecId: input.column.codecId,
+					message: messageOf(error),
+					elementIndex,
+					stored
+				},
+				suggestedTypes
+			};
+		}
 		return {
 			ok: true,
 			value: stored
@@ -145,16 +160,30 @@ function readDataTypeDefault(input) {
 	}
 	if (input.isList) {
 		const elements = [];
+		let codecRefusal;
 		for (const [elementIndex, written] of input.written.elements.entries()) {
 			if (written.kind === "list") return nestedList(elementIndex, suggestedTypes);
 			const element = readOne(written, elementIndex);
-			if (!element.ok) return element;
+			if (!element.ok && element.refusal.kind === "refused-by-codec") {
+				codecRefusal ??= element.refusal;
+				elements.push(element.refusal.stored);
+				continue;
+			}
+			if (!element.ok) return codecRefusal === void 0 ? element : refused({
+				kind: "refused-by-column",
+				codecId: codecRefusal.codecId,
+				message: codecRefusal.message,
+				elementIndex: codecRefusal.elementIndex
+			}, suggestedTypes);
 			elements.push(element.value);
 		}
-		return {
+		return codecRefusal === void 0 ? {
 			ok: true,
 			value: elements
-		};
+		} : refused({
+			...codecRefusal,
+			stored: elements
+		}, suggestedTypes);
 	}
 	return readListIntoScalar({
 		...input,
@@ -263,11 +292,7 @@ function codecRefusalMessage(refusal, subject) {
 	};
 }
 function storedRefusalMessage(refusal, subject) {
-	if (refusal.kind === "refused-by-column") return codecRefusalMessage(refusal, subject);
-	return {
-		code: "PSL_INVALID_LITERAL",
-		message: `${location(subject, refusal.elementIndex)}: ${refusal.message}`
-	};
+	return codecRefusalMessage(refusal, subject);
 }
 /** A refusal worded as a PSL diagnostic's code and message; `guidance` says what to write instead. */
 function refusalMessage(refusal, subject, dataTypes, guidance) {
@@ -277,7 +302,8 @@ function refusalMessage(refusal, subject, dataTypes, guidance) {
 			code: PSL_DEFAULT_LIST_EXPECTED,
 			message: `${where}: this column holds a list, so its default is a list literal, as in [1, 2]`
 		};
-		case "refused-by-column": return codecRefusalMessage(refusal, subject);
+		case "refused-by-column":
+		case "refused-by-codec": return codecRefusalMessage(refusal, subject);
 		case "no-list-cast": return {
 			code: PSL_VALUE_TYPE_INCOMPATIBLE,
 			message: `${where}: ${describeExpected(guidance.forms)}; got a list`
@@ -298,7 +324,8 @@ function refusalMessage(refusal, subject, dataTypes, guidance) {
 function refusalSpan(refusal, spans, subject) {
 	switch (refusal.kind) {
 		case "not-a-list":
-		case "refused-by-column": return spans.attribute;
+		case "refused-by-column":
+		case "refused-by-codec": return spans.attribute;
 		default: return writtenValueSpan(spans, refusal.elementIndex, subject);
 	}
 }
@@ -448,8 +475,8 @@ function defaultFunctionCall(name, entry, dataTypes) {
 }
 /** The data type of the column a field declares, when its type, or the named type it is declared with, is a constructor the stack knows. */
 function receivingDataType(ctx) {
-	const typeConstructor = ctx.typeConstructor;
-	return typeConstructor === void 0 ? void 0 : ctx.dataTypes.dataTypeOfCodec(contributedTypeCodecId(typeConstructor.descriptor));
+	const codecId = ctx.contributedType === void 0 ? void 0 : contributedTypeCodecId(ctx.contributedType, ctx.dataTypes);
+	return codecId === void 0 ? void 0 : ctx.dataTypes.dataTypeOfCodec(codecId);
 }
 /** Whether a value of `type` can be written for a column of `receiving`: it is that type, or the column's type casts from it. An unknown column takes every type. */
 function receives(dataTypes, receiving, type) {
@@ -797,7 +824,7 @@ function fieldSpecContext(input) {
 		model: input.model,
 		field: input.field,
 		typeResolution,
-		typeConstructor: contributedTypeOf(typeResolution, input.binder),
+		contributedType: contributedTypeOf(typeResolution, input.binder, input.field.typeConstructor),
 		defaultFunctionRegistry: input.defaultFunctionRegistry,
 		generatorFunctions: input.generatorFunctions,
 		dataTypes: input.dataTypes
@@ -960,13 +987,6 @@ function jsonKind(value) {
 	if (typeof value === "object") return "a JSON object";
 	return `a JSON ${typeof value}`;
 }
-function argumentSpan(call, descriptors, index) {
-	if (index === void 0) return call.span;
-	const name = descriptors?.[index]?.name;
-	const named = call.args.find((arg) => arg.kind === "named" && arg.name === name);
-	const positional = call.args.filter((arg) => arg.kind === "positional")[index];
-	return (named ?? positional)?.span ?? call.span;
-}
 /**
 * Checks the type parameters a constructor produced against its codec's parameter schema,
 * reporting a failure at the argument the failing parameter came from. Returns whether they passed.
@@ -986,12 +1006,6 @@ function checkPslTypeParams(input) {
 		return false;
 	}
 }
-function argumentIndexOf(error) {
-	if (typeof error !== "object" || error === null || !("details" in error)) return void 0;
-	const { details } = error;
-	if (typeof details !== "object" || details === null || !("argumentIndex" in details)) return;
-	return typeof details.argumentIndex === "number" ? details.argumentIndex : void 0;
-}
 /**
 * Walks `authoringContributions.entityTypes` segment-by-segment and returns
 * the entity type descriptor at the resolved path, or `undefined` if no
@@ -1186,6 +1200,22 @@ function resolveFieldTypeDescriptor(input) {
 		case "contributedNamespace":
 		case "mixin": return NOT_RESOLVED;
 		case "contributedType": {
+			if (isContributedTypeChoice(resolution.symbol)) {
+				const instantiated = instantiatePslTypeChoice({
+					symbol: resolution.symbol,
+					call,
+					span: field.span,
+					codecLookup: input.codecLookup,
+					diagnostics,
+					source,
+					entityLabel,
+					dataTypes: input.dataTypes
+				});
+				return instantiated === void 0 ? NOT_RESOLVED : {
+					ok: true,
+					descriptor: instantiated
+				};
+			}
 			const { descriptor, path } = resolution.symbol;
 			const written = path.join(".");
 			if (descriptor.kind === "typeAlias") {
@@ -1870,4 +1900,4 @@ function mergeExecutionDefaults(fromAttributes, fromTypeAlias) {
 //#endregion
 export { modelSpecContext as _, describeUnsupportedSqlAttribute as a, sqlAttributeSpecs as b, instantiateFieldTypeConstructor as c, interpretModelAttribute as d, lowerEnumDefault as f, modelCoordinateKey as g, modelAttributeSpecsFrom as h, defaultFunctionCall as i, instantiatePslTypeConstructor as l, lowerTypeGenerators as m, collectResolvedFields as n, fieldSpecContext as o, lowerTypeDefault as p, contractError as r, getAuthoringEntity as s, PSL_CHECK_ON_STI_VARIANT as t, interpretFieldAttribute as u, readDataTypeDefault as v, resolveFieldTypeDescriptor as y };
 
-//# sourceMappingURL=psl-field-resolution-Bvhx79fP-CuyYFk8z.mjs.map
+//# sourceMappingURL=psl-field-resolution-BW2_FOb9-DxqR43fo.mjs.map