oxygen-cli 1.40.1 → 1.40.2-beta.1

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

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConnectionPoolMetrics = void 0;
+/** @internal */
+
+class ConnectionPoolMetrics {
+  constructor() {
+    this.txnConnections = 0;
+    this.cursorConnections = 0;
+    this.otherConnections = 0;
+  }
+  /**
+   * Mark a connection as pinned for a specific operation.
+   */
+
+
+  markPinned(pinType) {
+    if (pinType === ConnectionPoolMetrics.TXN) {
+      this.txnConnections += 1;
+    } else if (pinType === ConnectionPoolMetrics.CURSOR) {
+      this.cursorConnections += 1;
+    } else {
+      this.otherConnections += 1;
+    }
+  }
+  /**
+   * Unmark a connection as pinned for an operation.
+   */
+
+
+  markUnpinned(pinType) {
+    if (pinType === ConnectionPoolMetrics.TXN) {
+      this.txnConnections -= 1;
+    } else if (pinType === ConnectionPoolMetrics.CURSOR) {
+      this.cursorConnections -= 1;
+    } else {
+      this.otherConnections -= 1;
+    }
+  }
+  /**
+   * Return information about the cmap metrics as a string.
+   */
+
+
+  info(maxPoolSize) {
+    return 'Timed out while checking out a connection from connection pool: ' + `maxPoolSize: ${maxPoolSize}, ` + `connections in use by cursors: ${this.cursorConnections}, ` + `connections in use by transactions: ${this.txnConnections}, ` + `connections in use by other operations: ${this.otherConnections}`;
+  }
+  /**
+   * Reset the metrics to the initial values.
+   */
+
+
+  reset() {
+    this.txnConnections = 0;
+    this.cursorConnections = 0;
+    this.otherConnections = 0;
+  }
+
+}
+
+exports.ConnectionPoolMetrics = ConnectionPoolMetrics;
+ConnectionPoolMetrics.TXN = 'txn';
+ConnectionPoolMetrics.CURSOR = 'cursor';
+ConnectionPoolMetrics.OTHER = 'other';

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

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StreamDescription = void 0;
+
+const bson_1 = require("../bson");
+
+const common_1 = require("../sdam/common");
+
+const server_description_1 = require("../sdam/server_description");
+
+const RESPONSE_FIELDS = ['minWireVersion', 'maxWireVersion', 'maxBsonObjectSize', 'maxMessageSizeBytes', 'maxWriteBatchSize', 'logicalSessionTimeoutMinutes'];
+/** @public */
+
+class StreamDescription {
+  constructor(address, options) {
+    this.hello = null;
+    this.address = address;
+    this.type = common_1.ServerType.Unknown;
+    this.minWireVersion = undefined;
+    this.maxWireVersion = undefined;
+    this.maxBsonObjectSize = 16777216;
+    this.maxMessageSizeBytes = 48000000;
+    this.maxWriteBatchSize = 100000;
+    this.logicalSessionTimeoutMinutes = options?.logicalSessionTimeoutMinutes;
+    this.loadBalanced = !!options?.loadBalanced;
+    this.compressors = options && options.compressors && Array.isArray(options.compressors) ? options.compressors : [];
+    this.serverConnectionId = null;
+  }
+
+  receiveResponse(response) {
+    if (response == null) {
+      return;
+    }
+
+    this.hello = response;
+    this.type = (0, server_description_1.parseServerType)(response);
+
+    if ('connectionId' in response) {
+      this.serverConnectionId = this.parseServerConnectionID(response.connectionId);
+    } else {
+      this.serverConnectionId = null;
+    }
+
+    for (const field of RESPONSE_FIELDS) {
+      if (response[field] != null) {
+        this[field] = response[field];
+      } // testing case
+
+
+      if ('__nodejs_mock_server__' in response) {
+        this.__nodejs_mock_server__ = response['__nodejs_mock_server__'];
+      }
+    }
+
+    if (response.compression) {
+      this.compressor = this.compressors.filter(c => response.compression?.includes(c))[0];
+    }
+  }
+  /* @internal */
+
+
+  parseServerConnectionID(serverConnectionId) {
+    // Connection ids are always integral, so it's safe to coerce doubles as well as
+    // any integral type.
+    return bson_1.Long.isLong(serverConnectionId) ? serverConnectionId.toBigInt() : // @ts-expect-error: Doubles are coercible to number
+    BigInt(serverConnectionId);
+  }
+
+}
+
+exports.StreamDescription = StreamDescription;

