oxygen-cli 1.40.1 → 1.40.2-beta.1

package/transpiled/mongodb/lib/operations/distinct.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DistinctOperation = void 0;
+
+const utils_1 = require("../utils");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/**
+ * Return a list of distinct values for the given key across a collection.
+ * @internal
+ */
+
+
+class DistinctOperation extends command_1.CommandOperation {
+  /**
+   * Construct a Distinct operation.
+   *
+   * @param collection - Collection instance.
+   * @param key - Field of the document to find distinct values for.
+   * @param query - The query for filtering the set of documents to which we apply the distinct filter.
+   * @param options - Optional settings. See Collection.prototype.distinct for a list of options.
+   */
+  constructor(collection, key, query, options) {
+    super(collection, options);
+    this.options = options ?? {};
+    this.collection = collection;
+    this.key = key;
+    this.query = query;
+  }
+
+  get commandName() {
+    return 'distinct';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const coll = this.collection;
+    const key = this.key;
+    const query = this.query;
+    const options = this.options; // Distinct command
+
+    const cmd = {
+      distinct: coll.collectionName,
+      key: key,
+      query: query
+    }; // Add maxTimeMS if defined
+
+    if (typeof options.maxTimeMS === 'number') {
+      cmd.maxTimeMS = options.maxTimeMS;
+    } // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+
+
+    if (typeof options.comment !== 'undefined') {
+      cmd.comment = options.comment;
+    }
+
+    if (options.hint != null) {
+      cmd.hint = options.hint;
+    } // Do we have a readConcern specified
+
+
+    (0, utils_1.decorateWithReadConcern)(cmd, coll, options); // Have we specified collation
+
+    (0, utils_1.decorateWithCollation)(cmd, coll, options);
+    const result = await super.executeCommand(server, session, cmd, timeoutContext);
+    return this.explain ? result : result.values;
+  }
+
+}
+
+exports.DistinctOperation = DistinctOperation;
+(0, operation_1.defineAspects)(DistinctOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.RETRYABLE, operation_1.Aspect.EXPLAINABLE]);

package/transpiled/mongodb/lib/operations/drop.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DropDatabaseOperation = exports.DropCollectionOperation = void 0;
+
+const error_1 = require("../error");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class DropCollectionOperation extends command_1.CommandOperation {
+  constructor(db, name, options = {}) {
+    super(db, options);
+    this.db = db;
+    this.options = options;
+    this.name = name;
+  }
+
+  get commandName() {
+    return 'drop';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const db = this.db;
+    const options = this.options;
+    const name = this.name;
+    const encryptedFieldsMap = db.client.s.options.autoEncryption?.encryptedFieldsMap;
+    let encryptedFields = options.encryptedFields ?? encryptedFieldsMap?.[`${db.databaseName}.${name}`];
+
+    if (!encryptedFields && encryptedFieldsMap) {
+      // If the MongoClient was configured with an encryptedFieldsMap,
+      // and no encryptedFields config was available in it or explicitly
+      // passed as an argument, the spec tells us to look one up using
+      // listCollections().
+      const listCollectionsResult = await db.listCollections({
+        name
+      }, {
+        nameOnly: false
+      }).toArray();
+      encryptedFields = listCollectionsResult?.[0]?.options?.encryptedFields;
+    }
+
+    if (encryptedFields) {
+      const escCollection = encryptedFields.escCollection || `enxcol_.${name}.esc`;
+      const ecocCollection = encryptedFields.ecocCollection || `enxcol_.${name}.ecoc`;
+
+      for (const collectionName of [escCollection, ecocCollection]) {
+        // Drop auxilliary collections, ignoring potential NamespaceNotFound errors.
+        const dropOp = new DropCollectionOperation(db, collectionName);
+
+        try {
+          await dropOp.executeWithoutEncryptedFieldsCheck(server, session, timeoutContext);
+        } catch (err) {
+          if (!(err instanceof error_1.MongoServerError) || err.code !== error_1.MONGODB_ERROR_CODES.NamespaceNotFound) {
+            throw err;
+          }
+        }
+      }
+    }
+
+    return await this.executeWithoutEncryptedFieldsCheck(server, session, timeoutContext);
+  }
+
+  async executeWithoutEncryptedFieldsCheck(server, session, timeoutContext) {
+    await super.executeCommand(server, session, {
+      drop: this.name
+    }, timeoutContext);
+    return true;
+  }
+
+}
+
+exports.DropCollectionOperation = DropCollectionOperation;
+/** @internal */
+
+class DropDatabaseOperation extends command_1.CommandOperation {
+  constructor(db, options) {
+    super(db, options);
+    this.options = options;
+  }
+
+  get commandName() {
+    return 'dropDatabase';
+  }
+
+  async execute(server, session, timeoutContext) {
+    await super.executeCommand(server, session, {
+      dropDatabase: 1
+    }, timeoutContext);
+    return true;
+  }
+
+}
+
+exports.DropDatabaseOperation = DropDatabaseOperation;
+(0, operation_1.defineAspects)(DropCollectionOperation, [operation_1.Aspect.WRITE_OPERATION]);
+(0, operation_1.defineAspects)(DropDatabaseOperation, [operation_1.Aspect.WRITE_OPERATION]);

