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

package/dist/contract-prisma7__provider.mjs

@@ -36,10 +36,18 @@ function andList(items) {
 function fieldList(modelName, fieldNames) {
 	return andList(fieldNames.map((name) => `"${modelName}.${name}"`));
 }
-function ignoredFieldReferenced(input) {
+/** An `@ignore` field in the model's primary key: without it the model has no field that identifies a row. */
+function ignoredFieldInPrimaryKey(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 Prisma 7 still creates the ${input.constraint} that includes ${one ? "its column" : "their columns"}. 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.`, input.sourceId, input.span);
+	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);
+}
+/** 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) {
+	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);
 }
 function parseIndexAttribute(attribute, owner, sourceId, indexTypes, diagnostics) {
 	const unsupported = (what, span) => {
@@ -528,10 +536,25 @@ function parseRelationAttribute(attribute, label, sourceId, diagnostics) {
 		span: attribute.span
 	};
 }
+function storageColumn(model, fieldName) {
+	return model.columns.get(fieldName) ?? model.ignoredColumns.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) {
+	const table = {
+		table: model.tableName,
+		columns,
+		namespaceId: model.namespaceId
+	};
+	return model.ignored ? table : {
+		model: model.modelName,
+		...table
+	};
+}
 function columnNames(model, fieldNames) {
 	const columns = [];
 	for (const fieldName of fieldNames) {
-		const column = model.columns.get(fieldName);
+		const column = storageColumn(model, fieldName);
 		if (column === void 0) return void 0;
 		columns.push(column.columnName);
 	}
@@ -575,7 +598,7 @@ function referentialActionRejections(input) {
 	const { model, relationField, label, fieldNames, span } = input;
 	const anotherAction = "choose another action, which replaces the foreign key on Prisma 7's next migration and leaves the Prisma 7 client unchanged.";
 	const fieldsWhere = (predicate) => fieldNames.filter((name) => {
-		const column = model.columns.get(name);
+		const column = storageColumn(model, name);
 		return column !== void 0 && predicate(column);
 	});
 	const rejections = [];
@@ -614,6 +637,7 @@ function lowerRelations(models, naming, diagnostics) {
 	const invalidFkPairings = [];
 	const foreignKeys = /* @__PURE__ */ new Map();
 	const junctions = /* @__PURE__ */ new Map();
+	const ignoredJunctions = /* @__PURE__ */ new Map();
 	const reportedJunctionNames = /* @__PURE__ */ new Set();
 	const junctionRequests = [];
 	const addForeignKey = (modelName, node) => {
@@ -630,7 +654,7 @@ function lowerRelations(models, naming, diagnostics) {
 			relationName: effectiveRelationName(relationField.attribute, model.modelName, relationField.targetModelName)
 		});
 	};
-	for (const model of models.values()) for (const relationField of model.relationFields) {
+	for (const model of models.values()) for (const relationField of [...model.relationFields, ...model.ignoredRelationFields]) {
 		const { field, targetModelName } = relationField;
 		const label = `Relation field "${model.modelName}.${field.name}"`;
 		const target = models.get(targetModelName);
@@ -638,23 +662,32 @@ function lowerRelations(models, naming, diagnostics) {
 		if (isFkSide(relationField)) {
 			const attribute = relationField.attribute;
 			if (attribute === void 0 || attribute.fields === void 0) continue;
-			const ignoredScalars = attribute.fields.filter((name) => model.ignoredFields.has(name));
-			if (ignoredScalars.length > 0) {
-				rejectFkSide(model, relationField, ignoredFieldReferenced({
-					modelName: model.modelName,
-					fieldNames: ignoredScalars,
-					usedBy: `relation field "${model.modelName}.${field.name}"`,
-					constraint: "foreign key",
+			const ignoredRelation = model.ignoredRelationFields.includes(relationField);
+			const joinedIgnored = ignoredRelation ? [] : [{
+				owner: model,
+				names: attribute.fields
+			}, {
+				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
-				}));
+				})];
+			});
+			if (joinedIgnored.length > 0) {
+				rejectFkSide(model, relationField, ...joinedIgnored);
 				continue;
 			}
 			if (attribute.references === void 0) {
 				rejectFkSide(model, relationField, unresolved(label, "declares fields without references.", model.sourceId, attribute.span));
 				continue;
 			}
-			if (attribute.fields.some((name) => model.rejectedFields.has(name)) || attribute.references.some((name) => target.ignoredFields.has(name) || target.rejectedFields.has(name))) {
+			if (attribute.fields.some((name) => model.rejectedFields.has(name)) || attribute.references.some((name) => target.rejectedFields.has(name))) {
 				rejectFkSide(model, relationField);
 				continue;
 			}
@@ -668,7 +701,7 @@ function lowerRelations(models, naming, diagnostics) {
 				rejectFkSide(model, relationField, unresolved(label, "must list as many fields as references.", model.sourceId, attribute.span));
 				continue;
 			}
-			const nullability = attribute.fields.map((name) => model.columns.get(name)?.nullable === true);
+			const nullability = attribute.fields.map((name) => storageColumn(model, name)?.nullable === true);
 			const anyNullable = nullability.includes(true);
 			if (anyNullable && !field.optional) {
 				rejectFkSide(model, relationField, unresolved(label, "must be optional because one of its fields is optional.", model.sourceId, field.span));
@@ -695,16 +728,12 @@ function lowerRelations(models, naming, diagnostics) {
 			addForeignKey(model.modelName, {
 				...ifDefined("name", foreignKeyName),
 				columns: localColumns,
-				references: {
-					model: target.modelName,
-					table: target.tableName,
-					columns: referencedColumns,
-					namespaceId: target.namespaceId
-				},
+				references: referenceTo(target, referencedColumns),
 				onDelete,
 				onUpdate,
 				index: false
 			});
+			if (ignoredRelation) continue;
 			fkRelationMetadata.push({
 				declaringModelName: model.modelName,
 				declaringFieldName: field.name,
@@ -720,8 +749,10 @@ function lowerRelations(models, naming, diagnostics) {
 			});
 			continue;
 		}
-		if (target.ignoredRelationFields.some((other) => other.targetModelName === model.modelName && sameName(other, relationField))) continue;
-		if (target.relationFields.filter((other) => other.targetModelName === model.modelName && isFkSide(other) && sameName(other, relationField)).length > 0 || !field.list) {
+		const ignoredPair = model.ignoredRelationFields.includes(relationField) || target.ignoredRelationFields.some((other) => other.targetModelName === model.modelName && sameName(other, relationField));
+		const targetRelationFields = [...target.relationFields, ...target.ignoredRelationFields];
+		if (targetRelationFields.filter((other) => other.targetModelName === model.modelName && isFkSide(other) && sameName(other, relationField)).length > 0 || !field.list) {
+			if (ignoredPair) continue;
 			candidates.push({
 				modelName: model.modelName,
 				tableName: model.tableName,
@@ -732,7 +763,7 @@ function lowerRelations(models, naming, diagnostics) {
 			});
 			continue;
 		}
-		const partners = target.relationFields.filter((other) => other !== relationField && other.targetModelName === model.modelName && other.field.list && !isFkSide(other) && sameName(other, relationField));
+		const partners = targetRelationFields.filter((other) => other !== relationField && other.targetModelName === model.modelName && other.field.list && !isFkSide(other) && sameName(other, relationField));
 		const [partner] = partners;
 		if (partner === void 0) {
 			diagnostics.push(unresolved(label, `has no matching relation field on "${target.modelName}".`, model.sourceId, field.span));
@@ -764,7 +795,8 @@ function lowerRelations(models, naming, diagnostics) {
 		junctionRequests.push({
 			requester,
 			partner: partnerSide,
-			name: junctionName
+			name: junctionName,
+			ignored: ignoredPair
 		});
 	}
 	const requestsByJunction = groupBy(junctionRequests, (request) => junctionKey(orderJunctionSides(request.requester, request.partner)[0].model.namespaceId, request.name));
@@ -795,11 +827,15 @@ function lowerRelations(models, naming, diagnostics) {
 			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_TABLE_COLLISION", message, tableOwner.sourceId, tableOwner.tableSpan), prisma7Diagnostic("PSL.PRISMA7_TABLE_COLLISION", message, first.requester.model.sourceId, first.requester.field.field.span));
 			continue;
 		}
-		for (const { requester, partner } of requests) {
+		for (const { requester, partner, ignored } of requests) {
 			const junction = synthesizeJunction(requester, partner, naming, diagnostics);
 			if (junction === void 0) continue;
+			if (ignored) {
+				ignoredJunctions.set(junction.key, junction.table);
+				continue;
+			}
 			if (!junctions.has(junction.key)) {
-				junctions.set(junction.key, junction.node);
+				junctions.set(junction.key, junctionModel(junction.name, junction.table));
 				fkRelationMetadata.push(...junction.foreignKeys);
 			}
 			candidates.push({
@@ -863,10 +899,23 @@ function lowerRelations(models, naming, diagnostics) {
 	for (const [modelName, nodes] of modelRelations) relations.set(modelName, [...nodes].sort((left, right) => left.fieldName.localeCompare(right.fieldName)));
 	return {
 		junctions,
+		ignoredJunctions,
 		foreignKeys,
 		relations
 	};
 }
+/** The junction model over a junction table: a field for each of its columns. */
+function junctionModel(name, table) {
+	const { columns, ...properties } = table;
+	return {
+		...properties,
+		modelName: name,
+		fields: columns.map((column) => ({
+			fieldName: column.columnName,
+			...column
+		}))
+	};
+}
 /**
 * The id column a junction side contributes. The diagnostic names the
 * requesting relation field, so it is located at that field, whichever side's
@@ -875,7 +924,7 @@ function lowerRelations(models, naming, diagnostics) {
 function singleIdColumn(side, requester, diagnostics) {
 	if (side.model.idFields.some((name) => side.model.ignoredFields.has(name) || side.model.rejectedFields.has(name))) return;
 	const [idField, ...rest] = side.model.idFields;
-	const column = idField === void 0 ? void 0 : side.model.columns.get(idField);
+	const column = idField === void 0 ? void 0 : storageColumn(side.model, idField);
 	if (column === void 0 || rest.length > 0) {
 		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_JUNCTION_ID_UNSUPPORTED", `Relation field "${requester.model.modelName}.${requester.field.field.name}" is an implicit many-to-many relation, but "${side.model.modelName}" ${column === void 0 ? "has no single-field @id" : "has a composite id"}; Prisma 7 requires a single-field @id on both models of an implicit many-to-many relation.`, requester.model.sourceId, requester.field.field.span));
 		return;
@@ -908,12 +957,7 @@ function synthesizeJunction(requester, partner, naming, diagnostics) {
 	const foreignKey = (column, side, id) => ({
 		...ifDefined("name", foreignKeyName(column)),
 		columns: [column],
-		references: {
-			model: side.model.modelName,
-			table: side.model.tableName,
-			columns: [id.columnName],
-			namespaceId: side.model.namespaceId
-		},
+		references: referenceTo(side.model, [id.columnName]),
 		onDelete: "cascade",
 		onUpdate: "cascade",
 		index: false
@@ -942,18 +986,16 @@ function synthesizeJunction(requester, partner, naming, diagnostics) {
 	};
 	return {
 		key,
-		node: {
-			modelName: name,
+		name,
+		table: {
 			tableName,
 			namespaceId,
-			fields: [{
-				fieldName: "A",
+			columns: [{
 				columnName: "A",
 				descriptor: idA.descriptor,
 				nullable: false,
 				many: false
 			}, {
-				fieldName: "B",
 				columnName: "B",
 				descriptor: idB.descriptor,
 				nullable: false,
@@ -1029,7 +1071,6 @@ function interpretPrisma7Documents(input) {
 	const datasources = [];
 	const enumBlocks = [];
 	const models = [];
-	const ignoredModels = /* @__PURE__ */ new Set();
 	const declaredNames = /* @__PURE__ */ new Map();
 	const claimName = (kind, name, sourceId, span) => {
 		const previous = declaredNames.get(name);
@@ -1095,9 +1136,7 @@ function interpretPrisma7Documents(input) {
 		for (const namedType of Object.values(symbolTable.topLevel.namedTypes)) unsupported("types", namedType.span);
 		for (const symbol of Object.values(symbolTable.topLevel.models)) {
 			if (!claimName("model", symbol.name, sourceId, symbol.span)) continue;
-			const declaration = readModelDeclaration(symbol, sourceId, sources, defaultNamespaceId, binding, diagnostics);
-			if (declaration === void 0) ignoredModels.add(symbol.name);
-			else models.push(declaration);
+			models.push(readModelDeclaration(symbol, sourceId, sources, defaultNamespaceId, binding, diagnostics));
 		}
 	}
 	checkDatasource(datasources, input.documents[0]?.sourceId ?? "schema.prisma", binding, diagnostics);
@@ -1108,13 +1147,15 @@ function interpretPrisma7Documents(input) {
 		if (declaration !== void 0) enums.set(declaration.name, declaration);
 	}
 	const namespaceEntities = lowerNativeEnums(enums, input, diagnostics);
-	const modelNames = /* @__PURE__ */ new Set([...models.map((model) => model.symbol.name), ...ignoredModels]);
+	const modelNames = new Set(models.map((model) => model.symbol.name));
+	const ignoredModels = new Set(models.filter((model) => model.ignored).map((model) => model.symbol.name));
 	const composedExtensions = new Set(input.composedExtensions);
 	const builds = /* @__PURE__ */ new Map();
 	for (const declaration of models) {
 		const build = {
 			declaration,
 			columns: /* @__PURE__ */ new Map(),
+			ignoredColumns: /* @__PURE__ */ new Map(),
 			ignoredFields: /* @__PURE__ */ new Set(),
 			ignoredRelationFields: [],
 			rejectedFields: /* @__PURE__ */ new Set(),
@@ -1136,7 +1177,7 @@ function interpretPrisma7Documents(input) {
 				input,
 				diagnostics
 			});
-			if (diagnostics.length > reported && !build.columns.has(field.name) && !build.ignoredFields.has(field.name)) build.rejectedFields.add(field.name);
+			if (diagnostics.length > reported && !build.columns.has(field.name) && !build.ignoredColumns.has(field.name)) build.rejectedFields.add(field.name);
 		}
 		builds.set(declaration.symbol.name, build);
 	}
@@ -1144,11 +1185,13 @@ function interpretPrisma7Documents(input) {
 	for (const [modelName, build] of builds) relationModels.set(modelName, {
 		modelName,
 		tableName: build.declaration.tableName,
+		ignored: build.declaration.ignored,
 		tableSpan: build.declaration.symbol.attributes.find((attribute) => attribute.name === "map")?.span ?? build.declaration.symbol.span,
 		namespaceId: build.declaration.namespaceId,
 		sourceId: build.declaration.sourceId,
 		sources: build.declaration.sources,
 		columns: build.columns,
+		ignoredColumns: build.ignoredColumns,
 		ignoredFields: build.ignoredFields,
 		ignoredRelationFields: build.ignoredRelationFields,
 		rejectedFields: build.rejectedFields,
@@ -1158,17 +1201,17 @@ function interpretPrisma7Documents(input) {
 	});
 	const lowered = lowerRelations(relationModels, binding, diagnostics);
 	const modelNodes = [];
+	const tables = [];
 	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(ignoredFieldReferenced({
+		if (idAttribute !== void 0 && ignoredIdFields.length > 0) diagnostics.push(ignoredFieldInPrimaryKey({
 			modelName,
 			fieldNames: ignoredIdFields,
 			usedBy: `@@id on model "${modelName}"`,
-			constraint: "primary key",
 			sourceId: model.sourceId,
 			span: idAttribute.span
 		}));
@@ -1180,18 +1223,6 @@ function interpretPrisma7Documents(input) {
 			attribute,
 			unique: false
 		}))].flatMap(({ attribute, unique }) => {
-			const ignoredIndexFields = ignoredAmong(attribute.fields);
-			if (ignoredIndexFields.length > 0) {
-				diagnostics.push(ignoredFieldReferenced({
-					modelName,
-					fieldNames: ignoredIndexFields,
-					usedBy: `${unique ? "@@unique" : "@@index"} on model "${modelName}"`,
-					constraint: unique ? "unique index" : "index",
-					sourceId: model.sourceId,
-					span: attribute.span
-				}));
-				return [];
-			}
 			if (attribute.fields?.some((name) => build.rejectedFields.has(name))) return [];
 			const columns = attribute.fields === void 0 ? void 0 : keyColumns(model, attribute.fields);
 			if (columns === void 0) {
@@ -1203,20 +1234,38 @@ function interpretPrisma7Documents(input) {
 		const foreignKeys = lowered.foreignKeys.get(modelName);
 		const relations = lowered.relations.get(modelName);
 		const primaryKeyName = statedConstraintName(prisma7PrimaryKeyName(model.tableName, build.idMap, binding.identifierMaxBytes), binding.defaultConstraintNames.primaryKey(model.tableName));
-		modelNodes.push(stateServedBackingIndexes({
-			modelName,
+		const tableProperties = stateServedBackingIndexes({
 			tableName: model.tableName,
-			namespaceId: model.namespaceId,
-			fields: [...build.columns.values()],
 			...id !== void 0 && id.length > 0 ? { id: {
 				columns: id,
 				...ifDefined("name", primaryKeyName)
 			} } : {},
 			...indexes.length > 0 ? { indexes } : {},
-			...foreignKeys !== void 0 ? { foreignKeys } : {},
+			...foreignKeys !== void 0 ? { foreignKeys } : {}
+		});
+		const ignoredColumns = [...build.ignoredColumns.values()];
+		if (model.ignored) {
+			tables.push({
+				...tableProperties,
+				namespaceId: model.namespaceId,
+				columns: ignoredColumns
+			});
+			continue;
+		}
+		modelNodes.push({
+			...tableProperties,
+			modelName,
+			namespaceId: model.namespaceId,
+			fields: [...build.columns.values()],
 			...relations !== void 0 ? { relations } : {}
-		}));
+		});
+		if (ignoredColumns.length > 0) tables.push({
+			namespaceId: model.namespaceId,
+			tableName: model.tableName,
+			columns: ignoredColumns
+		});
 	}
+	tables.push(...[...lowered.ignoredJunctions.values()].map(stateServedBackingIndexes));
 	for (const [key, junction] of lowered.junctions) {
 		const relations = lowered.relations.get(key);
 		modelNodes.push(stateServedBackingIndexes(relations === void 0 ? junction : {
@@ -1249,7 +1298,8 @@ function interpretPrisma7Documents(input) {
 		warnings: void 0,
 		createNamespace,
 		...namespaceEntities.size > 0 ? { namespaces: [...namespaceEntities.keys()] } : {},
-		models: modelNodes
+		models: modelNodes,
+		...tables.length > 0 ? { tables } : {}
 	}, input.codecLookup, input.dataTypes.lookup));
 }
 /**
@@ -1316,7 +1366,7 @@ function reportTableCollisions(models, diagnostics) {
 function keyColumns(model, fieldNames) {
 	const columns = [];
 	for (const fieldName of fieldNames) {
-		const column = model.columns.get(fieldName);
+		const column = model.columns.get(fieldName) ?? model.ignoredColumns.get(fieldName);
 		if (column === void 0) return void 0;
 		columns.push(column.columnName);
 	}
@@ -1324,7 +1374,7 @@ function keyColumns(model, fieldNames) {
 }
 function readModelDeclaration(symbol, sourceId, sources, defaultNamespaceId, binding, diagnostics) {
 	const { indexTypes } = binding;
-	if (symbol.attributes.some((attribute) => attribute.name === "ignore")) return void 0;
+	let ignored = false;
 	let tableName = symbol.name;
 	let namespaceId = defaultNamespaceId;
 	let id;
@@ -1364,6 +1414,9 @@ function readModelDeclaration(symbol, sourceId, sources, defaultNamespaceId, bin
 				if (parsed?.fields !== void 0) indexes.push(parsed);
 				break;
 			}
+			case "ignore":
+				ignored = true;
+				break;
 			default: diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_ATTRIBUTE", `Model "${symbol.name}": attribute "@@${attribute.name}" is not supported yet by the Prisma 7 contract source.`, sourceId, attribute.span));
 		}
 	}
@@ -1373,6 +1426,7 @@ function readModelDeclaration(symbol, sourceId, sources, defaultNamespaceId, bin
 		sources,
 		namespaceId,
 		tableName,
+		ignored,
 		id,
 		uniqueIndexes,
 		indexes
@@ -1492,75 +1546,8 @@ function lowerNativeEnums(enums, input, diagnostics) {
 	}
 	return result;
 }
-function keysUsingField(field, model) {
-	const modelName = model.symbol.name;
-	const uses = [];
-	for (const attribute of field.attributes) {
-		if (attribute.name === "id") uses.push({
-			usedBy: "its @id",
-			constraint: "primary key"
-		});
-		if (attribute.name === "unique") uses.push({
-			usedBy: "its @unique",
-			constraint: "unique index"
-		});
-	}
-	if (model.id?.fields?.includes(field.name)) uses.push({
-		usedBy: `@@id on model "${modelName}"`,
-		constraint: "primary key"
-	});
-	for (const unique of model.uniqueIndexes) if (unique.fields?.includes(field.name)) uses.push({
-		usedBy: `@@unique on model "${modelName}"`,
-		constraint: "unique index"
-	});
-	for (const index of model.indexes) if (index.fields?.includes(field.name)) uses.push({
-		usedBy: `@@index on model "${modelName}"`,
-		constraint: "index"
-	});
-	for (const other of Object.values(model.symbol.fields)) {
-		if (other.attributes.some((attribute) => attribute.name === "ignore")) continue;
-		const relation = other.attributes.find((attribute) => attribute.name === "relation");
-		if ((relation === void 0 ? void 0 : parseRelationAttribute(relation, other.name, model.sourceId, []))?.fields?.includes(field.name)) uses.push({
-			usedBy: `relation field "${modelName}.${other.name}"`,
-			constraint: "foreign key"
-		});
-	}
-	return uses;
-}
-function nativeTypeMessage(input) {
-	const { label, nativeType, field, model } = input;
-	const uses = keysUsingField(field, model);
-	if (uses.length > 0) {
-		const constraints = [...new Set(uses.map((use) => `the ${use.constraint}`))];
-		return `${label}: native type "@db.${nativeType}" has no Prisma 8 codec, and ${andList(uses.map((use) => use.usedBy))} ${uses.length === 1 ? "uses" : "use"} the field, so @ignore on the field does not help: Prisma 7 still creates ${andList(constraints)} over the column. Add @@ignore to model "${model.symbol.name}" to keep the model out of the contract: Prisma 7's next migration is empty, but the model disappears from the Prisma 7 client too, and every relation field in another model that points to it needs @ignore, which removes that field from the Prisma 7 client as well. Changing the field's type instead changes the column type on Prisma 7's next migration.`;
-	}
-	return `${label}: native type "@db.${nativeType}" has no Prisma 8 codec. Add @ignore to the field to keep its column out of the contract: Prisma 7's next migration is empty, and the field disappears from the Prisma 7 client too${!field.optional && !field.list && !givesColumnDefault(input.defaultAttribute) ? "; because the field is required and its column has no default, neither client can then insert rows" : ""}. Changing the field's type instead changes the column type on Prisma 7's next migration.`;
-}
-function readIgnoredField(field, isRelationField, args) {
-	const { build, diagnostics } = args;
-	const model = build.declaration;
-	if (isRelationField) {
-		if (args.ignoredModels.has(field.typeName)) return;
-		const relation = field.attributes.find((attribute) => attribute.name === "relation");
-		build.ignoredRelationFields.push({
-			field,
-			targetModelName: field.typeName,
-			attribute: relation === void 0 ? void 0 : parseRelationAttribute(relation, field.name, model.sourceId, [])
-		});
-		return;
-	}
-	for (const attribute of field.attributes) {
-		if (attribute.name !== "id" && attribute.name !== "unique") continue;
-		if (attribute.name === "id") build.idFields = [field.name];
-		diagnostics.push(ignoredFieldReferenced({
-			modelName: model.symbol.name,
-			fieldNames: [field.name],
-			usedBy: `its @${attribute.name}`,
-			constraint: attribute.name === "id" ? "primary key" : "unique index",
-			sourceId: model.sourceId,
-			span: attribute.span
-		}));
-	}
+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.`;
 }
 function readField(args) {
 	const { field, build, diagnostics, input } = args;
@@ -1569,11 +1556,9 @@ function readField(args) {
 	const sourceId = model.sourceId;
 	const label = `Field "${model.symbol.name}.${field.name}"`;
 	const isRelationField = args.modelNames.has(field.typeName) && field.typeConstructor === void 0;
-	if (field.attributes.some((attribute) => attribute.name === "ignore")) {
-		build.ignoredFields.add(field.name);
-		readIgnoredField(field, isRelationField, args);
-		return;
-	}
+	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;
 	let columnName = field.name;
 	let nativeType;
 	let relation;
@@ -1598,6 +1583,13 @@ function readField(args) {
 				build.idFields = [field.name];
 				build.idMap = parsed.map;
 			}
+			if (fieldIgnored) diagnostics.push(ignoredFieldInPrimaryKey({
+				modelName: model.symbol.name,
+				fieldNames: [field.name],
+				usedBy: "its @id",
+				sourceId,
+				span: attribute.span
+			}));
 		} else if (attribute.name === "unique" && !isRelationField) {
 			const parsed = parseIndexAttribute(attribute, label, sourceId, binding.indexTypes, diagnostics);
 			if (parsed !== void 0) build.uniqueIndexes.push({
@@ -1607,18 +1599,17 @@ function readField(args) {
 		} else if (attribute.name === "default" && !isRelationField) defaultAttribute = attribute;
 		else if (attribute.name === "updatedAt" && !isRelationField) updatedAt = attribute;
 		else if (attribute.name === "relation" && isRelationField) relation = attribute;
-		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));
+		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, so model "${model.symbol.name}" cannot use this contract source while it has the field. Prisma 7 rejects @ignore on an Unsupported field, and removing the field drops its column on Prisma 7's next migration. Adding @@ignore to model "${model.symbol.name}" keeps the model out of the contract: Prisma 7's next migration is empty, but the model disappears from the Prisma 7 client too, and every relation field in another model that points to it needs @ignore, which removes that field from the Prisma 7 client as well.`, sourceId, field.typeConstructor.span));
+		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));
 		return;
 	}
