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

package/dist/contract-prisma7__provider.d.mts

@@ -62,6 +62,11 @@ interface Prisma7TargetBinding {
   readonly indexTypes: Readonly<Record<string, string>>;
   /** The longest identifier the database keeps, in bytes. Prisma 7 cuts the names it generates to fit. */
   readonly identifierMaxBytes: number;
+  /** The names the target's migration planner gives a primary key or foreign key the contract leaves unnamed. */
+  readonly defaultConstraintNames: {
+    readonly primaryKey: (tableName: string) => string;
+    readonly foreignKey: (tableName: string, columns: readonly string[]) => string;
+  };
   /**
    * The relation field names `contract infer` gives a junction table whose
    * columns `A` and `B` reference `tableA` and `tableB`, so the junction model

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

@@ -1 +1 @@
-{"version":3,"file":"contract-prisma7__provider.d.mts","names":[],"sources":["../../../../2-sql/2-authoring/contract-prisma7/dist/provider.d.mts"],"mappings":";;;;;;;;;;;;UAUU;WACC;WACA;;UAED;;WAEC,SAAS,SAAS,eAAe;;;;;WAKjC,aAAa,SAAS,eAAe;;;;UAItC;WACC;;WAEA;WACA,aAAa,SAAS;;;KAG5B;;;WAGM;;;;WAIA;;WAEA,UAAU;;WAEV,OAAO;;;UAGR;WACC,QAAQ;WACR,kBAAkB,OAAO,sBAAsB;;WAE/C;;WAEA,SAAS;;WAET;aACE;aACA;;;WAGF,YAAY,SAAS;;WAErB;;;;;;WAMA,6BAA6B,gBAAgB;;WAE7C,uBAAuB;;WAEvB,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/2-authoring/contract-prisma7/dist/provider.d.mts"],"mappings":";;;;;;;;;;;;UAUU;WACC;WACA;;UAED;;WAEC,SAAS,SAAS,eAAe;;;;;WAKjC,aAAa,SAAS,eAAe;;;;UAItC;WACC;;WAEA;WACA,aAAa,SAAS;;;KAG5B;;;WAGM;;;;WAIA;;WAEA,UAAU;;WAEV,OAAO;;;UAGR;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,uBAAuB;;WAEvB,qBAAqB,QAAQ,sBAAsB;;;;UAIpD;WACC,SAAS;WACT;WACA,uBAAuB;;iBAEjB,gBAAgB,oBAAoB,SAAS,yBAAyB"}

package/dist/contract-prisma7__provider.mjs

@@ -1,17 +1,18 @@
 import { d as unquotedSqlBaseNameOfCodec, l as sqlDataTypeOfCodec } from "./data-type-CAPmGXg9.mjs";
-import { d as validateSqlStorageConsistency, l as validateModelStorageReferences } from "./validators-Ddcw8nHL.mjs";
+import { d as validateSqlStorageConsistency, l as validateModelStorageReferences } from "./validators-Xx-TKcx3.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
-import { n as buildSqlContractFromDefinition, t as applySqlSpecifierControlPolicy } from "./derived-checks-DAbro9yn-BgBbql-q.mjs";
-import { _ as readDataTypeDefault, u as instantiateFieldTypeConstructor } from "./psl-field-resolution-DUCrDnuq-BXwISml1.mjs";
-import { a as normalizeReferentialAction, n as buildEntityTypesByDiscriminator, r as indexFkRelations, t as applyBackrelationCandidates } from "./interpreter-BF5Xrf3W-DK928Clg.mjs";
+import { n as buildSqlContractFromDefinition, t as applySqlSpecifierControlPolicy } from "./derived-checks-DdguQPYm-BP57ljP8.mjs";
+import { _ as readDataTypeDefault, u as instantiateFieldTypeConstructor } from "./psl-field-resolution-DUCrDnuq-DSxPrd-4.mjs";
+import { a as normalizeReferentialAction, n as buildEntityTypesByDiscriminator, r as indexFkRelations, t as applyBackrelationCandidates } from "./interpreter-BF5Xrf3W-bdklH78q.mjs";
 import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { entryForTag, getAuthoringTypeConstructor, instantiateAuthoringEntityType } from "@prisma/orm-framework/components/authoring";
+import { clipToUtf8Bytes, utf8ByteLength } from "@prisma/orm-framework/utils/text";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { validateContractDomain } from "@prisma/orm-framework/contract/validate-domain";
 import { readFile, readdir, stat } from "node:fs/promises";
-import { ArrayLiteralAst, BooleanLiteralExprAst, FunctionCallAst, IdentifierAst, NumberLiteralExprAst, PathExprAst, StringLiteralExprAst, dottedPathsIn, parse, printSyntax } from "@prisma/orm-framework/psl-parser/syntax";
+import { ArrayLiteralAst, BooleanLiteralExprAst, FunctionCallAst, IdentifierAst, ModelAttributeAst, NumberLiteralExprAst, PathExprAst, StringLiteralExprAst, dottedPathsIn, parse, printSyntax } from "@prisma/orm-framework/psl-parser/syntax";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
 import { basename, dirname, extname, join, normalize } from "pathe";
 import { buildSymbolTable, createPslDiagnosticCollector, diagnosticSource, keywordPslSpan, nodePslSpan, readResolvedAttribute, readResolvedAttributes } from "@prisma/orm-framework/psl-parser";
@@ -38,6 +39,118 @@ function ignoredFieldReferenced(input) {
 	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);
 }
+function parseIndexAttribute(attribute, owner, sourceId, indexTypes, diagnostics) {
+	const unsupported = (what, span) => {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_INDEX_ARGUMENT_UNSUPPORTED", `"${owner}": @${attribute.name} ${what}`, sourceId, span));
+	};
+	let fields;
+	let map;
+	let type;
+	for (const arg of attribute.args) {
+		const key = arg.kind === "positional" ? "fields" : arg.name;
+		const expression = arg.expression;
+		switch (key) {
+			case "fields": {
+				const array = expression === void 0 ? void 0 : ArrayLiteralAst.cast(expression.syntax);
+				if (array === void 0) return unsupported("expects a list of field names.", arg.span);
+				const names = [];
+				for (const element of array.elements()) {
+					const path = PathExprAst.cast(element.syntax) ?? FunctionCallAst.cast(element.syntax)?.memberPath();
+					if (path !== void 0) return unsupported(`lists the dotted path "${path.path().join(".")}"; an index lists fields of its model by name, and Prisma 7 refuses the path as an unknown field.`, arg.span);
+					const name = IdentifierAst.cast(element.syntax)?.name();
+					if (name === void 0) return unsupported("field arguments such as sort or length are not supported; Prisma 8 indexes carry none.", arg.span);
+					names.push(name);
+				}
+				fields = names;
+				break;
+			}
+			case "map":
+				map = expression === void 0 ? void 0 : StringLiteralExprAst.cast(expression.syntax)?.value();
+				if (map === void 0) return unsupported("map must be a string.", arg.span);
+				break;
+			case "name": break;
+			case "type": {
+				const token = expression === void 0 ? void 0 : IdentifierAst.cast(expression.syntax)?.name();
+				type = token !== void 0 && Object.hasOwn(indexTypes, token) ? indexTypes[token] : void 0;
+				if (type === void 0) return unsupported(`type "${token ?? ""}" is not an index type Prisma 8 supports.`, arg.span);
+				break;
+			}
+			default: return unsupported(`argument "${key ?? ""}" is not supported.`, arg.span);
+		}
+	}
+	return {
+		fields,
+		map,
+		type,
+		span: attribute.span
+	};
+}
+/**
+* A generated constraint name as Prisma 7 spells it: `base` cut so that
+* `base + suffix` is at most `maxBytes` bytes, cut on a character boundary,
+* with the suffix kept whole. Prisma 7.10.0 emits `..._aVeryLongCo_idx` for a
+* long `@@index`, `..._AB_pkey` and `..._B_index` for a long implicit junction,
+* and cuts a multi-byte name before the character that would cross the budget.
+*/
+function prisma7ConstraintName(base, suffix, maxBytes) {
+	return `${clipToUtf8Bytes(base, maxBytes - utf8ByteLength(suffix))}${suffix}`;
+}
+/** Prisma 7's default index name: `{table}_{columns}_idx`, or `_key` for a unique index, cut to `maxBytes`. */
+function defaultIndexName(tableName, columns, unique, maxBytes) {
+	return prisma7ConstraintName(`${tableName}_${columns.join("_")}`, unique ? "_key" : "_idx", maxBytes);
+}
+function indexNode(tableName, columns, attribute, unique, maxBytes) {
+	return {
+		columns,
+		...attribute.type === void 0 ? {
+			type: void 0,
+			options: void 0
+		} : {
+			type: attribute.type,
+			options: {}
+		},
+		where: void 0,
+		unique: unique ? true : void 0,
+		map: attribute.map ?? defaultIndexName(tableName, columns, unique, maxBytes),
+		name: void 0
+	};
+}
+/** Prisma 7's primary key name: `map`, or `{table}_pkey` cut to `maxBytes`. */
+function prisma7PrimaryKeyName(tableName, map, maxBytes) {
+	return map ?? prisma7ConstraintName(tableName, "_pkey", maxBytes);
+}
+/** Prisma 7's foreign key name: `map`, or `{table}_{columns}_fkey` cut to `maxBytes`. */
+function prisma7ForeignKeyName(tableName, columns, map, maxBytes) {
+	return map ?? prisma7ConstraintName(`${tableName}_${columns.join("_")}`, "_fkey", maxBytes);
+}
+/** Prisma 7's primary key name for the junction table of an implicit many-to-many relation. */
+function prisma7JunctionPrimaryKeyName(relationName, maxBytes) {
+	return prisma7ConstraintName(`_${relationName}`, "_AB_pkey", maxBytes);
+}
+/** Prisma 7's name for the junction foreign key on column `A` or `B`. */
+function prisma7JunctionForeignKeyName(relationName, column, maxBytes) {
+	return prisma7ConstraintName(`_${relationName}`, `_${column}_fkey`, maxBytes);
+}
+/**
+* The name a contract states for a constraint Prisma 7 named `prisma7Name`: the name itself where the target would derive a different one, and `undefined` where the two agree, so the contract stays unnamed there and a table rename keeps deriving it.
+*/
+function statedConstraintName(prisma7Name, derivedName) {
+	return prisma7Name === derivedName ? void 0 : prisma7Name;
+}
+/**
+* Refuses a `map` on `@id`, `@@id`, `@unique`, `@@unique`, `@@index` or `@relation` longer than the database keeps, as Prisma 7 does. The database would store the name cut short, so a contract holding it whole would rename or drop a constraint the database does not have.
+*/
+function checkStatedConstraintNameLength(input) {
+	const { attribute, maxBytes } = input;
+	const mapArgument = attribute.args.find((arg) => arg.kind === "named" && arg.name === "map");
+	const expression = mapArgument?.expression;
+	const name = expression === void 0 ? void 0 : StringLiteralExprAst.cast(expression.syntax)?.value();
+	if (mapArgument === void 0 || name === void 0) return;
+	const bytes = utf8ByteLength(name);
+	if (bytes <= maxBytes) return;
+	const spelling = `${attribute.node instanceof ModelAttributeAst ? "@@" : "@"}${attribute.name}`;
+	input.diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_CONSTRAINT_NAME_TOO_LONG", `${input.owner}: the name "${name}" in the map argument of ${spelling} is ${bytes} bytes, longer than the ${maxBytes} bytes the database keeps. Shorten the map to ${maxBytes} bytes or fewer; Prisma 7 refuses this name too.`, input.sourceId, mapArgument.span));
+}
 const CLIENT_SIDE_GENERATORS = /* @__PURE__ */ new Set([
 	"uuid",
 	"cuid",
@@ -312,91 +425,6 @@ function dbgeneratedDefault(callArgs, unknown, span) {
 		onCreate: void 0
 	};
 }
-function parseIndexAttribute(attribute, owner, sourceId, indexTypes, diagnostics) {
-	const unsupported = (what, span) => {
-		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_INDEX_ARGUMENT_UNSUPPORTED", `"${owner}": @${attribute.name} ${what}`, sourceId, span));
-	};
-	let fields;
-	let map;
-	let type;
-	for (const arg of attribute.args) {
-		const key = arg.kind === "positional" ? "fields" : arg.name;
-		const expression = arg.expression;
-		switch (key) {
-			case "fields": {
-				const array = expression === void 0 ? void 0 : ArrayLiteralAst.cast(expression.syntax);
-				if (array === void 0) return unsupported("expects a list of field names.", arg.span);
-				const names = [];
-				for (const element of array.elements()) {
-					const path = PathExprAst.cast(element.syntax) ?? FunctionCallAst.cast(element.syntax)?.memberPath();
-					if (path !== void 0) return unsupported(`lists the dotted path "${path.path().join(".")}"; an index lists fields of its model by name, and Prisma 7 refuses the path as an unknown field.`, arg.span);
-					const name = IdentifierAst.cast(element.syntax)?.name();
-					if (name === void 0) return unsupported("field arguments such as sort or length are not supported; Prisma 8 indexes carry none.", arg.span);
-					names.push(name);
-				}
-				fields = names;
-				break;
-			}
-			case "map":
-				map = expression === void 0 ? void 0 : StringLiteralExprAst.cast(expression.syntax)?.value();
-				if (map === void 0) return unsupported("map must be a string.", arg.span);
-				break;
-			case "name": break;
-			case "type": {
-				const token = expression === void 0 ? void 0 : IdentifierAst.cast(expression.syntax)?.name();
-				type = token !== void 0 && Object.hasOwn(indexTypes, token) ? indexTypes[token] : void 0;
-				if (type === void 0) return unsupported(`type "${token ?? ""}" is not an index type Prisma 8 supports.`, arg.span);
-				break;
-			}
-			default: return unsupported(`argument "${key ?? ""}" is not supported.`, arg.span);
-		}
-	}
-	return {
-		fields,
-		map,
-		type,
-		span: attribute.span
-	};
-}
-const utf8 = new TextEncoder();
-/**
-* A generated constraint name as Prisma 7 spells it: `base` cut so that
-* `base + suffix` is at most `maxBytes` bytes, cut on a character boundary,
-* with the suffix kept whole. Prisma 7.10.0 emits `..._aVeryLongCo_idx` for a
-* long `@@index`, `..._AB_pkey` and `..._B_index` for a long implicit junction,
-* and cuts a multi-byte name before the character that would cross the budget.
-*/
-function prisma7ConstraintName(base, suffix, maxBytes) {
-	const budget = maxBytes - utf8.encode(suffix).length;
-	let bytes = 0;
-	let kept = "";
-	for (const character of base) {
-		bytes += utf8.encode(character).length;
-		if (bytes > budget) break;
-		kept += character;
-	}
-	return `${kept}${suffix}`;
-}
-/** Prisma 7's default index name: `{table}_{columns}_idx`, or `_key` for a unique index, cut to `maxBytes`. */
-function defaultIndexName(tableName, columns, unique, maxBytes) {
-	return prisma7ConstraintName(`${tableName}_${columns.join("_")}`, unique ? "_key" : "_idx", maxBytes);
-}
-function indexNode(tableName, columns, attribute, unique, maxBytes) {
-	return {
-		columns,
-		...attribute.type === void 0 ? {
-			type: void 0,
-			options: void 0
-		} : {
-			type: attribute.type,
-			options: {}
-		},
-		where: void 0,
-		unique: unique ? true : void 0,
-		map: attribute.map ?? defaultIndexName(tableName, columns, unique, maxBytes),
-		name: void 0
-	};
-}
 function prisma7ScalarMapping(typeMap, scalar) {
 	return Object.hasOwn(typeMap.scalars, scalar) ? typeMap.scalars[scalar] : void 0;
 }
@@ -445,6 +473,7 @@ function actionValue(expression) {
 }
 function parseRelationAttribute(attribute, label, sourceId, diagnostics) {
 	let name;
+	let map;
 	let fields;
 	let references;
 	let onDelete;
@@ -480,12 +509,16 @@ function parseRelationAttribute(attribute, label, sourceId, diagnostics) {
 				onUpdate = actionValue(arg.expression);
 				if (onUpdate === void 0) return invalid("onUpdate must be a referential action", arg.span);
 				break;
-			case "map": break;
+			case "map":
+				map = stringValue(arg.expression);
+				if (map === void 0) return invalid("map must be a string", arg.span);
+				break;
 			default: return invalid(`argument "${key ?? ""}" is not supported`, arg.span);
 		}
 	}
 	return {
 		name,
+		map,
 		fields,
 		references,
 		onDelete,
@@ -656,7 +689,9 @@ function lowerRelations(models, naming, diagnostics) {
 				rejectFkSide(model, relationField, ...actionRejections);
 				continue;
 			}
+			const foreignKeyName = statedConstraintName(prisma7ForeignKeyName(model.tableName, localColumns, attribute.map, naming.identifierMaxBytes), naming.defaultConstraintNames.foreignKey(model.tableName, localColumns));
 			addForeignKey(model.modelName, {
+				...ifDefined("name", foreignKeyName),
 				columns: localColumns,
 				references: {
 					model: target.modelName,
@@ -866,7 +901,10 @@ function synthesizeJunction(requester, partner, naming, diagnostics) {
 	const namespaceId = sideA.model.namespaceId;
 	const key = junctionKey(namespaceId, name);
 	const [relationFieldA, relationFieldB] = naming.junctionRelationFieldNames(sideA.model.tableName, sideB.model.tableName);
+	const foreignKeyName = (column) => statedConstraintName(prisma7JunctionForeignKeyName(name, column, naming.identifierMaxBytes), naming.defaultConstraintNames.foreignKey(tableName, [column]));
+	const primaryKeyName = statedConstraintName(prisma7JunctionPrimaryKeyName(name, naming.identifierMaxBytes), naming.defaultConstraintNames.primaryKey(tableName));
 	const foreignKey = (column, side, id) => ({
+		...ifDefined("name", foreignKeyName(column)),
 		columns: [column],
 		references: {
 			model: side.model.modelName,
@@ -919,7 +957,10 @@ function synthesizeJunction(requester, partner, naming, diagnostics) {
 				nullable: false,
 				many: false
 			}],
-			id: { columns: ["A", "B"] },
+			id: {
+				columns: ["A", "B"],
+				...ifDefined("name", primaryKeyName)
+			},
 			indexes: [index],
 			foreignKeys: [foreignKey("A", sideA, idA), foreignKey("B", sideB, idB)]
 		},
@@ -1052,7 +1093,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.indexTypes, diagnostics);
+			const declaration = readModelDeclaration(symbol, sourceId, sources, defaultNamespaceId, binding, diagnostics);
 			if (declaration === void 0) ignoredModels.add(symbol.name);
 			else models.push(declaration);
 		}
@@ -1076,6 +1117,7 @@ function interpretPrisma7Documents(input) {
 			ignoredRelationFields: [],
 			rejectedFields: /* @__PURE__ */ new Set(),
 			idFields: declaration.id?.fields ?? [],
+			idMap: declaration.id?.map,
 			uniqueIndexes: [...declaration.uniqueIndexes],
 			relationFields: []
 		};
@@ -1158,12 +1200,16 @@ 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({
 			modelName,
 			tableName: model.tableName,
 			namespaceId: model.namespaceId,
 			fields: [...build.columns.values()],
-			...id !== void 0 && id.length > 0 ? { id: { columns: id } } : {},
+			...id !== void 0 && id.length > 0 ? { id: {
+				columns: id,
+				...ifDefined("name", primaryKeyName)
+			} } : {},
 			...indexes.length > 0 ? { indexes } : {},
 			...foreignKeys !== void 0 ? { foreignKeys } : {},
 			...relations !== void 0 ? { relations } : {}
@@ -1248,36 +1294,50 @@ function keyColumns(model, fieldNames) {
 	}
 	return columns;
 }
-function readModelDeclaration(symbol, sourceId, sources, defaultNamespaceId, indexTypes, diagnostics) {
+function readModelDeclaration(symbol, sourceId, sources, defaultNamespaceId, binding, diagnostics) {
+	const { indexTypes } = binding;
 	if (symbol.attributes.some((attribute) => attribute.name === "ignore")) return void 0;
 	let tableName = symbol.name;
 	let namespaceId = defaultNamespaceId;
 	let id;
 	const uniqueIndexes = [];
 	const indexes = [];
-	for (const attribute of symbol.attributes) switch (attribute.name) {
-		case "map":
-			tableName = requireStringArgument(attribute, symbol.name, sourceId, diagnostics) ?? tableName;
-			break;
-		case "schema":
-			namespaceId = requireStringArgument(attribute, symbol.name, sourceId, diagnostics) ?? namespaceId;
-			break;
-		case "id": {
-			const parsed = parseIndexAttribute(attribute, symbol.name, sourceId, indexTypes, diagnostics);
-			if (parsed?.fields !== void 0) id = parsed;
-			break;
-		}
-		case "unique": {
-			const parsed = parseIndexAttribute(attribute, symbol.name, sourceId, indexTypes, diagnostics);
-			if (parsed?.fields !== void 0) uniqueIndexes.push(parsed);
-			break;
-		}
-		case "index": {
-			const parsed = parseIndexAttribute(attribute, symbol.name, sourceId, indexTypes, diagnostics);
-			if (parsed?.fields !== void 0) indexes.push(parsed);
-			break;
+	for (const attribute of symbol.attributes) {
+		if ([
+			"id",
+			"unique",
+			"index"
+		].includes(attribute.name)) checkStatedConstraintNameLength({
+			attribute,
+			owner: `Model "${symbol.name}"`,
+			maxBytes: binding.identifierMaxBytes,
+			sourceId,
+			diagnostics
+		});
+		switch (attribute.name) {
+			case "map":
+				tableName = requireStringArgument(attribute, symbol.name, sourceId, diagnostics) ?? tableName;
+				break;
+			case "schema":
+				namespaceId = requireStringArgument(attribute, symbol.name, sourceId, diagnostics) ?? namespaceId;
+				break;
+			case "id": {
+				const parsed = parseIndexAttribute(attribute, symbol.name, sourceId, indexTypes, diagnostics);
+				if (parsed?.fields !== void 0) id = parsed;
+				break;
+			}
+			case "unique": {
+				const parsed = parseIndexAttribute(attribute, symbol.name, sourceId, indexTypes, diagnostics);
+				if (parsed?.fields !== void 0) uniqueIndexes.push(parsed);
+				break;
+			}
+			case "index": {
+				const parsed = parseIndexAttribute(attribute, symbol.name, sourceId, indexTypes, diagnostics);
+				if (parsed?.fields !== void 0) indexes.push(parsed);
+				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));
 		}
-		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));
 	}
 	return {
 		symbol,
@@ -1491,23 +1551,36 @@ function readField(args) {
 	let relation;
 	let defaultAttribute;
 	let updatedAt;
-	for (const attribute of field.attributes) if (attribute.name === "map" && !isRelationField) columnName = requireStringArgument(attribute, label, sourceId, diagnostics) ?? columnName;
-	else if (attribute.name.startsWith("db.") && !isRelationField) nativeType = {
-		name: attribute.name.slice(3),
-		attribute
-	};
-	else if (attribute.name === "id" && !isRelationField) {
-		if (parseIndexAttribute(attribute, label, sourceId, binding.indexTypes, diagnostics) !== void 0) build.idFields = [field.name];
-	} else if (attribute.name === "unique" && !isRelationField) {
-		const parsed = parseIndexAttribute(attribute, label, sourceId, binding.indexTypes, diagnostics);
-		if (parsed !== void 0) build.uniqueIndexes.push({
-			...parsed,
-			fields: [field.name]
+	for (const attribute of field.attributes) {
+		if (isRelationField ? attribute.name === "relation" : ["id", "unique"].includes(attribute.name)) checkStatedConstraintNameLength({
+			attribute,
+			owner: label,
+			maxBytes: binding.identifierMaxBytes,
+			sourceId,
+			diagnostics
 		});
-	} 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));
+		if (attribute.name === "map" && !isRelationField) columnName = requireStringArgument(attribute, label, sourceId, diagnostics) ?? columnName;
+		else if (attribute.name.startsWith("db.") && !isRelationField) nativeType = {
+			name: attribute.name.slice(3),
+			attribute
+		};
+		else if (attribute.name === "id" && !isRelationField) {
+			const parsed = parseIndexAttribute(attribute, label, sourceId, binding.indexTypes, diagnostics);
+			if (parsed !== void 0) {
+				build.idFields = [field.name];
+				build.idMap = parsed.map;
+			}
+		} else if (attribute.name === "unique" && !isRelationField) {
+			const parsed = parseIndexAttribute(attribute, label, sourceId, binding.indexTypes, diagnostics);
+			if (parsed !== void 0) build.uniqueIndexes.push({
+				...parsed,
+				fields: [field.name]
+			});
+		} 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));
+	}
 	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));