@prisma/orm-target-mongo 8.0.0-rc.18-dev.31 → 8.0.0-rc.18-dev.32

package/dist/{control-lAuWLUE_.mjs → control-CfztdRLD.mjs}

@@ -11,17 +11,17 @@ import { AggregateCommand, MongoAddFieldsStage, MongoLimitStage, MongoLookupStag
 import { canonicalizeSchemasForVerification, contractToMongoSchemaIR, diffMongoSchemas, fieldRewriteOf } from "@prisma/orm-family-mongo/family/control";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
 import { MongoContractSerializerBase, MongoSchemaVerifierBase } from "@prisma/orm-family-mongo/family/ir";
-import { MongoCollection, MongoStorage, collectionControlPoliciesOf, collectionControlPolicyOf, collectionRootModelsOf, storedFieldNameOf, storesField, validatorFieldNamesOf, validatorRootShapesOf } from "@prisma/orm-family-mongo/contract";
+import { MongoCollection, MongoStorage, collectionControlPoliciesOf, collectionControlPolicyOf, collectionRootModelsOf, hasOwnFieldStoredAs, modelAndBasesOf, mongoModelsOf, ownEmbedStoredNamesOf, ownStoredNameOf, ownStoredNamesOf, validatorFieldNamesOf, validatorRootShapesOf } from "@prisma/orm-family-mongo/contract";
 import { composeMongoEntityKinds } from "@prisma/orm-family-mongo/contract/entity-kinds";
 import { asNamespaceId, governingControlPolicy } from "@prisma/orm-framework/contract/types";
 import { APP_SPACE_ID, VERIFY_CODE_SCHEMA_FAILURE, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, describeMigrationStatement, issueOutcome, modelDisplayName } from "@prisma/orm-framework/components/control";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { TsExpression, jsonToTsSource, renderImports } from "@prisma/orm-framework/ts-render";
 import { Migration } from "@prisma/orm-toolchain/migration-tools/migration";
 import { resolveRequirementSpecifiers } from "@prisma/orm-framework/components/emission";
 import { detectScaffoldRuntime, shebangLineFor } from "@prisma/orm-toolchain/migration-tools/migration-ts";
 import { errorRunnerFailed } from "@prisma/orm-framework/errors/execution";
 import { verifyMongoSchema } from "@prisma/orm-family-mongo/family/schema-verify";
-import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 //#region ../../../3-mongo-target/1-mongo-target/dist/control.mjs
 /**
 * Mongo target `Namespace` concretion. In Mongo the "namespace" concept
@@ -384,8 +384,19 @@ function collectionOf(contract, coordinate) {
 	return typeof collection === "string" ? collection : coordinate.model;
 }
 function modelAt(contract, coordinate) {
-	const namespace = contract.domain.namespaces[coordinate.namespaceId];
-	return namespace !== void 0 && Object.hasOwn(namespace.models, coordinate.model) ? namespace.models[coordinate.model] : void 0;
+	const models = mongoModelsOf(contract.domain, coordinate.namespaceId);
+	return Object.hasOwn(models, coordinate.model) ? models[coordinate.model] : void 0;
+}
+/** The stored name of `field` of the model at `coordinate`, or undefined when the model does not declare it. */
+function storedFieldNameAt(contract, coordinate) {
+	const model = modelAt(contract, coordinate);
+	return model === void 0 || !Object.hasOwn(model.fields, coordinate.field) ? void 0 : ownStoredNameOf(model, coordinate.field);
+}
+/** The stored name of a field the statement's resolution found on the model at `coordinate`. */
+function resolvedStoredNameAt(contract, coordinate) {
+	const storedName = storedFieldNameAt(contract, coordinate);
+	if (storedName === void 0) throw new InternalError(`Field "${coordinate.model}.${coordinate.field}" a statement names has no stored name`);
+	return storedName;
 }
 /**
 * The condition that selects a variant's documents in the collection it shares with its base: the
@@ -394,10 +405,13 @@ function modelAt(contract, coordinate) {
 function variantFilter(contract, coordinate) {
 	const base = modelAt(contract, coordinate)?.base;
 	if (base === void 0) return void 0;
-	const baseModel = contract.domain.namespaces[base.namespace]?.models[base.model];
+	const baseModel = modelAt(contract, {
+		namespaceId: asNamespaceId(base.namespace),
+		model: base.model
+	});
 	const field = baseModel?.discriminator?.field;
 	const value = Object.entries(baseModel?.variants ?? {}).find(([, variant]) => variant.namespace === coordinate.namespaceId && variant.model === coordinate.model)?.[0];
-	return field === void 0 || value === void 0 ? void 0 : { [field]: value };
+	return baseModel === void 0 || field === void 0 || value === void 0 ? void 0 : { [ownStoredNameOf(baseModel, field)]: value };
 }
 function declaredCollection(contract, collection) {
 	return Object.values(contract.storage.namespaces).map((namespace) => namespace.entries["collection"]?.[collection]).find((entry) => entry instanceof MongoCollection);
@@ -467,21 +481,18 @@ function discriminatorValueOf(filter) {
 * The other models stored in `collection`, root models and their variants, whose documents a change of `storedName` with `filter` reaches, and which store the field themselves or through their base. No discriminator tells the documents of several root models apart, so without a filter, or with a base model's filter, every other root model's documents are reached. A variant's filter, one discriminator value, reaches a model only when its documents can hold that value: a variant of another root model with the same discriminator field and value, or a model that declares the discriminator field itself.
 */
 function otherModelsReached(contract, model, collection, filter, storedName) {
-	const models = contract.domain.namespaces[model.namespaceId]?.models ?? {};
+	const models = mongoModelsOf(contract.domain, model.namespaceId);
 	const baseOf = (name) => {
 		const base = models[name]?.base;
 		return base === void 0 ? void 0 : models[base.model];
 	};
-	const storesOrInherits = (name, field) => {
-		const each = models[name];
-		const base = baseOf(name);
-		return each !== void 0 && storesField(each, field) || base !== void 0 && storesField(base, field);
-	};
+	const storesOrInherits = (name, storedName) => modelAndBasesOf(models, name).some((each) => ownStores(each, storedName));
 	const selected = discriminatorValueOf(filter);
 	const canHold = (name) => {
 		if (selected === void 0) return true;
 		const base = baseOf(name);
-		if (base?.discriminator?.field === selected.field) return Object.entries(base.variants ?? {}).some(([value, variant]) => variant.model === name && value === selected.value);
+		const discriminator = base?.discriminator?.field;
+		if (base !== void 0 && discriminator !== void 0 && ownStoredNameOf(base, discriminator) === selected.field) return Object.entries(base.variants ?? {}).some(([value, variant]) => variant.model === name && value === selected.value);
 		return storesOrInherits(name, selected.field);
 	};
 	const subjectRoot = modelAt(contract, model)?.base?.model ?? model.model;
@@ -633,28 +644,28 @@ function planFieldStatement(statement, label, renamedCollections, schema, input)
 	if (fromField.kind === "embed" || toField.kind === "embed") return refuse("the field is an embedded relation", `Renaming an embedded relation is not supported in this release. ${LEAVE_OUT}`);
 	if (fromField.kind !== "field" && toField.kind !== "field") return { kind: "unchanged" };
 	if (fromField.kind !== "field" || toField.kind !== "field") return refuse("the field is stored in documents on one side of the statement only", `A relation is not stored in documents, so a statement cannot rename a field to or from one. ${LEAVE_OUT}`);
-	if (statement.from.field === "_id" || statement.to.field === "_id") return refuse("it renames _id", `MongoDB does not let a document change its _id. ${LEAVE_OUT}`);
-	const unsafeFrom = unrewritableFieldNameReason(statement.from.field);
-	if (unsafeFrom !== void 0) return refuse(`the stored field name "${statement.from.field}" cannot be rewritten`, `${unsafeFrom}, so a statement cannot move its values. Rename it in the database yourself, or ${LEAVE_OUT.toLowerCase()}`);
-	const unsafeTo = unrewritableFieldNameReason(statement.to.field);
-	if (unsafeTo !== void 0) return refuse(`the stored field name "${statement.to.field}" cannot be written`, `${unsafeTo}. Give the field a stored name without "." that does not start with "$" (with @map), or ${LEAVE_OUT.toLowerCase()}`);
+	const fromStored = resolvedStoredNameAt(input.fromContract, statement.from);
+	const toStored = resolvedStoredNameAt(input.contract, statement.to);
 	const originCollection = collectionOf(input.fromContract, statement.from);
 	const collection = renamedCollections.get(originCollection) ?? originCollection;
 	const destinationCollection = collectionOf(input.contract, statement.to);
+	if (fromStored === toStored && collection === destinationCollection) return { kind: "unchanged" };
+	if (fromStored === "_id" || toStored === "_id") return refuse("it renames _id", `MongoDB does not let a document change its _id. ${LEAVE_OUT}`);
+	const unsafeFrom = unrewritableFieldNameReason(fromStored);
+	if (unsafeFrom !== void 0) return refuse(`the stored name "${fromStored}" cannot be rewritten`, `${unsafeFrom}, so a statement cannot move its values. Rename it in the database yourself, or ${LEAVE_OUT.toLowerCase()}`);
+	const unsafeTo = unrewritableFieldNameReason(toStored);
+	if (unsafeTo !== void 0) return refuse(`the stored name "${toStored}" cannot be written`, `${unsafeTo}. Give the field a stored name without "." that does not start with "$" (with @map), or ${LEAVE_OUT.toLowerCase()}`);
 	if (collection !== destinationCollection) return refuse(`the model's collection changes from "${originCollection}" to "${destinationCollection}", and no statement renames it`, collectionChangeAdvice(statement, originCollection, destinationCollection));
-	if (statement.from.field === statement.to.field) return { kind: "unchanged" };
-	if (schema.collection(collection)?.options?.timeseries !== void 0) return refuse(`collection "${collection}" is a time-series collection`, `${TIME_SERIES_UPDATES}, so a statement cannot move the values of a field in them. Keep the stored name: name the field ${JSON.stringify(statement.from.field)} in the contract (with @map(${JSON.stringify(statement.from.field)}) in PSL), then run this command again without this statement.`);
+	if (schema.collection(collection)?.options?.timeseries !== void 0) return refuse(`collection "${collection}" is a time-series collection`, `${TIME_SERIES_UPDATES}, so a statement cannot move the values of a field in them. Keep the stored name: store the field as ${JSON.stringify(fromStored)} (with @map(${JSON.stringify(fromStored)}) in PSL), then run this command again without this statement.`);
 	const policyRefusal = controlPolicyRefusal(statement, label, input.contract, collection);
 	if (policyRefusal !== void 0) return policyRefusal;
 	const variant = variantFilter(input.fromContract, statement.from);
-	const fromModel = modelAt(input.fromContract, statement.from);
-	const renamedTogether = new Set(input.statements.flatMap((other) => other.entity === "field" && other.from.namespaceId === statement.from.namespaceId && other.from.field === statement.from.field && other.to.field === statement.to.field ? [other.from.model] : []));
-	const others = otherModelsReached(input.fromContract, statement.from, originCollection, variant, fromModel === void 0 ? statement.from.field : storedFieldNameOf(fromModel, statement.from.field)).filter((name) => !renamedTogether.has(name));
-	if (others.length > 0) return refuse(`model ${others.map((name) => JSON.stringify(name)).join(", ")} stores field ${JSON.stringify(statement.from.field)} in the same collection, ${JSON.stringify(collection)}`, `${sharedCollectionWhy(collection, others, "renaming the field would rename it in the documents")} To change it, ${SEPARATE_THE_MODELS}.`);
-	const filter = variant ?? rootDocumentsLosing(input.contract, statement.to, statement.from.field)?.filter;
+	const renamedTogether = new Set(input.statements.flatMap((other) => other.entity === "field" && other.from.namespaceId === statement.from.namespaceId && storedFieldNameAt(input.fromContract, other.from) === fromStored && storedFieldNameAt(input.contract, other.to) === toStored ? [other.from.model] : []));
+	const others = otherModelsReached(input.fromContract, statement.from, originCollection, variant, fromStored).filter((name) => !renamedTogether.has(name));
+	if (others.length > 0) return refuse(`model ${others.map((name) => JSON.stringify(name)).join(", ")} stores field ${JSON.stringify(fromStored)} in the same collection, ${JSON.stringify(collection)}`, `${sharedCollectionWhy(collection, others, "renaming the field would rename it in the documents")} To change it, ${SEPARATE_THE_MODELS}.`);
 	return {
 		kind: "renameField",
-		call: new RenameFieldCall(collection, statement.from.field, statement.to.field, filter)
+		call: new RenameFieldCall(collection, fromStored, toStored, variant ?? rootDocumentsLosing(input.contract, statement.to, fromStored)?.filter)
 	};
 }
 function collectionChangeAdvice(statement, from, to) {
@@ -697,30 +708,33 @@ function destinationModelOf(origin, input) {
 function renamedByStatement(input, field) {
 	return input.statements.some((statement) => statement.entity === "field" && sameModel(statement.from, field) && statement.from.field === field.field);
 }
+/** Whether one of `model`'s own fields or embed relations is stored under `storedName`. */
+function ownStores(model, storedName) {
+	return hasOwnFieldStoredAs(model, storedName) || Object.values(ownEmbedStoredNamesOf(model)).includes(storedName);
+}
+/** The stored names of the documents of the model at `coordinate`: its fields and embed relations, its own and those it inherits. */
 function storedFieldsOf(contract, coordinate) {
-	const model = modelAt(contract, coordinate);
-	if (model === void 0) return /* @__PURE__ */ new Set();
-	const base = model.base === void 0 ? void 0 : modelAt(contract, {
-		namespaceId: asNamespaceId(model.base.namespace),
-		model: model.base.model
-	});
-	return /* @__PURE__ */ new Set([...Object.keys(model.fields), ...Object.keys(base?.fields ?? {})]);
+	const models = mongoModelsOf(contract.domain, coordinate.namespaceId);
+	return new Set(modelAndBasesOf(models, coordinate.model).flatMap((model) => [...Object.values(ownStoredNamesOf(model)), ...Object.values(ownEmbedStoredNamesOf(model))]));
 }
 /**
 * The documents of a root model that lose `field`: all of them, or, when some of its destination
 * variants now store the field themselves, those whose discriminator value is none of theirs.
 * `undefined` when the root model itself still stores it.
 */
-function rootDocumentsLosing(contract, root, field) {
+function rootDocumentsLosing(contract, root, storedName) {
 	const model = modelAt(contract, root);
-	if (model === void 0 || Object.hasOwn(model.fields, field)) return void 0;
+	if (model === void 0 || ownStores(model, storedName)) return void 0;
 	const discriminator = model.discriminator?.field;
-	const keeping = Object.entries(model.variants ?? {}).filter(([, variant]) => Object.hasOwn(modelAt(contract, {
-		namespaceId: variant.namespace,
-		model: variant.model
-	})?.fields ?? {}, field)).map(([value]) => value).sort();
+	const keeping = Object.entries(model.variants ?? {}).filter(([, variant]) => {
+		const variantModel = modelAt(contract, {
+			namespaceId: variant.namespace,
+			model: variant.model
+		});
+		return variantModel !== void 0 && ownStores(variantModel, storedName);
+	}).map(([value]) => value).sort();
 	if (discriminator === void 0 || keeping.length === 0) return { filter: void 0 };
-	return { filter: { [discriminator]: { $nin: keeping } } };
+	return { filter: { [ownStoredNameOf(model, discriminator)]: { $nin: keeping } } };
 }
 /**
 * Each field an origin model stores that its destination model no longer stores, in a collection
@@ -739,17 +753,17 @@ function planFieldRemovals(input) {
 		const model = modelAt(input.fromContract, origin);
 		if (model === void 0) return [];
 		const variant = variantFilter(input.fromContract, origin);
-		const losing = (field) => {
-			if (variant !== void 0) return storedFieldsOf(input.contract, destination).has(field) ? void 0 : { filter: variant };
-			return rootDocumentsLosing(input.contract, destination, field);
+		const losing = (storedName) => {
+			if (variant !== void 0) return storedFieldsOf(input.contract, destination).has(storedName) ? void 0 : { filter: variant };
+			return rootDocumentsLosing(input.contract, destination, storedName);
 		};
-		return Object.keys(model.fields).filter((field) => unrewritableFieldNameReason(field) === void 0 && !renamedByStatement(input, {
+		return Object.entries(ownStoredNamesOf(model)).filter(([field, storedName]) => unrewritableFieldNameReason(storedName) === void 0 && !renamedByStatement(input, {
 			...origin,
 			field
-		})).sort().flatMap((field) => {
-			const lost = losing(field);
+		})).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).flatMap(([field, storedName]) => {
+			const lost = losing(storedName);
 			return lost === void 0 ? [] : [{
-				call: new UnsetFieldCall(collection, field, lost.filter),
+				call: new UnsetFieldCall(collection, storedName, lost.filter),
 				subject: {
 					kind: "field",
 					...origin,
@@ -2360,4 +2374,4 @@ const mongoTargetDescriptor = {
 //#endregion
 export { schemaIndexToCreateIndexOptions as C, schemaCollectionToCreateCollectionOptions as S, deserializeMongoOp as _, DropIndexCall as a, renderCallsToTypeScript as b, MongoMigrationRunner as c, MongoTargetSchemaVerifier as d, MongoTargetUnboundDatabase as f, UnsetFieldCall as g, RenameFieldCall as h, DropCollectionCall as i, MongoTargetContractSerializer as l, RenameCollectionCall as m, CreateCollectionCall as n, FilterEvaluator as o, PlannerProducedMongoMigration as p, CreateIndexCall as r, MongoMigrationPlanner as s, CollModCall as t, MongoTargetDatabase as u, deserializeMongoOps as v, serializeMongoOps as w, renderOps as x, mongoTargetDescriptor as y };
 
-//# sourceMappingURL=control-lAuWLUE_.mjs.map
+//# sourceMappingURL=control-CfztdRLD.mjs.map