-	if (args.ignoredModels.has(field.typeName)) return;
 	if (isRelationField) {
 		const attribute = relation === void 0 ? void 0 : parseRelationAttribute(relation, label, sourceId, diagnostics);
 		if (relation !== void 0 && attribute === void 0) return;
-		build.relationFields.push({
+		(ignored ? build.ignoredRelationFields : build.relationFields).push({
 			field,
 			targetModelName: field.typeName,
 			attribute
@@ -1652,13 +1643,7 @@ function readField(args) {
 		if (nativeType !== void 0) {
 			const native = prisma7NativeTypeMapping(binding.typeMap, nativeType.name, nativeType.attribute.args.map((arg) => arg.value));
 			if (native === void 0) {
-				diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_NATIVE_TYPE_UNSUPPORTED", nativeTypeMessage({
-					label,
-					nativeType: nativeType.name,
-					field,
-					model,
-					defaultAttribute
-				}), sourceId, nativeType.attribute.span));
+				diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_NATIVE_TYPE_UNSUPPORTED", nativeTypeMessage(label, nativeType.name), sourceId, nativeType.attribute.span));
 				return;
 			}
 			mapping = native;
@@ -1697,13 +1682,13 @@ function readField(args) {
 		dataTypeLookup: input.dataTypes.lookup
 	};
 	const columnTypeName = unquotedSqlBaseNameOfCodec(resolved.descriptor.codecId, resolved.descriptor.typeParams, typeLookups);
-	const updatedAtGeneratorId = updatedAt === void 0 ? void 0 : binding.updatedAtGeneratorId(resolved.descriptor.codecId);
-	if (updatedAt !== void 0 && updatedAtGeneratorId === void 0) {
+	const updatedAtGeneratorId = updatedAt === void 0 || ignored ? void 0 : binding.updatedAtGeneratorId(resolved.descriptor.codecId);
+	if (updatedAt !== void 0 && !ignored && updatedAtGeneratorId === void 0) {
 		const withoutUpdatedAt = defaultAttribute !== void 0 && givesColumnDefault(defaultAttribute) ? `. Its ${attributeText(defaultAttribute)} still sets the value on create, and neither client changes it on update.` : field.optional ? ", but neither client then fills the value, so it stays empty unless a client writes it, and updates leave it unchanged." : ", but neither client then fills the value, so both require it on create and leave it unchanged on update.";
 		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UPDATED_AT_TYPE_UNSUPPORTED", `${label}: @updatedAt is not supported on this column, because Prisma 8 has no generator for column type "${columnTypeName}" yet. Remove @updatedAt: Prisma 7's next migration is empty${withoutUpdatedAt}`, sourceId, updatedAt.span));
 		return;
 	}
-	if (updatedAt !== void 0 && defaultAttribute !== void 0) {
+	if (updatedAt !== void 0 && !ignored && defaultAttribute !== void 0) {
 		const written = attributeText(defaultAttribute);
 		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UPDATED_AT_WITH_DEFAULT_UNSUPPORTED", `${label} combines @updatedAt with ${written}, which Prisma 8 cannot express yet. Remove ${written}: @updatedAt still sets the value on create and on update, and Prisma 7's next migration removes the column default.`, sourceId, defaultAttribute.span));
 		return;
@@ -1727,6 +1712,21 @@ function readField(args) {
 		diagnostics
 	});
 	if (defaultAttribute !== void 0 && lowered === void 0) return;
+	const column = {
+		columnName,
+		descriptor: resolved.descriptor,
+		nullable: field.optional || field.list,
+		many: field.list,
+		...field.list ? {
+			elementNullable: false,
+			noCheck: ["elementNotNull"]
+		} : {},
+		...ifDefined("default", lowered?.storage)
+	};
+	if (ignored) {
+		build.ignoredColumns.set(field.name, column);
+		return;
+	}
 	const updatedAtGenerator = updatedAtGeneratorId === void 0 ? void 0 : {
 		kind: "generator",
 		id: updatedAtGeneratorId
@@ -1744,15 +1744,7 @@ function readField(args) {
 	} : generator !== void 0 ? { onCreate: generator } : void 0;
 	build.columns.set(field.name, {
 		fieldName: field.name,
-		columnName,
-		descriptor: resolved.descriptor,
-		nullable: field.optional || field.list,
-		many: field.list,
-		...field.list ? {
-			elementNullable: false,
-			noCheck: ["elementNotNull"]
-		} : {},
-		...ifDefined("default", lowered?.storage),
+		...column,
 		...ifDefined("executionDefaults", executionDefaults)
 	});
 }