oxygen-cli 1.40.1 → 1.40.2-beta.1

package/transpiled/mongodb/lib/operations/client_bulk_write/results_merger.js

@@ -0,0 +1,228 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ClientBulkWriteResultsMerger = void 0;
+
+const __1 = require("../..");
+
+const error_1 = require("../../error");
+/**
+ * Unacknowledged bulk writes are always the same.
+ */
+
+
+const UNACKNOWLEDGED = {
+  acknowledged: false,
+  insertedCount: 0,
+  upsertedCount: 0,
+  matchedCount: 0,
+  modifiedCount: 0,
+  deletedCount: 0,
+  insertResults: undefined,
+  updateResults: undefined,
+  deleteResults: undefined
+};
+/**
+ * Merges client bulk write cursor responses together into a single result.
+ * @internal
+ */
+
+class ClientBulkWriteResultsMerger {
+  /**
+   * @returns The standard unacknowledged bulk write result.
+   */
+  static unacknowledged() {
+    return UNACKNOWLEDGED;
+  }
+  /**
+   * Instantiate the merger.
+   * @param options - The options.
+   */
+
+
+  constructor(options) {
+    this.options = options;
+    this.currentBatchOffset = 0;
+    this.writeConcernErrors = [];
+    this.writeErrors = new Map();
+    this.result = {
+      acknowledged: true,
+      insertedCount: 0,
+      upsertedCount: 0,
+      matchedCount: 0,
+      modifiedCount: 0,
+      deletedCount: 0,
+      insertResults: undefined,
+      updateResults: undefined,
+      deleteResults: undefined
+    };
+
+    if (options.verboseResults) {
+      this.result.insertResults = new Map();
+      this.result.updateResults = new Map();
+      this.result.deleteResults = new Map();
+    }
+  }
+  /**
+   * Get the bulk write result object.
+   */
+
+
+  get bulkWriteResult() {
+    return {
+      acknowledged: this.result.acknowledged,
+      insertedCount: this.result.insertedCount,
+      upsertedCount: this.result.upsertedCount,
+      matchedCount: this.result.matchedCount,
+      modifiedCount: this.result.modifiedCount,
+      deletedCount: this.result.deletedCount,
+      insertResults: this.result.insertResults,
+      updateResults: this.result.updateResults,
+      deleteResults: this.result.deleteResults
+    };
+  }
+  /**
+   * Merge the results in the cursor to the existing result.
+   * @param currentBatchOffset - The offset index to the original models.
+   * @param response - The cursor response.
+   * @param documents - The documents in the cursor.
+   * @returns The current result.
+   */
+
+
+  async merge(cursor) {
+    let writeConcernErrorResult;
+
+    try {
+      for await (const document of cursor) {
+        // Only add to maps if ok: 1
+        if (document.ok === 1) {
+          if (this.options.verboseResults) {
+            this.processDocument(cursor, document);
+          }
+        } else {
+          // If an individual write error is encountered during an ordered bulk write, drivers MUST
+          // record the error in writeErrors and immediately throw the exception. Otherwise, drivers
+          // MUST continue to iterate the results cursor and execute any further bulkWrite batches.
+          if (this.options.ordered) {
+            const error = new error_1.MongoClientBulkWriteError({
+              message: 'Mongo client ordered bulk write encountered a write error.'
+            });
+            error.writeErrors.set(document.idx + this.currentBatchOffset, {
+              code: document.code,
+              message: document.errmsg
+            });
+            error.partialResult = this.result;
+            throw error;
+          } else {
+            this.writeErrors.set(document.idx + this.currentBatchOffset, {
+              code: document.code,
+              message: document.errmsg
+            });
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof __1.MongoWriteConcernError) {
+        const result = error.result;
+        writeConcernErrorResult = {
+          insertedCount: result.nInserted,
+          upsertedCount: result.nUpserted,
+          matchedCount: result.nMatched,
+          modifiedCount: result.nModified,
+          deletedCount: result.nDeleted,
+          writeConcernError: result.writeConcernError
+        };
+
+        if (this.options.verboseResults && result.cursor.firstBatch) {
+          for (const document of result.cursor.firstBatch) {
+            if (document.ok === 1) {
+              this.processDocument(cursor, document);
+            }
+          }
+        }
+      } else {
+        throw error;
+      }
+    } finally {
+      // Update the counts from the cursor response.
+      if (cursor.response) {
+        const response = cursor.response;
+        this.incrementCounts(response);
+      } // Increment the batch offset.
+
+
+      this.currentBatchOffset += cursor.operations.length;
+    } // If we have write concern errors ensure they are added.
+
+
+    if (writeConcernErrorResult) {
+      const writeConcernError = writeConcernErrorResult.writeConcernError;
+      this.incrementCounts(writeConcernErrorResult);
+      this.writeConcernErrors.push({
+        code: writeConcernError.code,
+        message: writeConcernError.errmsg
+      });
+    }
+
+    return this.result;
+  }
+  /**
+   * Process an individual document in the results.
+   * @param cursor - The cursor.
+   * @param document - The document to process.
+   */
+
+
+  processDocument(cursor, document) {
+    // Get the corresponding operation from the command.
+    const operation = cursor.operations[document.idx]; // Handle insert results.
+
+    if ('insert' in operation) {
+      this.result.insertResults?.set(document.idx + this.currentBatchOffset, {
+        insertedId: operation.document._id
+      });
+    } // Handle update results.
+
+
+    if ('update' in operation) {
+      const result = {
+        matchedCount: document.n,
+        modifiedCount: document.nModified ?? 0,
+        // Check if the bulk did actually upsert.
+        didUpsert: document.upserted != null
+      };
+
+      if (document.upserted) {
+        result.upsertedId = document.upserted._id;
+      }
+
+      this.result.updateResults?.set(document.idx + this.currentBatchOffset, result);
+    } // Handle delete results.
+
+
+    if ('delete' in operation) {
+      this.result.deleteResults?.set(document.idx + this.currentBatchOffset, {
+        deletedCount: document.n
+      });
+    }
+  }
+  /**
+   * Increment the result counts.
+   * @param document - The document with the results.
+   */
+
+
+  incrementCounts(document) {
+    this.result.insertedCount += document.insertedCount;
+    this.result.upsertedCount += document.upsertedCount;
+    this.result.matchedCount += document.matchedCount;
+    this.result.modifiedCount += document.modifiedCount;
+    this.result.deletedCount += document.deletedCount;
+  }
+
+}
+
+exports.ClientBulkWriteResultsMerger = ClientBulkWriteResultsMerger;

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

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CollectionsOperation = void 0;
+
+const collection_1 = require("../collection");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class CollectionsOperation extends operation_1.AbstractOperation {
+  constructor(db, options) {
+    super(options);
+    this.options = options;
+    this.db = db;
+  }
+
+  get commandName() {
+    return 'listCollections';
+  }
+
+  async execute(server, session) {
+    // Let's get the collection names
+    const documents = await this.db.listCollections({}, { ...this.options,
+      nameOnly: true,
+      readPreference: this.readPreference,
+      session
+    }).toArray();
+    const collections = [];
+
+    for (const {
+      name
+    } of documents) {
+      if (!name.includes('$')) {
+        // Filter collections removing any illegal ones
+        collections.push(new collection_1.Collection(this.db, name, this.db.s.options));
+      }
+    } // Return the collection objects
+
+
+    return collections;
+  }
+
+}
+
+exports.CollectionsOperation = CollectionsOperation;

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

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CommandOperation = void 0;
+
+const error_1 = require("../error");
+
+const explain_1 = require("../explain");
+
+const read_concern_1 = require("../read_concern");
+
+const server_selection_1 = require("../sdam/server_selection");
+
+const utils_1 = require("../utils");
+
+const write_concern_1 = require("../write_concern");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class CommandOperation extends operation_1.AbstractOperation {
+  constructor(parent, options) {
+    super(options);
+    this.options = options ?? {}; // NOTE: this was explicitly added for the add/remove user operations, it's likely
+    //       something we'd want to reconsider. Perhaps those commands can use `Admin`
+    //       as a parent?
+
+    const dbNameOverride = options?.dbName || options?.authdb;
+
+    if (dbNameOverride) {
+      this.ns = new utils_1.MongoDBNamespace(dbNameOverride, '$cmd');
+    } else {
+      this.ns = parent ? parent.s.namespace.withCollection('$cmd') : new utils_1.MongoDBNamespace('admin', '$cmd');
+    }
+
+    this.readConcern = read_concern_1.ReadConcern.fromOptions(options);
+    this.writeConcern = write_concern_1.WriteConcern.fromOptions(options);
+
+    if (this.hasAspect(operation_1.Aspect.EXPLAINABLE)) {
+      this.explain = explain_1.Explain.fromOptions(options);
+      if (this.explain) (0, explain_1.validateExplainTimeoutOptions)(this.options, this.explain);
+    } else if (options?.explain != null) {
+      throw new error_1.MongoInvalidArgumentError(`Option "explain" is not supported on this command`);
+    }
+  }
+
+  get canRetryWrite() {
+    if (this.hasAspect(operation_1.Aspect.EXPLAINABLE)) {
+      return this.explain == null;
+    }
+
+    return super.canRetryWrite;
+  }
+
+  async executeCommand(server, session, cmd, timeoutContext, responseType) {
+    this.server = server;
+    const options = { ...this.options,
+      ...this.bsonOptions,
+      timeoutContext,
+      readPreference: this.readPreference,
+      session
+    };
+    const serverWireVersion = (0, utils_1.maxWireVersion)(server);
+    const inTransaction = this.session && this.session.inTransaction();
+
+    if (this.readConcern && (0, utils_1.commandSupportsReadConcern)(cmd) && !inTransaction) {
+      Object.assign(cmd, {
+        readConcern: this.readConcern
+      });
+    }
+
+    if (this.trySecondaryWrite && serverWireVersion < server_selection_1.MIN_SECONDARY_WRITE_WIRE_VERSION) {
+      options.omitReadPreference = true;
+    }
+
+    if (this.writeConcern && this.hasAspect(operation_1.Aspect.WRITE_OPERATION) && !inTransaction) {
+      write_concern_1.WriteConcern.apply(cmd, this.writeConcern);
+    }
+
+    if (options.collation && typeof options.collation === 'object' && !this.hasAspect(operation_1.Aspect.SKIP_COLLATION)) {
+      Object.assign(cmd, {
+        collation: options.collation
+      });
+    }
+
+    if (typeof options.maxTimeMS === 'number') {
+      cmd.maxTimeMS = options.maxTimeMS;
+    }
+
+    if (this.hasAspect(operation_1.Aspect.EXPLAINABLE) && this.explain) {
+      cmd = (0, explain_1.decorateWithExplain)(cmd, this.explain);
+    }
+
+    return await server.command(this.ns, cmd, options, responseType);
+  }
+
+}
+
+exports.CommandOperation = CommandOperation;

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

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CountOperation = void 0;
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class CountOperation extends command_1.CommandOperation {
+  constructor(namespace, filter, options) {
+    super({
+      s: {
+        namespace: namespace
+      }
+    }, options);
+    this.options = options;
+    this.collectionName = namespace.collection;
+    this.query = filter;
+  }
+
+  get commandName() {
+    return 'count';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const options = this.options;
+    const cmd = {
+      count: this.collectionName,
+      query: this.query
+    };
+
+    if (typeof options.limit === 'number') {
+      cmd.limit = options.limit;
+    }
+
+    if (typeof options.skip === 'number') {
+      cmd.skip = options.skip;
+    }
+
+    if (options.hint != null) {
+      cmd.hint = options.hint;
+    }
+
+    if (typeof options.maxTimeMS === 'number') {
+      cmd.maxTimeMS = options.maxTimeMS;
+    }
+
+    const result = await super.executeCommand(server, session, cmd, timeoutContext);
+    return result ? result.n : 0;
+  }
+
+}
+
+exports.CountOperation = CountOperation;
+(0, operation_1.defineAspects)(CountOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.RETRYABLE]);

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

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CreateCollectionOperation = void 0;
+
+const constants_1 = require("../cmap/wire_protocol/constants");
+
+const collection_1 = require("../collection");
+
+const error_1 = require("../error");
+
+const command_1 = require("./command");
+
+const indexes_1 = require("./indexes");
+
+const operation_1 = require("./operation");
+
+const ILLEGAL_COMMAND_FIELDS = new Set(['w', 'wtimeout', 'timeoutMS', 'j', 'fsync', 'autoIndexId', 'pkFactory', 'raw', 'readPreference', 'session', 'readConcern', 'writeConcern', 'raw', 'fieldsAsRaw', 'useBigInt64', 'promoteLongs', 'promoteValues', 'promoteBuffers', 'bsonRegExp', 'serializeFunctions', 'ignoreUndefined', 'enableUtf8Validation']);
+/* @internal */
+
+const INVALID_QE_VERSION = 'Driver support of Queryable Encryption is incompatible with server. Upgrade server to use Queryable Encryption.';
+/** @internal */
+
+class CreateCollectionOperation extends command_1.CommandOperation {
+  constructor(db, name, options = {}) {
+    super(db, options);
+    this.options = options;
+    this.db = db;
+    this.name = name;
+  }
+
+  get commandName() {
+    return 'create';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const db = this.db;
+    const name = this.name;
+    const options = this.options;
+    const encryptedFields = options.encryptedFields ?? db.client.s.options.autoEncryption?.encryptedFieldsMap?.[`${db.databaseName}.${name}`];
+
+    if (encryptedFields) {
+      // Creating a QE collection required min server of 7.0.0
+      // TODO(NODE-5353): Get wire version information from connection.
+      if (!server.loadBalanced && server.description.maxWireVersion < constants_1.MIN_SUPPORTED_QE_WIRE_VERSION) {
+        throw new error_1.MongoCompatibilityError(`${INVALID_QE_VERSION} The minimum server version required is ${constants_1.MIN_SUPPORTED_QE_SERVER_VERSION}`);
+      } // Create auxilliary collections for queryable encryption support.
+
+
+      const escCollection = encryptedFields.escCollection ?? `enxcol_.${name}.esc`;
+      const ecocCollection = encryptedFields.ecocCollection ?? `enxcol_.${name}.ecoc`;
+
+      for (const collectionName of [escCollection, ecocCollection]) {
+        const createOp = new CreateCollectionOperation(db, collectionName, {
+          clusteredIndex: {
+            key: {
+              _id: 1
+            },
+            unique: true
+          }
+        });
+        await createOp.executeWithoutEncryptedFieldsCheck(server, session, timeoutContext);
+      }
+
+      if (!options.encryptedFields) {
+        this.options = { ...this.options,
+          encryptedFields
+        };
+      }
+    }
+
+    const coll = await this.executeWithoutEncryptedFieldsCheck(server, session, timeoutContext);
+
+    if (encryptedFields) {
+      // Create the required index for queryable encryption support.
+      const createIndexOp = indexes_1.CreateIndexesOperation.fromIndexSpecification(db, name, {
+        __safeContent__: 1
+      }, {});
+      await createIndexOp.execute(server, session, timeoutContext);
+    }
+
+    return coll;
+  }
+
+  async executeWithoutEncryptedFieldsCheck(server, session, timeoutContext) {
+    const db = this.db;
+    const name = this.name;
+    const options = this.options;
+    const cmd = {
+      create: name
+    };
+
+    for (const n in options) {
+      if (options[n] != null && typeof options[n] !== 'function' && !ILLEGAL_COMMAND_FIELDS.has(n)) {
+        cmd[n] = options[n];
+      }
+    } // otherwise just execute the command
+
+
+    await super.executeCommand(server, session, cmd, timeoutContext);
+    return new collection_1.Collection(db, name, options);
+  }
+
+}
+
+exports.CreateCollectionOperation = CreateCollectionOperation;
+(0, operation_1.defineAspects)(CreateCollectionOperation, [operation_1.Aspect.WRITE_OPERATION]);

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

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DeleteManyOperation = exports.DeleteOneOperation = exports.DeleteOperation = void 0;
+exports.makeDeleteStatement = makeDeleteStatement;
+
+const error_1 = require("../error");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class DeleteOperation extends command_1.CommandOperation {
+  constructor(ns, statements, options) {
+    super(undefined, options);
+    this.options = options;
+    this.ns = ns;
+    this.statements = statements;
+  }
+
+  get commandName() {
+    return 'delete';
+  }
+
+  get canRetryWrite() {
+    if (super.canRetryWrite === false) {
+      return false;
+    }
+
+    return this.statements.every(op => op.limit != null ? op.limit > 0 : true);
+  }
+
+  async execute(server, session, timeoutContext) {
+    const options = this.options ?? {};
+    const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
+    const command = {
+      delete: this.ns.collection,
+      deletes: this.statements,
+      ordered
+    };
+
+    if (options.let) {
+      command.let = options.let;
+    } // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+
+
+    if (options.comment !== undefined) {
+      command.comment = options.comment;
+    }
+
+    const unacknowledgedWrite = this.writeConcern && this.writeConcern.w === 0;
+
+    if (unacknowledgedWrite) {
+      if (this.statements.find(o => o.hint)) {
+        // TODO(NODE-3541): fix error for hint with unacknowledged writes
+        throw new error_1.MongoCompatibilityError(`hint is not supported with unacknowledged writes`);
+      }
+    }
+
+    const res = await super.executeCommand(server, session, command, timeoutContext);
+    return res;
+  }
+
+}
+
+exports.DeleteOperation = DeleteOperation;
+
+class DeleteOneOperation extends DeleteOperation {
+  constructor(collection, filter, options) {
+    super(collection.s.namespace, [makeDeleteStatement(filter, { ...options,
+      limit: 1
+    })], options);
+  }
+
+  async execute(server, session, timeoutContext) {
+    const res = await super.execute(server, session, timeoutContext);
+    if (this.explain) return res;
+    if (res.code) throw new error_1.MongoServerError(res);
+    if (res.writeErrors) throw new error_1.MongoServerError(res.writeErrors[0]);
+    return {
+      acknowledged: this.writeConcern?.w !== 0,
+      deletedCount: res.n
+    };
+  }
+
+}
+
+exports.DeleteOneOperation = DeleteOneOperation;
+
+class DeleteManyOperation extends DeleteOperation {
+  constructor(collection, filter, options) {
+    super(collection.s.namespace, [makeDeleteStatement(filter, options)], options);
+  }
+
+  async execute(server, session, timeoutContext) {
+    const res = await super.execute(server, session, timeoutContext);
+    if (this.explain) return res;
+    if (res.code) throw new error_1.MongoServerError(res);
+    if (res.writeErrors) throw new error_1.MongoServerError(res.writeErrors[0]);
+    return {
+      acknowledged: this.writeConcern?.w !== 0,
+      deletedCount: res.n
+    };
+  }
+
+}
+
+exports.DeleteManyOperation = DeleteManyOperation;
+
+function makeDeleteStatement(filter, options) {
+  const op = {
+    q: filter,
+    limit: typeof options.limit === 'number' ? options.limit : 0
+  };
+
+  if (options.collation) {
+    op.collation = options.collation;
+  }
+
+  if (options.hint) {
+    op.hint = options.hint;
+  }
+
+  return op;
+}
+
+(0, operation_1.defineAspects)(DeleteOperation, [operation_1.Aspect.RETRYABLE, operation_1.Aspect.WRITE_OPERATION]);
+(0, operation_1.defineAspects)(DeleteOneOperation, [operation_1.Aspect.RETRYABLE, operation_1.Aspect.WRITE_OPERATION, operation_1.Aspect.EXPLAINABLE, operation_1.Aspect.SKIP_COLLATION]);
+(0, operation_1.defineAspects)(DeleteManyOperation, [operation_1.Aspect.WRITE_OPERATION, operation_1.Aspect.EXPLAINABLE, operation_1.Aspect.SKIP_COLLATION]);