@prisma/orm-family-mongo 8.0.0-rc.12-dev.11 → 8.0.0-rc.12-dev.13

package/dist/contract-prisma6__provider.mjs

@@ -0,0 +1,1020 @@
+import { o as MongoIndex } from "./entity-kinds-BFgLffz7-D8WUc2oo.mjs";
+import { c as buildMongoExecutionSection, h as validateMongoStorage, p as encodeMongoValueSets, u as buildMongoStorage } from "./dist-DsIID5AE.mjs";
+import { a as pairMongoBackRelations } from "./interpreter-DPALasb4-BORWXsN5.mjs";
+import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { crossRef } from "@prisma/orm-framework/contract/types";
+import { computeProfileHash } from "@prisma/orm-framework/contract/hashing";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+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, StringLiteralExprAst, parse } from "@prisma/orm-framework/psl-parser/syntax";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+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 { instantiateAuthoringEntityType, isAuthoringEntityTypeDescriptor } from "@prisma/orm-framework/components/authoring";
+import { buildSymbolTable, keywordPslSpan, mapPslDiagnostics, nodePslSpan, readResolvedAttribute, readResolvedAttributes } 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 = call?.path() ?? [];
+		const [callee] = path;
+		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.`, 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,
+			pslBlockDescriptors: {}
+		});
+		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
+			});
+		};
+		for (const block of Object.values(symbolTable.topLevel.blocks)) switch (block.keyword) {
+			case "datasource":
+				datasources.push({
+					symbol: block,
+					sourceId,
+					sources
+				});
+				break;
+			case "generator": 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.`, 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.topLevel.namespaces)) for (const { span } of namespace.declarations) unsupported("namespace", span);
+		for (const namedType of Object.values(symbolTable.topLevel.namedTypes)) unsupported("types", namedType.span);
+		for (const symbol of Object.values(symbolTable.topLevel.compositeTypes)) if (claimName("type", symbol.name, sourceId, symbol.span)) compositeTypes.push({
+			symbol,
+			sourceId,
+			sources
+		});
+		for (const symbol of Object.values(symbolTable.topLevel.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
+			});
+		}
+	}
+	checkDatasource(datasources, input.documents[0]?.sourceId ?? "schema.prisma", binding, diagnostics);
+	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 typeContext = {
+		binding,
+		enums,
+		compositeTypeNames: new Set(compositeTypes.map((c) => c.symbol.name)),
+		diagnostics
+	};
+	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);
+	const paired = pairMongoBackRelations({
+		foreignKeys,
+		candidates: backRelations,
+		invalidFkPairings
+	});
+	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, UNBOUND_NAMESPACE_ID);
+		for (const { field, phases } of build.executionDefaults) executionDefaults.push({
+			ref: {
+				namespace: UNBOUND_NAMESPACE_ID,
+				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
+	});
+	return ok(assembleContract({
+		binding,
+		builds,
+		collections,
+		roots,
+		valueObjects,
+		enums,
+		executionDefaults,
+		codecLookup: input.codecLookup
+	}));
+}
+function checkDatasource(datasources, fallbackSourceId, binding, diagnostics) {
+	const [datasource] = datasources;
+	const [namedProvider] = binding.providers;
+	if (datasource === void 0) {
+		diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_PROVIDER_MISMATCH", `No datasource block found; add \`datasource db { provider = "${namedProvider}" }\`.`, fallbackSourceId, void 0));
+		return;
+	}
+	const block = datasource.symbol.block;
+	const parameter = block.parameters["provider"];
+	let provider;
+	if (parameter?.kind === "value") try {
+		const parsed = JSON.parse(parameter.raw);
+		provider = typeof parsed === "string" ? parsed : void 0;
+	} catch {
+		provider = void 0;
+	}
+	if (provider === void 0 || !binding.providers.includes(provider)) diagnostics.push(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 : parameter.span));
+}
+function buildEnum(located, input, diagnostics) {
+	const { symbol: block, sourceId, sources } = located;
+	for (const attribute of readResolvedAttributes(block.node.attributes(), sources)) {
+		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 parameters = {};
+	for (const entry of block.node.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));
+		}
+		parameters[name] = {
+			kind: "value",
+			raw: JSON.stringify(value),
+			span: 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,
+		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,
+		parameters,
+		blockAttributes: [],
+		attributes: {},
+		span: block.span
+	}], context);
+	if (handle === void 0 || handle === null) return void 0;
+	return {
+		codecId: handle.codecId,
+		members: handle.enumMembers.map((member) => ({
+			name: member.name,
+			value: member.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 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", attribute.name === "db.ObjectId" ? `${label}: @db.ObjectId is only supported on a String field, and this field is "${field.typeName}". Remove @db.ObjectId, or change the field type to String.` : `${label}: native type "@${attribute.name}" is not supported by the Prisma 6 MongoDB contract source; only @db.ObjectId is. Remove it: the stored BSON type then follows the field type.`, sourceId, attribute.span));
+	};
+	const many = field.list ? { many: true } : {};
+	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: UNBOUND_NAMESPACE_ID,
+			entityName: field.typeName
+		};
+		return {
+			type: {
+				kind: "scalar",
+				codecId: enumBuild.codecId
+			},
+			nullable: field.optional,
+			valueSet,
+			...many
+		};
+	}
+	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) {
+		if (nativeType.name !== "db.ObjectId" || field.typeName !== "String") return nativeTypeUnsupported(nativeType);
+		codecId = binding.objectIdCodecId;
+	}
+	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, 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;
+}
+function defaultUnsupported(label, attribute, 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. Remove the default and set the value when you create documents.`, 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
+	};
+	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], `@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
+			});
+			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 resolved = resolveFieldType(field, {
+		kind: "model",
+		name: symbol.name
+	}, 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\`.`, sourceId, idAttribute.span));
+			return;
+		}
+		if (defaultAttribute !== void 0 && defaultKind(defaultAttribute) !== "auto") {
+			diagnostics.push(defaultUnsupported(label, defaultAttribute, sourceId));
+			return;
+		}
+		build.fields[storedName] = 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. Remove @updatedAt and set the value when you write documents.`, sourceId, updatedAt.span));
+		return;
+	}
+	const defaultIsNow = defaultAttribute !== void 0 && defaultKind(defaultAttribute) === "now";
+	if (defaultAttribute !== void 0 && (!defaultIsNow || !isDateTime)) {
+		diagnostics.push(defaultUnsupported(label, defaultAttribute, sourceId));
+		return;
+	}
+	const generator = {
+		kind: "generator",
+		id: binding.timestampGeneratorId
+	};
+	const phases = updatedAt !== void 0 ? {
+		onCreate: generator,
+		onUpdate: generator
+	} : defaultIsNow ? { onCreate: generator } : void 0;
+	if (phases !== void 0 && field.optional) {
+		const written = updatedAt ?? defaultAttribute;
+		diagnostics.push(prisma6Diagnostic("PSL.PRISMA6_MONGO_OPTIONAL_GENERATED_FIELD_UNSUPPORTED", `${label} is optional and its value comes from ${written === void 0 ? "a generator" : attributeText(written)}, which Prisma 8 cannot express on an optional field yet. Make the field required, or remove ${written === void 0 ? "the generator" : attributeText(written)} and set the value when you write documents.`, sourceId, written?.span ?? field.span));
+		return;
+	}
+	build.fields[storedName] = resolved;
+	if (phases !== void 0) build.executionDefaults.push({
+		field: storedName,
+		phases
+	});
+}
+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;
+}
+function readRelationArguments(attribute, label, sourceId, diagnostics) {
+	let name;
+	let fields;
+	let references;
+	const invalid = (what, span) => {
+		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) return invalid("name must be a string", arg.span);
+				break;
+			}
+			case "fields":
+				fields = identifierList(arg);
+				if (fields === void 0) return invalid("fields must be a list of field names", arg.span);
+				break;
+			case "references":
+				references = identifierList(arg);
+				if (references === void 0) return invalid("references must be a list of field names", arg.span);
+				break;
+			case "onDelete":
+			case "onUpdate":
+			case "map":
+				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".` : `${label}: @relation argument "${key}" is not supported; Prisma 8 enforces no referential actions on MongoDB. Remove "${key}" and handle related documents in application code.`, sourceId, arg.span));
+				return;
+			default: return invalid(`argument "${key ?? ""}" is not supported`, arg.span);
+		}
+	}
+	return {
+		name,
+		fields,
+		references
+	};
+}
+function ignoredFieldReferenced(modelName, fieldNames, usedBy, sourceId, span) {
+	const one = fieldNames.length === 1;
+	const fields = fieldNames.map((name) => `"${modelName}.${name}"`).join(", ");
+	return prisma6Diagnostic("PSL.PRISMA6_MONGO_IGNORED_FIELD_REFERENCED", `${one ? "Field" : "Fields"} ${fields} ${one ? "is" : "are"} marked @ignore, but ${usedBy} uses ${one ? "it" : "them"}. Remove @ignore from ${fields}, or remove ${usedBy}.`, sourceId, span);
+}
+function readRelationFields(build, builds, out, diagnostics) {
+	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, 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.`, 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, `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, `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;
+		}
+		const local = localFields.filter((name) => name !== void 0);
+		const referenced = targetFields.filter((name) => name !== void 0);
+		build.relations[field.name] = {
+			to: crossRef(field.typeName, UNBOUND_NAMESPACE_ID),
+			cardinality: "N:1",
+			nullable: field.optional,
+			on: {
+				localFields: local,
+				targetFields: referenced
+			}
+		};
+		out.foreignKeys.push({
+			declaringModel: symbol.name,
+			targetModel: field.typeName,
+			...ifDefined("relationName", args?.name),
+			localFields: local,
+			targetFields: referenced
+		});
+	}
+}
+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 = 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 = {};
+	for (const [enumName, built] of input.enums) builtEnums[enumName] = {
+		codecId: built.codecId,
+		members: built.members.map((member) => ({
+			name: member.name,
+			value: blindCast(member.value)
+		}))
+	};
+	const collections = {};
+	for (const [name, collection] of Object.entries(input.collections)) collections[name] = collection.indexes.length > 0 ? { indexes: collection.indexes } : {};
+	const storage = blindCast(buildMongoStorage({
+		collections,
+		valueSets: encodeMongoValueSets(Object.fromEntries(input.enums), input.codecLookup)
+	}));
+	const models = {};
+	for (const [modelName, build] of input.builds) models[modelName] = {
+		fields: build.fields,
+		relations: build.relations,
+		storage: { collection: build.collection }
+	};
+	const capabilities = {};
+	const execution = buildMongoExecutionSection(input.executionDefaults);
+	return {
+		targetFamily,
+		target,
+		roots: input.roots,
+		domain: { namespaces: { [UNBOUND_NAMESPACE_ID]: {
+			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 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) {
+	return {
+		source: {
+			format: "prisma6",
+			inputs: [schemaPath],
+			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 message = String(error);
+					return readFailure(schemaPath, message, {
+						schemaPath,
+						absolutePath,
+						cause: message
+					});
+				}
+				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, { grammar: "prisma7" });
+					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,
+						authoringContributions: context.authoringContributions,
+						codecLookup: context.codecLookup
+					});
+					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