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

package/dist/contract-builder-BHzQQk70.mjs

@@ -0,0 +1,965 @@
+import { i as MongoCollectionOptions, o as MongoIndex } from "./entity-kinds-BQBtfVet-B-Px7NHp.mjs";
+import { t as assertMongoFieldTypeParams } from "./mongo-data-type-DzyzU4LF-C1ydFXgE.mjs";
+import { M as unsupportedStoredNameReason, S as mongoContractRefusalsOf, g as deriveCollectionValidators, s as applyPolymorphicScopeToMongoIndex, u as buildMongoStorage, w as mongoValueSetsOf } from "./dist-B8f-pfcT.mjs";
+import { t as contractError } from "./contract-errors-BCN6RVI5-kMurtAbI.mjs";
+import { assembleDataTypes } from "@prisma/orm-framework/components/codec";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { crossRef } from "@prisma/orm-framework/contract/types";
+import { buildExecutionSection, computeProfileHash } from "@prisma/orm-framework/contract/hashing";
+import { bindEnumType, composePackAuthoringNamespace, createEntityHelpersFromNamespace, createFieldHelpersFromNamespace, encodeEnumTypeMembers, enumType as enumType$1, isEnumTypeHandle, member, resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
+import { assertNoCrossRegistryCollisions, assertTypeAliasesValid, instantiateAuthoringFieldPreset, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { assembleGeneratorFunctions, createGeneratorHelpers } from "@prisma/orm-framework/components/components";
+import { extractCodecLookup } from "@prisma/orm-framework/components/control";
+import { canonicalStringify } from "@prisma/orm-framework/utils/canonical-stringify";
+//#region ../../../2-mongo-family/2-authoring/contract-ts/dist/contract-builder.mjs
+const LIST_THE_CODEC_PACK = "List the pack that provides the codec in `extensions` in defineContract.";
+function codecRefusalError(subject, meta, codecId, refusal) {
+	if (refusal.kind === "unknownCodec") return contractError("CONTRACT.CODEC_DESCRIPTOR_MISSING", `${subject} ${refusal.reason}`, {
+		fix: LIST_THE_CODEC_PACK,
+		meta: {
+			...meta,
+			codecId
+		}
+	});
+	return contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `${subject} ${refusal.reason}`, {
+		fix: "Use a codec whose data type is a MongoDB data type, declared with mongoDataType.",
+		meta: {
+			...meta,
+			codecId,
+			dataType: refusal.dataType,
+			reason: "data-type-not-mongo"
+		}
+	});
+}
+function refusalError(refusal) {
+	switch (refusal.kind) {
+		case "embeddedModelHasVariants": return contractError("CONTRACT.RELATION_INVALID", `Relation "${refusal.modelName}.${refusal.relationName}" ${refusal.reason}`, { meta: {
+			modelName: refusal.modelName,
+			relationName: refusal.relationName,
+			reason: "embedded-model-has-variants"
+		} });
+		case "enumBsonType": return codecRefusalError(`enumType("${refusal.enumName}")`, { enumName: refusal.enumName }, refusal.codecId, refusal.refusal);
+		case "enumNotListable": return contractError("CONTRACT.ENUM_INVALID", `enumType("${refusal.enumName}") codec "${refusal.codecId}" ${refusal.reason}`, { meta: {
+			enumName: refusal.enumName,
+			codecId: refusal.codecId,
+			reason: "not-listable-by-validator"
+		} });
+		case "enumMemberNotListable": return contractError("CONTRACT.ENUM_INVALID", `enumType("${refusal.enumName}") member "${refusal.member}" ${refusal.reason}`, { meta: {
+			enumName: refusal.enumName,
+			member: refusal.member,
+			codecId: refusal.codecId,
+			reason: "member-not-listable-by-validator"
+		} });
+		case "fieldBsonType": {
+			const { owner } = refusal;
+			const label = owner.kind === "model" ? "Model" : "Value object";
+			const ownerMeta = owner.kind === "model" ? { modelName: owner.name } : { valueObjectName: owner.name };
+			return codecRefusalError(`${label} "${owner.name}" field "${refusal.fieldName}"`, {
+				...ownerMeta,
+				fieldName: refusal.fieldName
+			}, refusal.codecId, refusal.refusal);
+		}
+		case "documentId": return contractError("CONTRACT.COLLECTION_INVALID", `Model "${refusal.modelName}" field "${refusal.fieldName}" ${refusal.reason}`, { meta: {
+			modelName: refusal.modelName,
+			fieldName: refusal.fieldName,
+			collection: refusal.collection,
+			codecId: refusal.codecId,
+			bsonTypes: refusal.forbidden,
+			reason: "document-id-bson-type"
+		} });
+	}
+}
+/**
+* Throws the first part of the built contract that its collection validators cannot describe, as decided by `mongoContractRefusalsOf`.
+*/
+function assertCollectionValidatorSources(input) {
+	const [first] = mongoContractRefusalsOf(input);
+	if (first !== void 0) throw refusalError(first);
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+const MONGO_RESERVED_HELPER_KEYS = [
+	"field",
+	"gen",
+	"index",
+	"model",
+	"rel",
+	"valueObject"
+];
+function buildFieldPreset(helperPath, descriptor, args) {
+	validateAuthoringHelperArguments(helperPath, descriptor.args, args);
+	const preset = instantiateAuthoringFieldPreset(descriptor, args);
+	const unsupported = [
+		...preset.default !== void 0 ? ["default"] : [],
+		...preset.id ? ["id"] : [],
+		...preset.unique ? ["unique"] : []
+	];
+	if (unsupported.length > 0) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Field preset "${helperPath}" contributes ${unsupported.join(", ")}, which Mongo does not support. Mongo supports presets that set a codec and execution defaults only.`, { meta: {
+		helperPath,
+		reason: "preset-contribution-unsupported",
+		contribution: unsupported
+	} });
+	return createFieldBuilder({
+		type: {
+			kind: "scalar",
+			codecId: preset.descriptor.codecId,
+			...normalizeOptionalTypeParams(preset.descriptor.typeParams)
+		},
+		nullable: preset.nullable,
+		many: false
+	}, void 0, preset.executionDefaults);
+}
+function composeMongoFieldHelpers(fieldNamespace) {
+	const presetHelpers = createFieldHelpersFromNamespace(fieldNamespace, ({ helperPath, descriptor }) => (...args) => buildFieldPreset(helperPath, descriptor, args));
+	const collisions = Object.keys(presetHelpers).filter((name) => Object.hasOwn(field, name));
+	if (collisions.length > 0) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Pack-contributed field preset(s) ${collisions.map((c) => `"${c}"`).join(", ")} collide with the built-in Mongo field helper(s) of the same name.`, { meta: {
+		reason: "core-field-helper-collision",
+		contribution: collisions
+	} });
+	return {
+		...field,
+		...presetHelpers
+	};
+}
+/** The context an entity helper's factory runs in. The builder reads no written values, so its data types carry no authoring entries. */
+function entityContextOf(familyId, targetId, components) {
+	const codecLookup = extractCodecLookup(components);
+	return {
+		family: familyId,
+		target: targetId,
+		codecLookup,
+		dataTypes: {
+			entries: {},
+			lookup: assembleDataTypes(components).lookup,
+			dataTypeOfCodec: (codecId) => codecLookup.descriptorFor(codecId)?.dataType
+		}
+	};
+}
+function composeMongoAuthoringHelpers(family, target, extensions) {
+	const components = [
+		family,
+		target,
+		...Object.values(extensions ?? {})
+	];
+	const entityNamespace = composePackAuthoringNamespace(components, "entityTypes");
+	const fieldNamespace = composePackAuthoringNamespace(components, "field");
+	assertNoCrossRegistryCollisions({}, fieldNamespace, entityNamespace);
+	const collisions = Object.keys(entityNamespace).filter((name) => MONGO_RESERVED_HELPER_KEYS.includes(name));
+	if (collisions.length > 0) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Pack-contributed entity type(s) ${collisions.map((c) => `"${c}"`).join(", ")} collide with the reserved built-in helper key(s) on the Mongo composed helpers surface. Reserved keys: ${MONGO_RESERVED_HELPER_KEYS.map((k) => `"${k}"`).join(", ")}.`, { meta: {
+		reason: "reserved-helper-key-collision",
+		contribution: collisions
+	} });
+	return blindCast({
+		...createEntityHelpersFromNamespace(entityNamespace, { ctx: entityContextOf(family.familyId, target.targetId, components) }),
+		field: composeMongoFieldHelpers(fieldNamespace),
+		gen: createGeneratorHelpers(components),
+		index,
+		model,
+		rel,
+		valueObject
+	});
+}
+function createFieldBuilder(spec, enumHandle, executionDefaults, storedName, generatorCalls) {
+	function many(options) {
+		return createFieldBuilder({
+			type: spec.type,
+			nullable: spec.nullable,
+			many: { elementNullable: options?.elementsNullable ?? false }
+		}, enumHandle, executionDefaults, storedName, generatorCalls);
+	}
+	function withGeneratorCall(phase, call) {
+		if (generatorCalls?.[phase] !== void 0 || executionDefaults?.[phase] !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `.${phase}() is called on a field that already generates a value ${phase === "onCreate" ? "on create" : "on update"}. Set each phase once, and do not combine .${phase}() with a field preset, type alias or alias constant that sets it.`, { meta: {
+			reason: "generator-phase-set-twice",
+			phase
+		} });
+		return createFieldBuilder(spec, enumHandle, blindCast(executionDefaults), storedName, {
+			...generatorCalls,
+			[phase]: call
+		});
+	}
+	return {
+		__kind: "field",
+		...ifDefined("__executionDefaults", executionDefaults),
+		...ifDefined("__generatorCalls", generatorCalls),
+		onCreate: (call) => withGeneratorCall("onCreate", call),
+		onUpdate: (call) => withGeneratorCall("onUpdate", call),
+		__type: spec.type,
+		__nullable: spec.nullable,
+		__many: spec.many,
+		__enumHandle: blindCast(enumHandle),
+		__storedName: blindCast(storedName),
+		optional: blindCast(() => createFieldBuilder({
+			type: spec.type,
+			nullable: true,
+			many: spec.many
+		}, enumHandle, executionDefaults, storedName, generatorCalls)),
+		many: blindCast(many),
+		mongo: ({ field }) => createFieldBuilder(spec, enumHandle, executionDefaults, field, generatorCalls)
+	};
+}
+function normalizeOptionalTypeParams(typeParams) {
+	if (!typeParams) return {};
+	return { typeParams };
+}
+function createScalarFieldBuilder(codecId, options) {
+	return createFieldBuilder({
+		type: blindCast({
+			kind: "scalar",
+			codecId,
+			...normalizeOptionalTypeParams(options?.typeParams)
+		}),
+		nullable: false,
+		many: false
+	});
+}
+function vectorField(options) {
+	return createScalarFieldBuilder("mongo/vector@1", options);
+}
+const field = {
+	scalar: createScalarFieldBuilder,
+	objectId() {
+		return createScalarFieldBuilder("mongo/objectId@1");
+	},
+	string() {
+		return createScalarFieldBuilder("mongo/string@1");
+	},
+	double() {
+		return createScalarFieldBuilder("mongo/double@1");
+	},
+	int32() {
+		return createScalarFieldBuilder("mongo/int32@1");
+	},
+	bool() {
+		return createScalarFieldBuilder("mongo/bool@1");
+	},
+	date() {
+		return createScalarFieldBuilder("mongo/date@1");
+	},
+	int64() {
+		return createScalarFieldBuilder("mongo/int64@1");
+	},
+	int64Number() {
+		return createScalarFieldBuilder("mongo/int64Number@1");
+	},
+	decimal128() {
+		return createScalarFieldBuilder("mongo/decimal128@1");
+	},
+	binary() {
+		return createScalarFieldBuilder("mongo/binary@1");
+	},
+	json() {
+		return createScalarFieldBuilder("mongo/json@1");
+	},
+	bson() {
+		return createScalarFieldBuilder("mongo/bson@1");
+	},
+	vector: vectorField,
+	valueObject(valueObjectName) {
+		return createFieldBuilder({
+			type: blindCast({
+				kind: "valueObject",
+				name: resolveValueObjectName(valueObjectName)
+			}),
+			nullable: false,
+			many: false
+		});
+	},
+	namedType(handle) {
+		return createFieldBuilder({
+			type: blindCast({
+				kind: "scalar",
+				codecId: handle.codecId
+			}),
+			nullable: false,
+			many: false
+		}, handle);
+	}
+};
+function index(fields, options) {
+	return {
+		fields,
+		...options ? { options } : {}
+	};
+}
+function createFieldReference(modelName, fieldName) {
+	return {
+		__kind: "fieldRef",
+		modelName,
+		fieldName
+	};
+}
+function isFieldReference(value) {
+	return typeof value === "object" && value !== null && "__kind" in value && value.__kind === "fieldRef";
+}
+function resolveModelName(value) {
+	return typeof value === "string" ? value : value.__name;
+}
+function resolveValueObjectName(value) {
+	return typeof value === "string" ? value : value.__name;
+}
+function normalizeStringList(value) {
+	return typeof value === "string" ? [value] : [...value];
+}
+function normalizeTargetField(targetModelName, value) {
+	if (!isFieldReference(value)) return value;
+	if (value.modelName !== targetModelName) throw contractError("CONTRACT.RELATION_INVALID", `Relation target "${targetModelName}" cannot reference field "${value.modelName}.${value.fieldName}".`, { meta: {
+		modelName: targetModelName,
+		reason: "cross-model-field-reference",
+		referencedModel: value.modelName,
+		referencedField: value.fieldName
+	} });
+	return value.fieldName;
+}
+function normalizeTargetFields(targetModelName, value) {
+	if (typeof value === "string") return [value];
+	if (isFieldReference(value)) return [normalizeTargetField(targetModelName, value)];
+	return value.map((entry) => normalizeTargetField(targetModelName, entry));
+}
+function createRelationBuilder(spec) {
+	return {
+		__kind: "relation",
+		__to: spec.to,
+		__cardinality: spec.cardinality,
+		__on: spec.on,
+		__nullable: spec.nullable
+	};
+}
+function createReferenceRelationBuilder(target, cardinality, options, nullable) {
+	const targetModelName = resolveModelName(target);
+	return createRelationBuilder({
+		to: blindCast(targetModelName),
+		cardinality,
+		on: {
+			localFields: blindCast(normalizeStringList(options.from)),
+			targetFields: blindCast(normalizeTargetFields(targetModelName, options.to))
+		},
+		nullable
+	});
+}
+function createEmbedRelationBuilder(target, cardinality) {
+	return createRelationBuilder({
+		to: blindCast(resolveModelName(target)),
+		cardinality,
+		on: void 0,
+		nullable: void 0
+	});
+}
+function hasOne(target, options) {
+	if (!options) return createEmbedRelationBuilder(target, "1:1");
+	return createReferenceRelationBuilder(target, "1:1", options, true);
+}
+function hasMany(target, options) {
+	if (!options) return createEmbedRelationBuilder(target, "1:N");
+	return createReferenceRelationBuilder(target, "1:N", options, void 0);
+}
+function belongsTo(target, options) {
+	return createReferenceRelationBuilder(target, "N:1", options, options.optional);
+}
+const rel = {
+	belongsTo,
+	hasMany,
+	hasOne
+};
+function valueObject(name, input) {
+	return {
+		__kind: "valueObject",
+		__name: name,
+		__fields: input.fields
+	};
+}
+function model(name, input) {
+	return {
+		__kind: "model",
+		__name: name,
+		__fields: input.fields,
+		__relations: blindCast(input.relations ?? {}),
+		__indexes: input.indexes,
+		__collectionOptions: input.collectionOptions,
+		__controlPolicy: input.controlPolicy,
+		__collection: blindCast(input.collection),
+		__owner: blindCast(input.owner ? resolveModelName(input.owner) : void 0),
+		__base: blindCast(input.base ? resolveModelName(input.base) : void 0),
+		__storageRelations: blindCast(input.storageRelations),
+		__discriminator: blindCast(input.discriminator ? { field: input.discriminator.field } : void 0),
+		__variants: blindCast(input.discriminator?.variants),
+		ref(fieldName) {
+			return createFieldReference(name, fieldName);
+		}
+	};
+}
+function validateTargetPackRef(family, target) {
+	if (family.familyId !== "mongo") throw contractError("CONTRACT.PACK_FAMILY_MISMATCH", `defineContract only accepts Mongo family packs. Received family "${family.familyId}".`, { meta: {
+		packId: family.id,
+		packFamilyId: family.familyId,
+		contractFamilyId: "mongo"
+	} });
+	if (target.familyId !== family.familyId) throw contractError("CONTRACT.PACK_FAMILY_MISMATCH", `target pack "${target.id}" targets family "${target.familyId}" but contract family is "${family.familyId}".`, { meta: {
+		packId: target.id,
+		packFamilyId: target.familyId,
+		contractFamilyId: family.familyId
+	} });
+}
+function validateExtensionPackRefs(target, extensions) {
+	if (!extensions) return;
+	for (const packRef of Object.values(extensions)) {
+		if (packRef.kind !== "extension") throw contractError("CONTRACT.PACK_REF_INVALID", `defineContract only accepts extension pack refs in extensions. Received kind "${packRef.kind}".`, { meta: {
+			packId: packRef.id,
+			kind: packRef.kind
+		} });
+		if (packRef.familyId !== target.familyId) throw contractError("CONTRACT.PACK_FAMILY_MISMATCH", `extension pack "${packRef.id}" targets family "${packRef.familyId}" but contract target family is "${target.familyId}".`, { meta: {
+			packId: packRef.id,
+			packFamilyId: packRef.familyId,
+			contractFamilyId: target.familyId
+		} });
+		if (packRef.targetId && packRef.targetId !== target.targetId) throw contractError("CONTRACT.PACK_TARGET_MISMATCH", `extension pack "${packRef.id}" targets "${packRef.targetId}" but contract target is "${target.targetId}".`, { meta: {
+			packId: packRef.id,
+			packTargetId: packRef.targetId,
+			contractTargetId: target.targetId
+		} });
+	}
+}
+function isContractScaffold(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return "family" in value && "target" in value;
+}
+function buildContractField(builder) {
+	const valueSet = builder.__enumHandle ? {
+		plane: "domain",
+		entityKind: "enum",
+		namespaceId: UNBOUND_NAMESPACE_ID,
+		entityName: builder.__enumHandle.enumName
+	} : void 0;
+	return {
+		type: builder.__type,
+		nullable: builder.__nullable,
+		many: builder.__many,
+		...ifDefined("valueSet", valueSet)
+	};
+}
+function storedNameOf(fieldName, fieldBuilder) {
+	return fieldBuilder.__storedName ?? fieldName;
+}
+function buildStorageFields(modelName, fields) {
+	const storageFields = {};
+	const fieldsByStoredName = /* @__PURE__ */ new Map();
+	for (const [fieldName, fieldBuilder] of Object.entries(fields)) {
+		const storedName = storedNameOf(fieldName, fieldBuilder);
+		const unsupported = unsupportedStoredNameReason(storedName);
+		if (unsupported !== void 0) throw contractError("CONTRACT.ARGUMENT_INVALID", `Model "${modelName}" field "${fieldName}" ${unsupported}. Give it another stored name.`, { meta: {
+			modelName,
+			fieldName,
+			reason: "stored-name-unsupported"
+		} });
+		const existingField = fieldsByStoredName.get(storedName);
+		if (existingField !== void 0) throw contractError("CONTRACT.NAME_DUPLICATE", `Model "${modelName}" stores both "${existingField}" and "${fieldName}" as "${storedName}".`, { meta: {
+			kind: "field",
+			name: storedName,
+			first: existingField,
+			second: fieldName
+		} });
+		fieldsByStoredName.set(storedName, fieldName);
+		storageFields[fieldName] = { field: storedName };
+	}
+	return storageFields;
+}
+function storedFieldNameIn(fields, fieldName) {
+	const fieldBuilder = Object.hasOwn(fields, fieldName) ? fields[fieldName] : void 0;
+	return fieldBuilder === void 0 ? fieldName : storedNameOf(fieldName, fieldBuilder);
+}
+function buildFields(fields) {
+	const builtFields = {};
+	for (const [fieldName, fieldBuilder] of Object.entries(fields)) builtFields[fieldName] = buildContractField(fieldBuilder);
+	return builtFields;
+}
+function toOneRelationNullable(modelName, relationName, relationBuilder, on, fields) {
+	const location = `Relation "${modelName}.${relationName}"`;
+	const ownsForeignKey = relationBuilder.__cardinality !== "1:1";
+	const localFields = ownsForeignKey ? on.localFields.map((fieldName) => {
+		const localField = fields[fieldName];
+		if (localField === void 0) throw contractError("CONTRACT.RELATION_INVALID", `${location} joins on local field "${fieldName}", which model "${modelName}" does not declare`, { meta: {
+			modelName,
+			relationName,
+			fieldName,
+			reason: "local-field-unknown"
+		} });
+		return localField;
+	}) : [];
+	const { nullable, contradiction } = resolveToOneRelationNullable({
+		declaredNullable: relationBuilder.__nullable,
+		localFieldNullability: localFields.map((localField) => localField.__nullable === true),
+		ownsReference: ownsForeignKey
+	});
+	if (contradiction !== void 0) throw contractError("CONTRACT.RELATION_INVALID", !ownsForeignKey ? `${location} is required but does not own the foreign key, so nothing in storage guarantees the related document exists` : contradiction === "declared-optional" ? `${location} is optional but every local field it joins on is required` : `${location} is required but a local field it joins on is nullable`, { meta: {
+		modelName,
+		relationName,
+		reason: "to-one-nullability-mismatch"
+	} });
+	return nullable;
+}
+function buildRelation(modelName, relationName, relationBuilder, fields) {
+	const to = crossRef(relationBuilder.__to, UNBOUND_NAMESPACE_ID);
+	const on = relationBuilder.__on;
+	if (on === void 0) return {
+		to,
+		cardinality: relationBuilder.__cardinality
+	};
+	if (relationBuilder.__cardinality === "1:N") return {
+		to,
+		cardinality: "1:N",
+		on
+	};
+	return {
+		to,
+		cardinality: relationBuilder.__cardinality,
+		nullable: toOneRelationNullable(modelName, relationName, relationBuilder, on, fields),
+		on
+	};
+}
+function buildRelations(modelName, relations, fields) {
+	const builtRelations = {};
+	for (const [relationName, relationBuilder] of Object.entries(relations)) builtRelations[relationName] = buildRelation(modelName, relationName, relationBuilder, fields);
+	return builtRelations;
+}
+function buildValueObjects(valueObjects) {
+	const builtValueObjects = {};
+	for (const valueObjectBuilder of Object.values(valueObjects ?? {})) {
+		if (valueObjectBuilder.__name in builtValueObjects) throw contractError("CONTRACT.NAME_DUPLICATE", `Duplicate value object name "${valueObjectBuilder.__name}" in defineContract().`, { meta: {
+			kind: "valueObject",
+			name: valueObjectBuilder.__name
+		} });
+		for (const [fieldName, fieldBuilder] of Object.entries(valueObjectBuilder.__fields)) if (fieldBuilder.__storedName !== void 0) throw contractError("CONTRACT.ARGUMENT_INVALID", `Value object "${valueObjectBuilder.__name}" field "${fieldName}" sets .mongo({ field }), but a field of a value object is stored under its own name.`, { meta: {
+			valueObjectName: valueObjectBuilder.__name,
+			fieldName,
+			reason: "value-object-field-stored-name"
+		} });
+		builtValueObjects[valueObjectBuilder.__name] = { fields: buildFields(valueObjectBuilder.__fields) };
+	}
+	return builtValueObjects;
+}
+function buildModels(models) {
+	const builtModels = {};
+	for (const modelBuilder of Object.values(models ?? {})) {
+		if (modelBuilder.__name in builtModels) throw contractError("CONTRACT.NAME_DUPLICATE", `Duplicate model name "${modelBuilder.__name}" in defineContract().`, { meta: {
+			kind: "model",
+			name: modelBuilder.__name
+		} });
+		assertUniqueDiscriminatorValues(modelBuilder);
+		const storage = {
+			...modelBuilder.__collection ? { collection: modelBuilder.__collection } : {},
+			fields: buildStorageFields(modelBuilder.__name, modelBuilder.__fields),
+			...modelBuilder.__storageRelations ? { relations: modelBuilder.__storageRelations } : {}
+		};
+		builtModels[modelBuilder.__name] = {
+			fields: buildFields(modelBuilder.__fields),
+			relations: buildRelations(modelBuilder.__name, modelBuilder.__relations, modelBuilder.__fields),
+			storage,
+			...modelBuilder.__owner ? { owner: modelBuilder.__owner } : {},
+			...modelBuilder.__base ? { base: crossRef(modelBuilder.__base, UNBOUND_NAMESPACE_ID) } : {},
+			...modelBuilder.__discriminator ? { discriminator: modelBuilder.__discriminator } : {},
+			...modelBuilder.__variants ? { variants: Object.fromEntries(Object.entries(modelBuilder.__variants).map(([variantName, { value }]) => [value, crossRef(variantName, UNBOUND_NAMESPACE_ID)])) } : {}
+		};
+	}
+	return builtModels;
+}
+function assertUniqueDiscriminatorValues(modelBuilder) {
+	const variantNamesByValue = /* @__PURE__ */ new Map();
+	for (const [variantName, { value }] of Object.entries(modelBuilder.__variants ?? {})) {
+		const existingVariant = variantNamesByValue.get(value);
+		if (existingVariant !== void 0) throw contractError("CONTRACT.ARGUMENT_INVALID", `Discriminator value "${value}" is used by both "${existingVariant}" and "${variantName}" on base model "${modelBuilder.__name}".`, { meta: {
+			modelName: modelBuilder.__name,
+			value,
+			variants: [existingVariant, variantName],
+			reason: "duplicate-discriminator-value"
+		} });
+		variantNamesByValue.set(value, variantName);
+	}
+}
+function deriveRoots(models) {
+	const roots = {};
+	for (const modelBuilder of Object.values(models ?? {})) {
+		if (!modelBuilder.__collection || modelBuilder.__owner || modelBuilder.__base) continue;
+		roots[modelBuilder.__collection] = crossRef(modelBuilder.__name, UNBOUND_NAMESPACE_ID);
+	}
+	return roots;
+}
+function normalizeRoots(roots) {
+	const normalizedRoots = {};
+	for (const [rootName, rootValue] of Object.entries(roots ?? {})) normalizedRoots[rootName] = crossRef(resolveModelName(rootValue), UNBOUND_NAMESPACE_ID);
+	return normalizedRoots;
+}
+function storedIndexKey(fields, key) {
+	const scope = key.match(/^(.+)\.\$\*\*$/)?.[1];
+	if (scope !== void 0) return `${storedFieldNameIn(fields, scope)}.$**`;
+	return key === "$**" ? key : storedFieldNameIn(fields, key);
+}
+function toStorageIndex(index, fields) {
+	const input = { keys: Object.entries(index.fields).map(([field, direction]) => ({
+		field: storedIndexKey(fields, field),
+		direction
+	})) };
+	if (index.options) {
+		for (const [key, value] of Object.entries(index.options)) if (value !== void 0) input[key] = value;
+	}
+	return new MongoIndex(blindCast(input));
+}
+function toStorageCollectionOptions(opts) {
+	return new MongoCollectionOptions({
+		...opts.capped ? { capped: {
+			size: opts.size ?? 0,
+			...opts.max != null && { max: opts.max }
+		} } : {},
+		...ifDefined("storageEngine", opts.storageEngine),
+		...ifDefined("indexOptionDefaults", opts.indexOptionDefaults),
+		...ifDefined("collation", opts.collation),
+		...ifDefined("timeseries", opts.timeseries),
+		...opts.clusteredIndex !== void 0 && { clusteredIndex: opts.clusteredIndex.name !== void 0 ? { name: opts.clusteredIndex.name } : {} },
+		...ifDefined("expireAfterSeconds", opts.expireAfterSeconds),
+		...ifDefined("changeStreamPreAndPostImages", opts.changeStreamPreAndPostImages)
+	});
+}
+function findMissingIndexField(index, modelFields) {
+	for (const fieldName of Object.keys(index.fields)) {
+		const wildcardMatch = fieldName.match(/^(.+)\.\$\*\*$/);
+		const lookupName = wildcardMatch ? wildcardMatch[1] : fieldName;
+		if (lookupName === void 0 || lookupName.length === 0) continue;
+		if (lookupName === "$**") continue;
+		if (!Object.hasOwn(modelFields, lookupName)) return lookupName;
+	}
+}
+function resolveVariantScope(modelBuilder, modelsByName) {
+	if (!modelBuilder.__base) return void 0;
+	const baseBuilder = modelsByName[modelBuilder.__base];
+	if (!baseBuilder) return void 0;
+	const discriminatorField = baseBuilder.__discriminator?.field;
+	const variantValue = baseBuilder.__variants?.[modelBuilder.__name]?.value;
+	if (!discriminatorField || variantValue === void 0) return void 0;
+	return {
+		discriminatorField: storedFieldNameIn(baseBuilder.__fields, discriminatorField),
+		discriminatorValue: variantValue
+	};
+}
+function scopeVariantIndex(storageIndex, scope, variantName, authoredIndex) {
+	const result = applyPolymorphicScopeToMongoIndex(storageIndex, scope);
+	if (result.kind === "conflict") {
+		const indexLabel = authoredIndex ? canonicalStringify(authoredIndex) : "<unknown>";
+		throw contractError("CONTRACT.INDEX_INVALID", `Variant model "${variantName}" index ${indexLabel} conflicts with discriminator scope: ${result.reason}`, { meta: {
+			variantName,
+			indexLabel,
+			reason: result.reason
+		} });
+	}
+	return result.index;
+}
+function buildCollections(models) {
+	const intermediate = {};
+	const declaredIndexOwners = /* @__PURE__ */ new Map();
+	const modelMap = models ?? {};
+	const modelsByName = {};
+	for (const builder of Object.values(modelMap)) modelsByName[builder.__name] = builder;
+	for (const modelBuilder of Object.values(modelMap)) {
+		if (!modelBuilder.__collection) {
+			if (modelBuilder.__indexes && modelBuilder.__indexes.length > 0) throw contractError("CONTRACT.COLLECTION_INVALID", `Model "${modelBuilder.__name}" defines indexes but has no collection to attach them to.`, { meta: {
+				modelName: modelBuilder.__name,
+				reason: "indexes-without-collection"
+			} });
+			if (modelBuilder.__collectionOptions) throw contractError("CONTRACT.COLLECTION_INVALID", `Model "${modelBuilder.__name}" defines collectionOptions but has no collection to attach them to.`, { meta: {
+				modelName: modelBuilder.__name,
+				reason: "collectionOptions-without-collection"
+			} });
+			if (modelBuilder.__controlPolicy) throw contractError("CONTRACT.COLLECTION_INVALID", `Model "${modelBuilder.__name}" defines controlPolicy but has no collection to attach it to.`, { meta: {
+				modelName: modelBuilder.__name,
+				reason: "controlPolicy-without-collection"
+			} });
+			continue;
+		}
+		const existingCollection = intermediate[modelBuilder.__collection] ?? {};
+		const existingIndexes = existingCollection.indexes ?? [];
+		if (existingCollection.options && modelBuilder.__collectionOptions) throw contractError("CONTRACT.COLLECTION_INVALID", `Collection "${modelBuilder.__collection}" has collectionOptions declared by multiple models. Author collectionOptions on a single model per collection.`, { meta: {
+			modelName: modelBuilder.__name,
+			collection: modelBuilder.__collection,
+			reason: "collectionOptions-declared-by-multiple-models"
+		} });
+		if (existingCollection.control !== void 0 && modelBuilder.__controlPolicy) throw contractError("CONTRACT.COLLECTION_INVALID", `Collection "${modelBuilder.__collection}" has controlPolicy declared by multiple models. Author controlPolicy on a single model per collection.`, { meta: {
+			modelName: modelBuilder.__name,
+			collection: modelBuilder.__collection,
+			reason: "controlPolicy-declared-by-multiple-models"
+		} });
+		for (const collectionIndex of modelBuilder.__indexes ?? []) {
+			const missingField = findMissingIndexField(collectionIndex, modelBuilder.__fields);
+			if (missingField !== void 0) {
+				const indexSignature = canonicalStringify(collectionIndex);
+				throw contractError("CONTRACT.FIELD_UNKNOWN", `Model "${modelBuilder.__name}" index ${indexSignature} references unknown field "${missingField}".`, { meta: {
+					modelName: modelBuilder.__name,
+					fieldName: missingField,
+					indexSignature
+				} });
+			}
+		}
+		const polymorphicScope = resolveVariantScope(modelBuilder, modelsByName);
+		const rawStorageIndexes = (modelBuilder.__indexes ?? []).map((authored) => toStorageIndex(authored, modelBuilder.__fields));
+		const storageIndexes = polymorphicScope ? rawStorageIndexes.map((idx, i) => scopeVariantIndex(idx, polymorphicScope, modelBuilder.__name, modelBuilder.__indexes?.[i])) : rawStorageIndexes;
+		for (let i = 0; i < storageIndexes.length; i++) {
+			const storageIndex = storageIndexes[i];
+			if (storageIndex === void 0) continue;
+			const indexSignature = stableStringify(storageIndex);
+			const collectionIndexKey = `${modelBuilder.__collection}:${indexSignature}`;
+			const firstOwner = declaredIndexOwners.get(collectionIndexKey);
+			if (firstOwner) {
+				const authoredIndex = modelBuilder.__indexes?.[i];
+				const reportedSignature = authoredIndex ? canonicalStringify(authoredIndex) : indexSignature;
+				throw contractError("CONTRACT.NAME_DUPLICATE", `Collection "${modelBuilder.__collection}" defines duplicate index ${reportedSignature}. First declared on model "${firstOwner}" and duplicated on model "${modelBuilder.__name}".`, { meta: {
+					kind: "index",
+					name: reportedSignature,
+					collection: modelBuilder.__collection,
+					first: firstOwner,
+					second: modelBuilder.__name
+				} });
+			}
+			declaredIndexOwners.set(collectionIndexKey, modelBuilder.__name);
+		}
+		const storageOptions = modelBuilder.__collectionOptions ? toStorageCollectionOptions(modelBuilder.__collectionOptions) : void 0;
+		const controlPatch = modelBuilder.__controlPolicy !== void 0 ? { control: modelBuilder.__controlPolicy } : {};
+		intermediate[modelBuilder.__collection] = storageIndexes.length > 0 ? {
+			...existingCollection,
+			indexes: [...existingIndexes, ...storageIndexes],
+			...storageOptions ? { options: storageOptions } : {},
+			...controlPatch
+		} : storageOptions ? {
+			...existingCollection,
+			options: storageOptions,
+			...controlPatch
+		} : Object.keys(controlPatch).length > 0 ? {
+			...existingCollection,
+			...controlPatch
+		} : existingCollection;
+	}
+	return intermediate;
+}
+function executionDefaultError(modelName, fieldName, reason, message) {
+	return contractError("CONTRACT.DEFAULT_INVALID", `Field "${modelName}.${fieldName}" ${message}`, { meta: {
+		modelName,
+		fieldName,
+		reason
+	} });
+}
+function hasExecutionDefaults(fieldBuilder) {
+	const phases = fieldBuilder.__executionDefaults;
+	const calls = fieldBuilder.__generatorCalls;
+	return phases?.onCreate !== void 0 || phases?.onUpdate !== void 0 || calls?.onCreate !== void 0 || calls?.onUpdate !== void 0;
+}
+/**
+* The phases a field generates: a preset's, with the generators its `.onCreate(...)` and `.onUpdate(...)` calls resolve to for its codec.
+*/
+function executionDefaultsOf(fieldBuilder, modelName, fieldName, generatorFunctions) {
+	const calls = fieldBuilder.__generatorCalls;
+	if (calls === void 0) return fieldBuilder.__executionDefaults;
+	const type = fieldBuilder.__type;
+	const codecId = type.kind === "scalar" ? type.codecId : void 0;
+	const phases = { ...fieldBuilder.__executionDefaults };
+	for (const phase of ["onCreate", "onUpdate"]) {
+		const call = calls[phase];
+		if (call === void 0) continue;
+		const resolution = type.kind === "scalar" ? generatorFunctions.resolve(call, {
+			codecId: type.codecId,
+			typeParams: type.typeParams,
+			length: void 0
+		}) : void 0;
+		if (resolution?.ok === true) {
+			phases[phase] = resolution.generator;
+			continue;
+		}
+		const meta = {
+			modelName,
+			fieldName,
+			codecId,
+			function: call.name
+		};
+		if (resolution?.reason === "unknown-function") throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${modelName}.${fieldName}": no pack in the contract declares the generator function "${call.name}".`, { meta: {
+			...meta,
+			reason: "generator-unknown"
+		} });
+		throw contractError("CONTRACT.DEFAULT_INVALID", resolution?.reason === "refused" ? `Field "${modelName}.${fieldName}": ${resolution.message}` : `Field "${modelName}.${fieldName}": ${call.name}() does not apply to ${codecId === void 0 ? "the field's type" : `codec "${codecId}"`}.`, { meta: {
+			...meta,
+			reason: "generator-not-applicable"
+		} });
+	}
+	return phases;
+}
+function assertNoValueObjectExecutionDefaults(valueObjects) {
+	for (const valueObjectBuilder of Object.values(valueObjects ?? {})) for (const [fieldName, fieldBuilder] of Object.entries(valueObjectBuilder.__fields)) if (hasExecutionDefaults(fieldBuilder)) throw executionDefaultError(valueObjectBuilder.__name, fieldName, "executionDefaults-on-value-object", "has executionDefaults, but it belongs to a value object. Generated values are only supported on model fields.");
+}
+function buildExecutionDefaults(models, generatorFunctions) {
+	const modelBuilders = Object.values(models ?? {});
+	const collectionByModelName = new Map(modelBuilders.map((modelBuilder) => [modelBuilder.__name, modelBuilder.__collection]));
+	const byRef = /* @__PURE__ */ new Map();
+	const defaults = [];
+	for (const modelBuilder of modelBuilders) for (const [fieldName, fieldBuilder] of Object.entries(modelBuilder.__fields)) {
+		if (!hasExecutionDefaults(fieldBuilder)) continue;
+		const modelName = modelBuilder.__name;
+		const phases = executionDefaultsOf(fieldBuilder, modelName, fieldName, generatorFunctions);
+		if (phases === void 0) continue;
+		if (fieldBuilder.__nullable) throw executionDefaultError(modelName, fieldName, "nullable-with-executionDefaults", "generates a value on write, so it cannot be optional; remove .optional().");
+		if (fieldBuilder.__many) throw executionDefaultError(modelName, fieldName, "many-with-executionDefaults", "generates a value on write, so it cannot be a list; remove .many().");
+		if (modelBuilder.__base !== void 0) {
+			const collection = modelBuilder.__collection ?? collectionByModelName.get(modelBuilder.__base);
+			throw executionDefaultError(modelName, fieldName, "executionDefaults-on-variant", `has executionDefaults, but "${modelName}" is a variant of "${modelBuilder.__base}". Execution defaults apply to every document in collection "${collection}", so declare them on the base model.`);
+		}
+		const entry = modelBuilder.__collection;
+		if (entry === void 0) throw executionDefaultError(modelName, fieldName, "executionDefaults-without-collection", "has executionDefaults, but its model has no collection. Generated values are only supported on fields of a model stored in a collection.");
+		const storedName = storedNameOf(fieldName, fieldBuilder);
+		const refKey = JSON.stringify([entry, storedName]);
+		const phasesKey = canonicalStringify(phases);
+		const existing = byRef.get(refKey);
+		if (existing !== void 0) {
+			if (existing.phasesKey !== phasesKey) throw executionDefaultError(modelName, fieldName, "executionDefaults-conflict", `has different executionDefaults than "${existing.modelName}.${existing.fieldName}", which is stored in the same collection "${entry}". Use the same executionDefaults on both models.`);
+			continue;
+		}
+		byRef.set(refKey, {
+			modelName,
+			fieldName,
+			phasesKey
+		});
+		defaults.push({
+			ref: {
+				namespace: UNBOUND_NAMESPACE_ID,
+				entry,
+				field: storedName
+			},
+			...phases
+		});
+	}
+	return defaults;
+}
+function buildContractFromDefinition(definition) {
+	validateTargetPackRef(definition.family, definition.target);
+	validateExtensionPackRefs(definition.target, definition.extensions);
+	const builtModels = buildModels(definition.models);
+	const builtValueObjects = buildValueObjects(definition.valueObjects);
+	const roots = definition.roots ? normalizeRoots(definition.roots) : deriveRoots(definition.models);
+	const capabilities = {};
+	const collections = buildCollections(definition.models);
+	assertNoValueObjectExecutionDefaults(definition.valueObjects);
+	const components = [
+		definition.family,
+		definition.target,
+		...Object.values(definition.extensions ?? {})
+	];
+	const generatorFunctions = assembleGeneratorFunctions(components);
+	const codecLookup = extractCodecLookup(components);
+	assertTypeAliasesValid(composePackAuthoringNamespace(components, "type"), {
+		generatorFunctions,
+		paramsSchemaOf: (codecId) => codecLookup.descriptorFor(codecId)?.paramsSchema,
+		fieldLength: () => void 0
+	});
+	const execution = buildExecutionSection({
+		target: definition.target.targetId,
+		targetFamily: definition.family.familyId,
+		defaults: buildExecutionDefaults(definition.models, generatorFunctions)
+	});
+	const lookups = {
+		codecLookup,
+		dataTypeLookup: assembleDataTypes(components).lookup
+	};
+	assertMongoFieldTypeParams({ [UNBOUND_NAMESPACE_ID]: {
+		models: builtModels,
+		valueObjects: builtValueObjects
+	} }, lookups);
+	const builtEnums = {};
+	for (const [enumName, handle] of Object.entries(definition.enums ?? {})) builtEnums[enumName] = {
+		codecId: handle.codecId,
+		members: encodeEnumTypeMembers(handle, codecLookup, "the field")
+	};
+	const storageValueSets = mongoValueSetsOf(builtEnums);
+	for (const [enumName, handle] of Object.entries(definition.enums ?? {})) if (enumName !== handle.enumName) throw contractError("CONTRACT.ENUM_INVALID", `enum declaration key "${enumName}" must match enumType name "${handle.enumName}". Aliases are not supported.`, { meta: {
+		enumName: handle.enumName,
+		declaredKey: enumName,
+		reason: "declaration-key-mismatch"
+	} });
+	const hasEnums = Object.keys(builtEnums).length > 0;
+	for (const [modelName, modelBuilder] of Object.entries(definition.models ?? {})) for (const [fieldName, fieldBuilder] of Object.entries(modelBuilder.__fields)) {
+		const handle = fieldBuilder.__enumHandle;
+		if (handle && !(handle.enumName in builtEnums)) throw contractError("CONTRACT.ENUM_UNKNOWN", `Model "${modelName}" field "${fieldName}" references enum "${handle.enumName}" which is not declared in defineContract({ enums: { ... } }).`, { meta: {
+			modelName,
+			fieldName,
+			enumName: handle.enumName
+		} });
+	}
+	const controlPolicies = {
+		collections: Object.fromEntries(Object.entries(collections).map(([name, collection]) => [name, collection.control])),
+		defaultControlPolicy: definition.defaultControlPolicy
+	};
+	assertCollectionValidatorSources({
+		models: builtModels,
+		valueObjects: builtValueObjects,
+		enums: builtEnums,
+		lookups,
+		controlPolicies
+	});
+	const validators = deriveCollectionValidators({
+		models: builtModels,
+		lookups,
+		valueObjects: builtValueObjects,
+		valueSets: storageValueSets,
+		controlPolicies
+	});
+	const storage = buildMongoStorage({
+		collections: Object.fromEntries(Object.entries(collections).map(([name, collection]) => [name, {
+			...collection,
+			...ifDefined("validator", validators[name])
+		}])),
+		valueSets: storageValueSets
+	});
+	return blindCast({
+		target: definition.target.targetId,
+		targetFamily: definition.family.familyId,
+		...ifDefined("defaultControlPolicy", definition.defaultControlPolicy),
+		roots,
+		domain: { namespaces: { [UNBOUND_NAMESPACE_ID]: {
+			models: builtModels,
+			...Object.keys(builtValueObjects).length > 0 ? { valueObjects: builtValueObjects } : {},
+			...hasEnums ? { enum: builtEnums } : {}
+		} } },
+		storage,
+		capabilities,
+		extensions: definition.extensions ?? {},
+		profileHash: computeProfileHash({
+			target: definition.target.targetId,
+			targetFamily: definition.family.familyId,
+			capabilities
+		}),
+		meta: {},
+		...ifDefined("execution", execution)
+	});
+}
+/** Implementation. */
+function buildBoundContract(family, target, definition, factory) {
+	const full = {
+		...definition,
+		family,
+		target
+	};
+	if (factory !== void 0) {
+		const built = factory(composeMongoAuthoringHelpers(family, target, definition.extensions));
+		return buildContractFromDefinition({
+			...full,
+			...ifDefined("models", built.models),
+			...ifDefined("valueObjects", built.valueObjects),
+			...ifDefined("roots", built.roots)
+		});
+	}
+	return buildContractFromDefinition(full);
+}
+function defineContract(definition, factory) {
+	if (!isContractScaffold(definition)) throw contractError("CONTRACT.ARGUMENT_INVALID", "defineContract expects a contract definition object. Define your contract with defineContract({ family, target, models, ... }).");
+	if (factory !== void 0) return buildBoundContract(definition.family, definition.target, definition, factory);
+	return buildBoundContract(definition.family, definition.target, definition);
+}
+//#endregion
+export { field as a, member as c, valueObject as d, enumType$1 as i, model as l, buildBoundContract as n, index as o, defineContract as r, isEnumTypeHandle as s, bindEnumType as t, rel as u };
+
+//# sourceMappingURL=contract-builder-BHzQQk70.mjs.map