oxygen-cli 1.40.1 → 1.40.2-beta.1

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

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FindOneAndUpdateOperation = exports.FindOneAndReplaceOperation = exports.FindOneAndDeleteOperation = exports.FindAndModifyOperation = exports.ReturnDocument = void 0;
+
+const error_1 = require("../error");
+
+const read_preference_1 = require("../read_preference");
+
+const sort_1 = require("../sort");
+
+const utils_1 = require("../utils");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @public */
+
+
+exports.ReturnDocument = Object.freeze({
+  BEFORE: 'before',
+  AFTER: 'after'
+});
+
+function configureFindAndModifyCmdBaseUpdateOpts(cmdBase, options) {
+  cmdBase.new = options.returnDocument === exports.ReturnDocument.AFTER;
+  cmdBase.upsert = options.upsert === true;
+
+  if (options.bypassDocumentValidation === true) {
+    cmdBase.bypassDocumentValidation = options.bypassDocumentValidation;
+  }
+
+  return cmdBase;
+}
+/** @internal */
+
+
+class FindAndModifyOperation extends command_1.CommandOperation {
+  constructor(collection, query, options) {
+    super(collection, options);
+    this.options = options ?? {};
+    this.cmdBase = {
+      remove: false,
+      new: false,
+      upsert: false
+    };
+    options.includeResultMetadata ??= false;
+    const sort = (0, sort_1.formatSort)(options.sort);
+
+    if (sort) {
+      this.cmdBase.sort = sort;
+    }
+
+    if (options.projection) {
+      this.cmdBase.fields = options.projection;
+    }
+
+    if (options.maxTimeMS) {
+      this.cmdBase.maxTimeMS = options.maxTimeMS;
+    } // Decorate the findAndModify command with the write Concern
+
+
+    if (options.writeConcern) {
+      this.cmdBase.writeConcern = options.writeConcern;
+    }
+
+    if (options.let) {
+      this.cmdBase.let = options.let;
+    } // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+
+
+    if (options.comment !== undefined) {
+      this.cmdBase.comment = options.comment;
+    } // force primary read preference
+
+
+    this.readPreference = read_preference_1.ReadPreference.primary;
+    this.collection = collection;
+    this.query = query;
+  }
+
+  get commandName() {
+    return 'findAndModify';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const coll = this.collection;
+    const query = this.query;
+    const options = { ...this.options,
+      ...this.bsonOptions
+    }; // Create findAndModify command object
+
+    const cmd = {
+      findAndModify: coll.collectionName,
+      query: query,
+      ...this.cmdBase
+    };
+    (0, utils_1.decorateWithCollation)(cmd, coll, options);
+
+    if (options.hint) {
+      // TODO: once this method becomes a CommandOperation we will have the server
+      // in place to check.
+      const unacknowledgedWrite = this.writeConcern?.w === 0;
+
+      if (unacknowledgedWrite || (0, utils_1.maxWireVersion)(server) < 8) {
+        throw new error_1.MongoCompatibilityError('The current topology does not support a hint on findAndModify commands');
+      }
+
+      cmd.hint = options.hint;
+    } // Execute the command
+
+
+    const result = await super.executeCommand(server, session, cmd, timeoutContext);
+    return options.includeResultMetadata ? result : result.value ?? null;
+  }
+
+}
+
+exports.FindAndModifyOperation = FindAndModifyOperation;
+/** @internal */
+
+class FindOneAndDeleteOperation extends FindAndModifyOperation {
+  constructor(collection, filter, options) {
+    // Basic validation
+    if (filter == null || typeof filter !== 'object') {
+      throw new error_1.MongoInvalidArgumentError('Argument "filter" must be an object');
+    }
+
+    super(collection, filter, options);
+    this.cmdBase.remove = true;
+  }
+
+}
+
+exports.FindOneAndDeleteOperation = FindOneAndDeleteOperation;
+/** @internal */
+
+class FindOneAndReplaceOperation extends FindAndModifyOperation {
+  constructor(collection, filter, replacement, options) {
+    if (filter == null || typeof filter !== 'object') {
+      throw new error_1.MongoInvalidArgumentError('Argument "filter" must be an object');
+    }
+
+    if (replacement == null || typeof replacement !== 'object') {
+      throw new error_1.MongoInvalidArgumentError('Argument "replacement" must be an object');
+    }
+
+    if ((0, utils_1.hasAtomicOperators)(replacement)) {
+      throw new error_1.MongoInvalidArgumentError('Replacement document must not contain atomic operators');
+    }
+
+    super(collection, filter, options);
+    this.cmdBase.update = replacement;
+    configureFindAndModifyCmdBaseUpdateOpts(this.cmdBase, options);
+  }
+
+}
+
+exports.FindOneAndReplaceOperation = FindOneAndReplaceOperation;
+/** @internal */
+
+class FindOneAndUpdateOperation extends FindAndModifyOperation {
+  constructor(collection, filter, update, options) {
+    if (filter == null || typeof filter !== 'object') {
+      throw new error_1.MongoInvalidArgumentError('Argument "filter" must be an object');
+    }
+
+    if (update == null || typeof update !== 'object') {
+      throw new error_1.MongoInvalidArgumentError('Argument "update" must be an object');
+    }
+
+    if (!(0, utils_1.hasAtomicOperators)(update, options)) {
+      throw new error_1.MongoInvalidArgumentError('Update document requires atomic operators');
+    }
+
+    super(collection, filter, options);
+    this.cmdBase.update = update;
+    configureFindAndModifyCmdBaseUpdateOpts(this.cmdBase, options);
+
+    if (options.arrayFilters) {
+      this.cmdBase.arrayFilters = options.arrayFilters;
+    }
+  }
+
+}
+
+exports.FindOneAndUpdateOperation = FindOneAndUpdateOperation;
+(0, operation_1.defineAspects)(FindAndModifyOperation, [operation_1.Aspect.WRITE_OPERATION, operation_1.Aspect.RETRYABLE, operation_1.Aspect.EXPLAINABLE]);

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

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GetMoreOperation = void 0;
+
+const responses_1 = require("../cmap/wire_protocol/responses");
+
+const error_1 = require("../error");
+
+const utils_1 = require("../utils");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class GetMoreOperation extends operation_1.AbstractOperation {
+  constructor(ns, cursorId, server, options) {
+    super(options);
+    this.options = options;
+    this.ns = ns;
+    this.cursorId = cursorId;
+    this.server = server;
+  }
+
+  get commandName() {
+    return 'getMore';
+  }
+  /**
+   * Although there is a server already associated with the get more operation, the signature
+   * for execute passes a server so we will just use that one.
+   */
+
+
+  async execute(server, _session, timeoutContext) {
+    if (server !== this.server) {
+      throw new error_1.MongoRuntimeError('Getmore must run on the same server operation began on');
+    }
+
+    if (this.cursorId == null || this.cursorId.isZero()) {
+      throw new error_1.MongoRuntimeError('Unable to iterate cursor with no id');
+    }
+
+    const collection = this.ns.collection;
+
+    if (collection == null) {
+      // Cursors should have adopted the namespace returned by MongoDB
+      // which should always defined a collection name (even a pseudo one, ex. db.aggregate())
+      throw new error_1.MongoRuntimeError('A collection name must be determined before getMore');
+    }
+
+    const getMoreCmd = {
+      getMore: this.cursorId,
+      collection
+    };
+
+    if (typeof this.options.batchSize === 'number') {
+      getMoreCmd.batchSize = Math.abs(this.options.batchSize);
+    }
+
+    if (typeof this.options.maxAwaitTimeMS === 'number') {
+      getMoreCmd.maxTimeMS = this.options.maxAwaitTimeMS;
+    } // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+
+
+    if (this.options.comment !== undefined && (0, utils_1.maxWireVersion)(server) >= 9) {
+      getMoreCmd.comment = this.options.comment;
+    }
+
+    const commandOptions = {
+      returnFieldSelector: null,
+      documentsReturnedIn: 'nextBatch',
+      timeoutContext,
+      ...this.options
+    };
+    return await server.command(this.ns, getMoreCmd, commandOptions, responses_1.CursorResponse);
+  }
+
+}
+
+exports.GetMoreOperation = GetMoreOperation;
+(0, operation_1.defineAspects)(GetMoreOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.MUST_SELECT_SAME_SERVER]);

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