package/transpiled/mongodb/lib/operations/estimated_document_count.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EstimatedDocumentCountOperation = void 0;
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class EstimatedDocumentCountOperation extends command_1.CommandOperation {
+  constructor(collection, options = {}) {
+    super(collection, options);
+    this.options = options;
+    this.collectionName = collection.collectionName;
+  }
+
+  get commandName() {
+    return 'count';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const cmd = {
+      count: this.collectionName
+    };
+
+    if (typeof this.options.maxTimeMS === 'number') {
+      cmd.maxTimeMS = this.options.maxTimeMS;
+    } // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+
+
+    if (this.options.comment !== undefined) {
+      cmd.comment = this.options.comment;
+    }
+
+    const response = await super.executeCommand(server, session, cmd, timeoutContext);
+    return response?.n || 0;
+  }
+
+}
+
+exports.EstimatedDocumentCountOperation = EstimatedDocumentCountOperation;
+(0, operation_1.defineAspects)(EstimatedDocumentCountOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.RETRYABLE, operation_1.Aspect.CURSOR_CREATING]);

package/transpiled/mongodb/lib/operations/execute_operation.js

@@ -0,0 +1,251 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.executeOperation = executeOperation;
+
+const error_1 = require("../error");
+
+const read_preference_1 = require("../read_preference");
+
+const server_selection_1 = require("../sdam/server_selection");
+
+const timeout_1 = require("../timeout");
+
+const utils_1 = require("../utils");
+
+const operation_1 = require("./operation");
+
+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.';
+/**
+ * Executes the given operation with provided arguments.
+ * @internal
+ *
+ * @remarks
+ * Allows for a single point of entry to provide features such as implicit sessions, which
+ * are required by the Driver Sessions specification in the event that a ClientSession is
+ * not provided.
+ *
+ * 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}
+ *
+ * @typeParam T - The operation's type
+ * @typeParam TResult - The type of the operation's result, calculated from T
+ *
+ * @param client - The MongoClient to execute this operation with
+ * @param operation - The operation to execute
+ */
+
+async function executeOperation(client, operation, timeoutContext) {
+  if (!(operation instanceof operation_1.AbstractOperation)) {
+    // TODO(NODE-3483): Extend MongoRuntimeError
+    throw new error_1.MongoRuntimeError('This method requires a valid operation instance');
+  }
+
+  const topology = client.topology == null ? await (0, utils_1.abortable)(autoConnect(client), operation.options) : client.topology; // The driver sessions spec mandates that we implicitly create sessions for operations
+  // that are not explicitly provided with a session.
+
+  let session = operation.session;
+  let owner;
+
+  if (session == null) {
+    owner = Symbol();
+    session = client.startSession({
+      owner,
+      explicit: false
+    });
+  } else if (session.hasEnded) {
+    throw new error_1.MongoExpiredSessionError('Use of expired sessions is not permitted');
+  } else if (session.snapshotEnabled && !topology.capabilities.supportsSnapshotReads) {
+    throw new error_1.MongoCompatibilityError('Snapshot reads require MongoDB 5.0 or later');
+  } else if (session.client !== client) {
+    throw new error_1.MongoInvalidArgumentError('ClientSession must be from the same MongoClient');
+  }
+
+  const readPreference = operation.readPreference ?? read_preference_1.ReadPreference.primary;
+  const inTransaction = !!session?.inTransaction();
+  const hasReadAspect = operation.hasAspect(operation_1.Aspect.READ_OPERATION);
+
+  if (inTransaction && !readPreference.equals(read_preference_1.ReadPreference.primary) && (hasReadAspect || operation.commandName === 'runCommand')) {
+    throw new error_1.MongoTransactionError(`Read preference in a transaction must be primary, not: ${readPreference.mode}`);
+  }
+
+  if (session?.isPinned && session.transaction.isCommitted && !operation.bypassPinningCheck) {
+    session.unpin();
+  }
+
+  timeoutContext ??= timeout_1.TimeoutContext.create({
+    session,
+    serverSelectionTimeoutMS: client.s.options.serverSelectionTimeoutMS,
+    waitQueueTimeoutMS: client.s.options.waitQueueTimeoutMS,
+    timeoutMS: operation.options.timeoutMS
+  });
+
+  try {
+    return await tryOperation(operation, {
+      topology,
+      timeoutContext,
+      session,
+      readPreference
+    });
+  } finally {
+    if (session?.owner != null && session.owner === owner) {
+      await session.endSession();
+    }
+  }
+}
+/**
+ * Connects a client if it has not yet been connected
+ * @internal
+ */
+
+
+async function autoConnect(client) {
+  if (client.topology == null) {
+    if (client.s.hasBeenClosed) {
+      throw new error_1.MongoNotConnectedError('Client must be connected before running operations');
+    }
+
+    client.s.options.__skipPingOnConnect = true;
+
+    try {
+      await client.connect();
+
+      if (client.topology == null) {
+        throw new error_1.MongoRuntimeError('client.connect did not create a topology but also did not throw');
+      }
+
+      return client.topology;
+    } finally {
+      delete client.s.options.__skipPingOnConnect;
+    }
+  }
+
+  return client.topology;
+}
+/**
+ * Executes an operation and retries as appropriate
+ * @internal
+ *
+ * @remarks
+ * Implements behaviour described in [Retryable Reads](https://github.com/mongodb/specifications/blob/master/source/retryable-reads/retryable-reads.md) and [Retryable
+ * Writes](https://github.com/mongodb/specifications/blob/master/source/retryable-writes/retryable-writes.md) specification
+ *
+ * This function:
+ * - performs initial server selection
+ * - attempts to execute an operation
+ * - retries the operation if it meets the criteria for a retryable read or a retryable write
+ *
+ * @typeParam T - The operation's type
+ * @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
+}) {
+  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
+    // server selection to potentially force monitor checks if the server is
+    // in an unknown state.
+    selector = (0, server_selection_1.sameServerSelector)(operation.server?.description);
+  } else if (operation.trySecondaryWrite) {
+    // If operation should try to write to secondary use the custom server selector
+    // otherwise provide the read preference.
+    selector = (0, server_selection_1.secondaryWritableServerSelector)(topology.commonWireVersion, readPreference);
+  } else {
+    selector = readPreference;
+  }
+
+  let server = await topology.selectServer(selector, {
+    session,
+    operationName: operation.commandName,
+    timeoutContext,
+    signal: operation.options.signal
+  });
+  const hasReadAspect = operation.hasAspect(operation_1.Aspect.READ_OPERATION);
+  const hasWriteAspect = operation.hasAspect(operation_1.Aspect.WRITE_OPERATION);
+  const inTransaction = session?.inTransaction() ?? false;
+  const willRetryRead = topology.s.options.retryReads && !inTransaction && operation.canRetryRead;
+  const willRetryWrite = topology.s.options.retryWrites && !inTransaction && (0, utils_1.supportsRetryableWrites)(server) && operation.canRetryWrite;
+  const willRetry = operation.hasAspect(operation_1.Aspect.RETRYABLE) && session != null && (hasReadAspect && willRetryRead || hasWriteAspect && willRetryWrite);
+
+  if (hasWriteAspect && willRetryWrite && session != null) {
+    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) {
+        throw new error_1.MongoServerError({
+          message: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
+          errmsg: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
+          originalError: previousOperationError
+        });
+      }
+
+      if (operation.hasAspect(operation_1.Aspect.COMMAND_BATCHING) && !operation.canRetryWrite) {
+        throw previousOperationError;
+      }
+
+      if (hasWriteAspect && !(0, error_1.isRetryableWriteError)(previousOperationError)) throw previousOperationError;
+      if (hasReadAspect && !(0, error_1.isRetryableReadError)(previousOperationError)) throw previousOperationError;
+
+      if (previousOperationError instanceof error_1.MongoNetworkError && operation.hasAspect(operation_1.Aspect.CURSOR_CREATING) && session != null && session.isPinned && !session.inTransaction()) {
+        session.unpin({
+          force: true,
+          forceClear: true
+        });
+      }
+
+      server = await topology.selectServer(selector, {
+        session,
+        operationName: operation.commandName,
+        previousServer,
+        signal: operation.options.signal
+      });
+
+      if (hasWriteAspect && !(0, utils_1.supportsRetryableWrites)(server)) {
+        throw new error_1.MongoUnexpectedServerResponseError('Selected server does not support retryable writes');
+      }
+    }
+
+    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)) {
+        operation.resetBatch();
+      }
+
+      return await operation.execute(server, session, timeoutContext);
+    } 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();
+    }
+  }
+
+  throw previousOperationError ?? new error_1.MongoRuntimeError('Tried to propagate retryability error, but no error was found.');
+}

package/transpiled/mongodb/lib/operations/find.js

@@ -0,0 +1,197 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FindOperation = void 0;
+
+const responses_1 = require("../cmap/wire_protocol/responses");
+
+const error_1 = require("../error");
+
+const explain_1 = require("../explain");
+
+const read_concern_1 = require("../read_concern");
+
+const sort_1 = require("../sort");
+
+const utils_1 = require("../utils");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class FindOperation extends command_1.CommandOperation {
+  constructor(ns, filter = {}, options = {}) {
+    super(undefined, options);
+    this.options = { ...options
+    };
+    delete this.options.writeConcern;
+    this.ns = ns;
+
+    if (typeof filter !== 'object' || Array.isArray(filter)) {
+      throw new error_1.MongoInvalidArgumentError('Query filter must be a plain object or ObjectId');
+    } // special case passing in an ObjectId as a filter
+
+
+    this.filter = filter != null && filter._bsontype === 'ObjectId' ? {
+      _id: filter
+    } : filter;
+  }
+
+  get commandName() {
+    return 'find';
+  }
+
+  async execute(server, session, timeoutContext) {
+    this.server = server;
+    const options = this.options;
+    let findCommand = makeFindCommand(this.ns, this.filter, options);
+
+    if (this.explain) {
+      (0, explain_1.validateExplainTimeoutOptions)(this.options, this.explain);
+      findCommand = (0, explain_1.decorateWithExplain)(findCommand, this.explain);
+    }
+
+    return await server.command(this.ns, findCommand, { ...this.options,
+      ...this.bsonOptions,
+      documentsReturnedIn: 'firstBatch',
+      session,
+      timeoutContext
+    }, this.explain ? responses_1.ExplainedCursorResponse : responses_1.CursorResponse);
+  }
+
+}
+
+exports.FindOperation = FindOperation;
+
+function makeFindCommand(ns, filter, options) {
+  const findCommand = {
+    find: ns.collection,
+    filter
+  };
+
+  if (options.sort) {
+    findCommand.sort = (0, sort_1.formatSort)(options.sort);
+  }
+
+  if (options.projection) {
+    let projection = options.projection;
+
+    if (projection && Array.isArray(projection)) {
+      projection = projection.length ? projection.reduce((result, field) => {
+        result[field] = 1;
+        return result;
+      }, {}) : {
+        _id: 1
+      };
+    }
+
+    findCommand.projection = projection;
+  }
+
+  if (options.hint) {
+    findCommand.hint = (0, utils_1.normalizeHintField)(options.hint);
+  }
+
+  if (typeof options.skip === 'number') {
+    findCommand.skip = options.skip;
+  }
+
+  if (typeof options.limit === 'number') {
+    if (options.limit < 0) {
+      findCommand.limit = -options.limit;
+      findCommand.singleBatch = true;
+    } else {
+      findCommand.limit = options.limit;
+    }
+  }
+
+  if (typeof options.batchSize === 'number') {
+    if (options.batchSize < 0) {
+      if (options.limit && options.limit !== 0 && Math.abs(options.batchSize) < Math.abs(options.limit)) {
+        findCommand.limit = -options.batchSize;
+      }
+
+      findCommand.singleBatch = true;
+    } else {
+      findCommand.batchSize = options.batchSize;
+    }
+  }
+
+  if (typeof options.singleBatch === 'boolean') {
+    findCommand.singleBatch = options.singleBatch;
+  } // we check for undefined specifically here to allow falsy values
+  // eslint-disable-next-line no-restricted-syntax
+
+
+  if (options.comment !== undefined) {
+    findCommand.comment = options.comment;
+  }
+
+  if (typeof options.maxTimeMS === 'number') {
+    findCommand.maxTimeMS = options.maxTimeMS;
+  }
+
+  const readConcern = read_concern_1.ReadConcern.fromOptions(options);
+
+  if (readConcern) {
+    findCommand.readConcern = readConcern.toJSON();
+  }
+
+  if (options.max) {
+    findCommand.max = options.max;
+  }
+
+  if (options.min) {
+    findCommand.min = options.min;
+  }
+
+  if (typeof options.returnKey === 'boolean') {
+    findCommand.returnKey = options.returnKey;
+  }
+
+  if (typeof options.showRecordId === 'boolean') {
+    findCommand.showRecordId = options.showRecordId;
+  }
+
+  if (typeof options.tailable === 'boolean') {
+    findCommand.tailable = options.tailable;
+  }
+
+  if (typeof options.oplogReplay === 'boolean') {
+    findCommand.oplogReplay = options.oplogReplay;
+  }
+
+  if (typeof options.timeout === 'boolean') {
+    findCommand.noCursorTimeout = !options.timeout;
+  } else if (typeof options.noCursorTimeout === 'boolean') {
+    findCommand.noCursorTimeout = options.noCursorTimeout;
+  }
+
+  if (typeof options.awaitData === 'boolean') {
+    findCommand.awaitData = options.awaitData;
+  }
+
+  if (typeof options.allowPartialResults === 'boolean') {
+    findCommand.allowPartialResults = options.allowPartialResults;
+  }
+
+  if (options.collation) {
+    findCommand.collation = options.collation;
+  }
+
+  if (typeof options.allowDiskUse === 'boolean') {
+    findCommand.allowDiskUse = options.allowDiskUse;
+  }
+
+  if (options.let) {
+    findCommand.let = options.let;
+  }
+
+  return findCommand;
+}
+
+(0, operation_1.defineAspects)(FindOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.RETRYABLE, operation_1.Aspect.EXPLAINABLE, operation_1.Aspect.CURSOR_CREATING]);