package/transpiled/mongodb/lib/cmap/wire_protocol/compression.js

@@ -0,0 +1,196 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uncompressibleCommands = exports.Compressor = void 0;
+exports.compress = compress;
+exports.decompress = decompress;
+exports.compressCommand = compressCommand;
+exports.decompressResponse = decompressResponse;
+
+const util_1 = require("util");
+
+const zlib = require("zlib");
+
+const constants_1 = require("../../constants");
+
+const deps_1 = require("../../deps");
+
+const error_1 = require("../../error");
+
+const commands_1 = require("../commands");
+
+const constants_2 = require("./constants");
+/** @public */
+
+
+exports.Compressor = Object.freeze({
+  none: 0,
+  snappy: 1,
+  zlib: 2,
+  zstd: 3
+});
+exports.uncompressibleCommands = new Set([constants_1.LEGACY_HELLO_COMMAND, 'saslStart', 'saslContinue', 'getnonce', 'authenticate', 'createUser', 'updateUser', 'copydbSaslStart', 'copydbgetnonce', 'copydb']);
+const ZSTD_COMPRESSION_LEVEL = 3;
+const zlibInflate = (0, util_1.promisify)(zlib.inflate.bind(zlib));
+const zlibDeflate = (0, util_1.promisify)(zlib.deflate.bind(zlib));
+let zstd;
+let Snappy = null;
+
+function loadSnappy() {
+  if (Snappy == null) {
+    const snappyImport = (0, deps_1.getSnappy)();
+
+    if ('kModuleError' in snappyImport) {
+      throw snappyImport.kModuleError;
+    }
+
+    Snappy = snappyImport;
+  }
+
+  return Snappy;
+} // Facilitate compressing a message using an agreed compressor
+
+
+async function compress(options, dataToBeCompressed) {
+  const zlibOptions = {};
+
+  switch (options.agreedCompressor) {
+    case 'snappy':
+      {
+        Snappy ??= loadSnappy();
+        return await Snappy.compress(dataToBeCompressed);
+      }
+
+    case 'zstd':
+      {
+        loadZstd();
+
+        if ('kModuleError' in zstd) {
+          throw zstd['kModuleError'];
+        }
+
+        return await zstd.compress(dataToBeCompressed, ZSTD_COMPRESSION_LEVEL);
+      }
+
+    case 'zlib':
+      {
+        if (options.zlibCompressionLevel) {
+          zlibOptions.level = options.zlibCompressionLevel;
+        }
+
+        return await zlibDeflate(dataToBeCompressed, zlibOptions);
+      }
+
+    default:
+      {
+        throw new error_1.MongoInvalidArgumentError(`Unknown compressor ${options.agreedCompressor} failed to compress`);
+      }
+  }
+} // Decompress a message using the given compressor
+
+
+async function decompress(compressorID, compressedData) {
+  if (compressorID !== exports.Compressor.snappy && compressorID !== exports.Compressor.zstd && compressorID !== exports.Compressor.zlib && compressorID !== exports.Compressor.none) {
+    throw new error_1.MongoDecompressionError(`Server sent message compressed using an unsupported compressor. (Received compressor ID ${compressorID})`);
+  }
+
+  switch (compressorID) {
+    case exports.Compressor.snappy:
+      {
+        Snappy ??= loadSnappy();
+        return await Snappy.uncompress(compressedData, {
+          asBuffer: true
+        });
+      }
+
+    case exports.Compressor.zstd:
+      {
+        loadZstd();
+
+        if ('kModuleError' in zstd) {
+          throw zstd['kModuleError'];
+        }
+
+        return await zstd.decompress(compressedData);
+      }
+
+    case exports.Compressor.zlib:
+      {
+        return await zlibInflate(compressedData);
+      }
+
+    default:
+      {
+        return compressedData;
+      }
+  }
+}
+/**
+ * Load ZStandard if it is not already set.
+ */
+
+
+function loadZstd() {
+  if (!zstd) {
+    zstd = (0, deps_1.getZstdLibrary)();
+  }
+}
+
+const MESSAGE_HEADER_SIZE = 16;
+/**
+ * @internal
+ *
+ * Compresses an OP_MSG or OP_QUERY message, if compression is configured.  This method
+ * also serializes the command to BSON.
+ */
+
+async function compressCommand(command, description) {
+  const finalCommand = description.agreedCompressor === 'none' || !commands_1.OpCompressedRequest.canCompress(command) ? command : new commands_1.OpCompressedRequest(command, {
+    agreedCompressor: description.agreedCompressor ?? 'none',
+    zlibCompressionLevel: description.zlibCompressionLevel ?? 0
+  });
+  const data = await finalCommand.toBin();
+  return Buffer.concat(data);
+}
+/**
+ * @internal
+ *
+ * Decompresses an OP_MSG or OP_QUERY response from the server, if compression is configured.
+ *
+ * This method does not parse the response's BSON.
+ */
+
+
+async function decompressResponse(message) {
+  const messageHeader = {
+    length: message.readInt32LE(0),
+    requestId: message.readInt32LE(4),
+    responseTo: message.readInt32LE(8),
+    opCode: message.readInt32LE(12)
+  };
+
+  if (messageHeader.opCode !== constants_2.OP_COMPRESSED) {
+    const ResponseType = messageHeader.opCode === constants_2.OP_MSG ? commands_1.OpMsgResponse : commands_1.OpReply;
+    const messageBody = message.subarray(MESSAGE_HEADER_SIZE);
+    return new ResponseType(message, messageHeader, messageBody);
+  }
+
+  const header = { ...messageHeader,
+    fromCompressed: true,
+    opCode: message.readInt32LE(MESSAGE_HEADER_SIZE),
+    length: message.readInt32LE(MESSAGE_HEADER_SIZE + 4)
+  };
+  const compressorID = message[MESSAGE_HEADER_SIZE + 8];
+  const compressedBuffer = message.slice(MESSAGE_HEADER_SIZE + 9); // recalculate based on wrapped opcode
+
+  const ResponseType = header.opCode === constants_2.OP_MSG ? commands_1.OpMsgResponse : commands_1.OpReply;
+  const messageBody = await decompress(compressorID, compressedBuffer);
+
+  if (messageBody.length !== header.length) {
+    throw new error_1.MongoDecompressionError('Message body and message header must be the same length');
+  }
+
+  return new ResponseType(message, header, messageBody);
+}