@@ -0,0 +1,197 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ListIndexesOperation = exports.DropIndexOperation = exports.CreateIndexesOperation = void 0;
+
+const responses_1 = require("../cmap/wire_protocol/responses");
+
+const error_1 = require("../error");
+
+const utils_1 = require("../utils");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+
+const VALID_INDEX_OPTIONS = new Set(['background', 'unique', 'name', 'partialFilterExpression', 'sparse', 'hidden', 'expireAfterSeconds', 'storageEngine', 'collation', 'version', // text indexes
+'weights', 'default_language', 'language_override', 'textIndexVersion', // 2d-sphere indexes
+'2dsphereIndexVersion', // 2d indexes
+'bits', 'min', 'max', // geoHaystack Indexes
+'bucketSize', // wildcard indexes
+'wildcardProjection']);
+
+function isIndexDirection(x) {
+  return typeof x === 'number' || x === '2d' || x === '2dsphere' || x === 'text' || x === 'geoHaystack';
+}
+
+function isSingleIndexTuple(t) {
+  return Array.isArray(t) && t.length === 2 && isIndexDirection(t[1]);
+}
+/**
+ * Converts an `IndexSpecification`, which can be specified in multiple formats, into a
+ * valid `key` for the createIndexes command.
+ */
+
+
+function constructIndexDescriptionMap(indexSpec) {
+  const key = new Map();
+  const indexSpecs = !Array.isArray(indexSpec) || isSingleIndexTuple(indexSpec) ? [indexSpec] : indexSpec; // Iterate through array and handle different types
+
+  for (const spec of indexSpecs) {
+    if (typeof spec === 'string') {
+      key.set(spec, 1);
+    } else if (Array.isArray(spec)) {
+      key.set(spec[0], spec[1] ?? 1);
+    } else if (spec instanceof Map) {
+      for (const [property, value] of spec) {
+        key.set(property, value);
+      }
+    } else if ((0, utils_1.isObject)(spec)) {
+      for (const [property, value] of Object.entries(spec)) {
+        key.set(property, value);
+      }
+    }
+  }
+
+  return key;
+}
+/**
+ * Receives an index description and returns a modified index description which has had invalid options removed
+ * from the description and has mapped the `version` option to the `v` option.
+ */
+
+
+function resolveIndexDescription(description) {
+  const validProvidedOptions = Object.entries(description).filter(([optionName]) => VALID_INDEX_OPTIONS.has(optionName));
+  return Object.fromEntries( // we support the `version` option, but the `createIndexes` command expects it to be the `v`
+  validProvidedOptions.map(([name, value]) => name === 'version' ? ['v', value] : [name, value]));
+}
+/** @internal */
+
+
+class CreateIndexesOperation extends command_1.CommandOperation {
+  constructor(parent, collectionName, indexes, options) {
+    super(parent, options);
+    this.options = options ?? {};
+    this.collectionName = collectionName;
+    this.indexes = indexes.map(userIndex => {
+      // Ensure the key is a Map to preserve index key ordering
+      const key = userIndex.key instanceof Map ? userIndex.key : new Map(Object.entries(userIndex.key));
+      const name = userIndex.name ?? Array.from(key).flat().join('_');
+      const validIndexOptions = resolveIndexDescription(userIndex);
+      return { ...validIndexOptions,
+        name,
+        key
+      };
+    });
+  }
+
+  static fromIndexDescriptionArray(parent, collectionName, indexes, options) {
+    return new CreateIndexesOperation(parent, collectionName, indexes, options);
+  }
+
+  static fromIndexSpecification(parent, collectionName, indexSpec, options = {}) {
+    const key = constructIndexDescriptionMap(indexSpec);
+    const description = { ...options,
+      key
+    };
+    return new CreateIndexesOperation(parent, collectionName, [description], options);
+  }
+
+  get commandName() {
+    return 'createIndexes';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const options = this.options;
+    const indexes = this.indexes;
+    const serverWireVersion = (0, utils_1.maxWireVersion)(server);
+    const cmd = {
+      createIndexes: this.collectionName,
+      indexes
+    };
+
+    if (options.commitQuorum != null) {
+      if (serverWireVersion < 9) {
+        throw new error_1.MongoCompatibilityError('Option `commitQuorum` for `createIndexes` not supported on servers < 4.4');
+      }
+
+      cmd.commitQuorum = options.commitQuorum;
+    } // collation is set on each index, it should not be defined at the root
+
+
+    this.options.collation = undefined;
+    await super.executeCommand(server, session, cmd, timeoutContext);
+    const indexNames = indexes.map(index => index.name || '');
+    return indexNames;
+  }
+
+}
+
+exports.CreateIndexesOperation = CreateIndexesOperation;
+/** @internal */
+
+class DropIndexOperation extends command_1.CommandOperation {
+  constructor(collection, indexName, options) {
+    super(collection, options);
+    this.options = options ?? {};
+    this.collection = collection;
+    this.indexName = indexName;
+  }
+
+  get commandName() {
+    return 'dropIndexes';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const cmd = {
+      dropIndexes: this.collection.collectionName,
+      index: this.indexName
+    };
+    return await super.executeCommand(server, session, cmd, timeoutContext);
+  }
+
+}
+
+exports.DropIndexOperation = DropIndexOperation;
+/** @internal */
+
+class ListIndexesOperation extends command_1.CommandOperation {
+  constructor(collection, options) {
+    super(collection, options);
+    this.options = { ...options
+    };
+    delete this.options.writeConcern;
+    this.collectionNamespace = collection.s.namespace;
+  }
+
+  get commandName() {
+    return 'listIndexes';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const serverWireVersion = (0, utils_1.maxWireVersion)(server);
+    const cursor = this.options.batchSize ? {
+      batchSize: this.options.batchSize
+    } : {};
+    const command = {
+      listIndexes: this.collectionNamespace.collection,
+      cursor
+    }; // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+
+    if (serverWireVersion >= 9 && this.options.comment !== undefined) {
+      command.comment = this.options.comment;
+    }
+
+    return await super.executeCommand(server, session, command, timeoutContext, responses_1.CursorResponse);
+  }
+
+}
+
+exports.ListIndexesOperation = ListIndexesOperation;
+(0, operation_1.defineAspects)(ListIndexesOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.RETRYABLE, operation_1.Aspect.CURSOR_CREATING]);
+(0, operation_1.defineAspects)(CreateIndexesOperation, [operation_1.Aspect.WRITE_OPERATION]);
+(0, operation_1.defineAspects)(DropIndexOperation, [operation_1.Aspect.WRITE_OPERATION]);

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

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InsertManyOperation = exports.InsertOneOperation = exports.InsertOperation = void 0;
+
+const error_1 = require("../error");
+
+const utils_1 = require("../utils");
+
+const write_concern_1 = require("../write_concern");
+
+const bulk_write_1 = require("./bulk_write");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class InsertOperation extends command_1.CommandOperation {
+  constructor(ns, documents, options) {
+    super(undefined, options);
+    this.options = { ...options,
+      checkKeys: options.checkKeys ?? false
+    };
+    this.ns = ns;
+    this.documents = documents;
+  }
+
+  get commandName() {
+    return 'insert';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const options = this.options ?? {};
+    const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
+    const command = {
+      insert: this.ns.collection,
+      documents: this.documents,
+      ordered
+    };
+
+    if (typeof options.bypassDocumentValidation === 'boolean') {
+      command.bypassDocumentValidation = options.bypassDocumentValidation;
+    } // 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;
+    }
+
+    return await super.executeCommand(server, session, command, timeoutContext);
+  }
+
+}
+
+exports.InsertOperation = InsertOperation;
+
+class InsertOneOperation extends InsertOperation {
+  constructor(collection, doc, options) {
+    super(collection.s.namespace, (0, utils_1.maybeAddIdToDocuments)(collection, [doc], options), options);
+  }
+
+  async execute(server, session, timeoutContext) {
+    const res = await super.execute(server, session, timeoutContext);
+    if (res.code) throw new error_1.MongoServerError(res);
+
+    if (res.writeErrors) {
+      // This should be a WriteError but we can't change it now because of error hierarchy
+      throw new error_1.MongoServerError(res.writeErrors[0]);
+    }
+
+    return {
+      acknowledged: this.writeConcern?.w !== 0,
+      insertedId: this.documents[0]._id
+    };
+  }
+
+}
+
+exports.InsertOneOperation = InsertOneOperation;
+/** @internal */
+
+class InsertManyOperation extends operation_1.AbstractOperation {
+  constructor(collection, docs, options) {
+    super(options);
+
+    if (!Array.isArray(docs)) {
+      throw new error_1.MongoInvalidArgumentError('Argument "docs" must be an array of documents');
+    }
+
+    this.options = options;
+    this.collection = collection;
+    this.docs = docs;
+  }
+
+  get commandName() {
+    return 'insert';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const coll = this.collection;
+    const options = { ...this.options,
+      ...this.bsonOptions,
+      readPreference: this.readPreference
+    };
+    const writeConcern = write_concern_1.WriteConcern.fromOptions(options);
+    const bulkWriteOperation = new bulk_write_1.BulkWriteOperation(coll, this.docs.map(document => ({
+      insertOne: {
+        document
+      }
+    })), options);
+
+    try {
+      const res = await bulkWriteOperation.execute(server, session, timeoutContext);
+      return {
+        acknowledged: writeConcern?.w !== 0,
+        insertedCount: res.insertedCount,
+        insertedIds: res.insertedIds
+      };
+    } catch (err) {
+      if (err && err.message === 'Operation must be an object with an operation key') {
+        throw new error_1.MongoInvalidArgumentError('Collection.insertMany() cannot be called with an array that has null/undefined values');
+      }
+
+      throw err;
+    }
+  }
+
+}
+
+exports.InsertManyOperation = InsertManyOperation;
+(0, operation_1.defineAspects)(InsertOperation, [operation_1.Aspect.RETRYABLE, operation_1.Aspect.WRITE_OPERATION]);
+(0, operation_1.defineAspects)(InsertOneOperation, [operation_1.Aspect.RETRYABLE, operation_1.Aspect.WRITE_OPERATION]);
+(0, operation_1.defineAspects)(InsertManyOperation, [operation_1.Aspect.WRITE_OPERATION]);

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IsCappedOperation = void 0;
+
+const error_1 = require("../error");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class IsCappedOperation extends operation_1.AbstractOperation {
+  constructor(collection, options) {
+    super(options);
+    this.options = options;
+    this.collection = collection;
+  }
+
+  get commandName() {
+    return 'listCollections';
+  }
+
+  async execute(server, session) {
+    const coll = this.collection;
+    const [collection] = await coll.s.db.listCollections({
+      name: coll.collectionName
+    }, { ...this.options,
+      nameOnly: false,
+      readPreference: this.readPreference,
+      session
+    }).toArray();
+
+    if (collection == null || collection.options == null) {
+      throw new error_1.MongoAPIError(`collection ${coll.namespace} not found`);
+    }
+
+    return !!collection.options?.capped;
+  }
+
+}
+
+exports.IsCappedOperation = IsCappedOperation;