@prisma/orm-family-sql 8.0.0-rc.11-dev.42 → 8.0.0-rc.11-dev.44

package/dist/contract-prisma7__provider.d.mts

@@ -1,5 +1,5 @@
 import { i as SqlNamespaceBase, s as SqlNamespaceInput } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
-import "./types-BmgtemBx.mjs";
+import "./types-C36_3E6_.mjs";
 import { ControlPolicy } from "@prisma/orm-framework/contract/types";
 import { TargetPackRef } from "@prisma/orm-framework/components/components";
 import { ContractConfig } from "@prisma/orm-framework/config/config-types";

package/dist/contract-prisma7__provider.mjs

@@ -1,7 +1,7 @@
 import { d as validateSqlStorageConsistency, l as validateModelStorageReferences } from "./validators-y6eLjhcb.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
-import { n as buildSqlContractFromDefinition, t as applySqlSpecifierControlPolicy } from "./derived-checks-C4BPtrnO-B9MQRh6W.mjs";
-import { a as normalizeReferentialAction, n as buildEntityTypesByDiscriminator, o as numberLiteralDefault, r as indexFkRelations, s as resolveFieldTypeDescriptor, t as applyBackrelationCandidates } from "./interpreter-Bf7Um__3-DC_thY44.mjs";
+import { n as buildSqlContractFromDefinition, t as applySqlSpecifierControlPolicy } from "./derived-checks-6WZKIUxH-B3Pd6QA5.mjs";
+import { c as resolveFieldTypeDescriptor, i as indexFkRelations, n as buildEntityTypesByDiscriminator, o as normalizeReferentialAction, r as entryForTag, s as readDataTypeDefault, t as applyBackrelationCandidates } from "./interpreter-BIBwrA2w-DAiNN30m.mjs";
 import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { collectScalarTypeConstructors, instantiateAuthoringEntityType } from "@prisma/orm-framework/components/authoring";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
@@ -93,35 +93,84 @@ function lowerPrisma7Default(input) {
 	return {
 		storage: {
 			kind: "literal",
-			value: scalar
+			value: scalar,
+			canonical: true
 		},
 		onCreate: void 0
 	};
 }
