oxygen-cli 1.40.1 → 1.40.2-beta.1

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

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SetProfilingLevelOperation = exports.ProfilingLevel = void 0;
+
+const error_1 = require("../error");
+
+const utils_1 = require("../utils");
+
+const command_1 = require("./command");
+
+const levelValues = new Set(['off', 'slow_only', 'all']);
+/** @public */
+
+exports.ProfilingLevel = Object.freeze({
+  off: 'off',
+  slowOnly: 'slow_only',
+  all: 'all'
+});
+/** @internal */
+
+class SetProfilingLevelOperation extends command_1.CommandOperation {
+  constructor(db, level, options) {
+    super(db, options);
+    this.options = options;
+
+    switch (level) {
+      case exports.ProfilingLevel.off:
+        this.profile = 0;
+        break;
+
+      case exports.ProfilingLevel.slowOnly:
+        this.profile = 1;
+        break;
+
+      case exports.ProfilingLevel.all:
+        this.profile = 2;
+        break;
+
+      default:
+        this.profile = 0;
+        break;
+    }
+
+    this.level = level;
+  }
+
+  get commandName() {
+    return 'profile';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const level = this.level;
+
+    if (!levelValues.has(level)) {
+      throw new error_1.MongoInvalidArgumentError(`Profiling level must be one of "${(0, utils_1.enumToString)(exports.ProfilingLevel)}"`);
+    } // TODO(NODE-3483): Determine error to put here
+
+
+    await super.executeCommand(server, session, {
+      profile: this.profile
+    }, timeoutContext);
+    return level;
+  }
+
+}
+
+exports.SetProfilingLevelOperation = SetProfilingLevelOperation;

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

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

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