package/transpiled/mongodb/lib/cmap/wire_protocol/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OP_MSG = exports.OP_COMPRESSED = exports.OP_DELETE = exports.OP_QUERY = exports.OP_INSERT = exports.OP_UPDATE = exports.OP_REPLY = exports.MIN_SUPPORTED_QE_SERVER_VERSION = exports.MIN_SUPPORTED_QE_WIRE_VERSION = exports.MAX_SUPPORTED_WIRE_VERSION = exports.MIN_SUPPORTED_WIRE_VERSION = exports.MAX_SUPPORTED_SERVER_VERSION = exports.MIN_SUPPORTED_SERVER_VERSION = void 0;
+exports.MIN_SUPPORTED_SERVER_VERSION = '4.2';
+exports.MAX_SUPPORTED_SERVER_VERSION = '8.0';
+exports.MIN_SUPPORTED_WIRE_VERSION = 8;
+exports.MAX_SUPPORTED_WIRE_VERSION = 25;
+exports.MIN_SUPPORTED_QE_WIRE_VERSION = 21;
+exports.MIN_SUPPORTED_QE_SERVER_VERSION = '7.0';
+exports.OP_REPLY = 1;
+exports.OP_UPDATE = 2001;
+exports.OP_INSERT = 2002;
+exports.OP_QUERY = 2004;
+exports.OP_DELETE = 2006;
+exports.OP_COMPRESSED = 2012;
+exports.OP_MSG = 2013;

