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

package/dist/contract-prisma7__provider.d.mts

@@ -1,6 +1,6 @@
 import { a as SqlNamespaceBase, c as SqlNamespaceInput } from "./sql-storage-B_AM6tU1-BOPQxXo7.mjs";
 import "./types-CXRxo_TK.mjs";
-import { ControlPolicy } from "@prisma/orm-framework/contract/types";
+import { ControlPolicy, JsonValue } from "@prisma/orm-framework/contract/types";
 import { TargetPackRef } from "@prisma/orm-framework/components/components";
 import { ContractConfig } from "@prisma/orm-framework/config/config-types";
 //#region ../../../2-sql-family/2-authoring/contract-prisma7/dist/provider.d.mts
@@ -83,6 +83,8 @@ interface Prisma7TargetBinding {
   readonly junctionRelationFieldNames: (tableA: string, tableB: string) => readonly [string, string];
   /** How a literal `@default` on the column is read; `undefined` when the codec takes the written value. */
   readonly literalDefaultForm: (column: Prisma7ColumnType) => Prisma7LiteralDefaultForm | undefined;
+  /** The SQL expression of a default whose value the column's type holds but its codec cannot hold exactly, such as a timestamp with digits below a millisecond read as a JavaScript `Date`: `stored` is the value, or a list column's elements, as the type stores them. */
+  readonly literalDefaultExpression: (stored: JsonValue, column: Prisma7ColumnType) => string;
 }
 //#endregion
 //#region src/provider.d.ts

package/dist/contract-prisma7__provider.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"contract-prisma7__provider.d.mts","names":[],"sources":["../../../../2-sql-family/2-authoring/contract-prisma7/dist/provider.d.mts"],"mappings":";;;;;;;;;;;;UAUU;WACC;;WAEA;;UAED;;WAEC,SAAS,SAAS,eAAe;;;;;;WAMjC,aAAa,SAAS,eAAe;;;;UAItC;WACC;;WAEA;WACA,aAAa,SAAS;;;KAG5B;;;WAGM;;;;WAIA;WACA;;WAEA,OAAO;;WAEP,mBAAmB,iBAAiB;;;UAGrC;WACC;WACA;;;UAGD;WACC,QAAQ;WACR,kBAAkB,OAAO,sBAAsB;;WAE/C;;WAEA,SAAS;;WAET;aACE;aACA;;;WAGF,YAAY,SAAS;;WAErB;;WAEA;aACE,aAAa;aACb,aAAa,mBAAmB;;;;;;;WAOlC,6BAA6B,gBAAgB;;WAE7C,qBAAqB,QAAQ,sBAAsB;;;;UAIpD;WACC,SAAS;WACT;WACA,uBAAuB;;iBAEjB,gBAAgB,oBAAoB,SAAS,yBAAyB"}
+{"version":3,"file":"contract-prisma7__provider.d.mts","names":[],"sources":["../../../../2-sql-family/2-authoring/contract-prisma7/dist/provider.d.mts"],"mappings":";;;;;;;;;;;;UAUU;WACC;;WAEA;;UAED;;WAEC,SAAS,SAAS,eAAe;;;;;;WAMjC,aAAa,SAAS,eAAe;;;;UAItC;WACC;;WAEA;WACA,aAAa,SAAS;;;KAG5B;;;WAGM;;;;WAIA;WACA;;WAEA,OAAO;;WAEP,mBAAmB,iBAAiB;;;UAGrC;WACC;WACA;;;UAGD;WACC,QAAQ;WACR,kBAAkB,OAAO,sBAAsB;;WAE/C;;WAEA,SAAS;;WAET;aACE;aACA;;;WAGF,YAAY,SAAS;;WAErB;;WAEA;aACE,aAAa;aACb,aAAa,mBAAmB;;;;;;;WAOlC,6BAA6B,gBAAgB;;WAE7C,qBAAqB,QAAQ,sBAAsB;;WAEnD,2BAA2B,QAAQ,WAAW,QAAQ;;;;UAIvD;WACC,SAAS;WACT;WACA,uBAAuB;;iBAEjB,gBAAgB,oBAAoB,SAAS,yBAAyB"}

package/dist/contract-prisma7__provider.mjs

@@ -1,18 +1,18 @@
 import { r as lowerAuthoredIndex } from "./index-naming-BOcJT1B3-D-49owHA.mjs";
-import { p as sqlDataTypeOfCodec, u as sqlCodecColumnLength } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
+import { p as sqlDataTypeOfCodec, u as sqlCodecColumnLength } from "./sql-data-type-LVBldu1a-Bq203xWX.mjs";
 import { n as declaredBackingObjectName, r as declaredIndexesServeForeignKey } from "./foreign-key-materialization-CCHAR789.mjs";
 import { h as storedSqlText } from "./sql-expression-CKgKznXS.mjs";