+/**
+* The stored value of a written default: an enum member resolves through the enum's members, and
+* every other value is read by the authoring entry for its syntax, cast into the column's data type
+* and validated by the column's codec — the same path the current schema language takes.
+*/
 function scalarValue$1(expression, input, unknown) {
 	const span = input.attribute.span;
-	const isJson = input.literalForm?.kind === "json";
-	const jsonNull = (holds) => {
-		input.diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_JSON_NULL_DEFAULT_UNSUPPORTED", `Field "${input.modelName}.${input.field.name}": @default(${printSyntax(expression.syntax).trim()}) ${holds} the JSON value null, which the contract cannot tell apart from SQL NULL. Remove the @default or give it another JSON value; either changes the column default on Prisma 7's next migration.`, input.sourceId, span));
-	};
+	const enumValue = enumMemberValue(expression, input);
+	if (enumValue !== void 0) return enumValue;
 	const array = ArrayLiteralAst.cast(expression.syntax);
-	if (array !== void 0) {
+	const elements = array === void 0 ? void 0 : [...array.elements()];
+	if (elements?.some((element) => enumMemberValue(element, input) !== void 0) === true) {
 		const values = [];
-		for (const element of array.elements()) {
-			const value = elementValue(element, input);
-			if (value === void 0) return unknown(rejectedNumberReason(element, input) ?? "lists may only hold literals or enum members.", span);
+		for (const element of elements) {
+			const value = enumMemberValue(element, input);
+			if (value === void 0) return unknown("lists may only hold literals or enum members.", span);
 			values.push(value);
 		}
-		if (isJson && values.includes(null)) return jsonNull("holds");
 		return values;
 	}
-	const value = elementValue(expression, input);
-	if (isJson && value === null) return jsonNull("is");
-	if (value !== void 0) return value;
-	const numberReason = rejectedNumberReason(expression, input);
-	if (numberReason !== void 0) return unknown(numberReason, span);
+	const written = writtenLiteralFor(expression, elements, input);
+	if (written === void 0) return unreadableValue(expression, input, unknown);
+	const jsonNull = jsonNullDefault(written, expression, input);
+	if (jsonNull !== void 0) return jsonNull;
+	const read = readDataTypeDefault({
+		written,
+		isList: input.field.list,
+		column: {
+			codecId: input.codecId,
+			typeParams: input.typeParams
+		},
+		codecLookup: input.codecLookup,
+		support: input.dataTypeSupport,
+		fieldPath: `${input.modelName}.${input.field.name}`
+	});
+	return read.ok ? read.value : unknown(refusalReason(read.refusal), span);
+}
+/** The storage value of an enum member name, when the field is typed by a Prisma 7 enum. */
+function enumMemberValue(expression, input) {
+	const member = IdentifierAst.cast(expression.syntax)?.name();
+	return member === void 0 ? void 0 : input.enumMembers?.get(member);
+}
+function writtenLiteralFor(expression, elements, input) {
+	if (elements === void 0) return writtenLiteral(expression, input);
+	const written = [];
+	for (const element of elements) {
+		const elementLiteral = writtenLiteral(element, input);
+		if (elementLiteral === void 0) return void 0;
+		written.push(elementLiteral);
+	}
+	return {
+		kind: "list",
+		elements: written
+	};
+}
+/**
+* The JSON value null, which the contract cannot tell apart from SQL NULL, reported before the
+* column's codec sees the literal.
+*/
+function jsonNullDefault(written, expression, input) {
+	if (input.literalForm?.kind !== "json") return void 0;
+	const value = jsonDocumentOf(written, input);
+	if (value === void 0) return void 0;
+	if (!(Array.isArray(value) ? value.includes(null) : value === null)) return void 0;
+	input.diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_JSON_NULL_DEFAULT_UNSUPPORTED", `Field "${input.modelName}.${input.field.name}": @default(${printSyntax(expression.syntax).trim()}) ${written.kind === "list" ? "holds" : "is"} the JSON value null, which the contract cannot tell apart from SQL NULL. Remove the @default or give it another JSON value; either changes the column default on Prisma 7's next migration.`, input.sourceId, input.attribute.span));
+}
+/** A `@default(...)` this contract source cannot read as a literal at all. */
+function unreadableValue(expression, input, unknown) {
+	const span = input.attribute.span;
 	const identifier = IdentifierAst.cast(expression.syntax)?.name();
 	if (identifier !== void 0) return unknown(input.enumMembers === void 0 ? `refers to "${identifier}", but the field is not an enum.` : `refers to "${identifier}", which is not a member of the field's enum.`, span);
+	if (ArrayLiteralAst.cast(expression.syntax) !== void 0) return unknown("lists may only hold literals or enum members.", span);
 	return unknown("holds a value this contract source does not read.", span);
 }
 function sqlExpressionDefault(expression, form, isList) {
@@ -141,40 +190,55 @@ function sqlExpressionDefault(expression, form, isList) {
 	}
 	return { expression: form.list(literals) };
 }
-/** The Prisma 7 scalars whose number defaults must be whole numbers, as each is named in a message. */
-const WHOLE_NUMBER_SCALARS = {
-	Int: "an Int",
-	BigInt: "a BigInt"
-};
-const WHOLE_NUMBER_TEXT = /^-?\d+$/;
-/** The number literal the column codec reads neither as a number nor as text, such as `1.5` for a `BigInt`, which Prisma 7 rejects too. */
-function rejectedNumberReason(expression, input) {
-	const text = NumberLiteralExprAst.cast(expression.syntax)?.token()?.text;
-	if (text === void 0 || numberValue(text, input) !== void 0) return void 0;
-	const { typeName } = input.field;
-	const wholeNumberScalar = Object.hasOwn(WHOLE_NUMBER_SCALARS, typeName) ? WHOLE_NUMBER_SCALARS[typeName] : void 0;
-	return wholeNumberScalar === void 0 ? `holds ${text}, which is not a valid ${typeName} value.` : `holds ${text}, which is not an integer; ${wholeNumberScalar} default must be a whole number.`;
+/** The written literal a Prisma 7 expression is, or `undefined` when it is not a literal at all. */
+function writtenLiteral(expression, input) {
+	const text = StringLiteralExprAst.cast(expression.syntax)?.value();
+	if (text !== void 0) return input.literalForm?.kind === "json" ? {
+		kind: "tag",
+		tag: "json",
+		body: text
+	} : {
+		kind: "string",
+		text
+	};
+	const number = NumberLiteralExprAst.cast(expression.syntax)?.token()?.text;
+	if (number !== void 0) return {
+		kind: "number",
+		text: number
+	};
+	const boolean = BooleanLiteralExprAst.cast(expression.syntax)?.value();
+	return boolean === void 0 ? void 0 : {
+		kind: "boolean",
+		value: boolean
+	};
 }
-/** A number default for the field: Prisma 7 accepts only whole numbers for `Int` and `BigInt`. */
-function numberValue(text, input) {
-	if (Object.hasOwn(WHOLE_NUMBER_SCALARS, input.field.typeName) && !WHOLE_NUMBER_TEXT.test(text)) return;
-	return numberLiteralDefault(text, input.codecId, input.codecLookup);
+/**
+* The document a written JSON value holds, read through the same entry the interpreter uses, or
+* `undefined` when the body is not a document.
+*/
+function jsonDocumentOf(written, input) {
+	const entry = entryForTag(input.dataTypeSupport, "json");
+	if (entry === void 0 || entry.entry.written.kind !== "tag") return void 0;
+	const bodies = written.kind === "list" ? written.elements.flatMap((element) => element.kind === "tag" ? [element.body] : []) : written.kind === "tag" ? [written.body] : [];
+	const parse = entry.entry.written.parse;
+	try {
+		const documents = bodies.map((body) => parse(body));
+		return written.kind === "list" ? documents : documents[0];
+	} catch {
+		return;
+	}
 }
-function elementValue(expression, input) {
-	const member = IdentifierAst.cast(expression.syntax)?.name();
-	if (member !== void 0) return input.enumMembers?.get(member);
-	const number = NumberLiteralExprAst.cast(expression.syntax)?.token()?.text;
-	if (number !== void 0) return numberValue(number, input);
-	const text = StringLiteralExprAst.cast(expression.syntax)?.value();
-	if (text !== void 0) {
-		if (input.literalForm?.kind === "json") try {
-			return blindCast(JSON.parse(text));
-		} catch {
-			return;
-		}
-		return text;
+/** Why the column refused the value, as a phrase following `@default `. */
+function refusalReason(refusal) {
+	const at = refusal.elementIndex === void 0 ? "" : ` at element ${refusal.elementIndex + 1}`;
+	switch (refusal.kind) {
+		case "unreadable": return `holds text${at} that this contract source does not read: ${refusal.message}`;
+		case "unknown-tag": return `holds a ${refusal.tag} literal${at}, which this stack does not register.`;
+		case "unwritable": return `holds a ${refusal.syntax} value${at}, which this target has no data type for.`;
+		case "not-a-list": return "holds a single value on a list column, which takes a list literal.";
+		case "no-cast": return `holds a ${refusal.valueType} value${at}, which ${refusal.columnType} has no cast from; ${refusal.casts.length === 0 ? "it casts from nothing" : `it casts from ${refusal.casts.join(", ")}`}.`;
+		case "undecodable": return `holds a value${at} that ${refusal.codecId} does not read: ${refusal.message}`;
 	}
-	return BooleanLiteralExprAst.cast(expression.syntax)?.value();
 }
 function lowerFunction(call, input, label, unknown) {
 	const fn = call.path().join(".");
@@ -1485,7 +1549,12 @@ function readField(args) {
 		field,
 		modelName: model.symbol.name,
 		codecId: resolved.descriptor.codecId,
+		typeParams: resolved.descriptor.typeParams,
 		codecLookup: input.codecLookup,
+		dataTypeSupport: {
+			entries: input.authoringContributions?.dataTypes ?? {},
+			lookup: input.dataTypeLookup
+		},
 		literalForm: binding.literalDefaultForm(resolved.descriptor),
 		enumMembers: enumDeclaration === void 0 ? void 0 : new Map(enumDeclaration.members.map((member) => [member.name, member.value])),
 		controlMutationDefaults: input.controlMutationDefaults,
@@ -1634,6 +1703,7 @@ function prisma7Contract(schemaPath, options) {
 						controlMutationDefaults: context.controlMutationDefaults,
 						authoringContributions: context.authoringContributions,
 						codecLookup: context.codecLookup,
+						dataTypeLookup: context.dataTypeLookup,
 						composedExtensions: context.composedExtensions
 					});
 					if (!interpreted.ok) return interpreted;