@nullix/zod-mongoose-studio 1.0.13 → 2.1.0

package/.output/server/node_modules/mongodb/lib/sdam/topology.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerCapabilities = exports.Topology = void 0;
+exports.Topology = void 0;
 const connection_string_1 = require("../connection_string");
 const constants_1 = require("../constants");
 const error_1 = require("../error");
@@ -30,6 +30,28 @@ const stateTransition = (0, utils_1.makeStateMachine)({
  * @internal
  */
 class Topology extends mongo_types_1.TypedEventEmitter {
+    /** @event */
+    static { this.SERVER_OPENING = constants_1.SERVER_OPENING; }
+    /** @event */
+    static { this.SERVER_CLOSED = constants_1.SERVER_CLOSED; }
+    /** @event */
+    static { this.SERVER_DESCRIPTION_CHANGED = constants_1.SERVER_DESCRIPTION_CHANGED; }
+    /** @event */
+    static { this.TOPOLOGY_OPENING = constants_1.TOPOLOGY_OPENING; }
+    /** @event */
+    static { this.TOPOLOGY_CLOSED = constants_1.TOPOLOGY_CLOSED; }
+    /** @event */
+    static { this.TOPOLOGY_DESCRIPTION_CHANGED = constants_1.TOPOLOGY_DESCRIPTION_CHANGED; }
+    /** @event */
+    static { this.ERROR = constants_1.ERROR; }
+    /** @event */
+    static { this.OPEN = constants_1.OPEN; }
+    /** @event */
+    static { this.CONNECT = constants_1.CONNECT; }
+    /** @event */
+    static { this.CLOSE = constants_1.CLOSE; }
+    /** @event */
+    static { this.TIMEOUT = constants_1.TIMEOUT; }
     /**
      * @param seedlist - a list of HostAddress instances to connect to
      */
@@ -142,9 +164,6 @@ class Topology extends mongo_types_1.TypedEventEmitter {
     get serverApi() {
         return this.s.options.serverApi;
     }
-    get capabilities() {
-        return new ServerCapabilities(this.lastHello());
-    }
     /** Initiate server connect */
     async connect(options) {
         this.connectionLock ??= this._connect(options);
@@ -194,12 +213,13 @@ class Topology extends mongo_types_1.TypedEventEmitter {
         const selectServerOptions = {
             operationName: 'handshake',
             ...options,
-            timeoutContext
+            timeoutContext,
+            deprioritizedServers: new server_selection_1.DeprioritizedServers()
         };
         try {
             const server = await this.selectServer((0, server_selection_1.readPreferenceServerSelector)(readPreference), selectServerOptions);
             const skipPingOnConnect = this.s.options.__skipPingOnConnect === true;
-            if (!skipPingOnConnect && this.s.credentials) {
+            if (!skipPingOnConnect) {
                 const connection = await server.pool.checkOut({ timeoutContext: timeoutContext });
                 server.pool.checkIn(connection);
                 stateTransition(this, common_1.STATE_CONNECTED);
@@ -288,8 +308,9 @@ class Topology extends mongo_types_1.TypedEventEmitter {
             if (this.client.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, mongo_logger_1.SeverityLevel.DEBUG)) {
                 this.client.mongoLogger?.debug(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, new server_selection_events_1.ServerSelectionSucceededEvent(selector, this.description, transaction.server.pool.address, options.operationName));
             }
-            if (options.timeoutContext?.clearServerSelectionTimeout)
+            if (!options.timeoutContext || options.timeoutContext.clearServerSelectionTimeout) {
                 timeout?.clear();
+            }
             return transaction.server;
         }
         const { promise: serverPromise, resolve, reject } = (0, utils_1.promiseWithResolvers)();
@@ -301,10 +322,10 @@ class Topology extends mongo_types_1.TypedEventEmitter {
             resolve,
             reject,
             cancelled: false,
-            startTime: (0, utils_1.now)(),
+            startTime: (0, utils_1.processTimeMS)(),
             operationName: options.operationName,
             waitingLogged: false,
-            previousServer: options.previousServer
+            deprioritizedServers: options.deprioritizedServers
         };
         const abortListener = (0, utils_1.addAbortListener)(options.signal, function () {
             waitQueueMember.cancelled = true;
@@ -340,8 +361,9 @@ class Topology extends mongo_types_1.TypedEventEmitter {
         }
         finally {
             abortListener?.[utils_1.kDispose]();
-            if (options.timeoutContext?.clearServerSelectionTimeout)
+            if (!options.timeoutContext || options.timeoutContext.clearServerSelectionTimeout) {
                 timeout?.clear();
+            }
         }
     }
     /**
@@ -406,9 +428,6 @@ class Topology extends mongo_types_1.TypedEventEmitter {
         if (typeof callback === 'function')
             callback(undefined, true);
     }
-    get clientMetadata() {
-        return this.s.options.metadata;
-    }
     isConnected() {
         return this.s.state === common_1.STATE_CONNECTED;
     }
@@ -440,28 +459,6 @@ class Topology extends mongo_types_1.TypedEventEmitter {
     }
 }
 exports.Topology = Topology;
-/** @event */
-Topology.SERVER_OPENING = constants_1.SERVER_OPENING;
-/** @event */
-Topology.SERVER_CLOSED = constants_1.SERVER_CLOSED;
-/** @event */
-Topology.SERVER_DESCRIPTION_CHANGED = constants_1.SERVER_DESCRIPTION_CHANGED;
-/** @event */
-Topology.TOPOLOGY_OPENING = constants_1.TOPOLOGY_OPENING;
-/** @event */
-Topology.TOPOLOGY_CLOSED = constants_1.TOPOLOGY_CLOSED;
-/** @event */
-Topology.TOPOLOGY_DESCRIPTION_CHANGED = constants_1.TOPOLOGY_DESCRIPTION_CHANGED;
-/** @event */
-Topology.ERROR = constants_1.ERROR;
-/** @event */
-Topology.OPEN = constants_1.OPEN;
-/** @event */
-Topology.CONNECT = constants_1.CONNECT;
-/** @event */
-Topology.CLOSE = constants_1.CLOSE;
-/** @event */
-Topology.TIMEOUT = constants_1.TIMEOUT;
 /** Destroys a server, and removes all event listeners from the instance */
 function closeServer(server, topology) {
     for (const event of constants_1.LOCAL_SERVER_EVENTS) {
@@ -585,9 +582,9 @@ function processWaitQueue(topology) {
         let selectedDescriptions;
         try {
             const serverSelector = waitQueueMember.serverSelector;
-            const previousServer = waitQueueMember.previousServer;
+            const deprioritizedServers = waitQueueMember.deprioritizedServers;
             selectedDescriptions = serverSelector
-                ? serverSelector(topology.description, serverDescriptions, previousServer ? [previousServer] : [])
+                ? serverSelector(topology.description, serverDescriptions, deprioritizedServers)
                 : serverDescriptions;
         }
         catch (selectorError) {
@@ -602,7 +599,8 @@ function processWaitQueue(topology) {
             if (!waitQueueMember.waitingLogged) {
                 if (topology.client.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, mongo_logger_1.SeverityLevel.INFORMATIONAL)) {
                     topology.client.mongoLogger?.info(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, new server_selection_events_1.WaitingForSuitableServerEvent(waitQueueMember.serverSelector, topology.description, topology.s.serverSelectionTimeoutMS !== 0
-                        ? topology.s.serverSelectionTimeoutMS - ((0, utils_1.now)() - waitQueueMember.startTime)
+                        ? topology.s.serverSelectionTimeoutMS -
+                            ((0, utils_1.processTimeMS)() - waitQueueMember.startTime)
                         : -1, waitQueueMember.operationName));
                 }
                 waitQueueMember.waitingLogged = true;
@@ -642,7 +640,7 @@ function processWaitQueue(topology) {
     if (topology.waitQueue.length > 0) {
         // ensure all server monitors attempt monitoring soon
         for (const [, server] of topology.s.servers) {
-            process.nextTick(function scheduleServerCheck() {
+            queueMicrotask(function scheduleServerCheck() {
                 return server.requestCheck();
             });
         }
@@ -653,42 +651,4 @@ function isStaleServerDescription(topologyDescription, incomingServerDescription
     const currentTopologyVersion = currentServerDescription?.topologyVersion;
     return ((0, server_description_1.compareTopologyVersion)(currentTopologyVersion, incomingServerDescription.topologyVersion) > 0);
 }
-/**
- * @public
- * @deprecated This class will be removed as dead code in the next major version.
- */
-class ServerCapabilities {
-    constructor(hello) {
-        this.minWireVersion = hello.minWireVersion || 0;
-        this.maxWireVersion = hello.maxWireVersion || 0;
-    }
-    get hasAggregationCursor() {
-        return true;
-    }
-    get hasWriteCommands() {
-        return true;
-    }
-    get hasTextSearch() {
-        return true;
-    }
-    get hasAuthCommands() {
-        return true;
-    }
-    get hasListCollectionsCommand() {
-        return true;
-    }
-    get hasListIndexesCommand() {
-        return true;
-    }
-    get supportsSnapshotReads() {
-        return this.maxWireVersion >= 13;
-    }
-    get commandsTakeWriteConcern() {
-        return true;
-    }
-    get commandsTakeCollation() {
-        return true;
-    }
-}
-exports.ServerCapabilities = ServerCapabilities;
 //# sourceMappingURL=topology.js.map

package/.output/server/node_modules/mongodb/lib/sdam/topology_description.js

@@ -136,7 +136,7 @@ class TopologyDescription {
         const serverDescriptions = new Map(this.servers);
         // update common wire version
         if (serverDescription.maxWireVersion !== 0) {
-            if (commonWireVersion == null) {
+            if (commonWireVersion === 0) {
                 commonWireVersion = serverDescription.maxWireVersion;
             }
             else {

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

@@ -4,6 +4,7 @@ exports.ServerSessionPool = exports.ServerSession = exports.ClientSession = void
 exports.maybeClearPinnedConnection = maybeClearPinnedConnection;
 exports.applySession = applySession;
 exports.updateSessionFromResponse = updateSessionFromResponse;
+const promises_1 = require("timers/promises");
 const bson_1 = require("./bson");
 const metrics_1 = require("./cmap/metrics");
 const constants_1 = require("./constants");
@@ -13,7 +14,6 @@ const execute_operation_1 = require("./operations/execute_operation");
 const run_command_1 = require("./operations/run_command");
 const read_concern_1 = require("./read_concern");
 const read_preference_1 = require("./read_preference");
-const resource_management_1 = require("./resource_management");
 const common_1 = require("./sdam/common");
 const timeout_1 = require("./timeout");
 const transactions_1 = require("./transactions");
@@ -146,8 +146,11 @@ class ClientSession extends mongo_types_1.TypedEventEmitter {
             maybeClearPinnedConnection(this, { force: true, ...options });
         }
     }
-    /** @internal */
-    async asyncDispose() {
+    /**
+     * @experimental
+     * An alias for {@link ClientSession.endSession|ClientSession.endSession()}.
+     */
+    async [Symbol.asyncDispose]() {
         await this.endSession({ force: true });
     }
     /**
@@ -198,7 +201,7 @@ class ClientSession extends mongo_types_1.TypedEventEmitter {
         if (this.id == null || session.id == null) {
             return false;
         }
-        return utils_1.ByteUtils.equals(this.id.id.buffer, session.id.id.buffer);
+        return bson_1.ByteUtils.equals(this.id.id.buffer, session.id.id.buffer);
     }
     /**
      * Increment the transaction number on the internal ServerSession
@@ -285,7 +288,11 @@ class ClientSession extends mongo_types_1.TypedEventEmitter {
             else {
                 const wcKeys = Object.keys(wc);
                 if (wcKeys.length > 2 || (!wcKeys.includes('wtimeoutMS') && !wcKeys.includes('wTimeoutMS')))
-                    // if the write concern was specified with wTimeoutMS, then we set both wtimeoutMS and wTimeoutMS, guaranteeing at least two keys, so if we have more than two keys, then we can automatically assume that we should add the write concern to the command. If it has 2 or fewer keys, we need to check that those keys aren't the wtimeoutMS or wTimeoutMS options before we add the write concern to the command
+                    // if the write concern was specified with wTimeoutMS, then we set both wtimeoutMS
+                    // and wTimeoutMS, guaranteeing at least two keys, so if we have more than two keys,
+                    // then we can automatically assume that we should add the write concern to the command.
+                    // If it has 2 or fewer keys, we need to check that those keys aren't the wtimeoutMS
+                    // or wTimeoutMS options before we add the write concern to the command
                     write_concern_1.WriteConcern.apply(command, { ...wc, wtimeoutMS: undefined });
             }
         }
@@ -308,6 +315,7 @@ class ClientSession extends mongo_types_1.TypedEventEmitter {
             readPreference: read_preference_1.ReadPreference.primary,
             bypassPinningCheck: true
         });
+        operation.maxAttempts = this.clientOptions.maxAdaptiveRetries + 1;
         const timeoutContext = this.timeoutContext ??
             (typeof timeoutMS === 'number'
                 ? timeout_1.TimeoutContext.create({
@@ -323,17 +331,23 @@ class ClientSession extends mongo_types_1.TypedEventEmitter {
         }
         catch (firstCommitError) {
             this.commitAttempted = true;
+            const remainingAttempts = this.clientOptions.maxAdaptiveRetries + 1 - operation.attemptsMade;
+            if (remainingAttempts <= 0) {
+                throw firstCommitError;
+            }
             if (firstCommitError instanceof error_1.MongoError && (0, error_1.isRetryableWriteError)(firstCommitError)) {
                 // SPEC-1185: apply majority write concern when retrying commitTransaction
                 write_concern_1.WriteConcern.apply(command, { wtimeoutMS: 10000, ...wc, w: 'majority' });
                 // per txns spec, must unpin session in this case
                 this.unpin({ force: true });
                 try {
-                    await (0, execute_operation_1.executeOperation)(this.client, new run_command_1.RunCommandOperation(new utils_1.MongoDBNamespace('admin'), command, {
+                    const op = new run_command_1.RunCommandOperation(new utils_1.MongoDBNamespace('admin'), command, {
                         session: this,
                         readPreference: read_preference_1.ReadPreference.primary,
                         bypassPinningCheck: true
-                    }), timeoutContext);
+                    });
+                    op.maxAttempts = remainingAttempts;
+                    await (0, execute_operation_1.executeOperation)(this.client, op, timeoutContext);
                     return;
                 }
                 catch (retryCommitError) {
@@ -479,7 +493,7 @@ class ClientSession extends mongo_types_1.TypedEventEmitter {
      * @returns A raw command response or undefined
      */
     async withTransaction(fn, options) {
-        const MAX_TIMEOUT = 120000;
+        const MAX_TIMEOUT = 120_000;
         const timeoutMS = options?.timeoutMS ?? this.timeoutMS ?? null;
         this.timeoutContext =
             timeoutMS != null
@@ -489,71 +503,139 @@ class ClientSession extends mongo_types_1.TypedEventEmitter {
                     socketTimeoutMS: this.clientOptions.socketTimeoutMS
                 })
                 : null;
-        const startTime = this.timeoutContext?.csotEnabled() ? this.timeoutContext.start : (0, utils_1.now)();
+        // 1. Define the following:
+        // 1.1 Record the current monotonic time, which will be used to enforce the 120-second / CSOT timeout before later retry attempts.
+        // 1.2 Set `transactionAttempt` to `0`.
+        // 1.3 Set `TIMEOUT_MS` to be `timeoutMS` if given, otherwise MAX_TIMEOUT (120-seconds).
+        // Timeout Error propagation
+        // When the previously encountered error needs to be propagated because there is no more time for another attempt,
+        // and it is not already a timeout error, then:
+        //  - A timeout error MUST be propagated instead. It MUST expose the previously encountered error as specified in
+        //    the "Errors" section of the CSOT specification.
+        //  - If exposing the previously encountered error from a timeout error is impossible in a driver, then the driver
+        //    is exempt from the requirement and MUST propagate the previously encountered error as is. The timeout error
+        //    MUST copy all error labels from the previously encountered error.
+        // The spec describes timeout checks as "elapsed time < TIMEOUT_MS" (where elapsed = now - start).
+        // We precompute `deadline = now + remainingTimeMS` so each check becomes simply `now < deadline`.
+        const csotEnabled = !!this.timeoutContext?.csotEnabled();
+        const remainingTimeMS = this.timeoutContext?.csotEnabled()
+            ? this.timeoutContext.remainingTimeMS
+            : MAX_TIMEOUT;
+        const deadline = (0, utils_1.processTimeMS)() + remainingTimeMS;
         let committed = false;
         let result;
+        let lastError = null;
         try {
-            while (!committed) {
-                this.startTransaction(options); // may throw on error
+            retryTransaction: for (let transactionAttempt = 0, isRetry = false; !committed; ++transactionAttempt, isRetry = transactionAttempt > 0) {
+                // 2. If `transactionAttempt` > 0:
+                if (isRetry) {
+                    // 2.1 Calculate backoffMS to be jitter * min(BACKOFF_INITIAL * 1.5 ** (transactionAttempt - 1), BACKOFF_MAX).
+                    //  If elapsed time + backoffMS > TIMEOUT_MS, then propagate the previously encountered error to the caller of
+                    //  withTransaction as per timeout error propagation and return immediately. Otherwise, sleep for backoffMS.
+                    //  2.1.1 jitter is a random float between [0, 1), optionally including 1, depending on what is most natural
+                    //    for the given driver language.
+                    //  2.1.2 transactionAttempt is the variable defined in step 1.
+                    //  2.1.3 BACKOFF_INITIAL is 5ms
+                    //  2.1.4 BACKOFF_MAX is 500ms
+                    const BACKOFF_INITIAL_MS = 5;
+                    const BACKOFF_MAX_MS = 500;
+                    const BACKOFF_GROWTH = 1.5;
+                    const jitter = Math.random();
+                    const backoffMS = jitter *
+                        Math.min(BACKOFF_INITIAL_MS * BACKOFF_GROWTH ** (transactionAttempt - 1), BACKOFF_MAX_MS);
+                    if ((0, utils_1.processTimeMS)() + backoffMS >= deadline) {
+                        throw makeTimeoutError(lastError ??
+                            new error_1.MongoRuntimeError(`Transaction retry did not record an error: should never occur. Please file a bug.`), csotEnabled);
+                    }
+                    await (0, promises_1.setTimeout)(backoffMS);
+                }
+                // 3. Invoke startTransaction on the session and increment transactionAttempt. If TransactionOptions were
+                // specified in the call to withTransaction, those MUST be used for startTransaction. Note that
+                // ClientSession.defaultTransactionOptions will be used in the absence of any explicit TransactionOptions.
+                // 4. If startTransaction reported an error, propagate that error to the caller of withTransaction as is and
+                // return immediately.
+                this.startTransaction(options);
                 try {
+                    // 5. Invoke the callback. Drivers MUST ensure that the ClientSession can be accessed within the callback
+                    // (e.g. pass ClientSession as the first parameter, rely on lexical scoping). Drivers MAY pass additional
+                    // parameters as needed (e.g. user data solicited by withTransaction).
                     const promise = fn(this);
                     if (!(0, utils_1.isPromiseLike)(promise)) {
                         throw new error_1.MongoInvalidArgumentError('Function provided to `withTransaction` must return a Promise');
                     }
+                    // 6. Control returns to withTransaction. Determine the current state of the ClientSession and whether the
+                    // callback reported an error (e.g. thrown exception, error output parameter).
                     result = await promise;
+                    // 8. If the ClientSession is in the "no transaction", "transaction aborted", or "transaction committed"
+                    // state, assume the callback intentionally aborted or committed the transaction and return immediately.
                     if (this.transaction.state === transactions_1.TxnState.NO_TRANSACTION ||
                         this.transaction.state === transactions_1.TxnState.TRANSACTION_COMMITTED ||
                         this.transaction.state === transactions_1.TxnState.TRANSACTION_ABORTED) {
-                        // Assume callback intentionally ended the transaction
                         return result;
                     }
                 }
                 catch (fnError) {
+                    // 7. If the callback reported an error
                     if (!(fnError instanceof error_1.MongoError) || fnError instanceof error_1.MongoInvalidArgumentError) {
+                        // This first preemptive abort regardless of TxnState isn't spec,
+                        // and it's unclear whether it's serving a practical purpose, but this logic is OLD
                         await this.abortTransaction();
                         throw fnError;
                     }
+                    lastError = fnError;
+                    // 7.1 If the ClientSession is in the "starting transaction" or "transaction in progress"
+                    // state, invoke abortTransaction on the session.
                     if (this.transaction.state === transactions_1.TxnState.STARTING_TRANSACTION ||
                         this.transaction.state === transactions_1.TxnState.TRANSACTION_IN_PROGRESS) {
                         await this.abortTransaction();
                     }
-                    if (fnError.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError) &&
-                        (this.timeoutContext != null || (0, utils_1.now)() - startTime < MAX_TIMEOUT)) {
-                        continue;
+                    // 7.2 If the callback's error includes a "TransientTransactionError" label, jump back to step two.
+                    if (fnError.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError)) {
+                        if ((0, utils_1.processTimeMS)() >= deadline) {
+                            throw makeTimeoutError(lastError, csotEnabled);
+                        }
+                        continue retryTransaction;
                     }
+                    // 7.3 If the callback's error includes a "UnknownTransactionCommitResult" label, the callback must
+                    // have manually committed a transaction, propagate the callback's error to the caller of withTransaction
+                    // as is and return immediately.
+                    // 7.4 Otherwise, propagate the callback's error to the caller of withTransaction as is and return immediately.
                     throw fnError;
                 }
-                while (!committed) {
+                retryCommit: while (!committed) {
                     try {
-                        /*
-                         * We will rely on ClientSession.commitTransaction() to
-                         * apply a majority write concern if commitTransaction is
-                         * being retried (see: DRIVERS-601)
-                         */
+                        // 9. Invoke commitTransaction on the session.
                         await this.commitTransaction();
                         committed = true;
                     }
                     catch (commitError) {
-                        /*
-                         * Note: a maxTimeMS error will have the MaxTimeMSExpired
-                         * code (50) and can be reported as a top-level error or
-                         * inside writeConcernError, ex.
-                         * { ok:0, code: 50, codeName: 'MaxTimeMSExpired' }
-                         * { ok:1, writeConcernError: { code: 50, codeName: 'MaxTimeMSExpired' } }
-                         */
-                        if (!isMaxTimeMSExpiredError(commitError) &&
-                            commitError.hasErrorLabel(error_1.MongoErrorLabel.UnknownTransactionCommitResult) &&
-                            (this.timeoutContext != null || (0, utils_1.now)() - startTime < MAX_TIMEOUT)) {
-                            continue;
+                        // 10. If commitTransaction reported an error:
+                        lastError = commitError;
+                        // 10.1 If the commitTransaction error includes a UnknownTransactionCommitResult label and the error is
+                        // not MaxTimeMSExpired
+                        if (commitError.hasErrorLabel(error_1.MongoErrorLabel.UnknownTransactionCommitResult) &&
+                            !isMaxTimeMSExpiredError(commitError)) {
+                            // 10.1.1 If the elapsed time of withTransaction exceeded TIMEOUT_MS, propagate the commitTransaction
+                            // error to the caller of withTransaction as per timeout error propagation and return immediately.
+                            if ((0, utils_1.processTimeMS)() >= deadline) {
+                                throw makeTimeoutError(commitError, csotEnabled);
+                            }
+                            // 10.1.2 Otherwise, jump back to step nine. We will trust commitTransaction to apply a majority write
+                            // concern on retry attempts (see: Majority write concern is used when retrying commitTransaction).
+                            continue retryCommit;
                         }
-                        if (commitError.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError) &&
-                            (this.timeoutContext != null || (0, utils_1.now)() - startTime < MAX_TIMEOUT)) {
-                            break;
+                        // 10.2 If the commitTransaction error includes a TransientTransactionError label, jump back to step two.
+                        if (commitError.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError)) {
+                            continue retryTransaction;
                         }
+                        // 10.3 Otherwise, propagate the commitTransaction error to the caller of withTransaction as is and return
+                        // immediately.
                         throw commitError;
                     }
                 }
             }
+            // 11. The transaction was committed successfully. Return immediately.
+            // @ts-expect-error Result is always defined if we reach here, the for-loop above convinces TS it is not.
             return result;
         }
         finally {
@@ -562,7 +644,24 @@ class ClientSession extends mongo_types_1.TypedEventEmitter {
     }
 }
 exports.ClientSession = ClientSession;
-(0, resource_management_1.configureResourceManagement)(ClientSession.prototype);
+function makeTimeoutError(cause, csotEnabled) {
+    // Async APIs know how to cancel themselves and might return CSOT error
+    if (cause instanceof error_1.MongoOperationTimeoutError) {
+        return cause;
+    }
+    if (csotEnabled) {
+        const timeoutError = new error_1.MongoOperationTimeoutError('Timed out during withTransaction', {
+            cause
+        });
+        if (cause instanceof error_1.MongoError) {
+            for (const label of cause.errorLabels) {
+                timeoutError.addErrorLabel(label);
+            }
+        }
+        return timeoutError;
+    }
+    return cause;
+}
 const NON_DETERMINISTIC_WRITE_CONCERN_ERRORS = new Set([
     'CannotSatisfyWriteConcern',
     'UnknownReplWriteConcern',
@@ -644,7 +743,7 @@ class ServerSession {
     /** @internal */
     constructor(cloned) {
         if (cloned != null) {
-            const idBytes = Buffer.allocUnsafe(16);
+            const idBytes = bson_1.ByteUtils.allocateUnsafe(16);
             idBytes.set(cloned.id.id.buffer);
             this.id = { id: new bson_1.Binary(idBytes, cloned.id.id.sub_type) };
             this.lastUse = cloned.lastUse;
@@ -653,7 +752,7 @@ class ServerSession {
             return;
         }
         this.id = { id: new bson_1.Binary((0, utils_1.uuidV4)(), bson_1.Binary.SUBTYPE_UUID) };
-        this.lastUse = (0, utils_1.now)();
+        this.lastUse = (0, utils_1.processTimeMS)();
         this.txnNumber = 0;
         this.isDirty = false;
     }
@@ -760,7 +859,7 @@ function applySession(session, command, options) {
         return;
     }
     // mark the last use of this session, and apply the `lsid`
-    serverSession.lastUse = (0, utils_1.now)();
+    serverSession.lastUse = (0, utils_1.processTimeMS)();
     command.lsid = serverSession.id;
     const inTxnOrTxnCommand = session.inTransaction() || (0, transactions_1.isTransactionCommand)(command);
     const isRetryableWrite = !!options.willRetryWrite;
@@ -792,7 +891,6 @@ function applySession(session, command, options) {
     // `autocommit` must always be false to differentiate from retryable writes
     command.autocommit = false;
     if (session.transaction.state === transactions_1.TxnState.STARTING_TRANSACTION) {
-        session.transaction.transition(transactions_1.TxnState.TRANSACTION_IN_PROGRESS);
         command.startTransaction = true;
         const readConcern = session.transaction.options.readConcern || session?.clientOptions?.readConcern;
         if (readConcern) {
@@ -823,5 +921,17 @@ function updateSessionFromResponse(session, document) {
             session.snapshotTime = atClusterTime;
         }
     }
+    if (session.transaction.state === transactions_1.TxnState.STARTING_TRANSACTION) {
+        if (document.ok === 1) {
+            session.transaction.transition(transactions_1.TxnState.TRANSACTION_IN_PROGRESS);
+        }
+        else {
+            const error = new error_1.MongoServerError(document.toObject());
+            const isRetryableError = error.hasErrorLabel(error_1.MongoErrorLabel.RetryableError);
+            if (!isRetryableError) {
+                session.transaction.transition(transactions_1.TxnState.TRANSACTION_IN_PROGRESS);
+            }
+        }
+    }
 }
 //# sourceMappingURL=sessions.js.map

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

@@ -50,12 +50,10 @@ const COMMITTED_STATES = new Set([
     exports.TxnState.TRANSACTION_ABORTED
 ]);
 /**
- * @public
- * @deprecated - Will be made internal in a future major release.
- * A class maintaining state related to a server transaction. Internal Only
+ * @internal
  */
 class Transaction {
-    /** Create a transaction @internal */
+    /** Create a transaction */
     constructor(options) {
         options = options ?? {};
         this.state = exports.TxnState.NO_TRANSACTION;
@@ -80,39 +78,32 @@ class Transaction {
         this._pinnedServer = undefined;
         this._recoveryToken = undefined;
     }
-    /** @internal */
     get server() {
         return this._pinnedServer;
     }
-    /** @deprecated - Will be made internal in a future major release. */
     get recoveryToken() {
         return this._recoveryToken;
     }
-    /** @deprecated - Will be made internal in a future major release. */
     get isPinned() {
         return !!this.server;
     }
     /**
-     * @deprecated - Will be made internal in a future major release.
      * @returns Whether the transaction has started
      */
     get isStarting() {
         return this.state === exports.TxnState.STARTING_TRANSACTION;
     }
     /**
-     * @deprecated - Will be made internal in a future major release.
      * @returns Whether this session is presently in a transaction
      */
     get isActive() {
         return ACTIVE_STATES.has(this.state);
     }
-    /** @deprecated - Will be made internal in a future major release. */
     get isCommitted() {
         return COMMITTED_STATES.has(this.state);
     }
     /**
      * Transition the transaction in the state machine
-     * @internal
      * @param nextState - The new state to transition to
      */
     transition(nextState) {
@@ -128,13 +119,11 @@ class Transaction {
         }
         throw new error_1.MongoRuntimeError(`Attempted illegal state transition from [${this.state}] to [${nextState}]`);
     }
-    /** @internal */
     pinServer(server) {
         if (this.isActive) {
             this._pinnedServer = server;
         }
     }
-    /** @internal */
     unpinServer() {
         this._pinnedServer = undefined;
     }