-import { p as validateSqlStorageConsistency, u as validateModelStorageReferences } from "./validators-CnQqLEIi.mjs";
+import { p as validateSqlStorageConsistency, u as validateModelStorageReferences } from "./validators-qcQteqs2.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-HVaxhALD.mjs";
-import { n as buildSqlContractFromDefinition, t as applySqlSpecifierControlPolicy } from "./derived-checks-BuTkSE9l-gyx0d0dX.mjs";
-import { c as instantiateFieldTypeConstructor, i as defaultFunctionCall, v as readDataTypeDefault } from "./psl-field-resolution-Bvhx79fP-CuyYFk8z.mjs";
-import { a as normalizeReferentialAction, n as buildEntityTypesByDiscriminator, r as indexFkRelations, t as applyBackrelationCandidates } from "./interpreter-CrQFtK4p-CM5k_t4g.mjs";
+import { n as buildSqlContractFromDefinition, t as applySqlSpecifierControlPolicy } from "./derived-checks-D__agoFB-Boa1MHcA.mjs";
+import { c as instantiateFieldTypeConstructor, i as defaultFunctionCall, v as readDataTypeDefault } from "./psl-field-resolution-BW2_FOb9-DxqR43fo.mjs";
+import { a as normalizeReferentialAction, n as buildEntityTypesByDiscriminator, r as indexFkRelations, t as applyBackrelationCandidates } from "./interpreter-ChvVEijY-FeJngsog.mjs";
 import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { entryForTag, getAuthoringTypeConstructor, instantiateAuthoringEntityType, instantiateAuthoringTypeConstructorFromValues } from "@prisma/orm-framework/components/authoring";
+import { entryForTag, getAuthoringTypeChoice, getAuthoringTypeConstructor, instantiateAuthoringEntityType, instantiateAuthoringTypeConstructorFromValues, resolveAuthoringTypeChoice } from "@prisma/orm-framework/components/authoring";
 import { clipToUtf8Bytes, utf8ByteLength } from "@prisma/orm-framework/utils/text";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { InternalError, isInternalError } from "@prisma/orm-framework/utils/internal-error";
 import { EMPTY_GENERATOR_FUNCTIONS } from "@prisma/orm-framework/components/components";
 import { validateContractDomain } from "@prisma/orm-framework/contract/validate-domain";
 import { readFile, readdir, stat } from "node:fs/promises";
