oxygen-cli 1.40.1 → 1.40.2-beta.1

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

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KillCursorsOperation = void 0;
+
+const error_1 = require("../error");
+
+const utils_1 = require("../utils");
+
+const operation_1 = require("./operation");
+
+class KillCursorsOperation extends operation_1.AbstractOperation {
+  constructor(cursorId, ns, server, options) {
+    super(options);
+    this.ns = ns;
+    this.cursorId = cursorId;
+    this.server = server;
+  }
+
+  get commandName() {
+    return 'killCursors';
+  }
+
+  async execute(server, session, timeoutContext) {
+    if (server !== this.server) {
+      throw new error_1.MongoRuntimeError('Killcursor must run on the same server operation began on');
+    }
+
+    const killCursors = this.ns.collection;
+
+    if (killCursors == 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 killCursors');
+    }
+
+    const killCursorsCommand = {
+      killCursors,
+      cursors: [this.cursorId]
+    };
+
+    try {
+      await server.command(this.ns, killCursorsCommand, {
+        session,
+        timeoutContext
+      });
+    } catch (error) {
+      // The driver should never emit errors from killCursors, this is spec-ed behavior
+      (0, utils_1.squashError)(error);
+    }
+  }
+
+}
+
+exports.KillCursorsOperation = KillCursorsOperation;
+(0, operation_1.defineAspects)(KillCursorsOperation, [operation_1.Aspect.MUST_SELECT_SAME_SERVER]);

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

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ListCollectionsOperation = void 0;
+
+const responses_1 = require("../cmap/wire_protocol/responses");
+
+const utils_1 = require("../utils");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class ListCollectionsOperation extends command_1.CommandOperation {
+  constructor(db, filter, options) {
+    super(db, options);
+    this.options = { ...options
+    };
+    delete this.options.writeConcern;
+    this.db = db;
+    this.filter = filter;
+    this.nameOnly = !!this.options.nameOnly;
+    this.authorizedCollections = !!this.options.authorizedCollections;
+
+    if (typeof this.options.batchSize === 'number') {
+      this.batchSize = this.options.batchSize;
+    }
+  }
+
+  get commandName() {
+    return 'listCollections';
+  }
+
+  async execute(server, session, timeoutContext) {
+    return await super.executeCommand(server, session, this.generateCommand((0, utils_1.maxWireVersion)(server)), timeoutContext, responses_1.CursorResponse);
+  }
+  /* This is here for the purpose of unit testing the final command that gets sent. */
+
+
+  generateCommand(wireVersion) {
+    const command = {
+      listCollections: 1,
+      filter: this.filter,
+      cursor: this.batchSize ? {
+        batchSize: this.batchSize
+      } : {},
+      nameOnly: this.nameOnly,
+      authorizedCollections: this.authorizedCollections
+    }; // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+
+    if (wireVersion >= 9 && this.options.comment !== undefined) {
+      command.comment = this.options.comment;
+    }
+
+    return command;
+  }
+
+}
+
+exports.ListCollectionsOperation = ListCollectionsOperation;
+(0, operation_1.defineAspects)(ListCollectionsOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.RETRYABLE, operation_1.Aspect.CURSOR_CREATING]);

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

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ListDatabasesOperation = void 0;
+
+const utils_1 = require("../utils");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class ListDatabasesOperation extends command_1.CommandOperation {
+  constructor(db, options) {
+    super(db, options);
+    this.options = options ?? {};
+    this.ns = new utils_1.MongoDBNamespace('admin', '$cmd');
+  }
+
+  get commandName() {
+    return 'listDatabases';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const cmd = {
+      listDatabases: 1
+    };
+
+    if (typeof this.options.nameOnly === 'boolean') {
+      cmd.nameOnly = this.options.nameOnly;
+    }
+
+    if (this.options.filter) {
+      cmd.filter = this.options.filter;
+    }
+
+    if (typeof this.options.authorizedDatabases === 'boolean') {
+      cmd.authorizedDatabases = this.options.authorizedDatabases;
+    } // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+
+
+    if ((0, utils_1.maxWireVersion)(server) >= 9 && this.options.comment !== undefined) {
+      cmd.comment = this.options.comment;
+    }
+
+    return await super.executeCommand(server, session, cmd, timeoutContext);
+  }
+
+}
+
+exports.ListDatabasesOperation = ListDatabasesOperation;
+(0, operation_1.defineAspects)(ListDatabasesOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.RETRYABLE]);

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

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbstractOperation = exports.Aspect = void 0;
+exports.defineAspects = defineAspects;
+
+const bson_1 = require("../bson");
+
+const read_preference_1 = require("../read_preference");
+
+exports.Aspect = {
+  READ_OPERATION: Symbol('READ_OPERATION'),
+  WRITE_OPERATION: Symbol('WRITE_OPERATION'),
+  RETRYABLE: Symbol('RETRYABLE'),
+  EXPLAINABLE: Symbol('EXPLAINABLE'),
+  SKIP_COLLATION: Symbol('SKIP_COLLATION'),
+  CURSOR_CREATING: Symbol('CURSOR_CREATING'),
+  MUST_SELECT_SAME_SERVER: Symbol('MUST_SELECT_SAME_SERVER'),
+  COMMAND_BATCHING: Symbol('COMMAND_BATCHING')
+};
+/**
+ * This class acts as a parent class for any operation and is responsible for setting this.options,
+ * as well as setting and getting a session.
+ * Additionally, this class implements `hasAspect`, which determines whether an operation has
+ * a specific aspect.
+ * @internal
+ */
+
+class AbstractOperation {
+  constructor(options = {}) {
+    this.readPreference = this.hasAspect(exports.Aspect.WRITE_OPERATION) ? read_preference_1.ReadPreference.primary : read_preference_1.ReadPreference.fromOptions(options) ?? read_preference_1.ReadPreference.primary; // Pull the BSON serialize options from the already-resolved options
+
+    this.bsonOptions = (0, bson_1.resolveBSONOptions)(options);
+    this._session = options.session != null ? options.session : undefined;
+    this.options = options;
+    this.bypassPinningCheck = !!options.bypassPinningCheck;
+    this.trySecondaryWrite = false;
+  }
+
+  hasAspect(aspect) {
+    const ctor = this.constructor;
+
+    if (ctor.aspects == null) {
+      return false;
+    }
+
+    return ctor.aspects.has(aspect);
+  } // Make sure the session is not writable from outside this class.
+
+
+  get session() {
+    return this._session;
+  }
+
+  clearSession() {
+    this._session = undefined;
+  }
+
+  resetBatch() {
+    return true;
+  }
+
+  get canRetryRead() {
+    return this.hasAspect(exports.Aspect.RETRYABLE) && this.hasAspect(exports.Aspect.READ_OPERATION);
+  }
+
+  get canRetryWrite() {
+    return this.hasAspect(exports.Aspect.RETRYABLE) && this.hasAspect(exports.Aspect.WRITE_OPERATION);
+  }
+
+}
+
+exports.AbstractOperation = AbstractOperation;
+
+function defineAspects(operation, aspects) {
+  if (!Array.isArray(aspects) && !(aspects instanceof Set)) {
+    aspects = [aspects];
+  }
+
+  aspects = new Set(aspects);
+  Object.defineProperty(operation, 'aspects', {
+    value: aspects,
+    writable: false
+  });
+  return aspects;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OptionsOperation = void 0;
+
+const error_1 = require("../error");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class OptionsOperation 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;
+  }
+
+}
+
+exports.OptionsOperation = OptionsOperation;

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ProfilingLevelOperation = void 0;
+
+const error_1 = require("../error");
+
+const command_1 = require("./command");
+/** @internal */
+
+
+class ProfilingLevelOperation extends command_1.CommandOperation {
+  constructor(db, options) {
+    super(db, options);
+    this.options = options;
+  }
+
+  get commandName() {
+    return 'profile';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const doc = await super.executeCommand(server, session, {
+      profile: -1
+    }, timeoutContext);
+
+    if (doc.ok === 1) {
+      const was = doc.was;
+      if (was === 0) return 'off';
+      if (was === 1) return 'slow_only';
+      if (was === 2) return 'all';
+      throw new error_1.MongoUnexpectedServerResponseError(`Illegal profiling level value ${was}`);
+    } else {
+      throw new error_1.MongoUnexpectedServerResponseError('Error with profile command');
+    }
+  }
+
+}
+
+exports.ProfilingLevelOperation = ProfilingLevelOperation;

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

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RemoveUserOperation = void 0;
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class RemoveUserOperation extends command_1.CommandOperation {
+  constructor(db, username, options) {
+    super(db, options);
+    this.options = options;
+    this.username = username;
+  }
+
+  get commandName() {
+    return 'dropUser';
+  }
+
+  async execute(server, session, timeoutContext) {
+    await super.executeCommand(server, session, {
+      dropUser: this.username
+    }, timeoutContext);
+    return true;
+  }
+
+}
+
+exports.RemoveUserOperation = RemoveUserOperation;
+(0, operation_1.defineAspects)(RemoveUserOperation, [operation_1.Aspect.WRITE_OPERATION]);

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RenameOperation = void 0;
+
+const collection_1 = require("../collection");
+
+const utils_1 = require("../utils");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class RenameOperation extends command_1.CommandOperation {
+  constructor(collection, newName, options) {
+    super(collection, options);
+    this.collection = collection;
+    this.newName = newName;
+    this.options = options;
+    this.ns = new utils_1.MongoDBNamespace('admin', '$cmd');
+  }
+
+  get commandName() {
+    return 'renameCollection';
+  }
+
+  async execute(server, session, timeoutContext) {
+    // Build the command
+    const renameCollection = this.collection.namespace;
+    const toCollection = this.collection.s.namespace.withCollection(this.newName).toString();
+    const dropTarget = typeof this.options.dropTarget === 'boolean' ? this.options.dropTarget : false;
+    const command = {
+      renameCollection: renameCollection,
+      to: toCollection,
+      dropTarget: dropTarget
+    };
+    await super.executeCommand(server, session, command, timeoutContext);
+    return new collection_1.Collection(this.collection.s.db, this.newName, this.collection.s.options);
+  }
+
+}
+
+exports.RenameOperation = RenameOperation;
+(0, operation_1.defineAspects)(RenameOperation, [operation_1.Aspect.WRITE_OPERATION]);

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

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RunAdminCommandOperation = exports.RunCommandOperation = void 0;
+
+const utils_1 = require("../utils");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class RunCommandOperation extends operation_1.AbstractOperation {
+  constructor(parent, command, options) {
+    super(options);
+    this.command = command;
+    this.options = options;
+    this.ns = parent.s.namespace.withCollection('$cmd');
+  }
+
+  get commandName() {
+    return 'runCommand';
+  }
+
+  async execute(server, session, timeoutContext) {
+    this.server = server;
+    const res = await server.command(this.ns, this.command, { ...this.options,
+      readPreference: this.readPreference,
+      session,
+      timeoutContext
+    }, this.options.responseType);
+    return res;
+  }
+
+}
+
+exports.RunCommandOperation = RunCommandOperation;
+
+class RunAdminCommandOperation extends operation_1.AbstractOperation {
+  constructor(command, options) {
+    super(options);
+    this.command = command;
+    this.options = options;
+    this.ns = new utils_1.MongoDBNamespace('admin', '$cmd');
+  }
+
+  get commandName() {
+    return 'runCommand';
+  }
+
+  async execute(server, session, timeoutContext) {
+    this.server = server;
+    const res = await server.command(this.ns, this.command, { ...this.options,
+      readPreference: this.readPreference,
+      session,
+      timeoutContext
+    });
+    return res;
+  }
+
+}
+
+exports.RunAdminCommandOperation = RunAdminCommandOperation;