@@ -0,0 +1,218 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReplaceOneOperation = exports.UpdateManyOperation = exports.UpdateOneOperation = exports.UpdateOperation = void 0;
+exports.makeUpdateStatement = makeUpdateStatement;
+
+const error_1 = require("../error");
+
+const sort_1 = require("../sort");
+
+const utils_1 = require("../utils");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/**
+ * @internal
+ * UpdateOperation is used in bulk write, while UpdateOneOperation and UpdateManyOperation are only used in the collections API
+ */
+
+
+class UpdateOperation extends command_1.CommandOperation {
+  constructor(ns, statements, options) {
+    super(undefined, options);
+    this.options = options;
+    this.ns = ns;
+    this.statements = statements;
+  }
+
+  get commandName() {
+    return 'update';
+  }
+
+  get canRetryWrite() {
+    if (super.canRetryWrite === false) {
+      return false;
+    }
+
+    return this.statements.every(op => op.multi == null || op.multi === false);
+  }
+
+  async execute(server, session, timeoutContext) {
+    const options = this.options ?? {};
+    const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
+    const command = {
+      update: this.ns.collection,
+      updates: this.statements,
+      ordered
+    };
+
+    if (typeof options.bypassDocumentValidation === 'boolean') {
+      command.bypassDocumentValidation = options.bypassDocumentValidation;
+    }
+
+    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.UpdateOperation = UpdateOperation;
+/** @internal */
+
+class UpdateOneOperation extends UpdateOperation {
+  constructor(collection, filter, update, options) {
+    super(collection.s.namespace, [makeUpdateStatement(filter, update, { ...options,
+      multi: false
+    })], options);
+
+    if (!(0, utils_1.hasAtomicOperators)(update, options)) {
+      throw new error_1.MongoInvalidArgumentError('Update document requires atomic operators');
+    }
+  }
+
+  async execute(server, session, timeoutContext) {
+    const res = await super.execute(server, session, timeoutContext);
+    if (this.explain != null) 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,
+      modifiedCount: res.nModified ?? res.n,
+      upsertedId: Array.isArray(res.upserted) && res.upserted.length > 0 ? res.upserted[0]._id : null,
+      upsertedCount: Array.isArray(res.upserted) && res.upserted.length ? res.upserted.length : 0,
+      matchedCount: Array.isArray(res.upserted) && res.upserted.length > 0 ? 0 : res.n
+    };
+  }
+
+}
+
+exports.UpdateOneOperation = UpdateOneOperation;
+/** @internal */
+
+class UpdateManyOperation extends UpdateOperation {
+  constructor(collection, filter, update, options) {
+    super(collection.s.namespace, [makeUpdateStatement(filter, update, { ...options,
+      multi: true
+    })], options);
+
+    if (!(0, utils_1.hasAtomicOperators)(update, options)) {
+      throw new error_1.MongoInvalidArgumentError('Update document requires atomic operators');
+    }
+  }
+
+  async execute(server, session, timeoutContext) {
+    const res = await super.execute(server, session, timeoutContext);
+    if (this.explain != null) 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,
+      modifiedCount: res.nModified ?? res.n,
+      upsertedId: Array.isArray(res.upserted) && res.upserted.length > 0 ? res.upserted[0]._id : null,
+      upsertedCount: Array.isArray(res.upserted) && res.upserted.length ? res.upserted.length : 0,
+      matchedCount: Array.isArray(res.upserted) && res.upserted.length > 0 ? 0 : res.n
+    };
+  }
+
+}
+
+exports.UpdateManyOperation = UpdateManyOperation;
+/** @internal */
+
+class ReplaceOneOperation extends UpdateOperation {
+  constructor(collection, filter, replacement, options) {
+    super(collection.s.namespace, [makeUpdateStatement(filter, replacement, { ...options,
+      multi: false
+    })], options);
+
+    if ((0, utils_1.hasAtomicOperators)(replacement)) {
+      throw new error_1.MongoInvalidArgumentError('Replacement document must not contain atomic operators');
+    }
+  }
+
+  async execute(server, session, timeoutContext) {
+    const res = await super.execute(server, session, timeoutContext);
+    if (this.explain != null) 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,
+      modifiedCount: res.nModified ?? res.n,
+      upsertedId: Array.isArray(res.upserted) && res.upserted.length > 0 ? res.upserted[0]._id : null,
+      upsertedCount: Array.isArray(res.upserted) && res.upserted.length ? res.upserted.length : 0,
+      matchedCount: Array.isArray(res.upserted) && res.upserted.length > 0 ? 0 : res.n
+    };
+  }
+
+}
+
+exports.ReplaceOneOperation = ReplaceOneOperation;
+
+function makeUpdateStatement(filter, update, options) {
+  if (filter == null || typeof filter !== 'object') {
+    throw new error_1.MongoInvalidArgumentError('Selector must be a valid JavaScript object');
+  }
+
+  if (update == null || typeof update !== 'object') {
+    throw new error_1.MongoInvalidArgumentError('Document must be a valid JavaScript object');
+  }
+
+  const op = {
+    q: filter,
+    u: update
+  };
+
+  if (typeof options.upsert === 'boolean') {
+    op.upsert = options.upsert;
+  }
+
+  if (options.multi) {
+    op.multi = options.multi;
+  }
+
+  if (options.hint) {
+    op.hint = options.hint;
+  }
+
+  if (options.arrayFilters) {
+    op.arrayFilters = options.arrayFilters;
+  }
+
+  if (options.collation) {
+    op.collation = options.collation;
+  }
+
+  if (!options.multi && options.sort != null) {
+    op.sort = (0, sort_1.formatSort)(options.sort);
+  }
+
+  return op;
+}
+
+(0, operation_1.defineAspects)(UpdateOperation, [operation_1.Aspect.RETRYABLE, operation_1.Aspect.WRITE_OPERATION, operation_1.Aspect.SKIP_COLLATION]);
+(0, operation_1.defineAspects)(UpdateOneOperation, [operation_1.Aspect.RETRYABLE, operation_1.Aspect.WRITE_OPERATION, operation_1.Aspect.EXPLAINABLE, operation_1.Aspect.SKIP_COLLATION]);
+(0, operation_1.defineAspects)(UpdateManyOperation, [operation_1.Aspect.WRITE_OPERATION, operation_1.Aspect.EXPLAINABLE, operation_1.Aspect.SKIP_COLLATION]);
+(0, operation_1.defineAspects)(ReplaceOneOperation, [operation_1.Aspect.RETRYABLE, operation_1.Aspect.WRITE_OPERATION, operation_1.Aspect.SKIP_COLLATION]);

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

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValidateCollectionOperation = void 0;
+
+const error_1 = require("../error");
+
+const command_1 = require("./command");
+/** @internal */
+
+
+class ValidateCollectionOperation extends command_1.CommandOperation {
+  constructor(admin, collectionName, options) {
+    // Decorate command with extra options
+    const command = {
+      validate: collectionName
+    };
+    const keys = Object.keys(options);
+
+    for (let i = 0; i < keys.length; i++) {
+      if (Object.prototype.hasOwnProperty.call(options, keys[i]) && keys[i] !== 'session') {
+        command[keys[i]] = options[keys[i]];
+      }
+    }
+
+    super(admin.s.db, options);
+    this.options = options;
+    this.command = command;
+    this.collectionName = collectionName;
+  }
+
+  get commandName() {
+    return 'validate';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const collectionName = this.collectionName;
+    const doc = await super.executeCommand(server, session, this.command, timeoutContext);
+    if (doc.result != null && typeof doc.result !== 'string') throw new error_1.MongoUnexpectedServerResponseError('Error with validation data');
+    if (doc.result != null && doc.result.match(/exception|corrupt/) != null) throw new error_1.MongoUnexpectedServerResponseError(`Invalid collection ${collectionName}`);
+    if (doc.valid != null && !doc.valid) throw new error_1.MongoUnexpectedServerResponseError(`Invalid collection ${collectionName}`);
+    return doc;
+  }
+
+}
+
+exports.ValidateCollectionOperation = ValidateCollectionOperation;

