@nullix/zod-mongoose-studio 1.0.13 → 2.1.0

package/.output/server/node_modules/mongodb/lib/mongo_client.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoClient = exports.ServerApiVersion = void 0;
 const fs_1 = require("fs");
+const _1 = require(".");
 const bson_1 = require("./bson");
 const change_stream_1 = require("./change_stream");
 const mongo_credentials_1 = require("./cmap/auth/mongo_credentials");
 const providers_1 = require("./cmap/auth/providers");
 const client_metadata_1 = require("./cmap/handshake/client_metadata");
-const responses_1 = require("./cmap/wire_protocol/responses");
 const connection_string_1 = require("./connection_string");
 const constants_1 = require("./constants");
 const db_1 = require("./db");
@@ -16,10 +16,9 @@ const mongo_client_auth_providers_1 = require("./mongo_client_auth_providers");
 const mongo_logger_1 = require("./mongo_logger");
 const mongo_types_1 = require("./mongo_types");
 const executor_1 = require("./operations/client_bulk_write/executor");
+const end_sessions_1 = require("./operations/end_sessions");
 const execute_operation_1 = require("./operations/execute_operation");
-const operation_1 = require("./operations/operation");
 const read_preference_1 = require("./read_preference");
-const resource_management_1 = require("./resource_management");
 const server_selection_1 = require("./sdam/server_selection");
 const topology_1 = require("./sdam/topology");
 const sessions_1 = require("./sessions");
@@ -101,8 +100,11 @@ class MongoClient extends mongo_types_1.TypedEventEmitter {
         };
         this.checkForNonGenuineHosts();
     }