@@ -202,26 +202,33 @@ function lowerPrisma7Default(input) {
 	const call = FunctionCallAst.cast(expression.syntax);
 	if (input.onlyDbgenerated && call?.path().join(".") !== "dbgenerated") return unknown("on a field of type Unsupported(...) must be dbgenerated(\"...\"). Prisma 7 refuses this schema too: \"Only @default(dbgenerated(\"...\")) can be used for Unsupported types.\" Write the default as @default(dbgenerated(\"<sql expression>\")), or remove it.", attribute.span);
 	if (call !== void 0) return lowerFunction(call, expression, input, label, unknown);
-	const scalar = scalarValue$1(expression, input, unknown);
-	if (scalar === void 0) return void 0;
-	return {
-		storage: {
-			kind: "literal",
-			value: scalar,
-			inStoredForm: true
-		},
+	const storage = scalarValue$1(expression, input, unknown);
+	return storage === void 0 ? void 0 : {
+		storage,
 		onCreate: void 0
 	};
 }
 /**
-* The stored value of a written default: an enum member resolves through the enum's members, and
+* The stored default of a written value: 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.
+* and validated by the column's codec — the same path the current schema language takes. A value
+* the column's type holds but its codec cannot hold exactly, such as a timestamp with digits below
+* a millisecond on a column read as a JavaScript `Date`, is kept as the SQL expression the target
+* writes for it.
 */
 function scalarValue$1(expression, input, unknown) {
+	const literal = scalarLiteral(expression, input, unknown);
+	if (literal === void 0 || "expression" in literal) return literal;
+	return {
+		kind: "literal",
+		value: literal.value,
+		inStoredForm: true
+	};
+}
+function scalarLiteral(expression, input, unknown) {
 	const span = input.attribute.span;
 	const enumValue = enumMemberValue$1(expression, input);
-	if (enumValue !== void 0) return enumValue;
+	if (enumValue !== void 0) return { value: enumValue };
 	const array = ArrayLiteralAst.cast(expression.syntax);
 	const elements = array === void 0 ? void 0 : [...array.elements()];
 	if (elements?.some((element) => enumMemberValue$1(element, input) !== void 0) === true) {
@@ -231,14 +238,14 @@ function scalarValue$1(expression, input, unknown) {
 			if (value === void 0) return unknown("lists may only hold literals or enum members.", span);
 			values.push(value);
 		}
-		return values;
+		return { value: values };
 	}
 	const finer = finerThanColumn(elements ?? [expression], elements !== void 0, input);
 	if (finer !== void 0) return unknown(finer, 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;
+	if (jsonNull !== void 0) return { value: jsonNull };
 	const read = readDataTypeDefault({
 		written,
 		isList: input.field.list,
@@ -250,7 +257,13 @@ function scalarValue$1(expression, input, unknown) {
 		dataTypes: input.dataTypes,
 		fieldPath: `${input.modelName}.${input.field.name}`
 	});
-	return read.ok ? read.value : unknown(refusalReason(read.refusal), span);
+	if (read.ok) return { value: read.value };
+	const { refusal } = read;
+	if (refusal.kind === "refused-by-codec") return {
+		kind: "function",
+		expression: input.literalDefaultExpression(refusal.stored)
+	};
+	return unknown(refusalReason(refusal), span);
 }
 /**
 * Why a written date and time is refused when it has more fraction digits than the column holds:
@@ -367,7 +380,8 @@ function refusalReason(refusal) {
 		case "no-cast": return `holds a ${refusal.valueType} value${at}, which ${refusal.receivingType} has no cast from; ${describeCasts(refusal.casts)}.`;
 		case "no-list-cast": return `holds a list, which ${refusal.receivingType} has no cast from; ${describeCasts(refusal.casts)}.`;
 		case "no-element-cast": return `holds a ${refusal.valueType} value${at}, which the list cast of ${refusal.receivingType} does not take; it takes ${refusal.elementTypes.join(", ")}.`;
-		case "refused-by-column": return `holds a value${at} that ${refusal.codecId} does not read: ${refusal.message}`;
+		case "refused-by-column":
+		case "refused-by-codec": return `holds a value${at} that ${refusal.codecId} does not read: ${refusal.message}`;
 	}
 }
 function describeCasts(casts) {
@@ -1641,6 +1655,20 @@ function lowerNativeEnums(enums, input, diagnostics) {
 }
 /** The SQL family's type constructor for a column of a type no data type claims (ADR 273). */
 const RAW_TYPE_CONSTRUCTOR = ["Raw"];
+/** The constructor the values a binding maps a Prisma 7 type to choose from the type choice it names; a refusal is the binding's mistake. */
+function chooseBindingType(label, path, typeChoice, values) {
+	try {
+		return resolveAuthoringTypeChoice({
+			helperPath: path.join("."),
+			descriptor: typeChoice.descriptor,
+			args: values,
+			constructorNamed: typeChoice.constructorNamed
+		});
+	} catch (error) {
+		if (isInternalError(error) || !(error instanceof Error)) throw error;
+		throw new InternalError(`The Prisma 7 target binding maps ${label} to type choice "${path.join(".")}" with values it refuses: ${error.message}`);
+	}
+}
 /** Prisma 7's `Unsupported("...")`, which this source reads as ``Raw(sql`...`)``. */
 function isUnsupportedType(call) {
 	return call?.path.length === 1 && call.path[0] === "Unsupported";
@@ -1802,7 +1830,10 @@ function readField(args) {
 		};
 	}
 	const constructorPath = fieldType.kind === "written" ? fieldType.call.path : fieldType.path;
-	const typeConstructor = getAuthoringTypeConstructor(input.authoringContributions, constructorPath);
+	const typeChoice = fieldType.kind === "values" ? getAuthoringTypeChoice(input.authoringContributions, constructorPath) : void 0;
+	const chosen = typeChoice === void 0 || fieldType.kind !== "values" ? void 0 : chooseBindingType(label, constructorPath, typeChoice, fieldType.values);
+	const typeConstructor = chosen?.descriptor ?? getAuthoringTypeConstructor(input.authoringContributions, constructorPath);
+	const typeValues = chosen?.args ?? (fieldType.kind === "values" ? fieldType.values : []);
 	if (typeConstructor === void 0) {
 		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label} type "${field.typeName}" could not be resolved against target "${binding.target.targetId}".`, sourceId, field.span));
 		return;
@@ -1823,7 +1854,7 @@ function readField(args) {
 		});
 		diagnostics.push(...typeDiagnostics.toExternal());
 	} else {
-		const instantiated = instantiateAuthoringTypeConstructorFromValues(typeConstructor, fieldType.values, input.codecLookup.descriptorFor(typeConstructor.output.codecId)?.paramsSchema);
+		const instantiated = instantiateAuthoringTypeConstructorFromValues(typeConstructor, typeValues, input.codecLookup.descriptorFor(typeConstructor.output.codecId)?.paramsSchema);
 		if (!instantiated.ok && unsupportedArgument !== void 0) {
 			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label}: Unsupported(${unsupportedArgument.written.value}) is not one type name: ${instantiated.failure.message}`, sourceId, unsupportedArgument.written.span));
 			return;
@@ -1860,6 +1891,11 @@ function readField(args) {
 			dataType: sqlDataTypeOfCodec(resolved.descriptor.codecId, typeLookups).id,
 			typeParams: resolved.descriptor.typeParams
 		}),
+		literalDefaultExpression: (stored) => binding.literalDefaultExpression(stored, {
+			codecId: resolved.descriptor.codecId,
+			dataType: sqlDataTypeOfCodec(resolved.descriptor.codecId, typeLookups).id,
+			typeParams: resolved.descriptor.typeParams
+		}),
 		enumMembers: enumDeclaration === void 0 ? void 0 : new Map(enumDeclaration.members.map((member) => [member.name, member.value])),
 		controlMutationDefaults: input.controlMutationDefaults,
 		argumentContext: model.argumentContext,