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

package/dist/dist-BbfUvuqQ.mjs

@@ -0,0 +1,629 @@
+import { t as mongoContractCanonicalizationHooks } from "./canonicalization-hooks-CRVM-Kqh-Qi-VmEVg.mjs";
+import { l as MongoValidator, n as MongoCollationOptions, o as MongoIndex, p as composeMongoEntityKinds } from "./entity-kinds-RooUvcN8-B1AF_ppw.mjs";
+import { t as bsonTypesOfCodec } from "./mongo-data-type-DJ7W2ota-BnUN7ydW.mjs";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { IRNodeBase, NamespaceBase, UNBOUND_NAMESPACE_ID, buildNamespacedEntities, buildSingleNamespaceView, freezeNode, hydrateNamespaceEntities } from "@prisma/orm-framework/components/ir";
+import { RelationKeys } from "@prisma/orm-framework/components/runtime";
+import { computeStorageHash } from "@prisma/orm-framework/contract/hashing";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { UNBOUND_DOMAIN_NAMESPACE_ID } from "@prisma/orm-framework/contract/default-namespace";
+import { assertDefined } from "@prisma/orm-framework/utils/assertions";
+//#region ../../../2-mongo-family/1-foundation/mongo-contract/dist/index.mjs
+var MongoUnboundNamespace = class MongoUnboundNamespace extends NamespaceBase {
+	static instance = new MongoUnboundNamespace();
+	id = UNBOUND_NAMESPACE_ID;
+	entries = Object.freeze({ collection: Object.freeze({}) });
+	constructor() {
+		super();
+		Object.defineProperty(this, "kind", {
+			value: "mongo-namespace",
+			writable: false,
+			enumerable: false,
+			configurable: true
+		});
+		freezeNode(this);
+	}
+};
+const MONGO_NAMESPACE_KIND = "mongo-namespace";
+var MongoBoundNamespace = class MongoBoundNamespace extends NamespaceBase {
+	id;
+	entries;
+	static fromCollectionsInput(input) {
+		const collectionMap = input.entries["collection"];
+		const collectionCount = collectionMap !== void 0 ? Object.keys(collectionMap).length : 0;
+		const hasUnknownKinds = Object.keys(input.entries).some((kind) => kind !== "collection");
+		if (input.id === UNBOUND_NAMESPACE_ID && collectionCount === 0 && !hasUnknownKinds) return MongoUnboundNamespace.instance;
+		return new MongoBoundNamespace(input);
+	}
+	constructor(input) {
+		super();
+		this.id = input.id;
+		const rawEntries = {
+			collection: {},
+			...input.entries
+		};
+		this.entries = Object.freeze(blindCast(hydrateNamespaceEntities(rawEntries, composeMongoEntityKinds(), "carry")));
+		Object.defineProperty(this, "kind", {
+			value: MONGO_NAMESPACE_KIND,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		});
+		freezeNode(this);
+	}
+	get collection() {
+		return this.entries.collection ?? Object.freeze({});
+	}
+};
+function buildMongoNamespace(input) {
+	return MongoBoundNamespace.fromCollectionsInput(input);
+}
+var MongoStorage = class extends IRNodeBase {
+	storageHash;
+	namespaces;
+	constructor(input) {
+		super();
+		Object.defineProperty(this, "kind", {
+			value: "mongo-storage",
+			writable: false,
+			enumerable: false,
+			configurable: true
+		});
+		this.storageHash = input.storageHash;
+		this.namespaces = Object.freeze(input.namespaces);
+		freezeNode(this);
+	}
+};
+/**
+* Builds a Mongo contract's storage: the unbound namespace holding the collections and value sets, and the storage hash that `db sign` and `db verify` compare. Every Mongo contract source calls this, so they hash storage the same way.
+*/
+function buildMongoStorage(input) {
+	const hasValueSets = Object.keys(input.valueSets).length > 0;
+	const namespace = buildMongoNamespace({
+		id: UNBOUND_NAMESPACE_ID,
+		entries: {
+			collection: input.collections,
+			...hasValueSets ? { valueSet: input.valueSets } : {}
+		}
+	});
+	return new MongoStorage({
+		storageHash: computeStorageHash({
+			target: "mongo",
+			targetFamily: "mongo",
+			storage: { namespaces: { [UNBOUND_NAMESPACE_ID]: {
+				id: UNBOUND_NAMESPACE_ID,
+				entries: {
+					collection: namespace.entries.collection,
+					...namespace.entries.valueSet !== void 0 ? { valueSet: namespace.entries.valueSet } : {}
+				}
+			} } },
+			...mongoContractCanonicalizationHooks
+		}),
+		namespaces: { [UNBOUND_NAMESPACE_ID]: namespace }
+	});
+}
+const MONGO_BUILTIN_KINDS = ["collection"];
+/**
+* Builds the Mongo view: unwraps the sole namespace's built-in `collection` kind
+* to the root, attaches the namespace-keyed `namespace` map, and layers both
+* over the deserialized contract so the result is a structural superset of the
+* contract.
+*/
+function buildMongoContractView(contract) {
+	const rootAccessors = buildSingleNamespaceView(contract.storage, MONGO_BUILTIN_KINDS);
+	const namespace = buildNamespacedEntities(contract.storage, MONGO_BUILTIN_KINDS);
+	return {
+		...contract,
+		...rootAccessors,
+		namespace
+	};
+}
+/** Default storage namespace for Mongo-family contracts at runtime. */
+const defaultMongoStorageNamespaceId = UNBOUND_NAMESPACE_ID;
+/** Default domain namespace for Mongo-family contracts at runtime. */
+const defaultMongoDomainNamespaceId = UNBOUND_DOMAIN_NAMESPACE_ID;
+const DOCUMENT_ID_FIELD = "_id";
+/**
+* The model facts behind a same-space to-one relation's nullability: which side owns the
+* foreign key, and whether each local field is nullable.
+*/
+function resolveMongoToOneRelationFields(model, relation) {
+	const fields = relation.on.localFields.map((name) => ({
+		name,
+		nullable: model.fields[name]?.nullable ?? true
+	}));
+	return {
+		ownsForeignKey: !(relation.cardinality === "1:1" && fields.every((field) => field.name === DOCUMENT_ID_FIELD)),
+		fields
+	};
+}
+/** Whether `relation` stores the related model inside the document, rather than referring to documents elsewhere. */
+function isEmbedRelation(relation) {
+	return !("on" in relation) && !("through" in relation);
+}
+function typeKey(kind, name) {
+	return `${kind}:${name}`;
+}
+function referencesOf(fields) {
+	return Object.values(fields).flatMap((field) => field.type.kind === "valueObject" ? [typeKey("valueObject", field.type.name)] : []);
+}
+/**
+* The recursive groups of value objects and embedded models: each set of types that can reach each other through value-object fields and embed relations (a strongly connected component of that graph), and each type that refers to itself. Maps the {@link typeKey} of every type in such a group to the group's number; a type in no recursive group is absent.
+*/
+function recursiveGroupsOf(valueObjects, models) {
+	const edges = /* @__PURE__ */ new Map();
+	for (const [name, valueObject] of Object.entries(valueObjects)) edges.set(typeKey("valueObject", name), referencesOf(valueObject.fields));
+	for (const [name, model] of Object.entries(models)) {
+		const embeds = Object.values(model.relations).flatMap((relation) => isEmbedRelation(relation) ? [typeKey("model", relation.to.model)] : []);
+		edges.set(typeKey("model", name), [...referencesOf(model.fields), ...embeds]);
+	}
+	const groups = /* @__PURE__ */ new Map();
+	const index = /* @__PURE__ */ new Map();
+	const lowLink = /* @__PURE__ */ new Map();
+	const stack = [];
+	const onStack = /* @__PURE__ */ new Set();
+	let nextIndex = 0;
+	let nextGroup = 0;
+	const visit = (node) => {
+		index.set(node, nextIndex);
+		lowLink.set(node, nextIndex);
+		nextIndex++;
+		stack.push(node);
+		onStack.add(node);
+		for (const target of edges.get(node) ?? []) {
+			if (!edges.has(target)) continue;
+			if (!index.has(target)) {
+				visit(target);
+				lowLink.set(node, Math.min(lowLink.get(node) ?? 0, lowLink.get(target) ?? 0));
+			} else if (onStack.has(target)) lowLink.set(node, Math.min(lowLink.get(node) ?? 0, index.get(target) ?? 0));
+		}
+		if (lowLink.get(node) !== index.get(node)) return;
+		const members = [];
+		let member;
+		do {
+			member = stack.pop();
+			if (member === void 0) break;
+			onStack.delete(member);
+			members.push(member);
+		} while (member !== node);
+		const refersToItself = (edges.get(node) ?? []).includes(node);
+		if (members.length > 1 || refersToItself) {
+			for (const each of members) groups.set(each, nextGroup);
+			nextGroup++;
+		}
+	};
+	for (const node of edges.keys()) if (!index.has(node)) visit(node);
+	return groups;
+}
+/**
+* `$jsonSchema` has no references, so a type that contains itself, directly or through other types, cannot be described at every depth. The validator describes the type through which a path enters a recursive group in full, and accepts any object for each field below it that refers back into that group. So each group is written out once for each place a document enters it, and no valid document is refused.
+*/
+const OPEN_OBJECT = { bsonType: "object" };
+function sourcesFor(input, rootKey) {
+	const groups = recursiveGroupsOf(input.valueObjects, input.models);
+	const rootGroup = groups.get(rootKey);
+	return {
+		...input,
+		groups,
+		enteredGroups: new Set(rootGroup === void 0 ? [] : [rootGroup])
+	};
+}
+function objectSchemaOf(kind, name, shape, sources) {
+	const key = typeKey(kind, name);
+	const group = sources.groups.get(key);
+	if (group !== void 0 && sources.enteredGroups.has(group)) return OPEN_OBJECT;
+	return deriveObjectSchema(shape, entering(key, sources));
+}
+/** `sources` with the recursive group of the type `key` entered, if it has one. */
+function entering(key, sources) {
+	const group = sources.groups.get(key);
+	if (group === void 0 || sources.enteredGroups.has(group)) return sources;
+	return {
+		...sources,
+		enteredGroups: /* @__PURE__ */ new Set([...sources.enteredGroups, group])
+	};
+}
+const NO_RELATIONS = {};
+const NOTHING_INHERITED = {
+	fields: {},
+	relations: NO_RELATIONS
+};
+/**
+* The `bsonType` keyword for a list of BSON type names: the name itself for one entry, the list for several.
+*/
+function bsonTypeKeyword(bsonTypes) {
+	const [only, ...rest] = bsonTypes;
+	return only !== void 0 && rest.length === 0 ? only : [...bsonTypes];
+}
+function withNull(bsonTypes) {
+	return bsonTypes.includes("null") ? bsonTypes : ["null", ...bsonTypes];
+}
+function anyValueSchema(field) {
+	if ("many" in field && field.many) return {
+		bsonType: field.nullable ? ["null", "array"] : "array",
+		items: {}
+	};
+	return {};
+}
+function fieldToBsonSchema(field, sources) {
+	const { lookups, valueObjects, valueSets } = sources;
+	if (field.type.kind === "scalar") {
+		const bsonTypes = bsonTypesOfCodec(field.type.codecId, lookups);
+		if (bsonTypes === void 0) return void 0;
+		if (bsonTypes.length === 0) return anyValueSchema(field);
+		const bsonType = bsonTypeKeyword(bsonTypes);
+		const enumValues = field.valueSet !== void 0 ? valueSets[field.valueSet.entityName]?.values ?? null : null;
+		if (field.many) {
+			const items = { bsonType: field.many.elementNullable ? ["null", bsonType] : bsonType };
+			if (enumValues) items["enum"] = field.many.elementNullable ? [...enumValues, null] : enumValues;
+			return {
+				bsonType: field.nullable ? ["null", "array"] : "array",
+				items
+			};
+		}
+		if (field.nullable) {
+			const s = { bsonType: bsonTypeKeyword(withNull(bsonTypes)) };
+			if (enumValues) s["enum"] = [...enumValues, null];
+			return s;
+		}
+		const s = { bsonType };
+		if (enumValues) s["enum"] = enumValues;
+		return s;
+	}
+	if (field.type.kind === "valueObject") {
+		const vo = valueObjects[field.type.name];
+		if (!vo) return void 0;
+		const voSchema = objectSchemaOf("valueObject", field.type.name, {
+			fields: vo.fields,
+			relations: NO_RELATIONS
+		}, sources);
+		if (field.many) return {
+			bsonType: field.nullable ? ["null", "array"] : "array",
+			items: field.many.elementNullable ? { oneOf: [{ bsonType: "null" }, voSchema] } : voSchema
+		};
+		if (field.nullable) return { oneOf: [{ bsonType: "null" }, voSchema] };
+		return voSchema;
+	}
+}
+/**
+* An embedded model is stored inside its owner's document as a closed object (a list of them for `1:N`). The contract does not say whether one must be present, and the ORM creates documents without them, so the property is never required.
+*/
+function embedToBsonSchema(relation, sources) {
+	const embeddedName = relation.to.model;
+	const embedded = sources.models[embeddedName];
+	assertDefined(embedded, `Embedded model "${embeddedName}" is missing`);
+	const schema = objectSchemaOf("model", embeddedName, embedded, sources);
+	return relation.cardinality === "1:N" ? {
+		bsonType: "array",
+		items: schema
+	} : schema;
+}
+/**
+* The properties of `shape`, leaving out the fields and relations `inherited` already describes.
+*/
+function propertiesOf(shape, sources, inherited) {
+	const properties = {};
+	const required = [];
+	for (const [fieldName, field] of Object.entries(shape.fields)) {
+		if (Object.hasOwn(inherited.fields, fieldName)) continue;
+		const schema = fieldToBsonSchema(field, sources);
+		if (schema) {
+			properties[fieldName] = schema;
+			if (!field.nullable) required.push(fieldName);
+		}
+	}
+	for (const [relationName, relation] of Object.entries(shape.relations)) {
+		if (Object.hasOwn(inherited.relations, relationName) || !isEmbedRelation(relation)) continue;
+		properties[relationName] = embedToBsonSchema(relation, sources);
+	}
+	return {
+		properties,
+		required
+	};
+}
+function deriveObjectSchema(shape, sources) {
+	const { properties, required } = propertiesOf(shape, sources, NOTHING_INHERITED);
+	const result = {
+		bsonType: "object",
+		properties,
+		additionalProperties: false
+	};
+	if (required.length > 0) result["required"] = required.sort();
+	return result;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validatorOf(jsonSchema) {
+	return new MongoValidator({
+		jsonSchema,
+		validationLevel: "strict",
+		validationAction: "error"
+	});
+}
+function polymorphicSchema(base, discriminatorField, variants, sources) {
+	const baseSchema = deriveObjectSchema(base, sources);
+	const baseProperties = isRecord(baseSchema["properties"]) ? baseSchema["properties"] : {};
+	const oneOf = [];
+	for (const variant of variants) {
+		const { properties: variantProperties, required } = propertiesOf(variant, entering(typeKey("model", variant.modelName), sources), base);
+		oneOf.push({
+			properties: {
+				...baseProperties,
+				[discriminatorField]: { enum: [variant.discriminatorValue] },
+				...variantProperties
+			},
+			required: [discriminatorField, ...required].sort(),
+			additionalProperties: false
+		});
+	}
+	const jsonSchema = { ...baseSchema };
+	delete jsonSchema["additionalProperties"];
+	if (oneOf.length > 0) jsonSchema["oneOf"] = oneOf;
+	return jsonSchema;
+}
+/**
+* The validator of a root model's collection: the model's fields and embedded models, and for a model with variants one `oneOf` branch per variant.
+*/
+function deriveModelValidator(modelName, model, sources) {
+	const schemaSources = sourcesFor(sources, typeKey("model", modelName));
+	if (!model.discriminator || !model.variants) return validatorOf(deriveObjectSchema(model, schemaSources));
+	const variants = Object.entries(model.variants).map(([discriminatorValue, variant]) => {
+		const variantModel = sources.models[variant.model];
+		assertDefined(variantModel, `Variant model "${variant.model}" of "${modelName}" is missing`);
+		return {
+			discriminatorValue,
+			modelName: variant.model,
+			...variantModel
+		};
+	});
+	return validatorOf(polymorphicSchema(model, model.discriminator.field, variants, schemaSources));
+}
+/**
+* The validator of each collection in `roots`, keyed by collection name, derived from the collection's root model. A root model with variants gets one polymorphic validator covering every variant.
+*/
+function deriveCollectionValidators(input) {
+	const validators = {};
+	for (const [collectionName, root] of Object.entries(input.roots)) {
+		const model = input.models[root.model];
+		assertDefined(model, `Root model "${root.model}" of collection "${collectionName}" is missing`);
+		validators[collectionName] = deriveModelValidator(root.model, model, input);
+	}
+	return validators;
+}
+const notObjectId = {
+	kind: "notObjectId",
+	reason: "has no _id field stored as BSON type objectId. MongoDB adds an objectId _id to every document it inserts without one, so a collection validator without it rejects every insert."
+};
+/**
+* Why a root model with `fields` cannot be stored in a collection with a validator, or undefined when it can. The reason leaves out its subject so each authoring surface can lead with its own, as in `Model "User" has no _id field ...`.
+*/
+function documentIdRefusalOf(fields, lookups) {
+	const id = Object.hasOwn(fields, "_id") ? fields["_id"] : void 0;
+	if (id?.type.kind !== "scalar") return notObjectId;
+	const bsonTypes = bsonTypesOfCodec(id.type.codecId, lookups);
+	if (bsonTypes === void 0) return {
+		kind: "unknownCodec",
+		reason: `has an _id field whose codec "${id.type.codecId}" has no MongoDB data type, so its BSON type is unknown.`
+	};
+	return bsonTypes.length === 1 && bsonTypes[0] === "objectId" ? void 0 : notObjectId;
+}
+/**
+* Clustered-collection options (the `clusteredIndex` collection-creation
+* field). Lifted from a `type =` data shape to an AST class extending
+* `IRNodeBase` per FR18.
+*
+* MongoDB requires `key` and `unique` for any clustered collection; the
+* constructor enforces presence by type signature.
+*/
+var MongoClusteredCollectionOptions = class extends IRNodeBase {
+	kind = "mongo-clustered-collection-options";
+	key;
+	unique;
+	constructor(options) {
+		super();
+		if (options.name !== void 0) this.name = options.name;
+		this.key = options.key;
+		this.unique = options.unique;
+		freezeNode(this);
+	}
+};
+/**
+* Mongo Contract IR node for the per-index option vocabulary (the second
+* argument to `db.collection.createIndex(keys, options)` minus the keys
+* themselves). Lifted from a `type =` data shape to an AST class
+* extending `IRNodeBase` per FR18.
+*
+* Nested `collation` is itself an IR class (`MongoCollationOptions`); the
+* constructor accepts either a class instance or a data literal and
+* normalises to the class form so downstream walks see a uniform IR tree.
+*/
+var MongoIndexOptions = class extends IRNodeBase {
+	kind = "mongo-index-options";
+	constructor(options = {}) {
+		super();
+		if (options.unique !== void 0) this.unique = options.unique;
+		if (options.name !== void 0) this.name = options.name;
+		if (options.partialFilterExpression !== void 0) this.partialFilterExpression = options.partialFilterExpression;
+		if (options.sparse !== void 0) this.sparse = options.sparse;
+		if (options.expireAfterSeconds !== void 0) this.expireAfterSeconds = options.expireAfterSeconds;
+		if (options.weights !== void 0) this.weights = options.weights;
+		if (options.default_language !== void 0) this.default_language = options.default_language;
+		if (options.language_override !== void 0) this.language_override = options.language_override;
+		if (options.textIndexVersion !== void 0) this.textIndexVersion = options.textIndexVersion;
+		if (options["2dsphereIndexVersion"] !== void 0) this["2dsphereIndexVersion"] = options["2dsphereIndexVersion"];
+		if (options.bits !== void 0) this.bits = options.bits;
+		if (options.min !== void 0) this.min = options.min;
+		if (options.max !== void 0) this.max = options.max;
+		if (options.bucketSize !== void 0) this.bucketSize = options.bucketSize;
+		if (options.hidden !== void 0) this.hidden = options.hidden;
+		if (options.collation !== void 0) this.collation = options.collation instanceof MongoCollationOptions ? options.collation : new MongoCollationOptions(options.collation);
+		if (options.wildcardProjection !== void 0) this.wildcardProjection = options.wildcardProjection;
+		freezeNode(this);
+	}
+};
+/**
+* The storage value set of each enum: its members as the contract holds them, in the form their codec stores.
+*/
+function mongoValueSetsOf(enums) {
+	const valueSets = {};
+	for (const [enumName, { members }] of Object.entries(enums)) valueSets[enumName] = {
+		kind: "valueSet",
+		values: members.map((member) => member.value)
+	};
+	return valueSets;
+}
+function isScalarDiscriminatorValue(value) {
+	const t = typeof value;
+	return t === "string" || t === "number" || t === "boolean";
+}
+function formatValue(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (value === null) return "null";
+	if (Array.isArray(value)) return JSON.stringify(value);
+	if (typeof value === "object") return JSON.stringify(value);
+	return String(value);
+}
+function applyPolymorphicScopeToMongoIndex(index, scope) {
+	if (!isScalarDiscriminatorValue(scope.discriminatorValue)) return {
+		kind: "conflict",
+		reason: `Variant-scoped indexes require a scalar (string, number, or boolean) discriminator value for field "${scope.discriminatorField}", but received ${formatValue(scope.discriminatorValue)}.`
+	};
+	const existing = index.partialFilterExpression;
+	if (existing && Object.hasOwn(existing, scope.discriminatorField)) {
+		const existingValue = existing[scope.discriminatorField];
+		if (existingValue === scope.discriminatorValue) return {
+			kind: "ok",
+			index
+		};
+		return {
+			kind: "conflict",
+			reason: `Index partialFilterExpression sets "${scope.discriminatorField}" to ${formatValue(existingValue)}, which conflicts with the variant's discriminator value ${formatValue(scope.discriminatorValue)}.`
+		};
+	}
+	const merged = {
+		...existing ?? {},
+		[scope.discriminatorField]: scope.discriminatorValue
+	};
+	return {
+		kind: "ok",
+		index: new MongoIndex({
+			keys: index.keys,
+			...index.unique !== void 0 && { unique: index.unique },
+			...index.sparse !== void 0 && { sparse: index.sparse },
+			...index.expireAfterSeconds !== void 0 && { expireAfterSeconds: index.expireAfterSeconds },
+			partialFilterExpression: merged,
+			...index.wildcardProjection !== void 0 && { wildcardProjection: index.wildcardProjection },
+			...index.collation !== void 0 && { collation: index.collation },
+			...index.weights !== void 0 && { weights: index.weights },
+			...index.default_language !== void 0 && { default_language: index.default_language },
+			...index.language_override !== void 0 && { language_override: index.language_override }
+		})
+	};
+}
+function formatCrossRef(crossRef) {
+	return `${crossRef.namespace}.${crossRef.model}`;
+}
+function storageDeclaresCollection(storage, collectionName) {
+	for (const ns of Object.values(storage.namespaces)) if (Object.hasOwn(ns.entries["collection"] ?? {}, collectionName)) return true;
+	return false;
+}
+function validateMongoStorage(contract) {
+	const errors = [];
+	for (const [namespaceId, namespace] of Object.entries(contract.domain.namespaces)) {
+		const models = namespace.models;
+		for (const [modelName, model] of Object.entries(models)) {
+			const qualifiedName = `${namespaceId}:${modelName}`;
+			if (model.storage.collection && !storageDeclaresCollection(contract.storage, model.storage.collection)) errors.push(`Model "${qualifiedName}" references collection "${model.storage.collection}" which is not declared under any namespace's collections map`);
+			if (model.base) {
+				const baseModel = models[model.base.model];
+				if (baseModel) {
+					const variantCollection = model.storage.collection;
+					const baseCollection = baseModel.storage.collection;
+					if (variantCollection !== baseCollection) errors.push(`Mongo does not support multi-table inheritance; variant "${qualifiedName}" must share its base's collection ("${baseCollection ?? "(none)"}"), but has "${variantCollection ?? "(none)"}"`);
+				}
+			}
+			for (const [relName, relation] of Object.entries(model.relations ?? {})) {
+				const targetModel = models[relation.to.model];
+				const targetLabel = formatCrossRef(relation.to);
+				if (targetModel?.owner) {
+					if (targetModel.owner !== modelName) errors.push(`Embed relation "${relName}" targets "${targetLabel}" which is owned by "${targetModel.owner}", not "${qualifiedName}"`);
+					if (targetModel.storage.collection) errors.push(`Embed relation "${relName}" targets "${targetLabel}" which must not have a collection`);
+				} else if ("on" in relation && relation.on) {
+					for (const localField of relation.on.localFields) if (!(localField in model.fields)) errors.push(`Reference relation "${relName}": localField "${localField}" is not a field on model "${qualifiedName}"`);
+					if (targetModel) {
+						for (const targetField of relation.on.targetFields) if (!(targetField in targetModel.fields)) errors.push(`Reference relation "${relName}": targetField "${targetField}" is not a field on model "${targetLabel}"`);
+					}
+					const nullabilityError = toOneRelationNullabilityError(qualifiedName, relName, relation, model);
+					if (nullabilityError !== void 0) errors.push(nullabilityError);
+				}
+			}
+		}
+	}
+	if (errors.length > 0) throw structuredError("CONTRACT.VALIDATION_FAILED", `Contract storage validation failed:\n- ${errors.join("\n- ")}`);
+}
+/**
+* A same-space to-one relation that states `nullable` must agree with its local fields: nullable
+* exactly when one of them is nullable (a field that is not declared counts as nullable). A
+* relation without the flag is left to hydration, which derives it the same way.
+*/
+function toOneRelationNullabilityError(qualifiedName, relationName, relation, model) {
+	if (!("on" in relation && (relation.cardinality === "1:1" || relation.cardinality === "N:1") && relation.to.space === void 0) || relation.nullable === void 0) return void 0;
+	const location = `Relation "${relationName}" on model "${qualifiedName}"`;
+	const { ownsForeignKey, fields } = resolveMongoToOneRelationFields(model, relation);
+	if (!ownsForeignKey) return relation.nullable ? void 0 : `${location} is required but does not own the foreign key, so nothing in storage guarantees the related document exists`;
+	const anyNullable = fields.some((field) => field.nullable);
+	if (relation.nullable === anyNullable) return void 0;
+	const fieldList = fields.filter((field) => field.nullable !== relation.nullable).map((field) => `"${field.name}"`).join(", ");
+	return relation.nullable ? `${location} is nullable but every local field is required (fields ${fieldList})` : `${location} is required but a local field is nullable (fields ${fieldList})`;
+}
+const STORED_JSON_TYPE_NAMES = {
+	string: "a string",
+	number: "a finite number",
+	boolean: "a boolean",
+	object: "a JSON object",
+	array: "a JSON array"
+};
+/**
+* A collection validator lists an enum's members in their stored forms, so an enum's BSON type must be one whose values JSON holds. Maps each such type to the JSON type of a member's stored form.
+*/
+const VALIDATOR_LISTABLE_BSON_TYPES = {
+	string: "string",
+	int: "number",
+	double: "number",
+	bool: "boolean",
+	object: "object",
+	array: "array"
+};
+function storedJsonTypeOf(stored) {
+	if (stored === null) return "null";
+	if (Array.isArray(stored)) return "array";
+	if (typeof stored === "number" && !Number.isFinite(stored)) return "non-finite number";
+	return typeof stored;
+}
+function storedText(stored) {
+	return typeof stored === "number" || typeof stored === "bigint" ? String(stored) : JSON.stringify(stored);
+}
+/**
+* Why a collection validator cannot list the members of an enum whose codec stores `bsonTypes`, or undefined when it can. Like {@link validatorEnumMemberRefusalOf}, the reason leaves out its subject so each authoring surface can lead with its own, as in `enum "Role" @@type codec "mongo/int64@1" stores BSON type long, ...`.
+*/
+function validatorEnumRefusalOf(bsonTypes) {
+	const [bsonType, ...otherBsonTypes] = bsonTypes;
+	if (bsonType === void 0 || otherBsonTypes.length > 0) return `declares ${bsonTypes.length} BSON types; an enum needs exactly one. Use a codec with one BSON type, such as mongo/string@1.`;
+	if (VALIDATOR_LISTABLE_BSON_TYPES[bsonType] === void 0) return `stores BSON type ${bsonType}, which a collection validator cannot list as an enum value. Use a codec whose BSON type is string, int, double, bool, object or array.`;
+}
+/**
+* Why a collection validator cannot list an enum member stored as `stored`, for an enum whose codec stores `bsonTypes`, or undefined when it can. The reason leaves out its subject, as in `enum "Role" member "Admin" is stored as ...`.
+*/
+function validatorEnumMemberRefusalOf(bsonTypes, stored) {
+	const enumRefusal = validatorEnumRefusalOf(bsonTypes);
+	if (enumRefusal !== void 0) return enumRefusal;
+	const [bsonType] = bsonTypes;
+	const storedJsonType = bsonType === void 0 ? void 0 : VALIDATOR_LISTABLE_BSON_TYPES[bsonType];
+	if (storedJsonType === void 0 || storedJsonTypeOf(stored) === storedJsonType) return void 0;
+	return `is stored as ${storedText(stored)}, which a collection validator cannot list as a ${bsonType}. A member of a ${bsonType} enum must be ${STORED_JSON_TYPE_NAMES[storedJsonType]}.`;
+}
+//#endregion
+export { validatorEnumMemberRefusalOf as _, RelationKeys as a, buildMongoNamespace as c, defaultMongoStorageNamespaceId as d, deriveCollectionValidators as f, validateMongoStorage as g, resolveMongoToOneRelationFields as h, MongoUnboundNamespace as i, buildMongoStorage as l, mongoValueSetsOf as m, MongoIndexOptions as n, applyPolymorphicScopeToMongoIndex as o, documentIdRefusalOf as p, MongoStorage as r, buildMongoContractView as s, MongoClusteredCollectionOptions as t, defaultMongoDomainNamespaceId as u, validatorEnumRefusalOf as v };
+
+//# sourceMappingURL=dist-BbfUvuqQ.mjs.map