package/transpiled/mongodb/lib/read_concern.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReadConcern = exports.ReadConcernLevel = void 0;
+/** @public */
+
+exports.ReadConcernLevel = Object.freeze({
+  local: 'local',
+  majority: 'majority',
+  linearizable: 'linearizable',
+  available: 'available',
+  snapshot: 'snapshot'
+});
+/**
+ * The MongoDB ReadConcern, which allows for control of the consistency and isolation properties
+ * of the data read from replica sets and replica set shards.
+ * @public
+ *
+ * @see https://www.mongodb.com/docs/manual/reference/read-concern/index.html
+ */
+
+class ReadConcern {
+  /** Constructs a ReadConcern from the read concern level.*/
+  constructor(level) {
+    /**
+     * A spec test exists that allows level to be any string.
+     * "invalid readConcern with out stage"
+     * @see ./test/spec/crud/v2/aggregate-out-readConcern.json
+     * @see https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.md#unknown-levels-and-additional-options-for-string-based-readconcerns
+     */
+    this.level = exports.ReadConcernLevel[level] ?? level;
+  }
+  /**
+   * Construct a ReadConcern given an options object.
+   *
+   * @param options - The options object from which to extract the write concern.
+   */
+
+
+  static fromOptions(options) {
+    if (options == null) {
+      return;
+    }
+
+    if (options.readConcern) {
+      const {
+        readConcern
+      } = options;
+
+      if (readConcern instanceof ReadConcern) {
+        return readConcern;
+      } else if (typeof readConcern === 'string') {
+        return new ReadConcern(readConcern);
+      } else if ('level' in readConcern && readConcern.level) {
+        return new ReadConcern(readConcern.level);
+      }
+    }
+
+    if (options.level) {
+      return new ReadConcern(options.level);
+    }
+
+    return;
+  }
+
+  static get MAJORITY() {
+    return exports.ReadConcernLevel.majority;
+  }
+
+  static get AVAILABLE() {
+    return exports.ReadConcernLevel.available;
+  }
+
+  static get LINEARIZABLE() {
+    return exports.ReadConcernLevel.linearizable;
+  }
+
+  static get SNAPSHOT() {
+    return exports.ReadConcernLevel.snapshot;
+  }
+
+  toJSON() {
+    return {
+      level: this.level
+    };
+  }
+
+}
+
+exports.ReadConcern = ReadConcern;

