oxygen-cli 1.40.2-beta.1 → 1.41.0

package/transpiled/mongodb/lib/sort.js

@@ -1,123 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.formatSort = formatSort;
-
-const error_1 = require("./error");
-/** @internal */
-
-
-function prepareDirection(direction = 1) {
-  const value = `${direction}`.toLowerCase();
-  if (isMeta(direction)) return direction;
-
-  switch (value) {
-    case 'ascending':
-    case 'asc':
-    case '1':
-      return 1;
-
-    case 'descending':
-    case 'desc':
-    case '-1':
-      return -1;
-
-    default:
-      throw new error_1.MongoInvalidArgumentError(`Invalid sort direction: ${JSON.stringify(direction)}`);
-  }
-}
-/** @internal */
-
-
-function isMeta(t) {
-  return typeof t === 'object' && t != null && '$meta' in t && typeof t.$meta === 'string';
-}
-/** @internal */
-
-
-function isPair(t) {
-  if (Array.isArray(t) && t.length === 2) {
-    try {
-      prepareDirection(t[1]);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  return false;
-}
-
-function isDeep(t) {
-  return Array.isArray(t) && Array.isArray(t[0]);
-}
-
-function isMap(t) {
-  return t instanceof Map && t.size > 0;
-}
-
-function isReadonlyArray(value) {
-  return Array.isArray(value);
-}
-/** @internal */
-
-
-function pairToMap(v) {
-  return new Map([[`${v[0]}`, prepareDirection([v[1]])]]);
-}
-/** @internal */
-
-
-function deepToMap(t) {
-  const sortEntries = t.map(([k, v]) => [`${k}`, prepareDirection(v)]);
-  return new Map(sortEntries);
-}
-/** @internal */
-
-
-function stringsToMap(t) {
-  const sortEntries = t.map(key => [`${key}`, 1]);
-  return new Map(sortEntries);
-}
-/** @internal */
-
-
-function objectToMap(t) {
-  const sortEntries = Object.entries(t).map(([k, v]) => [`${k}`, prepareDirection(v)]);
-  return new Map(sortEntries);
-}
-/** @internal */
-
-
-function mapToMap(t) {
-  const sortEntries = Array.from(t).map(([k, v]) => [`${k}`, prepareDirection(v)]);
-  return new Map(sortEntries);
-}
-/** converts a Sort type into a type that is valid for the server (SortForCmd) */
-
-
-function formatSort(sort, direction) {
-  if (sort == null) return undefined;
-  if (typeof sort === 'string') return new Map([[sort, prepareDirection(direction)]]); // 'fieldName'
-
-  if (typeof sort !== 'object') {
-    throw new error_1.MongoInvalidArgumentError(`Invalid sort format: ${JSON.stringify(sort)} Sort must be a valid object`);
-  }
-
-  if (!isReadonlyArray(sort)) {
-    if (isMap(sort)) return mapToMap(sort); // Map<fieldName, SortDirection>
-
-    if (Object.keys(sort).length) return objectToMap(sort); // { [fieldName: string]: SortDirection }
-
-    return undefined;
-  }
-
-  if (!sort.length) return undefined;
-  if (isDeep(sort)) return deepToMap(sort); // [ [fieldName, sortDir], [fieldName, sortDir] ... ]
-
-  if (isPair(sort)) return pairToMap(sort); // [ fieldName, sortDir ]
-
-  return stringsToMap(sort); // [ fieldName, fieldName ]
-}

package/transpiled/mongodb/lib/timeout.js

@@ -1,349 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.LegacyTimeoutContext = exports.CSOTTimeoutContext = exports.TimeoutContext = exports.Timeout = exports.TimeoutError = void 0;
-
-const timers_1 = require("timers");
-
-const error_1 = require("./error");
-
-const utils_1 = require("./utils");
-/** @internal */
-
-
-class TimeoutError extends Error {
-  get name() {
-    return 'TimeoutError';
-  }
-
-  constructor(message, options) {
-    super(message, options);
-    this.duration = options.duration;
-  }
-
-  static is(error) {
-    return error != null && typeof error === 'object' && 'name' in error && error.name === 'TimeoutError';
-  }
-
-}
-
-exports.TimeoutError = TimeoutError;
-/**
- * @internal
- * This class is an abstraction over timeouts
- * The Timeout class can only be in the pending or rejected states. It is guaranteed not to resolve
- * if interacted with exclusively through its public API
- * */
-
-class Timeout extends Promise {
-  get remainingTime() {
-    if (this.timedOut) return 0;
-    if (this.duration === 0) return Infinity;
-    return this.start + this.duration - Math.trunc(performance.now());
-  }
-
-  get timeElapsed() {
-    return Math.trunc(performance.now()) - this.start;
-  }
-  /** Create a new timeout that expires in `duration` ms */
-
-
-  constructor(executor = () => null, options) {
-    const duration = options?.duration ?? 0;
-    const unref = !!options?.unref;
-    const rejection = options?.rejection;
-
-    if (duration < 0) {
-      throw new error_1.MongoInvalidArgumentError('Cannot create a Timeout with a negative duration');
-    }
-
-    let reject;
-    super((_, promiseReject) => {
-      reject = promiseReject;
-      executor(utils_1.noop, promiseReject);
-    });
-    this.ended = null;
-    this.timedOut = false;
-    this.cleared = false;
-    this.duration = duration;
-    this.start = Math.trunc(performance.now());
-
-    if (rejection == null && this.duration > 0) {
-      this.id = (0, timers_1.setTimeout)(() => {
-        this.ended = Math.trunc(performance.now());
-        this.timedOut = true;
-        reject(new TimeoutError(`Expired after ${duration}ms`, {
-          duration
-        }));
-      }, this.duration);
-
-      if (typeof this.id.unref === 'function' && unref) {
-        // Ensure we do not keep the Node.js event loop running
-        this.id.unref();
-      }
-    } else if (rejection != null) {
-      this.ended = Math.trunc(performance.now());
-      this.timedOut = true;
-      reject(rejection);
-    }
-  }
-  /**
-   * Clears the underlying timeout. This method is idempotent
-   */
-
-
-  clear() {
-    (0, timers_1.clearTimeout)(this.id);
-    this.id = undefined;
-    this.timedOut = false;
-    this.cleared = true;
-  }
-
-  throwIfExpired() {
-    if (this.timedOut) {
-      // This method is invoked when someone wants to throw immediately instead of await the result of this promise
-      // Since they won't be handling the rejection from the promise (because we're about to throw here)
-      // attach handling to prevent this from bubbling up to Node.js
-      this.then(undefined, utils_1.squashError);
-      throw new TimeoutError('Timed out', {
-        duration: this.duration
-      });
-    }
-  }
-
-  static expires(duration, unref) {
-    return new Timeout(undefined, {
-      duration,
-      unref
-    });
-  }
-
-  static reject(rejection) {
-    return new Timeout(undefined, {
-      duration: 0,
-      unref: true,
-      rejection
-    });
-  }
-
-}
-
-exports.Timeout = Timeout;
-
-function isLegacyTimeoutContextOptions(v) {
-  return v != null && typeof v === 'object' && 'serverSelectionTimeoutMS' in v && typeof v.serverSelectionTimeoutMS === 'number' && 'waitQueueTimeoutMS' in v && typeof v.waitQueueTimeoutMS === 'number';
-}
-
-function isCSOTTimeoutContextOptions(v) {
-  return v != null && typeof v === 'object' && 'serverSelectionTimeoutMS' in v && typeof v.serverSelectionTimeoutMS === 'number' && 'timeoutMS' in v && typeof v.timeoutMS === 'number';
-}
-/** @internal */
-
-
-class TimeoutContext {
-  static create(options) {
-    if (options.session?.timeoutContext != null) return options.session?.timeoutContext;
-    if (isCSOTTimeoutContextOptions(options)) return new CSOTTimeoutContext(options);else if (isLegacyTimeoutContextOptions(options)) return new LegacyTimeoutContext(options);else throw new error_1.MongoRuntimeError('Unrecognized options');
-  }
-
-}
-
-exports.TimeoutContext = TimeoutContext;
-/** @internal */
-
-class CSOTTimeoutContext extends TimeoutContext {
-  constructor(options) {
-    super();
-    this.minRoundTripTime = 0;
-    this.start = Math.trunc(performance.now());
-    this.timeoutMS = options.timeoutMS;
-    this.serverSelectionTimeoutMS = options.serverSelectionTimeoutMS;
-    this.socketTimeoutMS = options.socketTimeoutMS;
-    this.clearServerSelectionTimeout = false;
-  }
-
-  get maxTimeMS() {
-    return this.remainingTimeMS - this.minRoundTripTime;
-  }
-
-  get remainingTimeMS() {
-    const timePassed = Math.trunc(performance.now()) - this.start;
-    return this.timeoutMS <= 0 ? Infinity : this.timeoutMS - timePassed;
-  }
-
-  csotEnabled() {
-    return true;
-  }
-
-  get serverSelectionTimeout() {
-    // check for undefined
-    if (typeof this._serverSelectionTimeout !== 'object' || this._serverSelectionTimeout?.cleared) {
-      const {
-        remainingTimeMS,
-        serverSelectionTimeoutMS
-      } = this;
-      if (remainingTimeMS <= 0) return Timeout.reject(new error_1.MongoOperationTimeoutError(`Timed out in server selection after ${this.timeoutMS}ms`));
-      const usingServerSelectionTimeoutMS = serverSelectionTimeoutMS !== 0 && (0, utils_1.csotMin)(remainingTimeMS, serverSelectionTimeoutMS) === serverSelectionTimeoutMS;
-
-      if (usingServerSelectionTimeoutMS) {
-        this._serverSelectionTimeout = Timeout.expires(serverSelectionTimeoutMS);
-      } else {
-        if (remainingTimeMS > 0 && Number.isFinite(remainingTimeMS)) {
-          this._serverSelectionTimeout = Timeout.expires(remainingTimeMS);
-        } else {
-          this._serverSelectionTimeout = null;
-        }
-      }
-    }
-
-    return this._serverSelectionTimeout;
-  }
-
-  get connectionCheckoutTimeout() {
-    if (typeof this._connectionCheckoutTimeout !== 'object' || this._connectionCheckoutTimeout?.cleared) {
-      if (typeof this._serverSelectionTimeout === 'object') {
-        // null or Timeout
-        this._connectionCheckoutTimeout = this._serverSelectionTimeout;
-      } else {
-        throw new error_1.MongoRuntimeError('Unreachable. If you are seeing this error, please file a ticket on the NODE driver project on Jira');
-      }
-    }
-
-    return this._connectionCheckoutTimeout;
-  }
-
-  get timeoutForSocketWrite() {
-    const {
-      remainingTimeMS
-    } = this;
-    if (!Number.isFinite(remainingTimeMS)) return null;
-    if (remainingTimeMS > 0) return Timeout.expires(remainingTimeMS);
-    return Timeout.reject(new error_1.MongoOperationTimeoutError('Timed out before socket write'));
-  }
-
-  get timeoutForSocketRead() {
-    const {
-      remainingTimeMS
-    } = this;
-    if (!Number.isFinite(remainingTimeMS)) return null;
-    if (remainingTimeMS > 0) return Timeout.expires(remainingTimeMS);
-    return Timeout.reject(new error_1.MongoOperationTimeoutError('Timed out before socket read'));
-  }
-
-  refresh() {
-    this.start = Math.trunc(performance.now());
-    this.minRoundTripTime = 0;
-    this._serverSelectionTimeout?.clear();
-    this._connectionCheckoutTimeout?.clear();
-  }
-
-  clear() {
-    this._serverSelectionTimeout?.clear();
-    this._connectionCheckoutTimeout?.clear();
-  }
-  /**
-   * @internal
-   * Throws a MongoOperationTimeoutError if the context has expired.
-   * If the context has not expired, returns the `remainingTimeMS`
-   **/
-
-
-  getRemainingTimeMSOrThrow(message) {
-    const {
-      remainingTimeMS
-    } = this;
-    if (remainingTimeMS <= 0) throw new error_1.MongoOperationTimeoutError(message ?? `Expired after ${this.timeoutMS}ms`);
-    return remainingTimeMS;
-  }
-  /**
-   * @internal
-   * This method is intended to be used in situations where concurrent operation are on the same deadline, but cannot share a single `TimeoutContext` instance.
-   * Returns a new instance of `CSOTTimeoutContext` constructed with identical options, but setting the `start` property to `this.start`.
-   */
-
-
-  clone() {
-    const timeoutContext = new CSOTTimeoutContext({
-      timeoutMS: this.timeoutMS,
-      serverSelectionTimeoutMS: this.serverSelectionTimeoutMS
-    });
-    timeoutContext.start = this.start;
-    return timeoutContext;
-  }
-
-  refreshed() {
-    return new CSOTTimeoutContext(this);
-  }
-
-  addMaxTimeMSToCommand(command, options) {
-    if (options.omitMaxTimeMS) return;
-    const maxTimeMS = this.remainingTimeMS - this.minRoundTripTime;
-    if (maxTimeMS > 0 && Number.isFinite(maxTimeMS)) command.maxTimeMS = maxTimeMS;
-  }
-
-  getSocketTimeoutMS() {
-    return 0;
-  }
-
-}
-
-exports.CSOTTimeoutContext = CSOTTimeoutContext;
-/** @internal */
-
-class LegacyTimeoutContext extends TimeoutContext {
-  constructor(options) {
-    super();
-    this.options = options;
-    this.clearServerSelectionTimeout = true;
-  }
-
-  csotEnabled() {
-    return false;
-  }
-
-  get serverSelectionTimeout() {
-    if (this.options.serverSelectionTimeoutMS != null && this.options.serverSelectionTimeoutMS > 0) return Timeout.expires(this.options.serverSelectionTimeoutMS);
-    return null;
-  }
-
-  get connectionCheckoutTimeout() {
-    if (this.options.waitQueueTimeoutMS != null && this.options.waitQueueTimeoutMS > 0) return Timeout.expires(this.options.waitQueueTimeoutMS);
-    return null;
-  }
-
-  get timeoutForSocketWrite() {
-    return null;
-  }
-
-  get timeoutForSocketRead() {
-    return null;
-  }
-
-  refresh() {
-    return;
-  }
-
-  clear() {
-    return;
-  }
-
-  get maxTimeMS() {
-    return null;
-  }
-
-  refreshed() {
-    return new LegacyTimeoutContext(this.options);
-  }
-
-  addMaxTimeMSToCommand(_command, _options) {// No max timeMS is added to commands in legacy timeout mode.
-  }
-
-  getSocketTimeoutMS() {
-    return this.options.socketTimeoutMS;
-  }
-
-}
-
-exports.LegacyTimeoutContext = LegacyTimeoutContext;

package/transpiled/mongodb/lib/transactions.js

@@ -1,149 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Transaction = exports.TxnState = void 0;
-exports.isTransactionCommand = isTransactionCommand;
-
-const error_1 = require("./error");
-
-const read_concern_1 = require("./read_concern");
-
-const read_preference_1 = require("./read_preference");
-
-const write_concern_1 = require("./write_concern");
-/** @internal */
-
-
-exports.TxnState = Object.freeze({
-  NO_TRANSACTION: 'NO_TRANSACTION',
-  STARTING_TRANSACTION: 'STARTING_TRANSACTION',
-  TRANSACTION_IN_PROGRESS: 'TRANSACTION_IN_PROGRESS',
-  TRANSACTION_COMMITTED: 'TRANSACTION_COMMITTED',
-  TRANSACTION_COMMITTED_EMPTY: 'TRANSACTION_COMMITTED_EMPTY',
-  TRANSACTION_ABORTED: 'TRANSACTION_ABORTED'
-});
-const stateMachine = {
-  [exports.TxnState.NO_TRANSACTION]: [exports.TxnState.NO_TRANSACTION, exports.TxnState.STARTING_TRANSACTION],
-  [exports.TxnState.STARTING_TRANSACTION]: [exports.TxnState.TRANSACTION_IN_PROGRESS, exports.TxnState.TRANSACTION_COMMITTED, exports.TxnState.TRANSACTION_COMMITTED_EMPTY, exports.TxnState.TRANSACTION_ABORTED],
-  [exports.TxnState.TRANSACTION_IN_PROGRESS]: [exports.TxnState.TRANSACTION_IN_PROGRESS, exports.TxnState.TRANSACTION_COMMITTED, exports.TxnState.TRANSACTION_ABORTED],
-  [exports.TxnState.TRANSACTION_COMMITTED]: [exports.TxnState.TRANSACTION_COMMITTED, exports.TxnState.TRANSACTION_COMMITTED_EMPTY, exports.TxnState.STARTING_TRANSACTION, exports.TxnState.NO_TRANSACTION],
-  [exports.TxnState.TRANSACTION_ABORTED]: [exports.TxnState.STARTING_TRANSACTION, exports.TxnState.NO_TRANSACTION],
-  [exports.TxnState.TRANSACTION_COMMITTED_EMPTY]: [exports.TxnState.TRANSACTION_COMMITTED_EMPTY, exports.TxnState.NO_TRANSACTION]
-};
-const ACTIVE_STATES = new Set([exports.TxnState.STARTING_TRANSACTION, exports.TxnState.TRANSACTION_IN_PROGRESS]);
-const COMMITTED_STATES = new Set([exports.TxnState.TRANSACTION_COMMITTED, exports.TxnState.TRANSACTION_COMMITTED_EMPTY, exports.TxnState.TRANSACTION_ABORTED]);
-/**
- * @public
- * A class maintaining state related to a server transaction. Internal Only
- */
-
-class Transaction {
-  /** Create a transaction @internal */
-  constructor(options) {
-    options = options ?? {};
-    this.state = exports.TxnState.NO_TRANSACTION;
-    this.options = {};
-    const writeConcern = write_concern_1.WriteConcern.fromOptions(options);
-
-    if (writeConcern) {
-      if (writeConcern.w === 0) {
-        throw new error_1.MongoTransactionError('Transactions do not support unacknowledged write concern');
-      }
-
-      this.options.writeConcern = writeConcern;
-    }
-
-    if (options.readConcern) {
-      this.options.readConcern = read_concern_1.ReadConcern.fromOptions(options);
-    }
-
-    if (options.readPreference) {
-      this.options.readPreference = read_preference_1.ReadPreference.fromOptions(options);
-    }
-
-    if (options.maxCommitTimeMS) {
-      this.options.maxTimeMS = options.maxCommitTimeMS;
-    } // TODO: This isn't technically necessary
-
-
-    this._pinnedServer = undefined;
-    this._recoveryToken = undefined;
-  }
-  /** @internal */
-
-
-  get server() {
-    return this._pinnedServer;
-  }
-
-  get recoveryToken() {
-    return this._recoveryToken;
-  }
-
-  get isPinned() {
-    return !!this.server;
-  }
-  /** @returns Whether the transaction has started */
-
-
-  get isStarting() {
-    return this.state === exports.TxnState.STARTING_TRANSACTION;
-  }
-  /**
-   * @returns Whether this session is presently in a transaction
-   */
-
-
-  get isActive() {
-    return ACTIVE_STATES.has(this.state);
-  }
-
-  get isCommitted() {
-    return COMMITTED_STATES.has(this.state);
-  }
-  /**
-   * Transition the transaction in the state machine
-   * @internal
-   * @param nextState - The new state to transition to
-   */
-
-
-  transition(nextState) {
-    const nextStates = stateMachine[this.state];
-
-    if (nextStates && nextStates.includes(nextState)) {
-      this.state = nextState;
-
-      if (this.state === exports.TxnState.NO_TRANSACTION || this.state === exports.TxnState.STARTING_TRANSACTION || this.state === exports.TxnState.TRANSACTION_ABORTED) {
-        this.unpinServer();
-      }
-
-      return;
-    }
-
-    throw new error_1.MongoRuntimeError(`Attempted illegal state transition from [${this.state}] to [${nextState}]`);
-  }
-  /** @internal */
-
-
-  pinServer(server) {
-    if (this.isActive) {
-      this._pinnedServer = server;
-    }
-  }
-  /** @internal */
-
-
-  unpinServer() {
-    this._pinnedServer = undefined;
-  }
-
-}
-
-exports.Transaction = Transaction;
-
-function isTransactionCommand(command) {
-  return !!(command.commitTransaction || command.abortTransaction);
-}