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

package/dist/contract-prisma7__provider.mjs

@@ -8,7 +8,7 @@ import { c as instantiateFieldTypeConstructor, h as readDataTypeDefault } from "
 import { a as normalizeReferentialAction, n as buildEntityTypesByDiscriminator, r as indexFkRelations, t as applyBackrelationCandidates } from "./interpreter-Dq32sxoS-BcLhPY0_.mjs";
 import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { entryForTag, getAuthoringTypeConstructor, instantiateAuthoringEntityType } from "@prisma/orm-framework/components/authoring";
+import { entryForTag, getAuthoringTypeConstructor, instantiateAuthoringEntityType, instantiateAuthoringTypeConstructor } 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";
@@ -36,18 +36,34 @@ function andList(items) {
 function fieldList(modelName, fieldNames) {
 	return andList(fieldNames.map((name) => `"${modelName}.${name}"`));
 }
-/** An `@ignore` field in the model's primary key: without it the model has no field that identifies a row. */
-function ignoredFieldInPrimaryKey(input) {
+const UNMAPPED_REASONS = ["ignored", "unsupported"];
+function unmappedClause(reason, one) {
+	if (reason === "ignored") return `${one ? "is" : "are"} marked @ignore`;
+	return `${one ? "has" : "have"} type Unsupported(...), so the Prisma 8 model has no field for ${one ? "it" : "them"}`;
+}
+/** A field with no Prisma 8 field in the model's primary key: without it the model has no field that identifies a row. */
+function unmappedFieldInPrimaryKey(input) {
 	const fields = fieldList(input.modelName, input.fieldNames);
 	const one = input.fieldNames.length === 1;
-	return prisma7Diagnostic("PSL.PRISMA7_IGNORED_FIELD_REFERENCED", `${one ? "Field" : "Fields"} ${fields} ${one ? "is" : "are"} marked @ignore, but ${input.usedBy} uses ${one ? "it" : "them"}, and without ${one ? "it" : "them"} model "${input.modelName}" has no field that identifies a row, so Prisma 8 could not update, delete or relate its rows. Remove @ignore from ${fields}: Prisma 7's next migration is then empty, and ${one ? "the field appears" : "the fields appear"} in the Prisma 7 client again. Or replace ${one ? "it" : "them"} with @@ignore on model "${input.modelName}": Prisma 7 then requires @ignore on every relation field that points to the model, its next migration is empty, Prisma 8 keeps the model's table with its primary key, and the model disappears from both clients.`, input.sourceId, input.span);
+	const modelIgnore = `@@ignore on model "${input.modelName}": Prisma 7 then requires @ignore on every relation field that points to the model, its next migration is empty, Prisma 8 keeps the model's table with its primary key, and the model disappears from both clients.`;
+	const edits = input.reason === "ignored" ? `Remove @ignore from ${fields}: Prisma 7's next migration is then empty, and ${one ? "the field appears" : "the fields appear"} in the Prisma 7 client again. Or replace ${one ? "it" : "them"} with ${modelIgnore}` : `Add ${modelIgnore}`;
+	return prisma7Diagnostic("PSL.PRISMA7_IGNORED_FIELD_REFERENCED", `${one ? "Field" : "Fields"} ${fields} ${unmappedClause(input.reason, one)}, but ${input.usedBy} uses ${one ? "it" : "them"}, and without ${one ? "it" : "them"} model "${input.modelName}" has no field that identifies a row, so Prisma 8 could not update, delete or relate its rows. ${edits}`, input.sourceId, input.span);
 }
-/** A relation that is not `@ignore` joins on `@ignore` fields: Prisma 8 relations join on fields, and the domain has no ignored field. */
-function ignoredFieldJoined(input) {
+/** A relation that is not `@ignore` joins on fields with no Prisma 8 field: Prisma 8 relations join on fields. */
+function unmappedFieldJoined(input) {
 	const fields = fieldList(input.modelName, input.fieldNames);
 	const one = input.fieldNames.length === 1;
 	const relation = `relation field "${input.relationField}"`;
-	return prisma7Diagnostic("PSL.PRISMA7_IGNORED_FIELD_REFERENCED", `${one ? "Field" : "Fields"} ${fields} ${one ? "is" : "are"} marked @ignore, but ${relation} joins on ${one ? "it" : "them"}, and Prisma 8 relations join on fields. Remove @ignore from ${fields}: Prisma 7's next migration is then empty, and ${one ? "the field appears" : "the fields appear"} in the Prisma 7 client again. Or mark ${relation} @ignore as well: Prisma 7's next migration is then empty, the relation field disappears from the Prisma 7 client, and Prisma 8 keeps its foreign key while leaving the relation out of the contract's models.`, input.sourceId, input.span);
+	const relationIgnore = `${relation} @ignore${input.reason === "ignored" ? " as well" : ""}: Prisma 7's next migration is then empty, the relation field disappears from the Prisma 7 client, and Prisma 8 keeps its foreign key while leaving the relation out of the contract's models.`;
+	const edits = input.reason === "ignored" ? `Remove @ignore from ${fields}: Prisma 7's next migration is then empty, and ${one ? "the field appears" : "the fields appear"} in the Prisma 7 client again. Or mark ${relationIgnore}` : `Mark ${relationIgnore}`;
+	return prisma7Diagnostic("PSL.PRISMA7_IGNORED_FIELD_REFERENCED", `${one ? "Field" : "Fields"} ${fields} ${unmappedClause(input.reason, one)}, but ${relation} joins on ${one ? "it" : "them"}, and Prisma 8 relations join on fields. ${edits}`, input.sourceId, input.span);
+}
+/** The diagnostics for the fields among `fieldNames` that have no Prisma 8 field, one per reason. */
+function unmappedFieldDiagnostics(fieldNames, unmapped, diagnostic) {
+	return UNMAPPED_REASONS.flatMap((reason) => {
+		const names = fieldNames.filter((name) => unmapped.get(name) === reason);
+		return names.length === 0 ? [] : [diagnostic(names, reason)];
+	});
 }
 function parseIndexAttribute(attribute, owner, sourceId, indexTypes, diagnostics) {
 	const unsupported = (what, span) => {
@@ -187,6 +203,7 @@ function lowerPrisma7Default(input) {
 	const expression = argument?.expression;
 	if (argument === void 0 || expression === void 0) return unknown("needs one value.", attribute.span);
 	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, input, label, unknown);
 	const scalar = scalarValue$1(expression, input, unknown);
 	if (scalar === void 0) return void 0;
@@ -543,7 +560,7 @@ function parseRelationAttribute(attribute, label, sourceId, diagnostics) {
 	};
 }
 function storageColumn(model, fieldName) {
-	return model.columns.get(fieldName) ?? model.ignoredColumns.get(fieldName);
+	return model.columns.get(fieldName) ?? model.unmappedColumns.get(fieldName);
 }
 /** A foreign key reaches a table with a model through the model, and an `@@ignore` model's table by its name. */
 function referenceTo(model, columns) {
@@ -675,16 +692,14 @@ function lowerRelations(models, naming, diagnostics) {
 			}, {
 				owner: target,
 				names: attribute.references ?? []
-			}].flatMap(({ owner, names }) => {
-				const ignored = names.filter((name) => owner.ignoredFields.has(name));
-				return ignored.length === 0 ? [] : [ignoredFieldJoined({
-					modelName: owner.modelName,
-					fieldNames: ignored,
-					relationField: `${model.modelName}.${field.name}`,
-					sourceId: model.sourceId,
-					span: attribute.span
-				})];
-			});
+			}].flatMap(({ owner, names }) => unmappedFieldDiagnostics(names, owner.unmappedFields, (fieldNames, reason) => unmappedFieldJoined({
+				modelName: owner.modelName,
+				fieldNames,
+				reason,
+				relationField: `${model.modelName}.${field.name}`,
+				sourceId: model.sourceId,
+				span: attribute.span
+			})));
 			if (joinedIgnored.length > 0) {
 				rejectFkSide(model, relationField, ...joinedIgnored);
 				continue;
@@ -928,7 +943,7 @@ function junctionModel(name, table) {
 * id is at fault.
 */
 function singleIdColumn(side, requester, diagnostics) {
-	if (side.model.idFields.some((name) => side.model.ignoredFields.has(name) || side.model.rejectedFields.has(name))) return;
+	if (side.model.idFields.some((name) => side.model.unmappedFields.has(name) || side.model.rejectedFields.has(name))) return;
 	const [idField, ...rest] = side.model.idFields;
 	const column = idField === void 0 ? void 0 : storageColumn(side.model, idField);
 	if (column === void 0 || rest.length > 0) {
@@ -1180,8 +1195,8 @@ function interpretPrisma7Documents(input) {
 		const build = {
 			declaration,
 			columns: /* @__PURE__ */ new Map(),
-			ignoredColumns: /* @__PURE__ */ new Map(),
-			ignoredFields: /* @__PURE__ */ new Set(),
+			unmappedColumns: /* @__PURE__ */ new Map(),
+			unmappedFields: /* @__PURE__ */ new Map(),
 			ignoredRelationFields: [],
 			rejectedFields: /* @__PURE__ */ new Set(),
 			idFields: declaration.id?.fields ?? [],
@@ -1202,7 +1217,7 @@ function interpretPrisma7Documents(input) {
 				input,
 				diagnostics
 			});
-			if (diagnostics.length > reported && !build.columns.has(field.name) && !build.ignoredColumns.has(field.name)) build.rejectedFields.add(field.name);
+			if (diagnostics.length > reported && !build.columns.has(field.name) && !build.unmappedColumns.has(field.name)) build.rejectedFields.add(field.name);
 		}
 		builds.set(declaration.symbol.name, build);
 	}
@@ -1216,8 +1231,8 @@ function interpretPrisma7Documents(input) {
 		sourceId: build.declaration.sourceId,
 		sources: build.declaration.sources,
 		columns: build.columns,
-		ignoredColumns: build.ignoredColumns,
-		ignoredFields: build.ignoredFields,
+		unmappedColumns: build.unmappedColumns,
+		unmappedFields: build.unmappedFields,
 		ignoredRelationFields: build.ignoredRelationFields,
 		rejectedFields: build.rejectedFields,
 		idFields: build.idFields,
@@ -1230,16 +1245,15 @@ function interpretPrisma7Documents(input) {
 	for (const [modelName, build] of builds) {
 		const model = relationModels.get(modelName);
 		if (model === void 0) continue;
-		const ignoredAmong = (fieldNames) => fieldNames?.filter((name) => build.ignoredFields.has(name)) ?? [];
 		const idAttribute = build.declaration.id;
-		const ignoredIdFields = ignoredAmong(idAttribute?.fields);
-		if (idAttribute !== void 0 && ignoredIdFields.length > 0) diagnostics.push(ignoredFieldInPrimaryKey({
+		if (idAttribute?.fields !== void 0) diagnostics.push(...unmappedFieldDiagnostics(idAttribute.fields, build.unmappedFields, (fieldNames, reason) => unmappedFieldInPrimaryKey({
 			modelName,
-			fieldNames: ignoredIdFields,
+			fieldNames,
+			reason,
 			usedBy: `@@id on model "${modelName}"`,
 			sourceId: model.sourceId,
 			span: idAttribute.span
-		}));
+		})));
 		const id = keyColumns(model, model.idFields);
 		const indexes = [...build.uniqueIndexes.map((attribute) => ({
 			attribute,
@@ -1268,12 +1282,12 @@ function interpretPrisma7Documents(input) {
 			...indexes.length > 0 ? { indexes } : {},
 			...foreignKeys !== void 0 ? { foreignKeys } : {}
 		});
-		const ignoredColumns = [...build.ignoredColumns.values()];
+		const unmappedColumns = [...build.unmappedColumns.values()];
 		if (model.ignored) {
 			tables.push({
 				...tableProperties,
 				namespaceId: model.namespaceId,
-				columns: ignoredColumns
+				columns: unmappedColumns
 			});
 			continue;
 		}
@@ -1284,10 +1298,10 @@ function interpretPrisma7Documents(input) {
 			fields: [...build.columns.values()],
 			...relations !== void 0 ? { relations } : {}
 		});
-		if (ignoredColumns.length > 0) tables.push({
+		if (unmappedColumns.length > 0) tables.push({
 			namespaceId: model.namespaceId,
 			tableName: model.tableName,
-			columns: ignoredColumns
+			columns: unmappedColumns
 		});
 	}
 	tables.push(...[...lowered.ignoredJunctions.values()].map(stateServedBackingIndexes));
@@ -1391,7 +1405,7 @@ function reportTableCollisions(models, diagnostics) {
 function keyColumns(model, fieldNames) {
 	const columns = [];
 	for (const fieldName of fieldNames) {
-		const column = model.columns.get(fieldName) ?? model.ignoredColumns.get(fieldName);
+		const column = model.columns.get(fieldName) ?? model.unmappedColumns.get(fieldName);
 		if (column === void 0) return void 0;
 		columns.push(column.columnName);
 	}
@@ -1571,6 +1585,32 @@ function lowerNativeEnums(enums, input, diagnostics) {
 	}
 	return result;
 }
+/** The SQL family's type constructor for a column of a type no data type claims (ADR 273). */
+const RAW_TYPE_CONSTRUCTOR = ["Raw"];
+/** Prisma 7's `Unsupported("...")`, which this source reads as `Raw("...")`. */
+function isUnsupportedType(call) {
+	return call?.path.length === 1 && call.path[0] === "Unsupported";
+}
+/** The one double-quoted string `Unsupported(...)` takes, as written and with its escapes undone. */
+function unsupportedTypeArgument(call) {
+	const [written, ...rest] = call.args;
+	if (written === void 0 || rest.length > 0 || written.kind !== "positional") return void 0;
+	const literal = written.expression === void 0 ? void 0 : StringLiteralExprAst.cast(written.expression.syntax);
+	const text = literal?.quote() === "\"" ? literal.value() : void 0;
+	return text === void 0 ? void 0 : {
+		written,
+		text
+	};
+}
+/** Why the type parameters a constructor makes from `args` fail its codec's parameter schema, or undefined when they pass. */
+function typeParamsRefusal(descriptor, args, codecLookup) {
+	const { typeParams } = instantiateAuthoringTypeConstructor(descriptor, args);
+	const schema = codecLookup.descriptorFor(descriptor.output.codecId)?.paramsSchema;
+	if (schema === void 0) return void 0;
+	const result = schema["~standard"].validate(typeParams ?? {});
+	if (result instanceof Promise) throw new InternalError(`The parameter schema of codec "${descriptor.output.codecId}" is asynchronous; authoring requires a synchronous schema.`);
+	return result.issues?.[0]?.message;
+}
 function nativeTypeMessage(label, nativeType) {
 	return `${label}: native type "@db.${nativeType}" has no Prisma 8 codec yet, and Prisma 8 cannot read this schema until it supports the column type. @ignore on the field or @@ignore on the model does not help: Prisma 8 keeps the columns of ignored fields and models in the contract. Changing the field's type to one Prisma 8 supports changes the column type on Prisma 7's next migration.`;
 }
@@ -1582,8 +1622,10 @@ function readField(args) {
 	const label = `Field "${model.symbol.name}.${field.name}"`;
 	const isRelationField = args.modelNames.has(field.typeName) && field.typeConstructor === void 0;
 	const fieldIgnored = field.attributes.some((attribute) => attribute.name === "ignore") || isRelationField && args.ignoredModels.has(field.typeName);
-	if (fieldIgnored) build.ignoredFields.add(field.name);
-	const ignored = fieldIgnored || model.ignored;
+	const unsupported = isUnsupportedType(field.typeConstructor);
+	const unmappedReason = unsupported && !model.ignored ? "unsupported" : fieldIgnored ? "ignored" : void 0;
+	if (unmappedReason !== void 0) build.unmappedFields.set(field.name, unmappedReason);
+	const ignored = fieldIgnored || model.ignored || unsupported;
 	let columnName = field.name;
 	let nativeType;
 	let relation;
@@ -1608,9 +1650,10 @@ function readField(args) {
 				build.idFields = [field.name];
 				build.idMap = parsed.map;
 			}
-			if (fieldIgnored) diagnostics.push(ignoredFieldInPrimaryKey({
+			if (unmappedReason !== void 0) diagnostics.push(unmappedFieldInPrimaryKey({
 				modelName: model.symbol.name,
 				fieldNames: [field.name],
+				reason: unmappedReason,
 				usedBy: "its @id",
 				sourceId,
 				span: attribute.span
@@ -1627,8 +1670,17 @@ function readField(args) {
 		else if (attribute.name === "ignore") {} else diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_ATTRIBUTE", `${label}: attribute "@${attribute.name}" is not supported yet by the Prisma 7 contract source.`, sourceId, attribute.span));
 	}
 	if (field.malformedType) return;
-	if (field.typeConstructor !== void 0) {
-		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label} has type "${field.typeConstructor.path.join(".")}(...)", which has no Prisma 8 codec yet, and Prisma 8 cannot read this schema until it supports the column type. @@ignore on model "${model.symbol.name}" does not help: Prisma 8 keeps the columns of ignored models in the contract. Removing the field drops its column on Prisma 7's next migration.`, sourceId, field.typeConstructor.span));
+	if (field.typeConstructor !== void 0 && !unsupported) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label} has type "${field.typeConstructor.path.join(".")}(...)", which is not a Prisma 7 type. Prisma 7 refuses this schema too.`, sourceId, field.typeConstructor.span));
+		return;
+	}
+	if (unsupported && nativeType !== void 0) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_ATTRIBUTE", `${label} has type Unsupported(...), which takes no native type, but has attribute "@db.${nativeType.name}". Prisma 7 refuses this schema too: "Attribute not known". Remove "@db.${nativeType.name}".`, sourceId, nativeType.attribute.span));
+		return;
+	}
+	const unsupportedArgument = field.typeConstructor === void 0 ? void 0 : unsupportedTypeArgument(field.typeConstructor);
+	if (field.typeConstructor !== void 0 && unsupportedArgument === void 0) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label}: Unsupported(...) takes one string, the column's type as the database prints it, such as Unsupported("tsvector").`, sourceId, field.typeConstructor.span));
 		return;
 	}
 	if (isRelationField) {
@@ -1649,9 +1701,18 @@ function readField(args) {
 		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UPDATED_AT_FIELD_INVALID", `${label} is a list, but @updatedAt is not allowed on a list field. Prisma 7 refuses this schema too: "Fields that are marked with @updatedAt cannot be lists." Remove @updatedAt, or make the field a single DateTime.`, sourceId, updatedAt.span));
 		return;
 	}
-	const enumDeclaration = args.enums.get(field.typeName);
+	const enumDeclaration = unsupported ? void 0 : args.enums.get(field.typeName);
 	let call;
-	if (enumDeclaration !== void 0) {
+	if (unsupportedArgument !== void 0) call = {
+		path: RAW_TYPE_CONSTRUCTOR,
+		args: [{
+			kind: "positional",
+			value: `"${unsupportedArgument.text}"`,
+			span: unsupportedArgument.written.span
+		}],
+		span: unsupportedArgument.written.span
+	};
+	else if (enumDeclaration !== void 0) {
 		if (enumDeclaration.namespaceId !== model.namespaceId) {
 			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_ENUM_NAMESPACE_MISMATCH", `${label} uses enum "${enumDeclaration.name}" from schema "${enumDeclaration.namespaceId}", but the model is in schema "${model.namespaceId}". Prisma 8 columns reference the enum type of their own schema; declare the enum in "${model.namespaceId}" or move the model.`, sourceId, field.span));
 			return;
@@ -1697,6 +1758,11 @@ function readField(args) {
 		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label} type "${field.typeName}" could not be resolved against target "${binding.target.targetId}".`, sourceId, field.span));
 		return;
 	}
+	const refusal = unsupportedArgument === void 0 ? void 0 : typeParamsRefusal(typeConstructor, [unsupportedArgument.text], input.codecLookup);
+	if (unsupportedArgument !== void 0 && refusal !== void 0) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label}: Unsupported(${unsupportedArgument.written.value}) is not one type name: ${refusal}`, sourceId, unsupportedArgument.written.span));
+		return;
+	}
 	const typeDiagnostics = createPslDiagnosticCollector(model.sources);
 	const resolved = instantiateFieldTypeConstructor({
 		call,
@@ -1724,6 +1790,7 @@ function readField(args) {
 		attribute: defaultAttribute,
 		field,
 		modelName: model.symbol.name,
+		onlyDbgenerated: unsupported,
 		codecId: resolved.descriptor.codecId,
 		typeParams: resolved.descriptor.typeParams,
 		codecLookup: input.codecLookup,
@@ -1749,7 +1816,7 @@ function readField(args) {
 		...ifDefined("default", lowered?.storage)
 	};
 	if (ignored) {
-		build.ignoredColumns.set(field.name, column);
+		build.unmappedColumns.set(field.name, column);
 		return;
 	}
 	const executionDefaults = updatedAtGenerator !== void 0 ? {