package/transpiled/mongodb/lib/read_preference.js

@@ -0,0 +1,215 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReadPreference = exports.ReadPreferenceMode = void 0;
+
+const error_1 = require("./error");
+/** @public */
+
+
+exports.ReadPreferenceMode = Object.freeze({
+  primary: 'primary',
+  primaryPreferred: 'primaryPreferred',
+  secondary: 'secondary',
+  secondaryPreferred: 'secondaryPreferred',
+  nearest: 'nearest'
+});
+/**
+ * The **ReadPreference** class is a class that represents a MongoDB ReadPreference and is
+ * used to construct connections.
+ * @public
+ *
+ * @see https://www.mongodb.com/docs/manual/core/read-preference/
+ */
+
+class ReadPreference {
+  /**
+   * @param mode - A string describing the read preference mode (primary|primaryPreferred|secondary|secondaryPreferred|nearest)
+   * @param tags - A tag set used to target reads to members with the specified tag(s). tagSet is not available if using read preference mode primary.
+   * @param options - Additional read preference options
+   */
+  constructor(mode, tags, options) {
+    if (!ReadPreference.isValid(mode)) {
+      throw new error_1.MongoInvalidArgumentError(`Invalid read preference mode ${JSON.stringify(mode)}`);
+    }
+
+    if (options == null && typeof tags === 'object' && !Array.isArray(tags)) {
+      options = tags;
+      tags = undefined;
+    } else if (tags && !Array.isArray(tags)) {
+      throw new error_1.MongoInvalidArgumentError('ReadPreference tags must be an array');
+    }
+
+    this.mode = mode;
+    this.tags = tags;
+    this.hedge = options?.hedge;
+    this.maxStalenessSeconds = undefined;
+    this.minWireVersion = undefined;
+    options = options ?? {};
+
+    if (options.maxStalenessSeconds != null) {
+      if (options.maxStalenessSeconds <= 0) {
+        throw new error_1.MongoInvalidArgumentError('maxStalenessSeconds must be a positive integer');
+      }
+
+      this.maxStalenessSeconds = options.maxStalenessSeconds; // NOTE: The minimum required wire version is 5 for this read preference. If the existing
+      //       topology has a lower value then a MongoError will be thrown during server selection.
+
+      this.minWireVersion = 5;
+    }
+
+    if (this.mode === ReadPreference.PRIMARY) {
+      if (this.tags && Array.isArray(this.tags) && this.tags.length > 0) {
+        throw new error_1.MongoInvalidArgumentError('Primary read preference cannot be combined with tags');
+      }
+
+      if (this.maxStalenessSeconds) {
+        throw new error_1.MongoInvalidArgumentError('Primary read preference cannot be combined with maxStalenessSeconds');
+      }
+
+      if (this.hedge) {
+        throw new error_1.MongoInvalidArgumentError('Primary read preference cannot be combined with hedge');
+      }
+    }
+  } // Support the deprecated `preference` property introduced in the porcelain layer
+
+
+  get preference() {
+    return this.mode;
+  }
+
+  static fromString(mode) {
+    return new ReadPreference(mode);
+  }
+  /**
+   * Construct a ReadPreference given an options object.
+   *
+   * @param options - The options object from which to extract the read preference.
+   */
+
+
+  static fromOptions(options) {
+    if (!options) return;
+    const readPreference = options.readPreference ?? options.session?.transaction.options.readPreference;
+    const readPreferenceTags = options.readPreferenceTags;
+
+    if (readPreference == null) {
+      return;
+    }
+
+    if (typeof readPreference === 'string') {
+      return new ReadPreference(readPreference, readPreferenceTags, {
+        maxStalenessSeconds: options.maxStalenessSeconds,
+        hedge: options.hedge
+      });
+    } else if (!(readPreference instanceof ReadPreference) && typeof readPreference === 'object') {
+      const mode = readPreference.mode || readPreference.preference;
+
+      if (mode && typeof mode === 'string') {
+        return new ReadPreference(mode, readPreference.tags ?? readPreferenceTags, {
+          maxStalenessSeconds: readPreference.maxStalenessSeconds,
+          hedge: options.hedge
+        });
+      }
+    }
+
+    if (readPreferenceTags) {
+      readPreference.tags = readPreferenceTags;
+    }
+
+    return readPreference;
+  }
+  /**
+   * Replaces options.readPreference with a ReadPreference instance
+   */
+
+
+  static translate(options) {
+    if (options.readPreference == null) return options;
+    const r = options.readPreference;
+
+    if (typeof r === 'string') {
+      options.readPreference = new ReadPreference(r);
+    } else if (r && !(r instanceof ReadPreference) && typeof r === 'object') {
+      const mode = r.mode || r.preference;
+
+      if (mode && typeof mode === 'string') {
+        options.readPreference = new ReadPreference(mode, r.tags, {
+          maxStalenessSeconds: r.maxStalenessSeconds
+        });
+      }
+    } else if (!(r instanceof ReadPreference)) {
+      throw new error_1.MongoInvalidArgumentError(`Invalid read preference: ${r}`);
+    }
+
+    return options;
+  }
+  /**
+   * Validate if a mode is legal
+   *
+   * @param mode - The string representing the read preference mode.
+   */
+
+
+  static isValid(mode) {
+    const VALID_MODES = new Set([ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST, null]);
+    return VALID_MODES.has(mode);
+  }
+  /**
+   * Validate if a mode is legal
+   *
+   * @param mode - The string representing the read preference mode.
+   */
+
+
+  isValid(mode) {
+    return ReadPreference.isValid(typeof mode === 'string' ? mode : this.mode);
+  }
+  /**
+   * Indicates that this readPreference needs the "SecondaryOk" bit when sent over the wire
+   * @see https://www.mongodb.com/docs/manual/reference/mongodb-wire-protocol/#op-query
+   */
+
+
+  secondaryOk() {
+    const NEEDS_SECONDARYOK = new Set([ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST]);
+    return NEEDS_SECONDARYOK.has(this.mode);
+  }
+  /**
+   * Check if the two ReadPreferences are equivalent
+   *
+   * @param readPreference - The read preference with which to check equality
+   */
+
+
+  equals(readPreference) {
+    return readPreference.mode === this.mode;
+  }
+  /** Return JSON representation */
+
+
+  toJSON() {
+    const readPreference = {
+      mode: this.mode
+    };
+    if (Array.isArray(this.tags)) readPreference.tags = this.tags;
+    if (this.maxStalenessSeconds) readPreference.maxStalenessSeconds = this.maxStalenessSeconds;
+    if (this.hedge) readPreference.hedge = this.hedge;
+    return readPreference;
+  }
+
+}
+
+exports.ReadPreference = ReadPreference;
+ReadPreference.PRIMARY = exports.ReadPreferenceMode.primary;
+ReadPreference.PRIMARY_PREFERRED = exports.ReadPreferenceMode.primaryPreferred;
+ReadPreference.SECONDARY = exports.ReadPreferenceMode.secondary;
+ReadPreference.SECONDARY_PREFERRED = exports.ReadPreferenceMode.secondaryPreferred;
+ReadPreference.NEAREST = exports.ReadPreferenceMode.nearest;
+ReadPreference.primary = new ReadPreference(exports.ReadPreferenceMode.primary);
+ReadPreference.primaryPreferred = new ReadPreference(exports.ReadPreferenceMode.primaryPreferred);
+ReadPreference.secondary = new ReadPreference(exports.ReadPreferenceMode.secondary);
+ReadPreference.secondaryPreferred = new ReadPreference(exports.ReadPreferenceMode.secondaryPreferred);
+ReadPreference.nearest = new ReadPreference(exports.ReadPreferenceMode.nearest);