oxygen-cli 1.40.2-beta.1 → 1.41.0

package/transpiled/mongodb/lib/cmap/connection.js

@@ -1,673 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.CryptoConnection = exports.SizedMessageTransform = exports.Connection = void 0;
-exports.hasSessionSupport = hasSessionSupport;
-
-const stream_1 = require("stream");
-
-const timers_1 = require("timers");
-
-const bson_1 = require("../bson");
-
-const constants_1 = require("../constants");
-
-const error_1 = require("../error");
-
-const mongo_logger_1 = require("../mongo_logger");
-
-const mongo_types_1 = require("../mongo_types");
-
-const read_preference_1 = require("../read_preference");
-
-const common_1 = require("../sdam/common");
-
-const sessions_1 = require("../sessions");
-
-const timeout_1 = require("../timeout");
-
-const utils_1 = require("../utils");
-
-const command_monitoring_events_1 = require("./command_monitoring_events");
-
-const commands_1 = require("./commands");
-
-const stream_description_1 = require("./stream_description");
-
-const compression_1 = require("./wire_protocol/compression");
-
-const on_data_1 = require("./wire_protocol/on_data");
-
-const responses_1 = require("./wire_protocol/responses");
-
-const shared_1 = require("./wire_protocol/shared");
-/** @internal */
-
-
-function hasSessionSupport(conn) {
-  const description = conn.description;
-  return description.logicalSessionTimeoutMinutes != null;
-}
-
-function streamIdentifier(stream, options) {
-  if (options.proxyHost) {
-    // If proxy options are specified, the properties of `stream` itself
-    // will not accurately reflect what endpoint this is connected to.
-    return options.hostAddress.toString();
-  }
-
-  const {
-    remoteAddress,
-    remotePort
-  } = stream;
-
-  if (typeof remoteAddress === 'string' && typeof remotePort === 'number') {
-    return utils_1.HostAddress.fromHostPort(remoteAddress, remotePort).toString();
-  }
-
-  return (0, utils_1.uuidV4)().toString('hex');
-}
-/** @internal */
-
-
-class Connection extends mongo_types_1.TypedEventEmitter {
-  constructor(stream, options) {
-    super();
-    this.lastHelloMS = -1;
-    this.helloOk = false;
-    this.delayedTimeoutId = null;
-    /** Indicates that the connection (including underlying TCP socket) has been closed. */
-
-    this.closed = false;
-    this.clusterTime = null;
-    this.error = null;
-    this.dataEvents = null;
-    this.on('error', utils_1.noop);
-    this.socket = stream;
-    this.id = options.id;
-    this.address = streamIdentifier(stream, options);
-    this.socketTimeoutMS = options.socketTimeoutMS ?? 0;
-    this.monitorCommands = options.monitorCommands;
-    this.serverApi = options.serverApi;
-    this.mongoLogger = options.mongoLogger;
-    this.established = false;
-    this.description = new stream_description_1.StreamDescription(this.address, options);
-    this.generation = options.generation;
-    this.lastUseTime = (0, utils_1.now)();
-    this.messageStream = this.socket.on('error', this.onSocketError.bind(this)).pipe(new SizedMessageTransform({
-      connection: this
-    })).on('error', this.onTransformError.bind(this));
-    this.socket.on('close', this.onClose.bind(this));
-    this.socket.on('timeout', this.onTimeout.bind(this));
-    this.messageStream.pause();
-  }
-
-  get hello() {
-    return this.description.hello;
-  } // the `connect` method stores the result of the handshake hello on the connection
-
-
-  set hello(response) {
-    this.description.receiveResponse(response);
-    Object.freeze(this.description);
-  }
-
-  get serviceId() {
-    return this.hello?.serviceId;
-  }
-
-  get loadBalanced() {
-    return this.description.loadBalanced;
-  }
-
-  get idleTime() {
-    return (0, utils_1.calculateDurationInMs)(this.lastUseTime);
-  }
-
-  get hasSessionSupport() {
-    return this.description.logicalSessionTimeoutMinutes != null;
-  }
-
-  get supportsOpMsg() {
-    return this.description != null && (0, utils_1.maxWireVersion)(this) >= 6 && !this.description.__nodejs_mock_server__;
-  }
-
-  get shouldEmitAndLogCommand() {
-    return (this.monitorCommands || this.established && !this.authContext?.reauthenticating && this.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.COMMAND, mongo_logger_1.SeverityLevel.DEBUG)) ?? false;
-  }
-
-  markAvailable() {
-    this.lastUseTime = (0, utils_1.now)();
-  }
-
-  onSocketError(cause) {
-    this.onError(new error_1.MongoNetworkError(cause.message, {
-      cause
-    }));
-  }
-
-  onTransformError(error) {
-    this.onError(error);
-  }
-
-  onError(error) {
-    this.cleanup(error);
-  }
-
-  onClose() {
-    const message = `connection ${this.id} to ${this.address} closed`;
-    this.cleanup(new error_1.MongoNetworkError(message));
-  }
-
-  onTimeout() {
-    this.delayedTimeoutId = (0, timers_1.setTimeout)(() => {
-      const message = `connection ${this.id} to ${this.address} timed out`;
-      const beforeHandshake = this.hello == null;
-      this.cleanup(new error_1.MongoNetworkTimeoutError(message, {
-        beforeHandshake
-      }));
-    }, 1).unref(); // No need for this timer to hold the event loop open
-  }
-
-  destroy() {
-    if (this.closed) {
-      return;
-    } // load balanced mode requires that these listeners remain on the connection
-    // after cleanup on timeouts, errors or close so we remove them before calling
-    // cleanup.
-
-
-    this.removeAllListeners(Connection.PINNED);
-    this.removeAllListeners(Connection.UNPINNED);
-    const message = `connection ${this.id} to ${this.address} closed`;
-    this.cleanup(new error_1.MongoNetworkError(message));
-  }
-  /**
-   * A method that cleans up the connection.  When `force` is true, this method
-   * forcibly destroys the socket.
-   *
-   * If an error is provided, any in-flight operations will be closed with the error.
-   *
-   * This method does nothing if the connection is already closed.
-   */
-
-
-  cleanup(error) {
-    if (this.closed) {
-      return;
-    }
-
-    this.socket.destroy();
-    this.error = error;
-    this.dataEvents?.throw(error).then(undefined, utils_1.squashError);
-    this.closed = true;
-    this.emit(Connection.CLOSE);
-  }
-
-  prepareCommand(db, command, options) {
-    let cmd = { ...command
-    };
-    const readPreference = (0, shared_1.getReadPreference)(options);
-    const session = options?.session;
-    let clusterTime = this.clusterTime;
-
-    if (this.serverApi) {
-      const {
-        version,
-        strict,
-        deprecationErrors
-      } = this.serverApi;
-      cmd.apiVersion = version;
-      if (strict != null) cmd.apiStrict = strict;
-      if (deprecationErrors != null) cmd.apiDeprecationErrors = deprecationErrors;
-    }
-
-    if (this.hasSessionSupport && session) {
-      if (session.clusterTime && clusterTime && session.clusterTime.clusterTime.greaterThan(clusterTime.clusterTime)) {
-        clusterTime = session.clusterTime;
-      }
-
-      const sessionError = (0, sessions_1.applySession)(session, cmd, options);
-      if (sessionError) throw sessionError;
-    } else if (session?.explicit) {
-      throw new error_1.MongoCompatibilityError('Current topology does not support sessions');
-    } // if we have a known cluster time, gossip it
-
-
-    if (clusterTime) {
-      cmd.$clusterTime = clusterTime;
-    } // For standalone, drivers MUST NOT set $readPreference.
-
-
-    if (this.description.type !== common_1.ServerType.Standalone) {
-      if (!(0, shared_1.isSharded)(this) && !this.description.loadBalanced && this.supportsOpMsg && options.directConnection === true && readPreference?.mode === 'primary') {
-        // For mongos and load balancers with 'primary' mode, drivers MUST NOT set $readPreference.
-        // For all other types with a direct connection, if the read preference is 'primary'
-        // (driver sets 'primary' as default if no read preference is configured),
-        // the $readPreference MUST be set to 'primaryPreferred'
-        // to ensure that any server type can handle the request.
-        cmd.$readPreference = read_preference_1.ReadPreference.primaryPreferred.toJSON();
-      } else if ((0, shared_1.isSharded)(this) && !this.supportsOpMsg && readPreference?.mode !== 'primary') {
-        // When sending a read operation via OP_QUERY and the $readPreference modifier,
-        // the query MUST be provided using the $query modifier.
-        cmd = {
-          $query: cmd,
-          $readPreference: readPreference.toJSON()
-        };
-      } else if (readPreference?.mode !== 'primary') {
-        // For mode 'primary', drivers MUST NOT set $readPreference.
-        // For all other read preference modes (i.e. 'secondary', 'primaryPreferred', ...),
-        // drivers MUST set $readPreference
-        cmd.$readPreference = readPreference.toJSON();
-      }
-    }
-
-    const commandOptions = {
-      numberToSkip: 0,
-      numberToReturn: -1,
-      checkKeys: false,
-      // This value is not overridable
-      secondaryOk: readPreference.secondaryOk(),
-      ...options
-    };
-    options.timeoutContext?.addMaxTimeMSToCommand(cmd, options);
-    const message = this.supportsOpMsg ? new commands_1.OpMsgRequest(db, cmd, commandOptions) : new commands_1.OpQueryRequest(db, cmd, commandOptions);
-    return message;
-  }
-
-  async *sendWire(message, options, responseType) {
-    this.throwIfAborted();
-    const timeout = options.socketTimeoutMS ?? options?.timeoutContext?.getSocketTimeoutMS() ?? this.socketTimeoutMS;
-    this.socket.setTimeout(timeout);
-
-    try {
-      await this.writeCommand(message, {
-        agreedCompressor: this.description.compressor ?? 'none',
-        zlibCompressionLevel: this.description.zlibCompressionLevel,
-        timeoutContext: options.timeoutContext,
-        signal: options.signal
-      });
-
-      if (options.noResponse || message.moreToCome) {
-        yield responses_1.MongoDBResponse.empty;
-        return;
-      }
-
-      this.throwIfAborted();
-
-      if (options.timeoutContext?.csotEnabled() && options.timeoutContext.minRoundTripTime != null && options.timeoutContext.remainingTimeMS < options.timeoutContext.minRoundTripTime) {
-        throw new error_1.MongoOperationTimeoutError('Server roundtrip time is greater than the time remaining');
-      }
-
-      for await (const response of this.readMany(options)) {
-        this.socket.setTimeout(0);
-        const bson = response.parse();
-        const document = (responseType ?? responses_1.MongoDBResponse).make(bson);
-        yield document;
-        this.throwIfAborted();
-        this.socket.setTimeout(timeout);
-      }
-    } finally {
-      this.socket.setTimeout(0);
-    }
-  }
-
-  async *sendCommand(ns, command, options, responseType) {
-    options?.signal?.throwIfAborted();
-    const message = this.prepareCommand(ns.db, command, options);
-    let started = 0;
-
-    if (this.shouldEmitAndLogCommand) {
-      started = (0, utils_1.now)();
-      this.emitAndLogCommand(this.monitorCommands, Connection.COMMAND_STARTED, message.databaseName, this.established, new command_monitoring_events_1.CommandStartedEvent(this, message, this.description.serverConnectionId));
-    } // If `documentsReturnedIn` not set or raw is not enabled, use input bson options
-    // Otherwise, support raw flag. Raw only works for cursors that hardcode firstBatch/nextBatch fields
-
-
-    const bsonOptions = options.documentsReturnedIn == null || !options.raw ? options : { ...options,
-      raw: false,
-      fieldsAsRaw: {
-        [options.documentsReturnedIn]: true
-      }
-    };
-    /** MongoDBResponse instance or subclass */
-
-    let document = undefined;
-    /** Cached result of a toObject call */
-
-    let object = undefined;
-
-    try {
-      this.throwIfAborted();
-
-      for await (document of this.sendWire(message, options, responseType)) {
-        object = undefined;
-
-        if (options.session != null) {
-          (0, sessions_1.updateSessionFromResponse)(options.session, document);
-        }
-
-        if (document.$clusterTime) {
-          this.clusterTime = document.$clusterTime;
-          this.emit(Connection.CLUSTER_TIME_RECEIVED, document.$clusterTime);
-        }
-
-        if (document.ok === 0) {
-          if (options.timeoutContext?.csotEnabled() && document.isMaxTimeExpiredError) {
-            throw new error_1.MongoOperationTimeoutError('Server reported a timeout error', {
-              cause: new error_1.MongoServerError(object ??= document.toObject(bsonOptions))
-            });
-          }
-
-          throw new error_1.MongoServerError(object ??= document.toObject(bsonOptions));
-        }
-
-        if (this.shouldEmitAndLogCommand) {
-          this.emitAndLogCommand(this.monitorCommands, Connection.COMMAND_SUCCEEDED, message.databaseName, this.established, new command_monitoring_events_1.CommandSucceededEvent(this, message, options.noResponse ? undefined : message.moreToCome ? {
-            ok: 1
-          } : object ??= document.toObject(bsonOptions), started, this.description.serverConnectionId));
-        }
-
-        if (responseType == null) {
-          yield object ??= document.toObject(bsonOptions);
-        } else {
-          yield document;
-        }
-
-        this.throwIfAborted();
-      }
-    } catch (error) {
-      if (this.shouldEmitAndLogCommand) {
-        this.emitAndLogCommand(this.monitorCommands, Connection.COMMAND_FAILED, message.databaseName, this.established, new command_monitoring_events_1.CommandFailedEvent(this, message, error, started, this.description.serverConnectionId));
-      }
-
-      throw error;
-    }
-  }
-
-  async command(ns, command, options = {}, responseType) {
-    this.throwIfAborted();
-    options.signal?.throwIfAborted();
-
-    for await (const document of this.sendCommand(ns, command, options, responseType)) {
-      if (options.timeoutContext?.csotEnabled()) {
-        if (responses_1.MongoDBResponse.is(document)) {
-          if (document.isMaxTimeExpiredError) {
-            throw new error_1.MongoOperationTimeoutError('Server reported a timeout error', {
-              cause: new error_1.MongoServerError(document.toObject())
-            });
-          }
-        } else {
-          if (Array.isArray(document?.writeErrors) && document.writeErrors.some(error => error?.code === error_1.MONGODB_ERROR_CODES.MaxTimeMSExpired) || document?.writeConcernError?.code === error_1.MONGODB_ERROR_CODES.MaxTimeMSExpired) {
-            throw new error_1.MongoOperationTimeoutError('Server reported a timeout error', {
-              cause: new error_1.MongoServerError(document)
-            });
-          }
-        }
-      }
-
-      return document;
-    }
-
-    throw new error_1.MongoUnexpectedServerResponseError('Unable to get response from server');
-  }
-
-  exhaustCommand(ns, command, options, replyListener) {
-    const exhaustLoop = async () => {
-      this.throwIfAborted();
-
-      for await (const reply of this.sendCommand(ns, command, options)) {
-        replyListener(undefined, reply);
-        this.throwIfAborted();
-      }
-
-      throw new error_1.MongoUnexpectedServerResponseError('Server ended moreToCome unexpectedly');
-    };
-
-    exhaustLoop().then(undefined, replyListener);
-  }
-
-  throwIfAborted() {
-    if (this.error) throw this.error;
-  }
-  /**
-   * @internal
-   *
-   * Writes an OP_MSG or OP_QUERY request to the socket, optionally compressing the command. This method
-   * waits until the socket's buffer has emptied (the Nodejs socket `drain` event has fired).
-   */
-
-
-  async writeCommand(command, options) {
-    const finalCommand = options.agreedCompressor === 'none' || !commands_1.OpCompressedRequest.canCompress(command) ? command : new commands_1.OpCompressedRequest(command, {
-      agreedCompressor: options.agreedCompressor ?? 'none',
-      zlibCompressionLevel: options.zlibCompressionLevel ?? 0
-    });
-    const buffer = Buffer.concat(await finalCommand.toBin());
-
-    if (options.timeoutContext?.csotEnabled()) {
-      if (options.timeoutContext.minRoundTripTime != null && options.timeoutContext.remainingTimeMS < options.timeoutContext.minRoundTripTime) {
-        throw new error_1.MongoOperationTimeoutError('Server roundtrip time is greater than the time remaining');
-      }
-    }
-
-    if (this.socket.write(buffer)) return;
-    const drainEvent = (0, utils_1.once)(this.socket, 'drain', options);
-    const timeout = options?.timeoutContext?.timeoutForSocketWrite;
-    const drained = timeout ? Promise.race([drainEvent, timeout]) : drainEvent;
-
-    try {
-      return await drained;
-    } catch (writeError) {
-      if (timeout_1.TimeoutError.is(writeError)) {
-        const timeoutError = new error_1.MongoOperationTimeoutError('Timed out at socket write');
-        this.onError(timeoutError);
-        throw timeoutError;
-      } else if (writeError === options.signal?.reason) {
-        this.onError(writeError);
-      }
-
-      throw writeError;
-    } finally {
-      timeout?.clear();
-    }
-  }
-  /**
-   * @internal
-   *
-   * Returns an async generator that yields full wire protocol messages from the underlying socket.  This function
-   * yields messages until `moreToCome` is false or not present in a response, or the caller cancels the request
-   * by calling `return` on the generator.
-   *
-   * Note that `for-await` loops call `return` automatically when the loop is exited.
-   */
-
-
-  async *readMany(options) {
-    try {
-      this.dataEvents = (0, on_data_1.onData)(this.messageStream, options);
-      this.messageStream.resume();
-
-      for await (const message of this.dataEvents) {
-        const response = await (0, compression_1.decompressResponse)(message);
-        yield response;
-
-        if (!response.moreToCome) {
-          return;
-        }
-      }
-    } catch (readError) {
-      if (timeout_1.TimeoutError.is(readError)) {
-        const timeoutError = new error_1.MongoOperationTimeoutError(`Timed out during socket read (${readError.duration}ms)`);
-        this.dataEvents = null;
-        this.onError(timeoutError);
-        throw timeoutError;
-      } else if (readError === options.signal?.reason) {
-        this.onError(readError);
-      }
-
-      throw readError;
-    } finally {
-      this.dataEvents = null;
-      this.messageStream.pause();
-    }
-  }
-
-}
-
-exports.Connection = Connection;
-/** @event */
-
-Connection.COMMAND_STARTED = constants_1.COMMAND_STARTED;
-/** @event */
-
-Connection.COMMAND_SUCCEEDED = constants_1.COMMAND_SUCCEEDED;
-/** @event */
-
-Connection.COMMAND_FAILED = constants_1.COMMAND_FAILED;
-/** @event */
-
-Connection.CLUSTER_TIME_RECEIVED = constants_1.CLUSTER_TIME_RECEIVED;
-/** @event */
-
-Connection.CLOSE = constants_1.CLOSE;
-/** @event */
-
-Connection.PINNED = constants_1.PINNED;
-/** @event */
-
-Connection.UNPINNED = constants_1.UNPINNED;
-/** @internal */
-
-class SizedMessageTransform extends stream_1.Transform {
-  constructor({
-    connection
-  }) {
-    super({
-      writableObjectMode: false,
-      readableObjectMode: true
-    });
-    this.bufferPool = new utils_1.BufferPool();
-    this.connection = connection;
-  }
-
-  _transform(chunk, encoding, callback) {
-    if (this.connection.delayedTimeoutId != null) {
-      (0, timers_1.clearTimeout)(this.connection.delayedTimeoutId);
-      this.connection.delayedTimeoutId = null;
-    }
-
-    this.bufferPool.append(chunk);
-
-    while (this.bufferPool.length) {
-      // While there are any bytes in the buffer
-      // Try to fetch a size from the top 4 bytes
-      const sizeOfMessage = this.bufferPool.getInt32();
-
-      if (sizeOfMessage == null) {
-        // Not even an int32 worth of data. Stop the loop, we need more chunks.
-        break;
-      }
-
-      if (sizeOfMessage < 0) {
-        // The size in the message has a negative value, this is probably corruption, throw:
-        return callback(new error_1.MongoParseError(`Message size cannot be negative: ${sizeOfMessage}`));
-      }
-
-      if (sizeOfMessage > this.bufferPool.length) {
-        // We do not have enough bytes to make a sizeOfMessage chunk
-        break;
-      } // Add a message to the stream
-
-
-      const message = this.bufferPool.read(sizeOfMessage);
-
-      if (!this.push(message)) {
-        // We only subscribe to data events so we should never get backpressure
-        // if we do, we do not have the handling for it.
-        return callback(new error_1.MongoRuntimeError(`SizedMessageTransform does not support backpressure`));
-      }
-    }
-
-    callback();
-  }
-
-}
-
-exports.SizedMessageTransform = SizedMessageTransform;
-/** @internal */
-
-class CryptoConnection extends Connection {
-  constructor(stream, options) {
-    super(stream, options);
-    this.autoEncrypter = options.autoEncrypter;
-  }
-
-  async command(ns, cmd, options, responseType) {
-    const {
-      autoEncrypter
-    } = this;
-
-    if (!autoEncrypter) {
-      // TODO(NODE-6065): throw a MongoRuntimeError in Node V7
-      // @ts-expect-error No cause provided because there is no underlying error.
-      throw new error_1.MongoMissingDependencyError('No AutoEncrypter available for encryption', {
-        dependencyName: 'n/a'
-      });
-    }
-
-    const serverWireVersion = (0, utils_1.maxWireVersion)(this);
-
-    if (serverWireVersion === 0) {
-      // This means the initial handshake hasn't happened yet
-      return await super.command(ns, cmd, options, responseType);
-    }
-
-    if (serverWireVersion < 8) {
-      throw new error_1.MongoCompatibilityError('Auto-encryption requires a minimum MongoDB version of 4.2');
-    } // Save sort or indexKeys based on the command being run
-    // the encrypt API serializes our JS objects to BSON to pass to the native code layer
-    // and then deserializes the encrypted result, the protocol level components
-    // of the command (ex. sort) are then converted to JS objects potentially losing
-    // import key order information. These fields are never encrypted so we can save the values
-    // from before the encryption and replace them after encryption has been performed
-
-
-    const sort = cmd.find || cmd.findAndModify ? cmd.sort : null;
-    const indexKeys = cmd.createIndexes ? cmd.indexes.map(index => index.key) : null;
-    const encrypted = await autoEncrypter.encrypt(ns.toString(), cmd, options); // Replace the saved values
-
-    if (sort != null && (cmd.find || cmd.findAndModify)) {
-      encrypted.sort = sort;
-    }
-
-    if (indexKeys != null && cmd.createIndexes) {
-      for (const [offset, index] of indexKeys.entries()) {
-        // @ts-expect-error `encrypted` is a generic "command", but we've narrowed for only `createIndexes` commands here
-        encrypted.indexes[offset].key = index;
-      }
-    }
-
-    const encryptedResponse = await super.command(ns, encrypted, options, // Eventually we want to require `responseType` which means we would satisfy `T` as the return type.
-    // In the meantime, we want encryptedResponse to always be _at least_ a MongoDBResponse if not a more specific subclass
-    // So that we can ensure we have access to the on-demand APIs for decorate response
-    responseType ?? responses_1.MongoDBResponse);
-    const result = await autoEncrypter.decrypt(encryptedResponse.toBytes(), options);
-    const decryptedResponse = responseType?.make(result) ?? (0, bson_1.deserialize)(result, options);
-
-    if (autoEncrypter[constants_1.kDecorateResult]) {
-      if (responseType == null) {
-        (0, utils_1.decorateDecryptionResult)(decryptedResponse, encryptedResponse.toObject(), true);
-      } else if (decryptedResponse instanceof responses_1.CursorResponse) {
-        decryptedResponse.encryptedResponse = encryptedResponse;
-      }
-    }
-
-    return decryptedResponse;
-  }
-
-}
-
-exports.CryptoConnection = CryptoConnection;