@prisma/orm-family-sql 8.0.0-rc.18-dev.16 → 8.0.0-rc.18-dev.18

package/dist/{psl-field-resolution-SPNDr-jr-CH_gs3Oy.mjs → psl-field-resolution-o9sXqIlE-BJnlxQ4z.mjs}

@@ -1,24 +1,25 @@
-import { m as sqlTextFromCanonical, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-DSRILiU2.mjs";
-import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-DlpO67uZ.mjs";
-import { a as storedAsListColumn, i as isValueObjectMember } from "./derived-checks-Cgx_VgS3-CmFqNFgU.mjs";
+import { p as sqlTextFromStored, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-BJCuy-WI.mjs";
+import { d as resolvedTypeParams } from "./types-M_FeBD9w.mjs";
+import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-Bvfk0aN7.mjs";
+import { a as storedAsListColumn, i as isValueObjectMember } from "./derived-checks-CrvMQTJF-DlxFFtNM.mjs";
 import { n as getAttribute, o as storageName, t as formatDbAttributeMigrationMessage } from "./psl-attribute-parsing-BCsFWsSp-LaNsbcrw.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { admittedForms, castTypedValue, describeExpected, describeRefusal, describeRefusedValueType, exactRewrite, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, readWrittenValue, tagForm, validateAuthoringHelperArguments, validateAuthoringTypeParams } from "@prisma/orm-framework/components/authoring";
-import { canonicalFormOf, codecForRef } from "@prisma/orm-framework/components/codec";
+import { codecForRef, dataTypeParams, readContractValue } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { InternalError, isInternalError } from "@prisma/orm-framework/utils/internal-error";
 import { FunctionCallAst } from "@prisma/orm-framework/psl-parser/syntax";
 import { invariant } from "@prisma/orm-framework/utils/assertions";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
-import { bool, dataTypeValue, diagnosticSource, entityRef, fieldAttribute, fieldRef, funcCall, identifier, interpretAttribute, leafDiagnostic, list, mapArg, modelAttribute, nodePslSpan, numLiteral, oneOf, optional, record, referencedFieldRef, str, taggedLiteral, typeReferenceNode, writtenList, writtenScalar } from "@prisma/orm-framework/psl-parser";
+import { bool, contributedTypeOf, dataTypeValue, diagnosticSource, entityRef, fieldAttribute, fieldRef, funcCall, identifier, interpretAttribute, leafDiagnostic, list, mapArg, modelAttribute, nodePslSpan, numLiteral, oneOf, optional, record, referencedFieldRef, str, taggedLiteral, typeReferenceNode, writtenList, writtenScalar } from "@prisma/orm-framework/psl-parser";
 import { describeTaggedLiteralFailure as describeTaggedLiteralFailure$1 } from "@prisma/orm-framework/components/control";
 import { instantiatePslFieldPreset, isBareTypeConstructor, mapPslHelperArgs, reportPresetNotCalled, reportTypeConstructorNotCalled } from "@prisma/orm-framework/psl-parser/interpret";
-//#region ../../../2-sql/2-authoring/contract-psl/dist/psl-field-resolution-SPNDr-jr.mjs
+//#region ../../../2-sql/2-authoring/contract-psl/dist/psl-field-resolution-o9sXqIlE.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
-/** A written value the column's codec refuses. */
+/** A written value the column's type, under the column's parameters, or the column's codec refuses. */
 const PSL_INVALID_DEFAULT_LITERAL = "PSL_INVALID_DEFAULT_LITERAL";
 /** A written value whose data type the receiving type neither is nor casts from. */
 const PSL_VALUE_TYPE_INCOMPATIBLE = "PSL_VALUE_TYPE_INCOMPATIBLE";
@@ -48,32 +49,8 @@ function readOneValue(dataTypes, written, elementIndex, suggestedTypes) {
 function codecRefTypeParams(typeParams) {
 	return typeParams === void 0 ? void 0 : blindCast(typeParams);
 }
-/** A value in the canonical form of the column's values, when they have one. */
-function inCanonicalForm(toCanonicalForm, value, elementIndex, suggestedTypes) {
-	if (toCanonicalForm === void 0) return {
-		ok: true,
-		value
-	};
-	try {
-		return {
-			ok: true,
-			value: toCanonicalForm(value)
-		};
-	} catch (error) {
-		if (isInternalError(error)) throw error;
-		return {
-			ok: false,
-			refusal: {
-				kind: "unreadable",
-				message: messageOf(error),
-				elementIndex
-			},
-			suggestedTypes
-		};
-	}
-}
 /**
-* The column's codec descriptor, and `read`, which reads a value in its stored JSON form with the column's codec, built with the column's type parameters, and gives it the canonical form of the column's values.
+* The column's codec descriptor, and `read`, which makes a value in its stored JSON form a value of the column's type under the column's parameters, and checks it with the column's codec, built with those parameters.
 */
 function storedValueReader(input) {
 	const descriptor = input.codecLookup.descriptorFor(input.column.codecId);
@@ -83,16 +60,19 @@ function storedValueReader(input) {
 	});
 	if (codec === void 0 || descriptor === void 0) throw new InternalError(`Field "${input.fieldPath}": no codec descriptor is registered for "${input.column.codecId}", but the column was resolved from one.`);
 	const suggestedTypes = [descriptor.dataType];
-	const toCanonicalForm = canonicalFormOf(descriptor, input.dataTypeLookup);
+	const params = dataTypeParams(codec.dataType, input.column.typeParams);
 	const read = (written, elementIndex) => {
+		let stored;
 		try {
-			codec.decodeJson(written);
+			const value = codec.dataType.valueFrom(written, params);
+			codec.fromDataTypeValue(value);
+			stored = codec.dataType.toContract(value);
 		} catch (error) {
 			if (isInternalError(error)) throw error;
 			return {
 				ok: false,
 				refusal: {
-					kind: "refused-by-codec",
+					kind: "refused-by-column",
 					codecId: input.column.codecId,
 					message: messageOf(error),
 					elementIndex
@@ -100,15 +80,19 @@ function storedValueReader(input) {
 				suggestedTypes
 			};
 		}
-		return inCanonicalForm(toCanonicalForm, written, elementIndex, suggestedTypes);
+		return {
+			ok: true,
+			value: stored
+		};
 	};
 	return {
 		descriptor,
+		params,
 		read
 	};
 }
 /**
-* Reads a value already in its stored JSON form, such as one member of a JSON document default, with the column's codec, and gives it the canonical form of the column's values. Worded as {@link lowerDataTypeDefault} words the same refusals.
+* Reads a value already in its stored JSON form, such as one member of a JSON document default, as a value of the column's type checked by the column's codec. Worded as {@link lowerDataTypeDefault} words the same refusals.
 */
 function readStoredValue(input) {
 	const reading = storedValueReader(input).read(input.value, void 0);
@@ -124,7 +108,7 @@ function readStoredValue(input) {
 * its type's list cast — which is how `pgvector.Vector(3) @default([0.1, 0.2])` is read.
 */
 function readDataTypeDefault(input) {
-	const { descriptor, read: readStored } = storedValueReader({
+	const { descriptor, params, read: readStored } = storedValueReader({
 		...input,
 		dataTypeLookup: input.dataTypes.lookup
 	});
@@ -133,11 +117,19 @@ function readDataTypeDefault(input) {
 	const readOne = (written, elementIndex) => {
 		const read = readOneValue(input.dataTypes, written, elementIndex, suggestedTypes);
 		if (!read.ok) return read;
-		const cast = castTypedValue(input.dataTypes, columnType, read.typed);
-		if (!cast.ok) return refused({
-			...cast.failure,
-			elementIndex
-		}, suggestedTypes);
+		const cast = castTypedValue(input.dataTypes, columnType, params, read.typed);
+		if (!cast.ok) {
+			const { failure } = cast;
+			return failure.kind === "refused-by-type" ? refused({
+				kind: "refused-by-column",
+				codecId: input.column.codecId,
+				message: failure.message,
+				elementIndex
+			}, suggestedTypes) : refused({
+				...failure,
+				elementIndex
+			}, suggestedTypes);
+		}
 		return readStored(cast.value.value, elementIndex);
 	};
 	if (input.written.kind !== "list") {
@@ -225,7 +217,7 @@ function formsOf(dataTypes, types) {
 function rewriteOf(refusal, written, dataTypes) {
 	if (refusal.kind !== "no-cast") return void 0;
 	const refused = refusal.elementIndex === void 0 || written.kind !== "list" ? written : written.elements[refusal.elementIndex];
-	return refused === void 0 || refused.kind === "list" ? void 0 : exactRewrite(dataTypes, refusal.receivingType, refused);
+	return refused === void 0 || refused.kind === "list" ? void 0 : exactRewrite(dataTypes, refusal, refused);
 }
 /**
 * {@link readDataTypeDefault} worded as a PSL diagnostic's code, message and span: a cast-rule
@@ -285,7 +277,7 @@ function codecRefusalMessage(refusal, subject) {
 	};
 }
 function storedRefusalMessage(refusal, subject) {
-	if (refusal.kind === "refused-by-codec") return codecRefusalMessage(refusal, subject);
+	if (refusal.kind === "refused-by-column") return codecRefusalMessage(refusal, subject);
 	return {
 		code: "PSL_INVALID_LITERAL",
 		message: `${location(subject, refusal.elementIndex)}: ${refusal.message}`
@@ -299,7 +291,7 @@ 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-codec": return codecRefusalMessage(refusal, subject);
+		case "refused-by-column": return codecRefusalMessage(refusal, subject);
 		case "no-list-cast": return {
 			code: PSL_VALUE_TYPE_INCOMPATIBLE,
 			message: `${where}: ${describeExpected(guidance.forms)}; got a list`
@@ -320,7 +312,7 @@ function refusalMessage(refusal, subject, dataTypes, guidance) {
 function refusalSpan(refusal, spans, fieldPath) {
 	switch (refusal.kind) {
 		case "not-a-list":
-		case "refused-by-codec": return spans.attribute;
+		case "refused-by-column": return spans.attribute;
 		default: return writtenValueSpan(spans, refusal.elementIndex, fieldPath);
 	}
 }
@@ -454,32 +446,44 @@ function defaultFunctionArm(name, signature) {
 		call
 	}));
 }
-function scalarDefaultArms(isList, dataTypes, defaultFunctionRegistry) {
+/** The data type of the column a field declares, when its type, or the named type it is declared with, is a constructor or preset the stack knows. */
+function receivingDataType(ctx) {
+	const typeConstructor = ctx.typeConstructor;
+	return typeConstructor === void 0 ? void 0 : ctx.dataTypes.dataTypeOfCodec(typeConstructor.descriptor.output.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) {
+	if (receiving === void 0 || type === receiving) return true;
+	const receivingType = dataTypes.lookup.get(receiving);
+	if (receivingType === void 0) return true;
+	return Object.hasOwn(receivingType.casts, type) || (receivingType.listCast?.of.some((of) => of === type) ?? false);
+}
+function scalarDefaultArms(isList, receiving, dataTypes, defaultFunctionRegistry) {
 	const tagArms = (admits) => {
 		const tagsByDocumentation = /* @__PURE__ */ new Map();
-		for (const [dataType, entry] of Object.entries(dataTypes.entries)) {
-			if (entry.written.kind !== "tag" || !admits(dataType)) continue;
+		for (const [key, entry] of Object.entries(dataTypes.entries)) {
+			if (entry.written.kind !== "tag" || !admits(key)) continue;
 			const tags = tagsByDocumentation.get(entry.documentation);
 			if (tags === void 0) tagsByDocumentation.set(entry.documentation, [entry.written.tag]);
 			else tags.push(entry.written.tag);
 		}
 		return [...tagsByDocumentation].map(([documentation, tags]) => writtenScalar(taggedLiteral(tags, { documentation })));
 	};
-	const anyTag = () => tagArms(() => true);
-	const literal = () => oneOf(writtenScalar(str()), writtenScalar(numLiteral()), writtenScalar(bool()), nullLiteral(), ...tagArms((dataType) => dataType !== SQL_EXPRESSION_DATA_TYPE_ID));
+	const columnTags = () => tagArms((dataType) => dataType === SQL_EXPRESSION_DATA_TYPE_ID || !isList && receives(dataTypes, receiving, dataType));
+	const literal = () => oneOf(writtenScalar(str()), writtenScalar(numLiteral()), writtenScalar(bool()), nullLiteral(), ...tagArms((dataType) => dataType !== SQL_EXPRESSION_DATA_TYPE_ID && receives(dataTypes, receiving, dataType)));
 	const listArm = () => writtenList(literal());
 	const funcArms = [...defaultFunctionRegistry.entries()].map(([name, entry]) => defaultFunctionArm(name, blindCast(entry.signature)));
 	return isList ? [
 		listArm(),
 		...funcArms,
-		...anyTag()
+		...columnTags()
 	] : [
 		writtenScalar(str()),
 		writtenScalar(numLiteral()),
 		writtenScalar(bool()),
 		nullLiteral(),
 		...funcArms,
-		...anyTag(),
+		...columnTags(),
 		listArm()
 	];
 }
@@ -535,7 +539,7 @@ function defaultFieldSpec(ctx) {
 		documentation: "Supplies a default value when this field is omitted from a mutation.",
 		positional: [{
 			key: "value",
-			type: defaultValueArm(members === void 0 ? scalarDefaultArms(ctx.field.list, ctx.dataTypes, ctx.defaultFunctionRegistry) : enumDefaultArms(members, ctx.field.typeName, ctx.field.list), ctx.defaultFunctionRegistry),
+			type: defaultValueArm(members === void 0 ? scalarDefaultArms(ctx.field.list, receivingDataType(ctx), ctx.dataTypes, ctx.defaultFunctionRegistry) : enumDefaultArms(members, ctx.field.typeName, ctx.field.list), ctx.defaultFunctionRegistry),
 			documentation: "A literal, enum member, or registered default function compatible with this field."
 		}]
 	});
@@ -668,7 +672,7 @@ function checkModelSpec(ctx) {
 		},
 		refine: (value, ctx, attributeNode) => {
 			const diagnostics = [];
-			if (sqlTextFromCanonical(value.expression.value).trim().length === 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` expression must not be empty — an empty predicate is not a constraint", PSL_CHECK_EXPRESSION_EMPTY));
+			if (sqlTextFromStored(value.expression.value.value).trim().length === 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` expression must not be empty — an empty predicate is not a constraint", PSL_CHECK_EXPRESSION_EMPTY));
 			if (value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` requires a `name` or `map` argument (a default name cannot be derived — a check has no column tuple to name itself after)", PSL_CHECK_REQUIRES_NAME_OR_MAP));
 			if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` takes at most one of `name` and `map`", PSL_CHECK_NAME_XOR_MAP));
 			return diagnostics;
@@ -774,11 +778,13 @@ function modelSpecContext(input) {
 }
 function fieldSpecContext(input) {
 	const node = typeReferenceNode(input.field);
+	const typeResolution = node === void 0 ? void 0 : input.binder.symbolForNode(node);
 	return {
 		symbols: input.symbols,
 		model: input.model,
 		field: input.field,
-		typeResolution: node === void 0 ? void 0 : input.binder.symbolForNode(node),
+		typeResolution,
+		typeConstructor: contributedTypeOf(typeResolution, input.binder),
 		defaultFunctionRegistry: input.defaultFunctionRegistry,
 		dataTypes: input.dataTypes
 	};
@@ -819,7 +825,7 @@ function valueObjectDefaultDocument(input) {
 		const document = input.stored.map((element) => readDocument(codec, element));
 		return {
 			document,
-			stored: codec.encodeJson(document)
+			stored: codec.dataType.toContract(codec.toDataTypeValue(document))
 		};
 	}
 	return {
@@ -830,7 +836,7 @@ function valueObjectDefaultDocument(input) {
 /** The column's codec has already read `stored` while the default was lowered, so it reads again. */
 function readDocument(codec, stored) {
 	if (stored === null) return null;
-	return blindCast(codec.decodeJson(stored));
+	return blindCast(readContractValue(codec, stored, void 0));
 }
 /** Each way the default does not match the composite type. */
 function valueObjectDefaultMismatches(input) {
@@ -923,7 +929,7 @@ function enumValueMismatch(value, member, path, codecLookup) {
 	const handle = member.enumTypeHandle;
 	if (handle === void 0) return void 0;
 	const codec = codecLookup.get(handle.codecId);
-	const stored = handle.values.map((enumValue) => codec === void 0 ? enumValue : codec.encodeJson(enumValue));
+	const stored = handle.values.map((enumValue) => codec === void 0 ? enumValue : codec.dataType.toContract(codec.toDataTypeValue(enumValue)));
 	if (stored.some((storedValue) => storedValue === value)) return void 0;
 	return {
 		code: PSL_INVALID_DEFAULT_LITERAL,
@@ -1332,7 +1338,7 @@ function lowerDefaultForField(input) {
 		return { defaultValue: {
 			kind: "literal",
 			value: null,
-			canonical: true
+			inStoredForm: true
 		} };
 	}
 	if (value.kind === "list" && rejectStrictListNullDefault({
@@ -1347,7 +1353,10 @@ function lowerDefaultForField(input) {
 			spans,
 			sourceElementIndexes,
 			isList: readsListElements(written),
-			column: input.columnDescriptor,
+			column: {
+				codecId: input.columnDescriptor.codecId,
+				typeParams: input.columnTypeParams
+			},
 			codecLookup: input.codecLookup,
 			dataTypes: input.dataTypes,
 			fieldPath: `${input.modelName}.${input.fieldName}`
@@ -1392,13 +1401,13 @@ function lowerDefaultForField(input) {
 			return { defaultValue: {
 				kind: "literal",
 				value: stored,
-				canonical: true
+				inStoredForm: true
 			} };
 		}
 		return { defaultValue: {
 			kind: "literal",
 			value: restoredValue,
-			canonical: true
+			inStoredForm: true
 		} };
 	};
 	const canonicalized = (scalar) => {
@@ -1472,7 +1481,7 @@ function lowerDefaultForField(input) {
 		};
 		if (written.kind !== "tag") return readAsLiteral(written, spans);
 		const read = readWrittenValue(input.dataTypes, written);
-		if (read.ok && read.value.type === SQL_EXPRESSION_DATA_TYPE_ID) return sqlExpressionDefault(sqlTextFromCanonical(read.value.value), value.span);
+		if (read.ok && read.value.type === SQL_EXPRESSION_DATA_TYPE_ID) return sqlExpressionDefault(sqlTextFromStored(read.value.value), value.span);
 		return readAsLiteral(written, spans);
 	}
 	const { call } = value;
@@ -1748,6 +1757,7 @@ function collectResolvedFields(input) {
 			sources: input.sources,
 			binder: input.binder,
 			columnDescriptor: descriptor,
+			columnTypeParams: resolvedTypeParams(descriptor, input.namedTypes),
 			isListColumn,
 			valueObjectDefault: valueObjectName === void 0 ? void 0 : {
 				valueObjectName,
@@ -1853,4 +1863,4 @@ function collectResolvedFields(input) {
 //#endregion
 export { resolveFieldTypeDescriptor as _, describeUnsupportedSqlAttribute as a, instantiateFieldTypeConstructor as c, interpretModelAttribute as d, modelAttributeSpecsFrom as f, readWrittenNumberForCodec as g, readDataTypeDefault as h, contractError as i, instantiatePslTypeConstructor as l, modelSpecContext as m, bareTypeConstructorOf as n, fieldSpecContext as o, modelCoordinateKey as p, collectResolvedFields as r, getAuthoringEntity as s, PSL_CHECK_ON_STI_VARIANT as t, interpretFieldAttribute as u, sqlAttributeSpecs as v, toNamedTypeFieldDescriptor as y };
 
-//# sourceMappingURL=psl-field-resolution-SPNDr-jr-CH_gs3Oy.mjs.map
+//# sourceMappingURL=psl-field-resolution-o9sXqIlE-BJnlxQ4z.mjs.map