-    /** @internal */
-    async asyncDispose() {
+    /**
+     * @experimental
+     * An alias for {@link MongoClient.close|MongoClient.close()}.
+     */
+    async [Symbol.asyncDispose]() {
         await this.close();
     }
     /**
@@ -114,8 +116,7 @@ class MongoClient extends mongo_types_1.TypedEventEmitter {
         if (isDuplicateDriverInfo)
             return;
         this.driverInfoList.push(driverInfo);
-        this.options.metadata = (0, client_metadata_1.makeClientMetadata)(this.driverInfoList, this.options);
-        this.options.extendedMetadata = (0, client_metadata_1.addContainerMetadata)(this.options.metadata)
+        this.options.metadata = (0, client_metadata_1.makeClientMetadata)(this.driverInfoList, this.options)
             .then(undefined, utils_1.squashError)
             .then(result => result ?? {}); // ensure Promise<Document>
     }
@@ -178,20 +179,13 @@ class MongoClient extends mongo_types_1.TypedEventEmitter {
         return await new executor_1.ClientBulkWriteExecutor(this, models, (0, utils_1.resolveOptions)(this, options)).execute();
     }
     /**
-     * Connect to MongoDB using a url
+     * An optional method to verify a handful of assumptions that are generally useful at application boot-time before using a MongoClient.
+     * For detailed information about the connect process see the MongoClient.connect static method documentation.
      *
-     * @remarks
-     * Calling `connect` is optional since the first operation you perform will call `connect` if it's needed.
-     * `timeoutMS` will bound the time any operation can take before throwing a timeout error.
-     * However, when the operation being run is automatically connecting your `MongoClient` the `timeoutMS` will not apply to the time taken to connect the MongoClient.
-     * This means the time to setup the `MongoClient` does not count against `timeoutMS`.
-     * If you are using `timeoutMS` we recommend connecting your client explicitly in advance of any operation to avoid this inconsistent execution time.
+     * @param url - The MongoDB connection string (supports `mongodb://` and `mongodb+srv://` schemes)
+     * @param options - Optional configuration options for the client
      *
-     * @remarks
-     * The driver will look up corresponding SRV and TXT records if the connection string starts with `mongodb+srv://`.
-     * If those look ups throw a DNS Timeout error, the driver will retry the look up once.
-     *
-     * @see docs.mongodb.org/manual/reference/connection-string/
+     * @see https://www.mongodb.com/docs/manual/reference/connection-string/
      */
     async connect() {
         if (this.connectionLock) {
@@ -355,44 +349,10 @@ class MongoClient extends mongo_types_1.TypedEventEmitter {
         if (this.topology == null) {
             return;
         }
-        // If we would attempt to select a server and get nothing back we short circuit
-        // to avoid the server selection timeout.
-        const selector = (0, server_selection_1.readPreferenceServerSelector)(read_preference_1.ReadPreference.primaryPreferred);
-        const topologyDescription = this.topology.description;
-        const serverDescriptions = Array.from(topologyDescription.servers.values());
-        const servers = selector(topologyDescription, serverDescriptions);
-        if (servers.length !== 0) {
-            const endSessions = Array.from(this.s.sessionPool.sessions, ({ id }) => id);
-            if (endSessions.length !== 0) {
-                try {
-                    class EndSessionsOperation extends operation_1.AbstractOperation {
-                        constructor() {
-                            super(...arguments);
-                            this.ns = utils_1.MongoDBNamespace.fromString('admin.$cmd');
-                            this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse;
-                        }
-                        buildCommand(_connection, _session) {
-                            return {
-                                endSessions
-                            };
-                        }
-                        buildOptions(timeoutContext) {
-                            return {
-                                timeoutContext,
-                                readPreference: read_preference_1.ReadPreference.primaryPreferred,
-                                noResponse: true
-                            };
-                        }
-                        get commandName() {
-                            return 'endSessions';
-                        }
-                    }
-                    await (0, execute_operation_1.executeOperation)(this, new EndSessionsOperation());
-                }
-                catch (error) {
-                    (0, utils_1.squashError)(error);
-                }
-            }
+        const supportsSessions = this.topology.description.type === _1.TopologyType.LoadBalanced ||
+            this.topology.description.logicalSessionTimeoutMinutes != null;
+        if (supportsSessions) {
+            await endSessions(this, this.topology);
         }
         // clear out references to old topology
         const topology = this.topology;
@@ -402,6 +362,24 @@ class MongoClient extends mongo_types_1.TypedEventEmitter {
         if (encrypter) {
             await encrypter.close(this);
         }
+        async function endSessions(client, { description: topologyDescription }) {
+            // If we would attempt to select a server and get nothing back we short circuit
+            // to avoid the server selection timeout.
+            const selector = (0, server_selection_1.readPreferenceServerSelector)(read_preference_1.ReadPreference.primaryPreferred);
+            const serverDescriptions = Array.from(topologyDescription.servers.values());
+            const servers = selector(topologyDescription, serverDescriptions, new server_selection_1.DeprioritizedServers());
+            if (servers.length !== 0) {
+                const endSessions = Array.from(client.s.sessionPool.sessions, ({ id }) => id);
+                if (endSessions.length !== 0) {
+                    try {
+                        await (0, execute_operation_1.executeOperation)(client, new end_sessions_1.EndSessionsOperation(endSessions));
+                    }
+                    catch (error) {
+                        (0, utils_1.squashError)(error);
+                    }
+                }
+            }
+        }
     }
     /**
      * Create a new Db instance sharing the current socket connections.
@@ -423,21 +401,35 @@ class MongoClient extends mongo_types_1.TypedEventEmitter {
         return db;
     }
     /**
-     * Connect to MongoDB using a url
+     * Creates a new MongoClient instance and immediately connects it to MongoDB.
+     * This convenience method combines `new MongoClient(url, options)` and `client.connect()` in a single step.
+     *
+     * Connect can be helpful to detect configuration issues early by validating:
+     * - **DNS Resolution**: Verifies that SRV records and hostnames in the connection string resolve DNS entries
+     * - **Network Connectivity**: Confirms that host addresses are reachable and ports are open
+     * - **TLS Configuration**: Validates SSL/TLS certificates, CA files, and encryption settings are correct
+     * - **Authentication**: Verifies that provided credentials are valid
+     * - **Server Compatibility**: Ensures the MongoDB server version is supported by this driver version
+     * - **Load Balancer Setup**: For load-balanced deployments, confirms the service is properly configured
+     *
+     * @returns A promise that resolves to the same MongoClient instance once connected
      *
      * @remarks
-     * Calling `connect` is optional since the first operation you perform will call `connect` if it's needed.
-     * `timeoutMS` will bound the time any operation can take before throwing a timeout error.
-     * However, when the operation being run is automatically connecting your `MongoClient` the `timeoutMS` will not apply to the time taken to connect the MongoClient.
-     * This means the time to setup the `MongoClient` does not count against `timeoutMS`.
-     * If you are using `timeoutMS` we recommend connecting your client explicitly in advance of any operation to avoid this inconsistent execution time.
+     * **Connection is Optional:** Calling `connect` is optional since any operation method (`find`, `insertOne`, etc.)
+     * will automatically perform these same validation steps if the client is not already connected.
+     * However, explicitly calling `connect` can make sense for:
+     * - **Fail-fast Error Detection**: Non-transient connection issues (hostname unresolved, port refused connection) are discovered immediately rather than during your first operation
+     * - **Predictable Performance**: Eliminates first connection overhead from your first database operation
      *
      * @remarks
-     * The programmatically provided options take precedence over the URI options.
+     * **Connection Pooling Impact:** Calling `connect` will populate the connection pool with one connection
+     * to a server selected by the client's configured `readPreference` (defaults to primary).
      *
      * @remarks
-     * The driver will look up corresponding SRV and TXT records if the connection string starts with `mongodb+srv://`.
-     * If those look ups throw a DNS Timeout error, the driver will retry the look up once.
+     * **Timeout Behavior:** When using `timeoutMS`, the connection establishment time does not count against
+     * the timeout for subsequent operations. This means `connect` runs without a `timeoutMS` limit, while
+     * your database operations will still respect the configured timeout. If you need predictable operation
+     * timing with `timeoutMS`, call `connect` explicitly before performing operations.
      *
      * @see https://www.mongodb.com/docs/manual/reference/connection-string/
      */
@@ -562,5 +554,4 @@ class MongoClient extends mongo_types_1.TypedEventEmitter {
     }
 }
 exports.MongoClient = MongoClient;
-(0, resource_management_1.configureResourceManagement)(MongoClient.prototype);
 //# sourceMappingURL=mongo_client.js.map

package/.output/server/node_modules/mongodb/lib/mongo_client_auth_providers.js

@@ -18,12 +18,6 @@ const AUTH_PROVIDERS = new Map([
         providers_1.AuthMechanism.MONGODB_AWS,
         ({ AWS_CREDENTIAL_PROVIDER }) => new mongodb_aws_1.MongoDBAWS(AWS_CREDENTIAL_PROVIDER)
     ],
-    [
-        providers_1.AuthMechanism.MONGODB_CR,
-        () => {
-            throw new error_1.MongoInvalidArgumentError('MONGODB-CR is no longer a supported auth mechanism in MongoDB 4.0+');
-        }
-    ],
     [providers_1.AuthMechanism.MONGODB_GSSAPI, () => new gssapi_1.GSSAPI()],
     [providers_1.AuthMechanism.MONGODB_OIDC, properties => new mongodb_oidc_1.MongoDBOIDC(getWorkflow(properties))],
     [providers_1.AuthMechanism.MONGODB_PLAIN, () => new plain_1.Plain()],

package/.output/server/node_modules/mongodb/lib/mongo_logger.js

@@ -5,6 +5,7 @@ exports.parseSeverityFromString = parseSeverityFromString;
 exports.createStdioLogger = createStdioLogger;
 exports.stringifyWithMaxLen = stringifyWithMaxLen;
 exports.defaultLogTransform = defaultLogTransform;
+const process = require("process");
 const util_1 = require("util");
 const bson_1 = require("./bson");
 const constants_1 = require("./constants");
@@ -84,11 +85,16 @@ function parseSeverityFromString(s) {
 /** @internal */
 function createStdioLogger(stream) {
     return {
-        write: (0, util_1.promisify)((log, cb) => {
-            const logLine = (0, util_1.inspect)(log, { compact: true, breakLength: Infinity });
-            stream.write(`${logLine}\n`, 'utf-8', cb);
-            return;
-        })
+        write: (log) => {
+            return new Promise((resolve, reject) => {
+                const logLine = (0, util_1.inspect)(log, { compact: true, breakLength: Infinity });
+                stream.write(`${logLine}\n`, 'utf-8', error => {
+                    if (error)
+                        return reject(error);
+                    resolve(true);
+                });
+            });
+        }
     };
 }
 /**

package/.output/server/node_modules/mongodb/lib/mongo_types.js

@@ -44,8 +44,7 @@ class TypedEventEmitter extends events_1.EventEmitter {
 }
 exports.TypedEventEmitter = TypedEventEmitter;
 /**
- * @public
- * @deprecated Will be removed in favor of `AbortSignal` in the next major release.
+ * @internal
  */
 class CancellationToken extends TypedEventEmitter {
     constructor(...args) {

package/.output/server/node_modules/mongodb/lib/operations/aggregate.js

@@ -32,9 +32,6 @@ class AggregateOperation extends command_1.CommandOperation {
         if (!this.hasWriteStage) {
             delete this.options.writeConcern;
         }
-        if (this.explain && this.writeConcern) {
-            throw new error_1.MongoInvalidArgumentError('Option "explain" cannot be used on an aggregate call with writeConcern');
-        }
         if (options?.cursor != null && typeof options.cursor !== 'object') {
             throw new error_1.MongoInvalidArgumentError('Cursor options must be an object');
         }

package/.output/server/node_modules/mongodb/lib/operations/create_collection.js

@@ -18,7 +18,6 @@ const ILLEGAL_COMMAND_FIELDS = new Set([
     'timeoutMS',
     'j',
     'fsync',
-    'autoIndexId',
     'pkFactory',
     'raw',
     'readPreference',

package/.output/server/node_modules/mongodb/lib/operations/drop.js

@@ -27,6 +27,13 @@ class DropCollectionOperation extends command_1.CommandOperation {
     handleOk(_response) {
         return true;
     }
+    handleError(error) {
+        if (!(error instanceof __1.MongoServerError))
+            throw error;
+        if (Number(error.code) !== error_1.MONGODB_ERROR_CODES.NamespaceNotFound)
+            throw error;
+        return false;
+    }
 }
 exports.DropCollectionOperation = DropCollectionOperation;
 async function dropCollections(db, name, options) {
@@ -58,15 +65,7 @@ async function dropCollections(db, name, options) {
         for (const collectionName of [escCollection, ecocCollection]) {
             // Drop auxilliary collections, ignoring potential NamespaceNotFound errors.
             const dropOp = new DropCollectionOperation(db, collectionName, options);
-            try {
-                await (0, execute_operation_1.executeOperation)(db.client, dropOp, timeoutContext);
-            }
-            catch (err) {
-                if (!(err instanceof __1.MongoServerError) ||
-                    err.code !== error_1.MONGODB_ERROR_CODES.NamespaceNotFound) {
-                    throw err;
-                }
-            }
+            await (0, execute_operation_1.executeOperation)(db.client, dropOp, timeoutContext);
         }
     }
     return await (0, execute_operation_1.executeOperation)(db.client, new DropCollectionOperation(db, name, options), timeoutContext);

package/.output/server/node_modules/mongodb/lib/operations/end_sessions.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndSessionsOperation = void 0;
+const responses_1 = require("../cmap/wire_protocol/responses");
+const command_1 = require("../operations/command");
+const read_preference_1 = require("../read_preference");
+const utils_1 = require("../utils");
+const operation_1 = require("./operation");
+class EndSessionsOperation extends command_1.CommandOperation {
+    constructor(sessions) {
+        super();
+        this.writeConcern = { w: 0 };
+        this.ns = utils_1.MongoDBNamespace.fromString('admin.$cmd');
+        this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse;
+        this.sessions = sessions;
+    }
+    buildCommandDocument(_connection, _session) {
+        return {
+            endSessions: this.sessions
+        };
+    }
+    buildOptions(timeoutContext) {
+        return {
+            timeoutContext,
+            readPreference: read_preference_1.ReadPreference.primaryPreferred
+        };
+    }
+    get commandName() {
+        return 'endSessions';
+    }
+}
+exports.EndSessionsOperation = EndSessionsOperation;
+(0, operation_1.defineAspects)(EndSessionsOperation, operation_1.Aspect.WRITE_OPERATION);
+//# sourceMappingURL=end_sessions.js.map

package/.output/server/node_modules/mongodb/lib/operations/execute_operation.js

@@ -2,13 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeOperation = executeOperation;
 exports.autoConnect = autoConnect;
+const promises_1 = require("timers/promises");
+const constants_1 = require("../cmap/wire_protocol/constants");
 const error_1 = require("../error");
 const read_preference_1 = require("../read_preference");
+const common_1 = require("../sdam/common");
 const server_selection_1 = require("../sdam/server_selection");
 const timeout_1 = require("../timeout");
 const utils_1 = require("../utils");
 const aggregate_1 = require("./aggregate");
 const operation_1 = require("./operation");
+const run_command_1 = require("./run_command");
 const MMAPv1_RETRY_WRITES_ERROR_CODE = error_1.MONGODB_ERROR_CODES.IllegalOperation;
 const MMAPv1_RETRY_WRITES_ERROR_MESSAGE = 'This MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string.';
 /**
@@ -23,7 +27,7 @@ const MMAPv1_RETRY_WRITES_ERROR_MESSAGE = 'This MongoDB deployment does not supp
  * The expectation is that this function:
  * - Connects the MongoClient if it has not already been connected, see {@link autoConnect}
  * - Creates a session if none is provided and cleans up the session it creates
- * - Tries an operation and retries under certain conditions, see {@link tryOperation}
+ * - Tries an operation and retries under certain conditions, see {@link executeOperationWithRetries}
  *
  * @typeParam T - The operation's type
  * @typeParam TResult - The type of the operation's result, calculated from T
@@ -50,7 +54,8 @@ async function executeOperation(client, operation, timeoutContext) {
     else if (session.hasEnded) {
         throw new error_1.MongoExpiredSessionError('Use of expired sessions is not permitted');
     }
-    else if (session.snapshotEnabled && !topology.capabilities.supportsSnapshotReads) {
+    else if (session.snapshotEnabled &&
+        (0, utils_1.maxWireVersion)(topology) < constants_1.MIN_SUPPORTED_SNAPSHOT_READS_WIRE_VERSION) {
         throw new error_1.MongoCompatibilityError('Snapshot reads require MongoDB 5.0 or later');
     }
     else if (session.client !== client) {
@@ -75,7 +80,7 @@ async function executeOperation(client, operation, timeoutContext) {
         timeoutMS: operation.options.timeoutMS
     });
     try {
-        return await tryOperation(operation, {
+        return await executeOperationWithRetries(operation, {
             topology,
             timeoutContext,
             session,
@@ -111,6 +116,10 @@ async function autoConnect(client) {
     }
     return client.topology;
 }
+/** @internal The base backoff duration in milliseconds */
+const BASE_BACKOFF_MS = 100;
+/** @internal The maximum backoff duration in milliseconds */
+const MAX_BACKOFF_MS = 10_000;
 /**
  * Executes an operation and retries as appropriate
  * @internal
@@ -128,8 +137,8 @@ async function autoConnect(client) {
  * @typeParam TResult - The type of the operation's result, calculated from T
  *
  * @param operation - The operation to execute
- * */
-async function tryOperation(operation, { topology, timeoutContext, session, readPreference }) {
+ */
+async function executeOperationWithRetries(operation, { topology, timeoutContext, session, readPreference }) {
     let selector;
     if (operation.hasAspect(operation_1.Aspect.MUST_SELECT_SAME_SERVER)) {
         // GetMore and KillCursor operations must always select the same server, but run through
@@ -149,7 +158,8 @@ async function tryOperation(operation, { topology, timeoutContext, session, read
         session,
         operationName: operation.commandName,
         timeoutContext,
-        signal: operation.options.signal
+        signal: operation.options.signal,
+        deprioritizedServers: new server_selection_1.DeprioritizedServers()
     });
     const hasReadAspect = operation.hasAspect(operation_1.Aspect.READ_OPERATION);
     const hasWriteAspect = operation.hasAspect(operation_1.Aspect.WRITE_OPERATION);
@@ -166,71 +176,137 @@ async function tryOperation(operation, { topology, timeoutContext, session, read
         operation.options.willRetryWrite = true;
         session.incrementTransactionNumber();
     }
-    const maxTries = willRetry ? (timeoutContext.csotEnabled() ? Infinity : 2) : 1;
-    let previousOperationError;
-    let previousServer;
-    for (let tries = 0; tries < maxTries; tries++) {
-        if (previousOperationError) {
-            if (hasWriteAspect && previousOperationError.code === MMAPv1_RETRY_WRITES_ERROR_CODE) {
+    const deprioritizedServers = new server_selection_1.DeprioritizedServers();
+    let maxAttempts = typeof operation.maxAttempts === 'number'
+        ? operation.maxAttempts
+        : willRetry
+            ? timeoutContext.csotEnabled()
+                ? Infinity
+                : 2
+            : 1;
+    let error = null;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        operation.attemptsMade = attempt + 1;
+        operation.server = server;
+        try {
+            try {
+                const result = await server.command(operation, timeoutContext);
+                return operation.handleOk(result);
+            }
+            catch (error) {
+                return operation.handleError(error);
+            }
+        }
+        catch (operationError) {
+            // Should never happen but if it does - propagate the error.
+            if (!(operationError instanceof error_1.MongoError))
+                throw operationError;
+            // Preserve the original error once a write has been performed.
+            // Only update to the latest error if no writes were performed.
+            if (error == null) {
+                error = operationError;
+            }
+            else {
+                if (!operationError.hasErrorLabel(error_1.MongoErrorLabel.NoWritesPerformed)) {
+                    error = operationError;
+                }
+            }
+            // Reset timeouts
+            timeoutContext.clear();
+            if (hasWriteAspect && operationError.code === MMAPv1_RETRY_WRITES_ERROR_CODE) {
                 throw new error_1.MongoServerError({
                     message: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
                     errmsg: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
-                    originalError: previousOperationError
+                    originalError: operationError
                 });
             }
-            if (operation.hasAspect(operation_1.Aspect.COMMAND_BATCHING) && !operation.canRetryWrite) {
-                throw previousOperationError;
+            if (!canRetry(operation, operationError)) {
+                throw error;
+            }
+            if (operationError.hasErrorLabel(error_1.MongoErrorLabel.SystemOverloadedError)) {
+                const maxOverloadAttempts = topology.s.options.maxAdaptiveRetries + 1;
+                maxAttempts = Math.min(maxOverloadAttempts, operation.maxAttempts ?? maxOverloadAttempts);
             }
-            if (hasWriteAspect && !(0, error_1.isRetryableWriteError)(previousOperationError))
-                throw previousOperationError;
-            if (hasReadAspect && !(0, error_1.isRetryableReadError)(previousOperationError)) {
-                throw previousOperationError;
+            if (attempt + 1 >= maxAttempts) {
+                throw error;
             }
-            if (previousOperationError instanceof error_1.MongoNetworkError &&
+            if (operationError instanceof error_1.MongoNetworkError &&
                 operation.hasAspect(operation_1.Aspect.CURSOR_CREATING) &&
                 session != null &&
                 session.isPinned &&
                 !session.inTransaction()) {
                 session.unpin({ force: true, forceClear: true });
             }
+            if (operationError.hasErrorLabel(error_1.MongoErrorLabel.SystemOverloadedError) &&
+                operation.hasAspect(operation_1.Aspect.CURSOR_CREATING) &&
+                session != null &&
+                session.isPinned &&
+                !session.inTransaction()) {
+                session.unpin({ force: true });
+            }
+            if (operationError.hasErrorLabel(error_1.MongoErrorLabel.SystemOverloadedError)) {
+                const backoffMS = Math.random() * Math.min(MAX_BACKOFF_MS, BASE_BACKOFF_MS * 2 ** attempt);
+                // if the backoff would exhaust the CSOT timeout, short-circuit.
+                if (timeoutContext.csotEnabled() && backoffMS > timeoutContext.remainingTimeMS) {
+                    throw error;
+                }
+                await (0, promises_1.setTimeout)(backoffMS);
+            }
+            if (topology.description.type === common_1.TopologyType.Sharded ||
+                (operationError.hasErrorLabel(error_1.MongoErrorLabel.SystemOverloadedError) &&
+                    topology.s.options.enableOverloadRetargeting)) {
+                deprioritizedServers.add(server.description);
+            }
             server = await topology.selectServer(selector, {
                 session,
                 operationName: operation.commandName,
-                previousServer,
+                deprioritizedServers,
                 signal: operation.options.signal
             });
-            if (hasWriteAspect && !(0, utils_1.supportsRetryableWrites)(server)) {
+            if (hasWriteAspect &&
+                !(0, utils_1.supportsRetryableWrites)(server) &&
+                !operationError.hasErrorLabel(error_1.MongoErrorLabel.SystemOverloadedError)) {
                 throw new error_1.MongoUnexpectedServerResponseError('Selected server does not support retryable writes');
             }
-        }
-        operation.server = server;
-        try {
-            // If tries > 0 and we are command batching we need to reset the batch.
-            if (tries > 0 && operation.hasAspect(operation_1.Aspect.COMMAND_BATCHING)) {
+            // Batched operations must reset the batch before retry,
+            // otherwise building a command will build the _next_ batch, not the current batch.
+            if (operation.hasAspect(operation_1.Aspect.COMMAND_BATCHING)) {
                 operation.resetBatch();
             }
-            try {
-                const result = await server.command(operation, timeoutContext);
-                return operation.handleOk(result);
+        }
+    }
+    throw (error ??
+        new error_1.MongoRuntimeError('Should never happen: operation execution loop terminated but no error was recorded.'));
+    function canRetry(operation, error) {
+        // SystemOverloadedError is retryable, but must respect retryReads/retryWrites settings
+        // Check topology options directly (not operation.canRetryRead/Write) because backpressure
+        // expands retry support beyond traditional retryable reads/writes
+        // NOTE: Unlike traditional retries, backpressure retries ARE allowed inside transactions
+        if (error.hasErrorLabel(error_1.MongoErrorLabel.SystemOverloadedError) &&
+            error.hasErrorLabel(error_1.MongoErrorLabel.RetryableError)) {
+            // runCommand requires BOTH retryReads and retryWrites to be enabled (per spec step 2.4)
+            if (operation instanceof run_command_1.RunCommandOperation) {
+                return topology.s.options.retryReads && topology.s.options.retryWrites;
             }
-            catch (error) {
-                return operation.handleError(error);
+            // Write-stage aggregates ($out/$merge) require retryWrites
+            if (operation instanceof aggregate_1.AggregateOperation && operation.hasWriteStage) {
+                return topology.s.options.retryWrites;
             }
+            // For other operations, check if retries are enabled based on operation type
+            const canRetryAsRead = hasReadAspect && topology.s.options.retryReads;
+            const canRetryAsWrite = hasWriteAspect && topology.s.options.retryWrites;
+            return canRetryAsRead || canRetryAsWrite;
         }
-        catch (operationError) {
-            if (!(operationError instanceof error_1.MongoError))
-                throw operationError;
-            if (previousOperationError != null &&
-                operationError.hasErrorLabel(error_1.MongoErrorLabel.NoWritesPerformed)) {
-                throw previousOperationError;
-            }
-            previousServer = server.description;
-            previousOperationError = operationError;
-            // Reset timeouts
-            timeoutContext.clear();
+        // run command is only retryable if we get retryable overload errors
+        if (operation instanceof run_command_1.RunCommandOperation) {
+            return false;
+        }
+        // batch operations are only retryable if the batch is retryable
+        if (operation.hasAspect(operation_1.Aspect.COMMAND_BATCHING)) {
+            return operation.canRetryWrite && (0, error_1.isRetryableWriteError)(error);
         }
+        return ((hasWriteAspect && willRetryWrite && (0, error_1.isRetryableWriteError)(error)) ||
+            (hasReadAspect && willRetryRead && (0, error_1.isRetryableReadError)(error)));
     }
-    throw (previousOperationError ??
-        new error_1.MongoRuntimeError('Tried to propagate retryability error, but no error was found.'));
 }
 //# sourceMappingURL=execute_operation.js.map

package/.output/server/node_modules/mongodb/lib/operations/operation.js

@@ -32,6 +32,7 @@ class AbstractOperation {
         this._session = options.session != null ? options.session : undefined;
         this.options = options;
         this.bypassPinningCheck = !!options.bypassPinningCheck;
+        this.attemptsMade = 0;
     }
     hasAspect(aspect) {
         const ctor = this.constructor;