package/transpiled/mongodb/lib/operations/search_indexes/create.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CreateSearchIndexesOperation = void 0;
+
+const operation_1 = require("../operation");
+/** @internal */
+
+
+class CreateSearchIndexesOperation extends operation_1.AbstractOperation {
+  constructor(collection, descriptions) {
+    super();
+    this.collection = collection;
+    this.descriptions = descriptions;
+  }
+
+  get commandName() {
+    return 'createSearchIndexes';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const namespace = this.collection.fullNamespace;
+    const command = {
+      createSearchIndexes: namespace.collection,
+      indexes: this.descriptions
+    };
+    const res = await server.command(namespace, command, {
+      session,
+      timeoutContext
+    });
+    const indexesCreated = res?.indexesCreated ?? [];
+    return indexesCreated.map(({
+      name
+    }) => name);
+  }
+
+}
+
+exports.CreateSearchIndexesOperation = CreateSearchIndexesOperation;

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

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DropSearchIndexOperation = void 0;
+
+const error_1 = require("../../error");
+
+const operation_1 = require("../operation");
+/** @internal */
+
+
+class DropSearchIndexOperation extends operation_1.AbstractOperation {
+  constructor(collection, name) {
+    super();
+    this.collection = collection;
+    this.name = name;
+  }
+
+  get commandName() {
+    return 'dropSearchIndex';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const namespace = this.collection.fullNamespace;
+    const command = {
+      dropSearchIndex: namespace.collection
+    };
+
+    if (typeof this.name === 'string') {
+      command.name = this.name;
+    }
+
+    try {
+      await server.command(namespace, command, {
+        session,
+        timeoutContext
+      });
+    } catch (error) {
+      const isNamespaceNotFoundError = error instanceof error_1.MongoServerError && error.code === error_1.MONGODB_ERROR_CODES.NamespaceNotFound;
+
+      if (!isNamespaceNotFoundError) {
+        throw error;
+      }
+    }
+  }
+
+}
+
+exports.DropSearchIndexOperation = DropSearchIndexOperation;

package/transpiled/mongodb/lib/operations/search_indexes/update.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UpdateSearchIndexOperation = void 0;
+
+const operation_1 = require("../operation");
+/** @internal */
+
+
+class UpdateSearchIndexOperation extends operation_1.AbstractOperation {
+  constructor(collection, name, definition) {
+    super();
+    this.collection = collection;
+    this.name = name;
+    this.definition = definition;
+  }
+
+  get commandName() {
+    return 'updateSearchIndex';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const namespace = this.collection.fullNamespace;
+    const command = {
+      updateSearchIndex: namespace.collection,
+      name: this.name,
+      definition: this.definition
+    };
+    await server.command(namespace, command, {
+      session,
+      timeoutContext
+    });
+    return;
+  }
+
+}
+
+exports.UpdateSearchIndexOperation = UpdateSearchIndexOperation;