@prisma/orm-target-mongo 8.0.0-rc.19-dev.2 → 8.0.0-rc.19-dev.3

package/dist/{control-Poy33Wpm.d.mts → control-BjaiAXAN.d.mts}

@@ -156,16 +156,24 @@ interface MongoMigrationRunnerExecuteOptions {
   readonly scopeVerifyResult?: (result: VerifyDatabaseSchemaResult) => VerifyDatabaseSchemaResult;
   /** Per-edge breakdown from graph-walk planning; drives per-edge ledger writes. */
   readonly migrationEdges: readonly AggregateMigrationEdgeRef[];
+  /** Whether an earlier space of the same apply already changed the database. */
+  readonly databaseChangedBefore?: boolean;
 }
 /** A failure of the Mongo runner: one of the codes it returns. */
 interface MongoMigrationRunnerFailure extends MigrationRunnerFailure {
   readonly code: MongoMigrationRunnerErrorCode;
 }
-type MongoMigrationRunnerResult = Result<MigrationRunnerPerSpaceSuccessValue, MongoMigrationRunnerFailure>;
+/** A space's apply: what the framework reports, and whether it changed the database, its marker and ledger included. */
+interface MongoSpaceSuccessValue extends MigrationRunnerPerSpaceSuccessValue {
+  readonly changedDatabase: boolean;
+}
+type MongoMigrationRunnerResult = Result<MongoSpaceSuccessValue, MongoMigrationRunnerFailure>;
 declare class MongoMigrationRunner {
   private readonly deps;
   constructor(deps: MongoRunnerDependencies);
   execute(options: MongoMigrationRunnerExecuteOptions): Promise<MongoMigrationRunnerResult>;
+  /** Applies the plan, calling `wrote` after each command that changes the database. */
+  private apply;
   private recordLedgerEntries;
   private executeDmlOperation;
   private evaluateDmlChecks;
@@ -339,4 +347,4 @@ declare class MongoTargetUnboundDatabase extends MongoTargetDatabase {
 }
 //#endregion
 export { deserializeMongoOps as _, MongoMigrationRunnerExecuteOptions as a, renderOps as b, MongoTargetContract as c, MongoTargetSchemaVerifier as d, MongoTargetUnboundDatabase as f, deserializeMongoOp as g, RenderMigrationMeta as h, MongoMigrationRunnerErrorCode as i, MongoTargetContractSerializer as l, PlannerProducedMongoMigration as m, MongoMigrationPlanner as n, MongoMigrationRunnerFailure as o, PlanCallsResult as p, MongoMigrationRunner as r, MongoMigrationRunnerResult as s, FilterEvaluator as t, MongoTargetDatabase as u, mongoTargetDescriptor as v, serializeMongoOps as x, renderCallsToTypeScript as y };
-//# sourceMappingURL=control-Poy33Wpm.d.mts.map
+//# sourceMappingURL=control-BjaiAXAN.d.mts.map

package/dist/control-BjaiAXAN.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-BjaiAXAN.d.mts","names":[],"sources":["../../../../3-mongo-target/1-mongo-target/dist/control.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6BK,sBAAsB,KAAK;WACrB,SAAS;;;;;;;;;;;;;;cAcN,uBAAuB,6BAA6B;;;cAGpD,2BAA2B;UAC/B;EACR,SAAS,QAAQ,iBAAiB,KAAK;EACvC,MAAM,MAAM;EACZ,IAAI,MAAM;EACV,GAAG,MAAM;EACT,IAAI,MAAM;EACV,OAAO,MAAM;EACb,KAAK,OAAO;;;;iBAIG,mBAAmB,gBAAgB;iBACnC,oBAAoB,2BAA2B;iBAC/C,kBAAkB,cAAc;;;;;;;;UAQvC;WACC,QAAQ;;WAER,4BAA4B;;WAE5B,oBAAoB,kBAAkB;;;;KAI5C;WACM;WACA,OAAO;;WAEP,mBAAmB;;WAEnB;WACA,WAAW;;cAER,iCAAiC;EAC7C,UAAU;aACC;aACA;aACA,QAAQ;aACR,qBAAqB,cAAc;;aAEnC,cAAc;;aAEd,iBAAiB;MACxB;EACJ,KAAK;aACM;aACA;aACA,QAAQ;;aAER,cAAc;;aAEd,QAAQ;;aAER,qBAAqB;aACrB,qBAAqB,cAAc;;;;;;aAMnC;MACP;;;;;;;;;;EAUJ,eAAe,SAAS,2BAA2B;;;;;KAKhD;;;UAGK;WACC,MAAM;WACN,qBAAqB;WACrB,QAAQ;WACR;IACP,kBAAkB,IAAI;IACtB,qBAAqB,IAAI;;WAElB,kBAAkB;WAClB,qBAAqB,cAAc;WACnC;WACA,UAAU;;;;;;;;;;;WAWV,qBAAqB,QAAQ,+BAA+B;;WAE5D,yBAAyB;;WAEzB;;;UAGD,oCAAoC;WACnC,MAAM;;;UAGP,+BAA+B;WAC9B;;KAEN,6BAA6B,OAAO,wBAAwB;cACnD;mBACK;EACjB,YAAY,MAAM;EAClB,QAAQ,SAAS,qCAAqC,QAAQ;;UAEtD;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;;;;;;;;;;;;;;;;;;;;;;;;cAyBI,kCAAkC,wBAAwB,qBAAqB;YACjF,gBAAgB;aACf,UAAU;aACV,QAAQ;aACR;aACA,WAAW;eACT;YACH,uBAAuB,UAAU,oBAAoB,qBAAqB,0BAA0B;;;;;;;;;;;;;;;;;;;cAmBlG,sCAAsC,UAAU,uCAAuC;mBAClF;mBACA;mBACA;WACR;EACT,YAAY,gBAAgB,mBAAiB,MAAM,eAAe;MAC9D,uBAAuB;EAC3B,YAAY;EACZ,iBAAiB,wBAAwB;;;;iBAI1B,UAAU,OAAO,cAAc,mBAAiB;;;UAGvD;WACC;WACA;;WAEA;;;;;;;WAOA,yBAAyB;;;;;;;;;;;;;;;;;;;iBAmBnB,wBAAwB,OAAO,cAAc,kBAAgB,MAAM;;;cAGtE,sCAAsC,4BAA4B;YACpE,wBAAwB,WAAW,gBAAgB;EAC7D,kBAAkB,UAAU,sBAAsB;;;;UAI1C;WACC;WACA,UAAU,SAAS,eAAe,SAAS;aACzC,aAAa,SAAS,eAAe;aACrC,WAAW,SAAS,eAAe;;;;;;;;;;;;;;;;;cAiBlC,4BAA4B;WAC/B;WACA;WACA,SAAS;EAClB,YAAY,OAAO;MACf,cAAc,SAAS,eAAe;;;;;EAK1C;;;;;;;EAOA,kBAAkB;;;;;;;;;;;;;;;cAeN,mCAAmC;kBAC/B,UAAU;UAClB;EACR;EACA,kBAAkB"}

package/dist/{control-zGCK2Hnz.mjs → control-CYS8H_t4.mjs}

@@ -1,6 +1,6 @@
 import { t as mongoTargetError } from "./mongo-target-errors-Btf3ML1w-B5EMYbz1.mjs";
 import { t as mongoTargetDescriptorMeta } from "./descriptor-meta-Dtl7SqQv-D50zqWiV.mjs";
-import { a as dropCollection, c as renameField, d as unsetField, n as createCollection, o as dropIndex, r as createIndex, s as renameCollection, t as collMod, u as unrewritableFieldNameReason } from "./migration-factories-jwrORVMV-BGqJk_WT.mjs";
+import { a as dropCollection, c as renameField, d as unsetField, n as createCollection, o as dropIndex, r as createIndex, s as renameCollection, t as collMod, u as unrewritableFieldNameReason } from "./migration-factories-BqROEHRs-C4K_DHy7.mjs";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { type } from "arktype";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
@@ -9,7 +9,7 @@ import { MongoSchemaCollection, MongoSchemaIR, canonicalize, deepEqual, indexLoo
 import { CollModCommand, CreateCollectionCommand, CreateIndexCommand, DropCollectionCommand, DropIndexCommand, ListCollectionsCommand, ListIndexesCommand, MongoAndExpr, MongoExistsExpr, MongoFieldFilter, MongoNotExpr, MongoOrExpr, RenameCollectionCommand, isMongoDmlOperation } from "@prisma/orm-family-mongo/query-ast/control";
 import { AggregateCommand, MongoAddFieldsStage, MongoLimitStage, MongoLookupStage, MongoMatchStage, MongoMergeStage, MongoProjectStage, MongoSortStage, RawAggregateCommand, RawDeleteManyCommand, RawDeleteOneCommand, RawFindOneAndDeleteCommand, RawFindOneAndUpdateCommand, RawInsertManyCommand, RawInsertOneCommand, RawUpdateManyCommand, RawUpdateOneCommand } from "@prisma/orm-family-mongo/query-ast/execution";
 import { canonicalizeSchemasForVerification, contractToMongoSchemaIR, diffMongoSchemas, fieldRewriteOf } from "@prisma/orm-family-mongo/family/control";
-import { APP_SPACE_ID, VERIFY_CODE_SCHEMA_FAILURE, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, describeMigrationStatement, failedPrecheckWhy, issueOutcome, migrationRunnerFailure, modelDisplayName, schemaCheckWhy, withFailingSpace } from "@prisma/orm-framework/components/control";
+import { APP_SPACE_ID, VERIFY_CODE_SCHEMA_FAILURE, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, describeMigrationStatement, expectAbsent, expectPresent, failedPostcheckWhy, failedPrecheckWhy, issueOutcome, migrationRunnerFailure, modelDisplayName, schemaCheckWhy, withDatabaseUnchanged, withFailingSpace } from "@prisma/orm-framework/components/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, hasOwnFieldStoredAs, modelAndBasesOf, mongoModelsOf, ownEmbedStoredNamesOf, ownStoredNameOf, ownStoredNamesOf, validatorFieldNamesOf, validatorRootShapesOf } from "@prisma/orm-family-mongo/contract";
@@ -1595,7 +1595,8 @@ const CheckJson = type({
 	description: "string",
 	source: "Record<string, unknown>",
 	filter: "Record<string, unknown>",
-	expect: "\"exists\" | \"notExists\""
+	expect: "\"exists\" | \"notExists\"",
+	"object?": "string > 0"
 });
 const StepJson = type({
 	description: "string",
@@ -1894,7 +1895,8 @@ function deserializeCheck(json) {
 		description: data.description,
 		source: deserializeInspectionCommand(data.source),
 		filter: deserializeFilterExpr(data.filter),
-		expect: data.expect
+		expect: data.expect,
+		...ifDefined("object", data.object)
 	};
 }
 function deserializeStep(json) {
@@ -1950,6 +1952,26 @@ function serializeMongoOps(ops) {
 	return JSON.stringify(ops, null, 2);
 }
 const READ_ONLY_CHECK_COMMAND_KINDS = /* @__PURE__ */ new Set(["aggregate", "rawAggregate"]);
+const CHANGED_DOCUMENT_COUNTS = [
+	"insertedCount",
+	"modifiedCount",
+	"upsertedCount",
+	"deletedCount"
+];
+/** Whether a write command's result row says it changed no document: every count it carries is zero. */
+function reportsNoChangedDocuments(row) {
+	if (typeof row !== "object" || row === null) return false;
+	const counts = CHANGED_DOCUMENT_COUNTS.map((field) => Reflect.get(row, field)).filter((count) => count !== void 0);
+	return counts.length > 0 && counts.every((count) => count === 0);
+}
+function failedCheckOf(operationId, phase, check) {
+	return {
+		operationId,
+		phase,
+		description: check.description,
+		...ifDefined("expectation", check.object === void 0 ? void 0 : check.expect === "exists" ? expectPresent(check.object) : expectAbsent(check.object))
+	};
+}
 function runnerFailure(code, summary, options) {
 	return notOk(migrationRunnerFailure(code, summary, options));
 }
@@ -1968,7 +1990,7 @@ function renameOverwriteRefusal(op) {
 	const match = source instanceof RawAggregateCommand ? Reflect.get(source.pipeline[0] ?? {}, "$match") : void 0;
 	const find = `db.getCollection(${JSON.stringify(rewrite.collection)}).find(${JSON.stringify(match ?? {})})`;
 	return runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${op.id} stopped: some documents in collection ${rewrite.collection} already hold ${to} as well as ${rewrite.field}`, {
-		why: `Renaming ${rewrite.field} to ${to} would overwrite their ${to}. Find them with ${find} in mongosh, and move or remove one of the two values in each. Nothing was renamed. The operations before this one in the plan already ran, such as dropping an index on ${rewrite.field}; once the documents are fixed, run the command again and the plan finishes from here.`,
+		why: `Renaming ${rewrite.field} to ${to} would overwrite their ${to}. Find them with ${find} in mongosh, and move or remove one of the two values in each. Nothing was renamed. Once the documents are fixed, run the command again; operations that already ran are skipped.`,
 		meta: {
 			operationId: op.id,
 			name: op.name
@@ -2012,6 +2034,17 @@ var MongoMigrationRunner = class {
 		this.deps = deps;
 	}
 	async execute(options) {
+		let changedDatabase = false;
+		const result = await this.apply(options, () => {
+			changedDatabase = true;
+		});
+		return result.ok ? ok({
+			...result.value,
+			changedDatabase
+		}) : notOk(withDatabaseUnchanged(result.failure, options.databaseChangedBefore !== true && !changedDatabase));
+	}
+	/** Applies the plan, calling `wrote` after each command that changes the database. */
+	async apply(options, wrote) {
 		const { inspectionExecutor, adapter, driver, executeDdl, markerOps } = this.deps;
 		const operations = deserializeMongoOps(blindCast(options.plan.operations));
 		const space = options.plan.spaceId ?? APP_SPACE_ID;
@@ -2030,7 +2063,7 @@ var MongoMigrationRunner = class {
 			options.callbacks?.onOperationStart?.(operation);
 			try {
 				if (isMongoDmlOperation(operation)) {
-					const result = await this.executeDmlOperation(operation, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks);
+					const result = await this.executeDmlOperation(operation, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks, wrote);
 					if (result.failure) return result.failure;
 					if (result.executed) operationsExecuted += 1;
 					continue;
@@ -2039,22 +2072,31 @@ var MongoMigrationRunner = class {
 					if (await this.allChecksSatisfied(operation.postcheck, inspectionExecutor, filterEvaluator)) continue;
 				}
 				if (runPrechecks) {
-					const failed = await this.firstFailingCheck(operation.precheck, inspectionExecutor, filterEvaluator);
-					if (failed !== void 0) {
-						const failedCheck = {
-							operationId: operation.id,
-							phase: "precheck",
-							description: failed.description
-						};
-						return renameTargetExistsRefusal(operation, failed) ?? runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${operation.id} failed during precheck: ${failed.description}`, {
+					const failing = await this.firstFailingCheck(operation.precheck, inspectionExecutor, filterEvaluator);
+					if (failing !== void 0) {
+						const failedCheck = failedCheckOf(operation.id, "precheck", failing);
+						return renameTargetExistsRefusal(operation, failing) ?? runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${operation.id} failed during precheck: ${failing.description}`, {
 							why: failedPrecheckWhy(failedCheck),
 							meta: { failedCheck }
 						});
 					}
 				}
-				for (const step of operation.execute) await executeDdl(step.command);
+				for (const step of operation.execute) {
+					await executeDdl(step.command);
+					wrote();
+				}
 				if (runPostchecks) {
-					if (!await this.evaluateChecks(operation.postcheck, inspectionExecutor, filterEvaluator)) return runnerFailure("MIGRATION.POSTCHECK_FAILED", `Operation ${operation.id} failed during postcheck`, { meta: { operationId: operation.id } });
+					const failing = await this.firstFailingCheck(operation.postcheck, inspectionExecutor, filterEvaluator);
+					if (failing !== void 0) {
+						const failedCheck = failedCheckOf(operation.id, "postcheck", failing);
+						return runnerFailure("MIGRATION.POSTCHECK_FAILED", `Operation ${operation.id} failed during postcheck: ${failing.description}`, {
+							why: failedPostcheckWhy(failedCheck),
+							meta: {
+								operationId: operation.id,
+								failedCheck
+							}
+						});
+					}
 				}
 				operationsExecuted += 1;
 			} finally {
@@ -2100,6 +2142,7 @@ var MongoMigrationRunner = class {
 				profileHash,
 				invariants: incomingInvariants
 			});
+			wrote();
 			await this.recordLedgerEntries(markerOps, space, options);
 		}
 		return ok({
@@ -2126,7 +2169,7 @@ var MongoMigrationRunner = class {
 			});
 		}
 	}
-	async executeDmlOperation(op, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks) {
+	async executeDmlOperation(op, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks, wrote) {
 		if (runPostchecks && runIdempotency && op.postcheck.length > 0) {
 			if (await this.evaluateDmlChecks(op.postcheck, adapter, driver, filterEvaluator)) return { executed: false };
 		}
@@ -2142,7 +2185,11 @@ var MongoMigrationRunner = class {
 		for (const plan of op.run) {
 			const wireCommand = await adapter.lower(plan, {});
 			try {
-				for await (const _ of driver.execute(wireCommand));
+				let reportedNoChange = false;
+				let reportedChange = false;
+				for await (const row of driver.execute(wireCommand)) if (reportsNoChangedDocuments(row)) reportedNoChange = true;
+				else reportedChange = true;
+				if (reportedChange || !reportedNoChange) wrote();
 			} catch (error) {
 				const refusal = bypassValidationRefusal(op, plan, error);
 				if (refusal === void 0) throw error;
@@ -2331,6 +2378,7 @@ const mongoTargetDescriptor = {
 			return { async execute({ driver, perSpaceOptions }) {
 				const contracts = perSpaceOptions.map((opts) => blindCast(opts.destinationContract));
 				const perSpaceResults = [];
+				let changedDatabase = false;
 				for (let i = 0; i < perSpaceOptions.length; i++) {
 					const spaceOptions = perSpaceOptions[i];
 					if (!spaceOptions) continue;
@@ -2339,12 +2387,15 @@ const mongoTargetDescriptor = {
 					const { space, ...runnerOptions } = spaceOptions;
 					const result = await runMongo(driver, {
 						...runnerOptions,
-						scopeVerifyResult
+						scopeVerifyResult,
+						databaseChangedBefore: changedDatabase
 					});
 					if (!result.ok) return notOk(withFailingSpace(result.failure, space));
+					const { changedDatabase: spaceChanged, ...value } = result.value;
+					changedDatabase ||= spaceChanged;
 					perSpaceResults.push({
 						space,
-						value: result.value
+						value
 					});
 				}
 				return ok({ perSpaceResults });
@@ -2364,4 +2415,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-zGCK2Hnz.mjs.map
+//# sourceMappingURL=control-CYS8H_t4.mjs.map