package/transpiled/mongodb/lib/cmap/wire_protocol/on_data.js

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onData = onData;
+
+const utils_1 = require("../../utils");
+/**
+ * onData is adapted from Node.js' events.on helper
+ * https://nodejs.org/api/events.html#eventsonemitter-eventname-options
+ *
+ * Returns an AsyncIterator that iterates each 'data' event emitted from emitter.
+ * It will reject upon an error event.
+ */
+
+
+function onData(emitter, {
+  timeoutContext,
+  signal
+}) {
+  signal?.throwIfAborted(); // Setup pending events and pending promise lists
+
+  /**
+   * When the caller has not yet called .next(), we store the
+   * value from the event in this list. Next time they call .next()
+   * we pull the first value out of this list and resolve a promise with it.
+   */
+
+  const unconsumedEvents = new utils_1.List();
+  /**
+   * When there has not yet been an event, a new promise will be created
+   * and implicitly stored in this list. When an event occurs we take the first
+   * promise in this list and resolve it.
+   */
+
+  const unconsumedPromises = new utils_1.List();
+  /**
+   * Stored an error created by an error event.
+   * This error will turn into a rejection for the subsequent .next() call
+   */
+
+  let error = null;
+  /** Set to true only after event listeners have been removed. */
+
+  let finished = false;
+  const iterator = {
+    next() {
+      // First, we consume all unread events
+      const value = unconsumedEvents.shift();
+
+      if (value != null) {
+        return Promise.resolve({
+          value,
+          done: false
+        });
+      } // Then we error, if an error happened
+      // This happens one time if at all, because after 'error'
+      // we stop listening
+
+
+      if (error != null) {
+        const p = Promise.reject(error); // Only the first element errors
+
+        error = null;
+        return p;
+      } // If the iterator is finished, resolve to done
+
+
+      if (finished) return closeHandler(); // Wait until an event happens
+
+      const {
+        promise,
+        resolve,
+        reject
+      } = (0, utils_1.promiseWithResolvers)();
+      unconsumedPromises.push({
+        resolve,
+        reject
+      });
+      return promise;
+    },
+
+    return() {
+      return closeHandler();
+    },
+
+    throw(err) {
+      errorHandler(err);
+      return Promise.resolve({
+        value: undefined,
+        done: true
+      });
+    },
+
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+
+  }; // Adding event handlers
+
+  emitter.on('data', eventHandler);
+  emitter.on('error', errorHandler);
+  const abortListener = (0, utils_1.addAbortListener)(signal, function () {
+    errorHandler(this.reason);
+  });
+  const timeoutForSocketRead = timeoutContext?.timeoutForSocketRead;
+  timeoutForSocketRead?.throwIfExpired();
+  timeoutForSocketRead?.then(undefined, errorHandler);
+  return iterator;
+
+  function eventHandler(value) {
+    const promise = unconsumedPromises.shift();
+    if (promise != null) promise.resolve({
+      value,
+      done: false
+    });else unconsumedEvents.push(value);
+  }
+
+  function errorHandler(err) {
+    const promise = unconsumedPromises.shift();
+    if (promise != null) promise.reject(err);else error = err;
+    void closeHandler();
+  }
+
+  function closeHandler() {
+    // Adding event handlers
+    emitter.off('data', eventHandler);
+    emitter.off('error', errorHandler);
+    abortListener?.[utils_1.kDispose]();
+    finished = true;
+    timeoutForSocketRead?.clear();
+    const doneResult = {
+      value: undefined,
+      done: finished
+    };
+
+    for (const promise of unconsumedPromises) {
+      promise.resolve(doneResult);
+    }
+
+    return Promise.resolve(doneResult);
+  }
+}