@prisma/orm-family-mongo 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

package/dist/contract-prisma6__provider.mjs

@@ -0,0 +1,1202 @@
+import { o as MongoIndex } from "./entity-kinds-BQBtfVet-B-Px7NHp.mjs";
+import { N as validateMongoStorage, u as buildMongoStorage, w as mongoValueSetsOf } from "./dist-B8f-pfcT.mjs";
+import { i as pairMongoBackRelations } from "./interpreter-BfHdPd7T-DGqi2_Um.mjs";
+import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { crossRef } from "@prisma/orm-framework/contract/types";
+import { buildExecutionSection, computeProfileHash } from "@prisma/orm-framework/contract/hashing";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { applySpecifierDefaultControlPolicy } from "@prisma/orm-framework/contract/apply-specifier-default-control-policy";
+import { validateContractDomain } from "@prisma/orm-framework/contract/validate-domain";
+import { ArrayLiteralAst, FunctionCallAst, IdentifierAst, 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 { resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
+import { encodeEnumMembers, enumMemberProblemDiagnostic, instantiateAuthoringEntityType, isAuthoringEntityTypeDescriptor } from "@prisma/orm-framework/components/authoring";
+import { buildSymbolTable, keywordPslSpan, mapPslDiagnostics, nodePslSpan, readResolvedAttribute } from "@prisma/orm-framework/psl-parser";
+import { fkRelationPairKey } from "@prisma/orm-framework/psl-parser/interpret";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+//#region ../../../2-mongo-family/2-authoring/contract-prisma6/dist/provider.mjs
+function prisma6Diagnostic(code, message, sourceId, span) {
+	return {
+		code,
+		message,
+		sourceId,
+		...span !== void 0 ? { span } : {}
+	};
+}
+function unsupported(attribute, what, span, ctx) {
+	ctx.diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_INDEX_ARGUMENT_UNSUPPORTED", `${ctx.owner}: ${ctx.prefix}${attribute.name} ${what}`, ctx.sourceId, span));
+}
+function sortDirection(expression) {
+	if (expression === void 0) return void 0;
+	const token = IdentifierAst.cast(expression.syntax)?.name();
+	return token === "Asc" ? 1 : token === "Desc" ? -1 : void 0;
+}
+/**
+* Reads `sort:` from one index element's or `@unique`'s arguments. `length:` and every other argument are refused: a MongoDB index has no prefix length, and Prisma 6 accepts no other argument there on MongoDB.
+*/
+function readSort(attribute, args, ctx) {
+	let direction;
+	for (const arg of args) {
+		const key = arg.name()?.name();
+		const span = nodePslSpan(arg.syntax, ctx.sources);
+		if (key !== "sort") return unsupported(attribute, key === "length" ? "argument \"length\" is not supported: a MongoDB index has no prefix length. Remove it; Prisma 6 ignores it on MongoDB." : `argument "${key ?? ""}" is not supported.`, span, ctx);
+		direction = sortDirection(arg.value());
+		if (direction === void 0) return unsupported(attribute, "sort must be Asc or Desc.", span, ctx);
+	}
+	return { direction };
+}
+function readFields(attribute, expression, span, ctx) {
+	const array = expression === void 0 ? void 0 : ArrayLiteralAst.cast(expression.syntax);
+	if (array === void 0) return unsupported(attribute, "expects a list of field names.", span, ctx);
+	const fields = [];
+	for (const element of array.elements()) {
+		const name = IdentifierAst.cast(element.syntax)?.name();
+		if (name !== void 0) {
+			fields.push({
+				name,
+				direction: void 0
+			});
+			continue;
+		}
+		const call = FunctionCallAst.cast(element.syntax);
+		const path = PathExprAst.cast(element.syntax)?.path() ?? call?.path() ?? [];
+		const [callee] = path;
+		if (path.length > 1 && (callee === void 0 || !ctx.compositeFields.has(callee))) return unsupported(attribute, `lists the dotted path "${path.join(".")}", but "${callee ?? ""}" is not a composite-type field of the model, and Prisma 6 refuses the path as an unknown field. List fields of the model by name.`, nodePslSpan(element.syntax, ctx.sources), ctx);
+		if (path.length > 1) {
+			ctx.diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_COMPOSITE_INDEX_PATH_UNSUPPORTED", `Index path "${path.join(".")}" reaches into a composite type; indexes on composite-type fields are not supported yet. Index a top-level field or remove the index. Either change also reaches the Prisma 6 app, whose \`db push\` builds its indexes from this schema.`, ctx.sourceId, nodePslSpan(element.syntax, ctx.sources)));
+			return;
+		}
+		if (call === void 0 || callee === void 0) return unsupported(attribute, "expects a list of field names.", nodePslSpan(element.syntax, ctx.sources), ctx);
+		const sort = readSort(attribute, call.args(), ctx);
+		if (sort === void 0) return void 0;
+		fields.push({
+			name: callee,
+			direction: sort.direction
+		});
+	}
+	return fields;
+}
+/** Reads `@@index`, `@@unique` or `@@fulltext`. `map:` and `name:` are dropped: MongoDB verify never compares index names. */
+function parseIndexAttribute(attribute, ctx) {
+	let fields;
+	for (const arg of attribute.args) {
+		const key = arg.kind === "positional" ? "fields" : arg.name;
+		if (key === "map" || key === "name") continue;
+		if (key !== "fields") return unsupported(attribute, `argument "${key ?? ""}" is not supported.`, arg.span, ctx);
+		fields = readFields(attribute, arg.expression, arg.span, ctx);
+		if (fields === void 0) return void 0;
+	}
+	if (fields === void 0 || fields.length === 0) return unsupported(attribute, "expects a list of field names.", attribute.span, ctx);
+	return {
+		kind: attribute.name,
+		fields,
+		span: attribute.span
+	};
+}
+/** Reads a field's `@unique`: `sort:` sets the key direction; `map:` and `name:` are dropped. */
+function parseFieldUnique(attribute, fieldName, ctx) {
+	let direction;
+	for (const arg of attribute.args) {
+		const key = arg.kind === "positional" ? void 0 : arg.name;
+		if (key === "map" || key === "name") continue;
+		if (key === "sort") {
+			direction = sortDirection(arg.expression);
+			if (direction === void 0) return unsupported(attribute, "sort must be Asc or Desc.", arg.span, ctx);
+			continue;
+		}
+		return unsupported(attribute, key === "length" ? "argument \"length\" is not supported: a MongoDB index has no prefix length. Remove it; Prisma 6 ignores it on MongoDB." : `argument "${key ?? ""}" is not supported.`, arg.span, ctx);
+	}
+	return {
+		kind: "unique",
+		fields: [{
+			name: fieldName,
+			direction
+		}],
+		span: attribute.span
+	};
+}
+const SUMMARY = "Prisma 6 MongoDB schema interpretation failed";
+function stringArgument(attribute) {
+	const expression = (attribute.args.find((arg) => arg.kind === "positional") ?? attribute.args.find((arg) => arg.name === "name"))?.expression;
+	return expression === void 0 ? void 0 : StringLiteralExprAst.cast(expression.syntax)?.value();
+}
+function requireString(attribute, owner, sourceId, diagnostics) {
+	const value = stringArgument(attribute);
+	if (value === void 0) diagnostics.push({
+		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+		message: `${owner}: attribute "@${attribute.name}" expects one string argument.`,
+		sourceId,
+		span: attribute.span
+	});
+	return value;
+}
+function attributeText(attribute) {
+	const args = attribute.args.map((arg) => arg.kind === "named" ? `${arg.name}: ${arg.value}` : arg.value);
+	return args.length === 0 ? `@${attribute.name}` : `@${attribute.name}(${args.join(", ")})`;
+}
+/** `auto()` and `now()` with no arguments; any other `@default` value is `other`. */
+function defaultKind(attribute) {
+	const expression = attribute.args.find((arg) => arg.kind === "positional")?.expression;
+	const call = expression === void 0 ? void 0 : FunctionCallAst.cast(expression.syntax);
+	if (call === void 0 || [...call.args()].length > 0) return "other";
+	const path = call.path().join(".");
+	return path === "auto" ? "auto" : path === "now" ? "now" : "other";
+}
+function unknownAttribute(owner, attribute, prefix, sourceId) {
+	return prisma6Diagnostic("PSL.PRISMA6_MONGO_UNKNOWN_ATTRIBUTE", `${owner}: attribute "${prefix}${attribute.name}" is not supported by the Prisma 6 MongoDB contract source.`, sourceId, attribute.span);
+}
+function interpretPrisma6Documents(input) {
+	const { binding } = input;
+	const diagnostics = [...input.seedDiagnostics];
+	const datasources = [];
+	const enumBlocks = [];
+	const compositeTypes = [];
+	const models = [];
+	const ignoredModels = /* @__PURE__ */ new Set();
+	const declaredNames = /* @__PURE__ */ new Map();
+	const claimName = (kind, name, sourceId, span) => {
+		const previous = declaredNames.get(name);
+		if (previous === void 0) {
+			declaredNames.set(name, sourceId);
+			return true;
+		}
+		diagnostics.push({
+			code: "PSL_DUPLICATE_DECLARATION",
+			message: `Duplicate declaration of ${kind} "${name}"; first declared in ${basename(previous)}.`,
+			sourceId,
+			span
+		});
+		return false;
+	};
+	for (const { document, sources, sourceFile, sourceId } of input.documents) {
+		const { symbolTable, diagnostics: tableDiagnostics } = buildSymbolTable({
+			documents: [document],
+			sources,
+			defaultNamespaceId: input.defaultNamespaceId
+		});
+		for (const diagnostic of tableDiagnostics) diagnostics.push({
+			code: diagnostic.code,
+			message: diagnostic.message,
+			sourceId,
+			span: sourceFile.rangeToPslSpan(diagnostic.range)
+		});
+		const unsupported = (keyword, span) => {
+			diagnostics.push({
+				code: "PSL_UNSUPPORTED_TOP_LEVEL_BLOCK",
+				message: `Unsupported top-level block "${keyword}"`,
+				sourceId,
+				span
+			});
+		};
+		const unsupportedInclusions = (code, holders) => {
+			for (const holder of Object.values(holders)) for (const inclusion of holder.node.inclusions()) diagnostics.push({
+				code,
+				message: `Unsupported mixin inclusion "${printSyntax(inclusion.syntax).trim()}"`,
+				sourceId,
+				span: nodePslSpan(inclusion.syntax, sources)
+			});
+		};
+		for (const block of Object.values(symbolTable.defaultNamespace.blocks)) switch (block.keyword) {
+			case "datasource":
+				datasources.push({
+					symbol: block,
+					sourceId,
+					sources
+				});
+				reportDottedBlockValues(block, sourceId, sources, diagnostics);
+				break;
+			case "generator":
+				reportDottedBlockValues(block, sourceId, sources, diagnostics);
+				break;
+			case "enum":
+				if (claimName("enum", block.name, sourceId, block.span)) enumBlocks.push({
+					symbol: block,
+					sourceId,
+					sources
+				});
+				break;
+			case "view":
+				diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_VIEW_UNSUPPORTED", `View "${block.name}" is not supported; Prisma 8 has no views on MongoDB. Remove the view from the schema this contract source reads. The Prisma 6 client then loses the view's model too.`, sourceId, keywordPslSpan(block.node.syntax, block.keyword, sources)));
+				break;
+			default: unsupported(block.keyword, keywordPslSpan(block.node.syntax, block.keyword, sources));
+		}
+		for (const namespace of Object.values(symbolTable.namespaces)) for (const { span } of namespace.declarations) unsupported("namespace", span);
+		for (const namedType of Object.values(symbolTable.namedTypes)) unsupported("types", namedType.span);
+		for (const mixin of Object.values(symbolTable.defaultNamespace.mixins)) unsupported(`${mixin.keyword} mixin`, mixin.span);
+		unsupportedInclusions("PSL_INVALID_MODEL_MEMBER", symbolTable.defaultNamespace.models);
+		unsupportedInclusions("PSL_INVALID_MODEL_MEMBER", symbolTable.defaultNamespace.compositeTypes);
+		unsupportedInclusions("PSL_INVALID_EXTENSION_BLOCK_MEMBER", symbolTable.defaultNamespace.blocks);
+		for (const symbol of Object.values(symbolTable.defaultNamespace.compositeTypes)) if (claimName("type", symbol.name, sourceId, symbol.span)) compositeTypes.push({
+			symbol,
+			sourceId,
+			sources
+		});
+		for (const symbol of Object.values(symbolTable.defaultNamespace.models)) {
+			if (!claimName("model", symbol.name, sourceId, symbol.span)) continue;
+			if (symbol.attributes.some((attribute) => attribute.name === "ignore")) ignoredModels.add(symbol.name);
+			else models.push({
+				symbol,
+				sourceId,
+				sources
+			});
+		}
+	}
+	const providerMismatch = checkDatasource(datasources, input.documents[0]?.sourceId ?? "schema.prisma", binding);
+	if (providerMismatch !== void 0) return notOk({
+		summary: SUMMARY,
+		diagnostics: inSourceOrder([...input.seedDiagnostics, providerMismatch], input.documents)
+	});
+	const enums = /* @__PURE__ */ new Map();
+	for (const located of enumBlocks) {
+		const built = buildEnum(located, input, diagnostics);
+		if (built !== void 0) enums.set(located.symbol.name, built);
+	}
+	const modelNames = /* @__PURE__ */ new Set([...models.map((m) => m.symbol.name), ...ignoredModels]);
+	const compositeTypeNames = new Set(compositeTypes.map((c) => c.symbol.name));
+	const enumNames = new Set(enumBlocks.map((located) => located.symbol.name));
+	const typeContext = {
+		binding,
+		generatorFunctions: input.generatorFunctions,
+		enums,
+		enumNames,
+		compositeTypeNames,
+		diagnostics,
+		namespaceId: input.defaultNamespaceId
+	};
+	const valueObjects = {};
+	for (const located of compositeTypes) valueObjects[located.symbol.name] = { fields: readCompositeFields(located, typeContext) };
+	const builds = /* @__PURE__ */ new Map();
+	for (const located of models) builds.set(located.symbol.name, readModel(located, modelNames, ignoredModels, typeContext));
+	const foreignKeys = [];
+	const invalidFkPairings = [];
+	const backRelations = [];
+	for (const build of builds.values()) readRelationFields(build, builds, {
+		foreignKeys,
+		invalidFkPairings,
+		backRelations
+	}, diagnostics, input.defaultNamespaceId);
+	const paired = pairMongoBackRelations({
+		foreignKeys,
+		candidates: backRelations,
+		invalidFkPairings,
+		namespaceId: input.defaultNamespaceId
+	});
+	diagnostics.push(...mapPslDiagnostics(paired.diagnostics, mergedSources(input.documents)));
+	for (const { modelName, fieldName, relation } of paired.relations) {
+		const build = builds.get(modelName);
+		if (build !== void 0) build.relations[fieldName] = relation;
+	}
+	const collections = {};
+	const roots = {};
+	const executionDefaults = [];
+	for (const [modelName, build] of builds) {
+		const indexes = buildIndexes(build, diagnostics);
+		const existing = collections[build.collection];
+		collections[build.collection] = { indexes: [...existing?.indexes ?? [], ...indexes] };
+		roots[build.collection] = crossRef(modelName, input.defaultNamespaceId);
+		for (const { field, phases } of build.executionDefaults) executionDefaults.push({
+			ref: {
+				namespace: input.defaultNamespaceId,
+				entry: build.collection,
+				field
+			},
+			...phases
+		});
+		if (!build.hasId) diagnostics.push({
+			code: "PSL_MISSING_ID_FIELD",
+			message: `Model "${modelName}" has no field with @id attribute. Every model must have exactly one @id field.`,
+			sourceId: build.located.sourceId,
+			span: build.located.symbol.span
+		});
+	}
+	if (diagnostics.length > 0) return notOk({
+		summary: SUMMARY,
+		diagnostics: inSourceOrder(diagnostics, input.documents)
+	});
+	return ok(assembleContract({
+		binding,
+		builds,
+		collections,
+		roots,
+		valueObjects,
+		enums,
+		executionDefaults,
+		namespaceId: input.defaultNamespaceId
+	}));
+}
+/**
+* Diagnostics by file, in the order the schema files were read, then by position; one with no position comes first in its file.
+*/
+function inSourceOrder(diagnostics, documents) {
+	const fileOrder = new Map(documents.map((document, index) => [document.sourceId, index]));
+	const fileRank = (diagnostic) => fileOrder.get(diagnostic.sourceId) ?? documents.length;
+	const offset = (diagnostic) => diagnostic.span?.start.offset ?? -1;
+	return [...diagnostics].sort((a, b) => fileRank(a) - fileRank(b) || offset(a) - offset(b));
+}
+/** Prisma 6 accepts no dotted path in a datasource or generator block, though the parser reads one as a value. */
+function reportDottedBlockValues(block, sourceId, sources, diagnostics) {
+	for (const entry of block.entries) {
+		const value = entry.value();
+		if (value === void 0) continue;
+		for (const path of dottedPathsIn(value)) diagnostics.push({
+			code: "PSL_INVALID_EXTENSION_BLOCK_MEMBER",
+			message: `${block.keyword} "${block.name}": the value of "${entry.key()?.name() ?? ""}" holds the dotted path ${path.path().join(".")}, which Prisma 6 does not accept in a ${block.keyword} block.`,
+			sourceId,
+			span: nodePslSpan(path.syntax, sources)
+		});
+	}
+}
+/** The provider-mismatch diagnostic, or `undefined` when the schema names a provider the target reads. */
+function checkDatasource(datasources, fallbackSourceId, binding) {
+	const [datasource] = datasources;
+	const [namedProvider] = binding.providers;
+	if (datasource === void 0) return prisma6Diagnostic("PSL.PRISMA6_MONGO_PROVIDER_MISMATCH", `No datasource block found; add \`datasource db { provider = "${namedProvider}" }\`.`, fallbackSourceId, void 0);
+	const block = datasource.symbol;
+	let parameter;
+	for (const entry of block.entries) if (entry.key()?.name() === "provider") {
+		parameter = entry;
+		break;
+	}
+	const expression = parameter?.value();
+	const provider = expression instanceof StringLiteralExprAst ? expression.value() : void 0;
+	if (provider !== void 0 && binding.providers.includes(provider)) return void 0;
+	return prisma6Diagnostic("PSL.PRISMA6_MONGO_PROVIDER_MISMATCH", provider === void 0 ? `The datasource block declares no string \`provider\`; this contract source reads Prisma 6 schemas for provider "${namedProvider}".` : `The datasource provider is "${provider}"; this contract source reads Prisma 6 schemas for provider "${namedProvider}".`, datasource.sourceId, parameter === void 0 ? block.span : nodePslSpan(parameter.syntax, datasource.sources));
+}
+function buildEnum(located, input, diagnostics) {
+	const { symbol: block, sourceId, sources } = located;
+	for (const attribute of block.attributes) {
+		if (attribute.name === "map") continue;
+		if (attribute.name === "schema") {
+			diagnostics.push(schemaUnsupported(`Enum "${block.name}"`, attribute, sourceId));
+			continue;
+		}
+		diagnostics.push(unknownAttribute(`Enum "${block.name}"`, attribute, "@@", sourceId));
+	}
+	const values = Object.create(null);
+	const writtenValues = Object.create(null);
+	const parameterSpans = Object.create(null);
+	for (const entry of block.entries) {
+		const name = entry.key()?.name();
+		if (name === void 0) continue;
+		let value = name;
+		for (const attributeNode of entry.attributes()) {
+			const attribute = readResolvedAttribute(attributeNode, sources);
+			if (attribute.name === "map") value = requireString(attribute, `Enum member "${block.name}.${name}"`, sourceId, diagnostics) ?? value;
+			else diagnostics.push(unknownAttribute(`Enum member "${block.name}.${name}"`, attribute, "@", sourceId));
+		}
+		values[name] = value;
+		writtenValues[name] = {
+			kind: "string",
+			text: value
+		};
+		parameterSpans[name] = nodePslSpan(entry.syntax, sources);
+	}
+	const descriptor = input.authoringContributions.entityTypes["enum"];
+	if (descriptor === void 0 || !isAuthoringEntityTypeDescriptor(descriptor)) {
+		diagnostics.push({
+			code: "PSL_ENUM_MISSING_FACTORY",
+			message: `enum "${block.name}" requires an "enum" entityType factory in the active authoring contributions`,
+			sourceId,
+			span: block.span
+		});
+		return;
+	}
+	const context = {
+		family: input.binding.target.familyId,
+		target: input.binding.target.targetId,
+		codecLookup: input.codecLookup,
+		dataTypes: input.dataTypes,
+		sourceId,
+		enumInferenceCodecs: {
+			text: input.binding.scalarCodecIds.String,
+			int: input.binding.scalarCodecIds.Int
+		},
+		diagnostics: { push: (diagnostic) => {
+			diagnostics.push(blindCast(diagnostic));
+		} }
+	};
+	const handle = instantiateAuthoringEntityType("enum", descriptor, [{
+		kind: "enum",
+		keyword: "enum",
+		name: block.name,
+		values,
+		writtenValues,
+		parameterSpans,
+		attributes: {},
+		span: block.span
+	}], context);
+	if (handle === void 0 || handle === null) return void 0;
+	const encoded = encodeEnumMembers(handle, input.codecLookup);
+	if (!encoded.ok) {
+		const site = {
+			enumName: block.name,
+			codecId: handle.codecId,
+			sourceId,
+			span: block.span,
+			memberSpans: parameterSpans
+		};
+		diagnostics.push(...encoded.failure.map((problem) => enumMemberProblemDiagnostic(problem, site)));
+		return;
+	}
+	return {
+		codecId: handle.codecId,
+		members: encoded.value
+	};
+}
+function schemaUnsupported(owner, attribute, sourceId) {
+	return prisma6Diagnostic("PSL.PRISMA6_MONGO_SCHEMA_UNSUPPORTED", `${owner}: "@@schema" is not supported; a MongoDB contract has one database, bound by the connection string. Remove @@schema.`, sourceId, attribute.span);
+}
+function unsupportedTypeMessage(label, typeName, owner) {
+	const base = `${label} has type "${typeName}(...)", which has no Prisma 8 codec, so ${`${owner.kind} "${owner.name}"`} cannot use this contract source while it has the field. Prisma 6 rejects @ignore on an Unsupported field. Removing the field from the schema leaves its stored values in the documents, but the Prisma 6 client no longer reads or writes them.`;
+	if (owner.kind === "type") return base;
+	return `${base} Adding @@ignore to model "${owner.name}" keeps the model out of the contract, but the model disappears from the Prisma 6 client too, and every relation field in another model that points to it needs @ignore, which removes that field from the Prisma 6 client as well.`;
+}
+/** The native types Prisma 6 accepts on each MongoDB scalar, checked with Prisma 6.19. */
+const PRISMA6_NATIVE_TYPES = {
+	String: ["db.String", "db.ObjectId"],
+	Boolean: ["db.Bool"],
+	Int: ["db.Int", "db.Long"],
+	BigInt: ["db.Long"],
+	Float: ["db.Double"],
+	DateTime: ["db.Date", "db.Timestamp"],
+	Bytes: ["db.BinData", "db.ObjectId"],
+	Json: ["db.Json"]
+};
+/** The BSON type Prisma 6 stores for each native type. */
+const PRISMA6_NATIVE_TYPE_BSON = {
+	"db.String": "string",
+	"db.ObjectId": "objectId",
+	"db.Bool": "bool",
+	"db.Int": "int",
+	"db.Long": "long",
+	"db.Double": "double",
+	"db.Date": "date",
+	"db.Timestamp": "timestamp",
+	"db.BinData": "binData",
+	"db.Json": "object"
+};
+/** The BSON type Prisma 6 stores for each MongoDB scalar that has no native type. `Int` is a long. */
+const PRISMA6_SCALAR_BSON = {
+	String: "string",
+	Boolean: "bool",
+	Int: "long",
+	BigInt: "long",
+	Float: "double",
+	DateTime: "date",
+	Bytes: "binData",
+	Json: "object"
+};
+function withArticle(typeName) {
+	return `${/^[AEIOU]/.test(typeName) ? "an" : "a"} ${typeName}`;
+}
+function acceptedByPrisma6(nativeType, typeName) {
+	return (Object.hasOwn(PRISMA6_NATIVE_TYPES, typeName) ? PRISMA6_NATIVE_TYPES[typeName] : void 0)?.includes(nativeType) === true;
+}
+/** Why the reader refuses a native type, and what removing it does to the Prisma 6 app. */
+function nativeTypeRefusal(label, nativeType, typeName) {
+	const refused = `${label}: native type "@${nativeType}" is not supported`;
+	if (!acceptedByPrisma6(nativeType, typeName)) return `${refused}, and Prisma 6 does not accept it on ${withArticle(typeName)} field either. Remove it.`;
+	const declared = PRISMA6_NATIVE_TYPE_BSON[nativeType];
+	const plain = PRISMA6_SCALAR_BSON[typeName];
+	return `${refused}: Prisma 6 stores it as a BSON ${declared}, and Prisma 8 has no codec for that BSON type. Remove it; this also changes the Prisma 6 app: its client then stores new ${typeName} values as BSON ${plain} instead of ${declared}. Documents already stored keep their ${declared} values, so rewrite them as ${plain}s before Prisma 8 reads them.`;
+}
+function nativeTypeCodecId(binding, typeName, nativeType) {
+	const forType = Object.hasOwn(binding.nativeTypeCodecIds, typeName) ? binding.nativeTypeCodecIds[typeName] : void 0;
+	return forType !== void 0 && Object.hasOwn(forType, nativeType) ? forType[nativeType] : void 0;
+}
+/** The field's contract type, or `undefined` after reporting why it has none. */
+function resolveFieldType(field, owner, nativeType, sourceId, ctx) {
+	const { binding, diagnostics } = ctx;
+	const label = `Field "${owner.name}.${field.name}"`;
+	if (field.typeConstructor !== void 0) {
+		diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_UNSUPPORTED_TYPE", unsupportedTypeMessage(label, field.typeConstructor.path.join("."), owner), sourceId, field.typeConstructor.span));
+		return;
+	}
+	const nativeTypeUnsupported = (attribute) => {
+		diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_NATIVE_TYPE_UNSUPPORTED", nativeTypeRefusal(label, attribute.name, field.typeName), sourceId, attribute.span));
+	};
+	const many = { many: field.list ? { elementNullable: false } : false };
+	if (ctx.compositeTypeNames.has(field.typeName)) {
+		if (nativeType !== void 0) return nativeTypeUnsupported(nativeType);
+		return {
+			type: {
+				kind: "valueObject",
+				name: field.typeName
+			},
+			nullable: field.optional,
+			...many
+		};
+	}
+	const enumBuild = ctx.enums.get(field.typeName);
+	if (enumBuild !== void 0) {
+		if (nativeType !== void 0) return nativeTypeUnsupported(nativeType);
+		const valueSet = {
+			plane: "domain",
+			entityKind: "enum",
+			namespaceId: ctx.namespaceId,
+			entityName: field.typeName
+		};
+		return {
+			type: {
+				kind: "scalar",
+				codecId: enumBuild.codecId
+			},
+			nullable: field.optional,
+			valueSet,
+			...many
+		};
+	}
+	if (ctx.enumNames.has(field.typeName)) return nativeType === void 0 ? void 0 : nativeTypeUnsupported(nativeType);
+	const scalarCodecId = Object.hasOwn(binding.scalarCodecIds, field.typeName) ? binding.scalarCodecIds[field.typeName] : void 0;
+	if (scalarCodecId === void 0) {
+		diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_UNSUPPORTED_TYPE", `${label} has unknown type "${field.typeName}": it is not a scalar type, an enum, a composite type, or a model. Correct the type name.`, sourceId, field.span));
+		return;
+	}
+	let codecId = scalarCodecId;
+	if (nativeType !== void 0) {
+		const nativeCodecId = nativeTypeCodecId(binding, field.typeName, nativeType.name);
+		if (nativeCodecId === void 0) return nativeTypeUnsupported(nativeType);
+		codecId = nativeCodecId;
+	}
+	return {
+		type: {
+			kind: "scalar",
+			codecId
+		},
+		nullable: field.optional,
+		...many
+	};
+}
+function readCompositeFields(located, ctx) {
+	const { symbol, sourceId } = located;
+	for (const attribute of symbol.attributes) ctx.diagnostics.push(unknownAttribute(`Type "${symbol.name}"`, attribute, "@@", sourceId));
+	const fields = {};
+	for (const field of Object.values(symbol.fields)) {
+		if (field.malformedType) continue;
+		const label = `Field "${symbol.name}.${field.name}"`;
+		let nativeType;
+		let rejected = false;
+		for (const attribute of field.attributes) if (attribute.name.startsWith("db.")) nativeType = attribute;
+		else if (attribute.name === "map") {
+			ctx.diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_COMPOSITE_MAP_UNSUPPORTED", `${label}: @map on a field of a composite type is not supported yet. The stored field keeps the name "${stringArgument(attribute) ?? field.name}", so removing @map renames it in storage; keep the schema as it is until Prisma 8 supports it.`, sourceId, attribute.span));
+			rejected = true;
+		} else if (attribute.name === "default") {
+			ctx.diagnostics.push(defaultUnsupported(label, attribute, {
+				kind: "type",
+				name: symbol.name
+			}, field, sourceId));
+			rejected = true;
+		} else {
+			ctx.diagnostics.push(unknownAttribute(label, attribute, "@", sourceId));
+			rejected = true;
+		}
+		if (rejected) continue;
+		const resolved = resolveFieldType(field, {
+			kind: "type",
+			name: symbol.name
+		}, nativeType, sourceId, ctx);
+		if (resolved !== void 0) fields[field.name] = resolved;
+	}
+	return fields;
+}
+/** What the Prisma 6 app loses when the Prisma 6 client stops filling a default. */
+function defaultRemovalConsequence(owner, field) {
+	if (field.optional || field.list) return owner.kind === "model" ? `a Prisma 6 create call that leaves "${field.name}" out no longer gets the default value` : `a "${owner.name}" value written without "${field.name}" no longer gets the default value`;
+	return owner.kind === "model" ? `every Prisma 6 create call must then pass "${field.name}"` : `every "${owner.name}" value the Prisma 6 app writes must then include "${field.name}"`;
+}
+function defaultUnsupported(label, attribute, owner, field, sourceId) {
+	return prisma6Diagnostic("PSL.PRISMA6_MONGO_DEFAULT_UNSUPPORTED", `${label}: ${attributeText(attribute)} is not supported. MongoDB has no stored defaults, and Prisma 8 fills only \`now()\` on DateTime fields. The Prisma 6 client fills this default today, so removing it also changes the Prisma 6 app: ${defaultRemovalConsequence(owner, field)}. Set the value in the application code that creates documents, then remove the default.`, sourceId, attribute.span);
+}
+function readModel(located, modelNames, ignoredModels, ctx) {
+	const { symbol, sourceId, sources } = located;
+	const { diagnostics } = ctx;
+	const modelLabel = `Model "${symbol.name}"`;
+	let collection = symbol.name;
+	const build = {
+		located,
+		collection: symbol.name,
+		storedNames: /* @__PURE__ */ new Map(),
+		ignoredFields: /* @__PURE__ */ new Set(),
+		rejectedFields: /* @__PURE__ */ new Set(),
+		fields: {},
+		relations: {},
+		executionDefaults: [],
+		uniqueFields: [],
+		modelIndexes: [],
+		relationFields: [],
+		hasId: false
+	};
+	const indexContext = {
+		owner: modelLabel,
+		prefix: "@@",
+		sourceId,
+		sources,
+		diagnostics,
+		compositeFields: new Set(Object.values(symbol.fields).filter((field) => ctx.compositeTypeNames.has(field.typeName)).map((field) => field.name))
+	};
+	for (const attribute of symbol.attributes) switch (attribute.name) {
+		case "map":
+			collection = requireString(attribute, modelLabel, sourceId, diagnostics) ?? collection;
+			break;
+		case "index":
+		case "unique":
+		case "fulltext": {
+			const parsed = parseIndexAttribute({
+				...attribute,
+				name: attribute.name
+			}, indexContext);
+			if (parsed !== void 0) build.modelIndexes.push(parsed);
+			break;
+		}
+		case "id":
+			build.hasId = true;
+			diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_COMPOSITE_ID_UNSUPPORTED", `${modelLabel}: @@id is not supported; a MongoDB document is identified by its "_id" field. Declare the id as \`id String @id @default(auto()) @map("_id") @db.ObjectId\`.`, sourceId, attribute.span));
+			break;
+		case "schema":
+			diagnostics.push(schemaUnsupported(modelLabel, attribute, sourceId));
+			break;
+		case "ignore": break;
+		default: diagnostics.push(unknownAttribute(modelLabel, attribute, "@@", sourceId));
+	}
+	for (const field of Object.values(symbol.fields)) {
+		const reported = diagnostics.length;
+		readModelField(field, build, modelNames, ignoredModels, ctx);
+		if (diagnostics.length > reported) build.rejectedFields.add(field.name);
+	}
+	return {
+		...build,
+		collection
+	};
+}
+function readModelField(field, build, modelNames, ignoredModels, ctx) {
+	const { symbol, sourceId, sources } = build.located;
+	const { diagnostics, binding } = ctx;
+	const label = `Field "${symbol.name}.${field.name}"`;
+	const isRelationField = modelNames.has(field.typeName) && field.typeConstructor === void 0;
+	if (field.attributes.some((attribute) => attribute.name === "ignore")) {
+		build.ignoredFields.add(field.name);
+		const unique = field.attributes.find((attribute) => attribute.name === "unique");
+		if (unique !== void 0) diagnostics.push(ignoredFieldReferenced(symbol.name, [field.name], {
+			kind: "index",
+			text: `@unique on field "${symbol.name}.${field.name}"`
+		}, sourceId, unique.span));
+		return;
+	}
+	if (isRelationField) {
+		if (ignoredModels.has(field.typeName)) return;
+		let relation;
+		for (const attribute of field.attributes) if (attribute.name === "relation") relation = attribute;
+		else diagnostics.push(unknownAttribute(label, attribute, "@", sourceId));
+		build.relationFields.push({
+			field,
+			relation
+		});
+		return;
+	}
+	let storedName = field.name;
+	let nativeType;
+	let idAttribute;
+	let defaultAttribute;
+	let updatedAt;
+	for (const attribute of field.attributes) switch (attribute.name) {
+		case "map":
+			storedName = requireString(attribute, label, sourceId, diagnostics) ?? storedName;
+			break;
+		case "id":
+			idAttribute = attribute;
+			break;
+		case "default":
+			defaultAttribute = attribute;
+			break;
+		case "updatedAt":
+			updatedAt = attribute;
+			break;
+		case "unique": {
+			const parsed = parseFieldUnique(attribute, field.name, {
+				owner: label,
+				prefix: "@",
+				sourceId,
+				sources,
+				diagnostics,
+				compositeFields: /* @__PURE__ */ new Set()
+			});
+			if (parsed !== void 0) build.uniqueFields.push(parsed);
+			break;
+		}
+		default: if (attribute.name.startsWith("db.")) nativeType = attribute;
+		else diagnostics.push(unknownAttribute(label, attribute, "@", sourceId));
+	}
+	build.storedNames.set(field.name, storedName);
+	if (field.malformedType) return;
+	const owner = {
+		kind: "model",
+		name: symbol.name
+	};
+	const resolved = resolveFieldType(field, owner, nativeType, sourceId, ctx);
+	if (resolved === void 0) return;
+	const codecId = resolved.type.kind === "scalar" ? resolved.type.codecId : void 0;
+	if (idAttribute !== void 0) {
+		build.hasId = true;
+		if (codecId !== binding.objectIdCodecId || storedName !== "_id" || field.optional || field.list) {
+			diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_ID_NOT_OBJECTID", `${label} is the model's @id, but it is not a required ObjectId stored as "_id". Prisma 8 identifies a MongoDB document by an ObjectId "_id"; declare the id as \`${field.name} String @id @default(auto()) @map("_id") @db.ObjectId\`. If stored documents have "_id" values that are not ObjectIds, this model cannot use this contract source until they are rewritten with ObjectId "_id" values, along with every field that refers to them.`, sourceId, idAttribute.span));
+			return;
+		}
+		if (defaultAttribute !== void 0 && defaultKind(defaultAttribute) !== "auto") {
+			diagnostics.push(defaultUnsupported(label, defaultAttribute, owner, field, sourceId));
+			return;
+		}
+		build.fields[field.name] = resolved;
+		return;
+	}
+	const isDateTime = codecId === binding.scalarCodecIds.DateTime && !field.list;
+	if (updatedAt !== void 0 && !isDateTime) {
+		diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_UPDATED_AT_TYPE_UNSUPPORTED", `${label}: @updatedAt is only supported on a DateTime field. Removing it also stops the Prisma 6 client from setting the field on every update. Set the value in application code when you write documents, then remove @updatedAt.`, sourceId, updatedAt.span));
+		return;
+	}
+	const defaultIsNow = defaultAttribute !== void 0 && defaultKind(defaultAttribute) === "now";
+	if (defaultAttribute !== void 0 && (!defaultIsNow || !isDateTime)) {
+		diagnostics.push(defaultUnsupported(label, defaultAttribute, owner, field, sourceId));
+		return;
+	}
+	const generator = updatedAt !== void 0 || defaultIsNow ? dateTimeNowGenerator(ctx.generatorFunctions, binding.scalarCodecIds.DateTime) : void 0;
+	const phases = generator === void 0 ? void 0 : updatedAt !== void 0 ? {
+		onCreate: generator,
+		onUpdate: generator
+	} : defaultIsNow ? { onCreate: generator } : void 0;
+	if (phases !== void 0 && field.optional) {
+		const written = updatedAt ?? defaultAttribute;
+		const generator = written === void 0 ? "the generator" : attributeText(written);
+		diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_OPTIONAL_GENERATED_FIELD_UNSUPPORTED", `${label} is optional and its value comes from ${generator}, which Prisma 8 cannot express on an optional field yet. Either fix also changes the Prisma 6 app: a required field makes the Prisma 6 client fail on a stored document that lacks it, and without ${generator} the Prisma 6 client no longer fills it. Make the field required once every stored document has a value, or set the value in application code and remove ${generator}.`, sourceId, written?.span ?? field.span));
+		return;
+	}
+	build.fields[field.name] = resolved;
+	if (phases !== void 0) build.executionDefaults.push({
+		field: storedName,
+		phases
+	});
+}
+/** The generator `now()` resolves to on the DateTime codec, which `@default(now())` and `@updatedAt` write. */
+function dateTimeNowGenerator(generatorFunctions, codecId) {
+	const now = generatorFunctions.resolve({
+		name: "now",
+		args: {}
+	}, {
+		codecId,
+		typeParams: void 0,
+		length: void 0
+	});
+	if (!now.ok) throw new InternalError(`The stack binds no "now" generator function to codec "${codecId}", which the DateTime scalar maps to.`);
+	return now.generator;
+}
+function identifierList(attributeArg) {
+	const expression = attributeArg.expression;
+	const array = expression === void 0 ? void 0 : ArrayLiteralAst.cast(expression.syntax);
+	if (array === void 0) return void 0;
+	const names = [];
+	for (const element of array.elements()) {
+		const name = IdentifierAst.cast(element.syntax)?.name();
+		if (name === void 0) return void 0;
+		names.push(name);
+	}
+	return names;
+}
+/**
+* What removing `onDelete` or `onUpdate` does to the Prisma 6 app. The Prisma 6 client emulates referential actions on MongoDB with these defaults: `onDelete` is `Restrict` on a required relation (a delete fails with P2014) and `SetNull` on an optional one, and `onUpdate` is `Cascade`.
+*/
+function referentialActionRemoval(key, declared, sides) {
+	const fallback = key === "onUpdate" ? {
+		action: "Cascade",
+		when: "its default",
+		effect: `changing the field a ${sides.model} refers to in a ${sides.target} updates the key in its ${sides.model} documents`
+	} : sides.optional ? {
+		action: "SetNull",
+		when: "its default for an optional relation",
+		effect: `deleting a ${sides.target} sets the key to null in its ${sides.model} documents`
+	} : {
+		action: "Restrict",
+		when: "its default for a required relation",
+		effect: `deleting a ${sides.target} that still has ${sides.model} documents fails with P2014`
+	};
+	if (declared === fallback.action) return `Removing "${key}: ${declared}" leaves the Prisma 6 app as it is: ${declared} is already what the Prisma 6 client does for this relation.`;
+	return `The Prisma 6 client emulates referential actions, so removing "${key}: ${declared}" also changes the Prisma 6 app: its client then applies ${fallback.action}, ${fallback.when}, so ${fallback.effect}.`;
+}
+function readRelationArguments(attribute, label, sides, sourceId, diagnostics) {
+	let name;
+	let fields;
+	let references;
+	let rejected = false;
+	const invalid = (what, span) => {
+		rejected = true;
+		diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `${label}: @relation ${what}.`,
+			sourceId,
+			span
+		});
+	};
+	for (const arg of attribute.args) {
+		const key = arg.kind === "positional" ? "name" : arg.name;
+		switch (key) {
+			case "name": {
+				const expression = arg.expression;
+				name = expression === void 0 ? void 0 : StringLiteralExprAst.cast(expression.syntax)?.value();
+				if (name === void 0) invalid("name must be a string", arg.span);
+				break;
+			}
+			case "fields":
+				fields = identifierList(arg);
+				if (fields === void 0) invalid("fields must be a list of field names", arg.span);
+				break;
+			case "references":
+				references = identifierList(arg);
+				if (references === void 0) invalid("references must be a list of field names", arg.span);
+				break;
+			case "onDelete":
+			case "onUpdate":
+			case "map":
+				rejected = true;
+				diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_REFERENTIAL_ACTION_UNSUPPORTED", key === "map" ? `${label}: @relation argument "map" is not supported; it names a foreign key constraint, and MongoDB has none. Remove "map"; the Prisma 6 app has no foreign key on MongoDB either, so nothing changes there.` : `${label}: @relation argument "${key}" is not supported; Prisma 8 enforces no referential actions on MongoDB. ${referentialActionRemoval(key, arg.value, sides)} Handle related documents in application code, then remove "${key}".`, sourceId, arg.span));
+				break;
+			default: invalid(`argument "${key ?? ""}" is not supported`, arg.span);
+		}
+	}
+	return rejected ? void 0 : {
+		name,
+		fields,
+		references
+	};
+}
+function ignoredFieldReferenced(modelName, fieldNames, usedBy, sourceId, span) {
+	const one = fieldNames.length === 1;
+	const fields = fieldNames.map((name) => `"${modelName}.${name}"`).join(", ");
+	const removal = usedBy.kind === "index" ? "which makes Prisma 6 `db push` drop the index" : "which removes that relation from the Prisma 6 client";
+	return prisma6Diagnostic("PSL.PRISMA6_MONGO_IGNORED_FIELD_REFERENCED", `${one ? "Field" : "Fields"} ${fields} ${one ? "is" : "are"} marked @ignore, but ${usedBy.text} uses ${one ? "it" : "them"}. Remove @ignore from ${fields}, which adds ${one ? "it" : "them"} to the Prisma 6 client, or remove ${usedBy.text}, ${removal}.`, sourceId, span);
+}
+function readRelationFields(build, builds, out, diagnostics, namespaceId) {
+	const { symbol, sourceId, sources } = build.located;
+	for (const { field, relation } of build.relationFields) {
+		const label = `Relation field "${symbol.name}.${field.name}"`;
+		const reject = () => {
+			out.invalidFkPairings.push({
+				pairKey: fkRelationPairKey(symbol.name, field.typeName),
+				...ifDefined("relationName", relation === void 0 ? void 0 : stringArgument(relation))
+			});
+		};
+		const args = relation === void 0 ? void 0 : readRelationArguments(relation, label, {
+			model: symbol.name,
+			target: field.typeName,
+			optional: field.optional
+		}, sourceId, diagnostics);
+		if (relation !== void 0 && args === void 0) {
+			reject();
+			continue;
+		}
+		const target = builds.get(field.typeName);
+		if (target === void 0) continue;
+		if (!(args?.fields !== void 0 || args?.references !== void 0)) {
+			out.backRelations.push({
+				modelName: symbol.name,
+				field,
+				targetModelName: field.typeName,
+				...ifDefined("relationName", args?.name),
+				cardinality: field.list ? "1:N" : "1:1",
+				sources
+			});
+			continue;
+		}
+		if (field.list) {
+			diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_LIST_RELATION_UNSUPPORTED", `${label} is a list relation that stores its keys in a list field (a many-to-many relation on MongoDB), which Prisma 8 does not support yet. Remove the relation fields from the schema this contract source reads and keep the key list as a plain field. The Prisma 6 client then loses the relation fields too, so Prisma 6 code that reads or writes the relation through them (\`include\`, \`connect\`) has to use the key list instead.`, sourceId, relation?.span ?? field.span));
+			reject();
+			continue;
+		}
+		const localNames = args?.fields ?? [];
+		const targetNames = args?.references ?? [];
+		const ignoredLocal = localNames.filter((name) => build.ignoredFields.has(name));
+		if (ignoredLocal.length > 0) {
+			diagnostics.push(ignoredFieldReferenced(symbol.name, ignoredLocal, {
+				kind: "relation",
+				text: `relation field "${symbol.name}.${field.name}"`
+			}, sourceId, relation?.span ?? field.span));
+			reject();
+			continue;
+		}
+		const ignoredTarget = targetNames.filter((name) => target.ignoredFields.has(name));
+		if (ignoredTarget.length > 0) {
+			diagnostics.push(ignoredFieldReferenced(target.located.symbol.name, ignoredTarget, {
+				kind: "relation",
+				text: `relation field "${symbol.name}.${field.name}"`
+			}, sourceId, relation?.span ?? field.span));
+			reject();
+			continue;
+		}
+		const localFields = localNames.map((name) => build.storedNames.get(name));
+		const targetFields = targetNames.map((name) => target.storedNames.get(name));
+		if (localFields.some((name) => name === void 0) || targetFields.some((name) => name === void 0) || localNames.length !== targetNames.length || localNames.length === 0) {
+			diagnostics.push({
+				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+				message: `${label}: @relation fields and references must name the same number of scalar fields of "${symbol.name}" and "${field.typeName}".`,
+				sourceId,
+				span: relation?.span ?? field.span
+			});
+			reject();
+			continue;
+		}
+		if (resolveToOneRelationNullable({
+			declaredNullable: field.optional,
+			localFieldNullability: localNames.map((name) => symbol.fields[name]?.optional === true),
+			ownsReference: true
+		}).contradiction !== void 0) {
+			diagnostics.push({
+				code: "PSL_RELATION_NULLABILITY_MISMATCH",
+				message: field.optional ? `${label} is optional but every field in @relation(fields: [...]) is required. Make one of those fields optional with "?" or remove "?" from "${field.name}".` : `${label} is required but a field in @relation(fields: [...]) is optional. Add "?" to "${field.name}" or make those fields required.`,
+				sourceId,
+				span: field.span
+			});
+			reject();
+			continue;
+		}
+		build.relations[field.name] = {
+			to: crossRef(field.typeName, namespaceId),
+			cardinality: "N:1",
+			nullable: field.optional,
+			on: {
+				localFields: localNames,
+				targetFields: targetNames
+			}
+		};
+		out.foreignKeys.push({
+			declaringModel: symbol.name,
+			targetModel: field.typeName,
+			...ifDefined("relationName", args?.name),
+			localFields: localNames,
+			targetFields: targetNames
+		});
+	}
+}
+function buildIndexes(build, diagnostics) {
+	const { symbol, sourceId } = build.located;
+	const indexes = [];
+	let textIndexes = 0;
+	const keyFor = (field, text) => ({
+		field: build.storedNames.get(field.name) ?? field.name,
+		direction: field.direction ?? (text ? "text" : 1)
+	});
+	for (const attribute of [...build.uniqueFields, ...build.modelIndexes]) {
+		const names = attribute.fields.map((field) => field.name);
+		const usedBy = {
+			kind: "index",
+			text: build.uniqueFields.includes(attribute) ? `@unique on field "${symbol.name}.${attribute.fields[0]?.name ?? ""}"` : `@@${attribute.kind} on model "${symbol.name}"`
+		};
+		const ignored = names.filter((name) => build.ignoredFields.has(name));
+		if (ignored.length > 0) {
+			diagnostics.push(ignoredFieldReferenced(symbol.name, ignored, usedBy, sourceId, attribute.span));
+			continue;
+		}
+		if (names.some((name) => build.rejectedFields.has(name))) continue;
+		const unknown = names.find((name) => !build.storedNames.has(name));
+		if (unknown !== void 0) {
+			diagnostics.push({
+				code: "PSL_INDEX_FIELD_NOT_FOUND",
+				message: `Index on model "${symbol.name}" references unknown field "${unknown}"`,
+				sourceId,
+				span: attribute.span
+			});
+			continue;
+		}
+		if (attribute.kind === "fulltext") {
+			textIndexes++;
+			if (textIndexes > 1) {
+				diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_TEXT_INDEX_LIMIT", `Model "${symbol.name}" has more than one @@fulltext; MongoDB allows one text index per collection. Merge the fields into one @@fulltext.`, sourceId, attribute.span));
+				continue;
+			}
+		}
+		indexes.push(new MongoIndex({
+			keys: attribute.fields.map((field) => keyFor(field, attribute.kind === "fulltext")),
+			...attribute.kind === "unique" ? { unique: true } : {}
+		}));
+	}
+	return indexes;
+}
+function assembleContract(input) {
+	const target = input.binding.target.targetId;
+	const targetFamily = input.binding.target.familyId;
+	const builtEnums = Object.fromEntries(input.enums);
+	const collections = {};
+	for (const [name, collection] of Object.entries(input.collections)) collections[name] = collection.indexes.length > 0 ? { indexes: collection.indexes } : {};
+	const storage = buildMongoStorage({
+		collections,
+		valueSets: mongoValueSetsOf(builtEnums)
+	});
+	const models = {};
+	for (const [modelName, build] of input.builds) models[modelName] = {
+		fields: build.fields,
+		relations: build.relations,
+		storage: {
+			collection: build.collection,
+			fields: Object.fromEntries(Object.keys(build.fields).map((name) => [name, { field: build.storedNames.get(name) ?? name }]))
+		}
+	};
+	const capabilities = {};
+	const execution = buildExecutionSection({
+		target,
+		targetFamily,
+		defaults: input.executionDefaults
+	});
+	return {
+		targetFamily,
+		target,
+		roots: input.roots,
+		domain: { namespaces: { [input.namespaceId]: {
+			models: blindCast(models),
+			...Object.keys(input.valueObjects).length > 0 ? { valueObjects: input.valueObjects } : {},
+			...Object.keys(builtEnums).length > 0 ? { enum: builtEnums } : {}
+		} } },
+		storage,
+		extensions: {},
+		capabilities,
+		profileHash: computeProfileHash({
+			target,
+			targetFamily,
+			capabilities
+		}),
+		meta: {},
+		...execution !== void 0 ? { execution } : {}
+	};
+}
+function mergedSources(documents) {
+	const [first, ...rest] = documents.map((document) => document.sources);
+	if (first === void 0) throw new InternalError("A Prisma 6 schema has at least one document");
+	return first.merge(...rest);
+}
+function defaultOutputFromSchemaPath(schemaPath) {
+	return join(dirname(schemaPath), "contract.json");
+}
+function mapParseDiagnostics(diagnostics, sourceFile, sourceId) {
+	return diagnostics.map((diagnostic) => ({
+		code: diagnostic.code,
+		message: diagnostic.message,
+		sourceId,
+		span: sourceFile.rangeToPslSpan(diagnostic.range)
+	}));
+}
+/**
+* The files a Prisma 6 schema input names: the file itself, or every regular `.prisma` file under the directory, nested directories and symbolic links included, as Prisma 6 reads a schema directory. Sorted by path so duplicate detection blames the later file deterministically.
+*/
+async function listSchemaFiles(absolutePath, displayPath) {
+	if (!(await stat(absolutePath)).isDirectory()) return [{
+		sourceId: displayPath,
+		absolutePath
+	}];
+	const entries = await readdir(absolutePath, { recursive: true });
+	const files = [];
+	for (const entry of entries.filter((name) => extname(name) === ".prisma").map((name) => normalize(name)).sort()) {
+		const entryPath = join(absolutePath, entry);
+		if ((await stat(entryPath)).isFile()) files.push({
+			sourceId: join(displayPath, entry),
+			absolutePath: entryPath
+		});
+	}
+	return files;
+}
+function isMissingPath(error) {
+	return error instanceof Error && Reflect.get(error, "code") === "ENOENT";
+}
+function readFailure(schemaPath, message, meta) {
+	return notOk({
+		summary: `Failed to read Prisma 6 schema at "${schemaPath}"`,
+		diagnostics: [prisma6Diagnostic("PSL.PRISMA6_MONGO_SCHEMA_READ_FAILED", message, schemaPath, void 0)],
+		meta
+	});
+}
+/**
+* A `ContractConfig` that reads a Prisma 6 MongoDB `schema.prisma` (a file, or a directory of `.prisma` files) as the contract source.
+*/
+function prisma6Contract(schemaPath, options) {
+	const parserOptions = { grammar: "prisma-7" };
+	return {
+		source: {
+			format: "psl",
+			inputs: [schemaPath],
+			parserOptions,
+			async load(context) {
+				const [absolutePath] = context.resolvedInputs;
+				if (absolutePath === void 0) throw new InternalError("prisma6Contract: context.resolvedInputs is empty. The CLI config loader should populate it from source.inputs.");
+				let files;
+				try {
+					files = await listSchemaFiles(absolutePath, schemaPath);
+				} catch (error) {
+					const cause = String(error);
+					return readFailure(schemaPath, isMissingPath(error) ? `There is no file or directory at "${schemaPath}". Fix the path passed to prisma6Schema() in prisma.config.ts.` : cause, {
+						schemaPath,
+						absolutePath,
+						cause
+					});
+				}
+				if (files.length === 0) return readFailure(schemaPath, `The schema directory "${schemaPath}" contains no .prisma file.`, {
+					schemaPath,
+					absolutePath
+				});
+				const documents = [];
+				const seedDiagnostics = [];
+				for (const file of files) {
+					let schema;
+					try {
+						schema = await readFile(file.absolutePath, "utf-8");
+					} catch (error) {
+						const message = String(error);
+						return readFailure(file.sourceId, message, {
+							schemaPath: file.sourceId,
+							absoluteSchemaPath: file.absolutePath,
+							cause: message
+						});
+					}
+					const { document, sources, diagnostics } = parse(schema, file.sourceId, parserOptions);
+					const sourceFile = sources.sourceFileFor(document.syntax);
+					seedDiagnostics.push(...mapParseDiagnostics(diagnostics, sourceFile, file.sourceId));
+					documents.push({
+						document,
+						sources,
+						sourceFile,
+						sourceId: file.sourceId
+					});
+				}
+				let contract;
+				try {
+					const interpreted = interpretPrisma6Documents({
+						documents,
+						seedDiagnostics,
+						binding: options.binding,
+						generatorFunctions: context.generatorFunctions,
+						authoringContributions: context.authoringContributions,
+						codecLookup: context.codecLookup,
+						dataTypes: context.dataTypes,
+						defaultNamespaceId: context.defaultNamespaceId
+					});
+					if (!interpreted.ok) return interpreted;
+					contract = applySpecifierDefaultControlPolicy(interpreted.value, options.defaultControlPolicy);
+					validateContractDomain(contract);
+					validateMongoStorage(blindCast(contract));
+				} catch (error) {
+					if (!isStructuredError(error)) throw error;
+					return notOk({
+						summary: "Prisma 6 MongoDB schema interpretation failed",
+						diagnostics: [prisma6Diagnostic("PSL.PRISMA6_MONGO_CONTRACT_INVALID", `This schema gives a contract that Prisma 8 rejects, and the Prisma 6 MongoDB contract source has no specific diagnostic for the cause: ${error.message.replace(/\.$/, "")}. This is a bug in Prisma ORM; please report it with this schema.`, schemaPath, void 0)],
+						meta: {
+							schemaPath,
+							code: error.code
+						}
+					});
+				}
+				return ok(contract);
+			}
+		},
+		output: options.output ?? defaultOutputFromSchemaPath(schemaPath)
+	};
+}
+//#endregion
+export { prisma6Contract };
+
+//# sourceMappingURL=contract-prisma6__provider.mjs.map