oxygen-cli 1.40.1 → 1.40.2-beta.1

package/transpiled/mongodb/lib/sdam/server.js

@@ -0,0 +1,463 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Server = void 0;
+
+const connection_1 = require("../cmap/connection");
+
+const connection_pool_1 = require("../cmap/connection_pool");
+
+const errors_1 = require("../cmap/errors");
+
+const constants_1 = require("../constants");
+
+const error_1 = require("../error");
+
+const mongo_types_1 = require("../mongo_types");
+
+const transactions_1 = require("../transactions");
+
+const utils_1 = require("../utils");
+
+const write_concern_1 = require("../write_concern");
+
+const common_1 = require("./common");
+
+const monitor_1 = require("./monitor");
+
+const server_description_1 = require("./server_description");
+
+const stateTransition = (0, utils_1.makeStateMachine)({
+  [common_1.STATE_CLOSED]: [common_1.STATE_CLOSED, common_1.STATE_CONNECTING],
+  [common_1.STATE_CONNECTING]: [common_1.STATE_CONNECTING, common_1.STATE_CLOSING, common_1.STATE_CONNECTED, common_1.STATE_CLOSED],
+  [common_1.STATE_CONNECTED]: [common_1.STATE_CONNECTED, common_1.STATE_CLOSING, common_1.STATE_CLOSED],
+  [common_1.STATE_CLOSING]: [common_1.STATE_CLOSING, common_1.STATE_CLOSED]
+});
+/** @internal */
+
+class Server extends mongo_types_1.TypedEventEmitter {
+  /**
+   * Create a server
+   */
+  constructor(topology, description, options) {
+    super();
+    this.on('error', utils_1.noop);
+    this.serverApi = options.serverApi;
+    const poolOptions = {
+      hostAddress: description.hostAddress,
+      ...options
+    };
+    this.topology = topology;
+    this.pool = new connection_pool_1.ConnectionPool(this, poolOptions);
+    this.s = {
+      description,
+      options,
+      state: common_1.STATE_CLOSED,
+      operationCount: 0
+    };
+
+    for (const event of [...constants_1.CMAP_EVENTS, ...constants_1.APM_EVENTS]) {
+      this.pool.on(event, e => this.emit(event, e));
+    }
+
+    this.pool.on(connection_1.Connection.CLUSTER_TIME_RECEIVED, clusterTime => {
+      this.clusterTime = clusterTime;
+    });
+
+    if (this.loadBalanced) {
+      this.monitor = null; // monitoring is disabled in load balancing mode
+
+      return;
+    } // create the monitor
+
+
+    this.monitor = new monitor_1.Monitor(this, this.s.options);
+
+    for (const event of constants_1.HEARTBEAT_EVENTS) {
+      this.monitor.on(event, e => this.emit(event, e));
+    }
+
+    this.monitor.on('resetServer', error => markServerUnknown(this, error));
+    this.monitor.on(Server.SERVER_HEARTBEAT_SUCCEEDED, event => {
+      this.emit(Server.DESCRIPTION_RECEIVED, new server_description_1.ServerDescription(this.description.hostAddress, event.reply, {
+        roundTripTime: this.monitor?.roundTripTime,
+        minRoundTripTime: this.monitor?.minRoundTripTime
+      }));
+
+      if (this.s.state === common_1.STATE_CONNECTING) {
+        stateTransition(this, common_1.STATE_CONNECTED);
+        this.emit(Server.CONNECT, this);
+      }
+    });
+  }
+
+  get clusterTime() {
+    return this.topology.clusterTime;
+  }
+
+  set clusterTime(clusterTime) {
+    this.topology.clusterTime = clusterTime;
+  }
+
+  get description() {
+    return this.s.description;
+  }
+
+  get name() {
+    return this.s.description.address;
+  }
+
+  get autoEncrypter() {
+    if (this.s.options && this.s.options.autoEncrypter) {
+      return this.s.options.autoEncrypter;
+    }
+
+    return;
+  }
+
+  get loadBalanced() {
+    return this.topology.description.type === common_1.TopologyType.LoadBalanced;
+  }
+  /**
+   * Initiate server connect
+   */
+
+
+  connect() {
+    if (this.s.state !== common_1.STATE_CLOSED) {
+      return;
+    }
+
+    stateTransition(this, common_1.STATE_CONNECTING); // If in load balancer mode we automatically set the server to
+    // a load balancer. It never transitions out of this state and
+    // has no monitor.
+
+    if (!this.loadBalanced) {
+      this.monitor?.connect();
+    } else {
+      stateTransition(this, common_1.STATE_CONNECTED);
+      this.emit(Server.CONNECT, this);
+    }
+  }
+
+  closeCheckedOutConnections() {
+    return this.pool.closeCheckedOutConnections();
+  }
+  /** Destroy the server connection */
+
+
+  close() {
+    if (this.s.state === common_1.STATE_CLOSED) {
+      return;
+    }
+
+    stateTransition(this, common_1.STATE_CLOSING);
+
+    if (!this.loadBalanced) {
+      this.monitor?.close();
+    }
+
+    this.pool.close();
+    stateTransition(this, common_1.STATE_CLOSED);
+    this.emit('closed');
+  }
+  /**
+   * Immediately schedule monitoring of this server. If there already an attempt being made
+   * this will be a no-op.
+   */
+
+
+  requestCheck() {
+    if (!this.loadBalanced) {
+      this.monitor?.requestCheck();
+    }
+  }
+
+  async command(ns, cmd, { ...options
+  }, responseType) {
+    if (ns.db == null || typeof ns === 'string') {
+      throw new error_1.MongoInvalidArgumentError('Namespace must not be a string');
+    }
+
+    if (this.s.state === common_1.STATE_CLOSING || this.s.state === common_1.STATE_CLOSED) {
+      throw new error_1.MongoServerClosedError();
+    }
+
+    options.directConnection = this.topology.s.options.directConnection; // There are cases where we need to flag the read preference not to get sent in
+    // the command, such as pre-5.0 servers attempting to perform an aggregate write
+    // with a non-primary read preference. In this case the effective read preference
+    // (primary) is not the same as the provided and must be removed completely.
+
+    if (options.omitReadPreference) {
+      delete options.readPreference;
+    }
+
+    if (this.description.iscryptd) {
+      options.omitMaxTimeMS = true;
+    }
+
+    const session = options.session;
+    let conn = session?.pinnedConnection;
+    this.incrementOperationCount();
+
+    if (conn == null) {
+      try {
+        conn = await this.pool.checkOut(options);
+
+        if (this.loadBalanced && isPinnableCommand(cmd, session)) {
+          session?.pin(conn);
+        }
+      } catch (checkoutError) {
+        this.decrementOperationCount();
+        if (!(checkoutError instanceof errors_1.PoolClearedError)) this.handleError(checkoutError);
+        throw checkoutError;
+      }
+    }
+
+    let reauthPromise = null;
+
+    try {
+      try {
+        const res = await conn.command(ns, cmd, options, responseType);
+        (0, write_concern_1.throwIfWriteConcernError)(res);
+        return res;
+      } catch (commandError) {
+        throw this.decorateCommandError(conn, cmd, options, commandError);
+      }
+    } catch (operationError) {
+      if (operationError instanceof error_1.MongoError && operationError.code === error_1.MONGODB_ERROR_CODES.Reauthenticate) {
+        reauthPromise = this.pool.reauthenticate(conn);
+        reauthPromise.then(undefined, error => {
+          reauthPromise = null;
+          (0, utils_1.squashError)(error);
+        });
+        await (0, utils_1.abortable)(reauthPromise, options);
+        reauthPromise = null; // only reachable if reauth succeeds
+
+        try {
+          const res = await conn.command(ns, cmd, options, responseType);
+          (0, write_concern_1.throwIfWriteConcernError)(res);
+          return res;
+        } catch (commandError) {
+          throw this.decorateCommandError(conn, cmd, options, commandError);
+        }
+      } else {
+        throw operationError;
+      }
+    } finally {
+      this.decrementOperationCount();
+
+      if (session?.pinnedConnection !== conn) {
+        if (reauthPromise != null) {
+          // The reauth promise only exists if it hasn't thrown.
+          const checkBackIn = () => {
+            this.pool.checkIn(conn);
+          };
+
+          void reauthPromise.then(checkBackIn, checkBackIn);
+        } else {
+          this.pool.checkIn(conn);
+        }
+      }
+    }
+  }
+  /**
+   * Handle SDAM error
+   * @internal
+   */
+
+
+  handleError(error, connection) {
+    if (!(error instanceof error_1.MongoError)) {
+      return;
+    }
+
+    const isStaleError = error.connectionGeneration && error.connectionGeneration < this.pool.generation;
+
+    if (isStaleError) {
+      return;
+    }
+
+    const isNetworkNonTimeoutError = error instanceof error_1.MongoNetworkError && !(error instanceof error_1.MongoNetworkTimeoutError);
+    const isNetworkTimeoutBeforeHandshakeError = error instanceof error_1.MongoNetworkError && error.beforeHandshake;
+    const isAuthHandshakeError = error.hasErrorLabel(error_1.MongoErrorLabel.HandshakeError);
+
+    if (isNetworkNonTimeoutError || isNetworkTimeoutBeforeHandshakeError || isAuthHandshakeError) {
+      // In load balanced mode we never mark the server as unknown and always
+      // clear for the specific service id.
+      if (!this.loadBalanced) {
+        error.addErrorLabel(error_1.MongoErrorLabel.ResetPool);
+        markServerUnknown(this, error);
+      } else if (connection) {
+        this.pool.clear({
+          serviceId: connection.serviceId
+        });
+      }
+    } else {
+      if ((0, error_1.isSDAMUnrecoverableError)(error)) {
+        if (shouldHandleStateChangeError(this, error)) {
+          const shouldClearPool = (0, utils_1.maxWireVersion)(this) <= 7 || (0, error_1.isNodeShuttingDownError)(error);
+
+          if (this.loadBalanced && connection && shouldClearPool) {
+            this.pool.clear({
+              serviceId: connection.serviceId
+            });
+          }
+
+          if (!this.loadBalanced) {
+            if (shouldClearPool) {
+              error.addErrorLabel(error_1.MongoErrorLabel.ResetPool);
+            }
+
+            markServerUnknown(this, error);
+            process.nextTick(() => this.requestCheck());
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Ensure that error is properly decorated and internal state is updated before throwing
+   * @internal
+   */
+
+
+  decorateCommandError(connection, cmd, options, error) {
+    if (typeof error !== 'object' || error == null || !('name' in error)) {
+      throw new error_1.MongoRuntimeError('An unexpected error type: ' + typeof error);
+    }
+
+    if (error.name === 'AbortError' && 'cause' in error && error.cause instanceof error_1.MongoError) {
+      error = error.cause;
+    }
+
+    if (!(error instanceof error_1.MongoError)) {
+      // Node.js or some other error we have not special handling for
+      return error;
+    }
+
+    if (connectionIsStale(this.pool, connection)) {
+      return error;
+    }
+
+    const session = options?.session;
+
+    if (error instanceof error_1.MongoNetworkError) {
+      if (session && !session.hasEnded && session.serverSession) {
+        session.serverSession.isDirty = true;
+      } // inActiveTransaction check handles commit and abort.
+
+
+      if (inActiveTransaction(session, cmd) && !error.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError)) {
+        error.addErrorLabel(error_1.MongoErrorLabel.TransientTransactionError);
+      }
+
+      if ((isRetryableWritesEnabled(this.topology) || (0, transactions_1.isTransactionCommand)(cmd)) && (0, utils_1.supportsRetryableWrites)(this) && !inActiveTransaction(session, cmd)) {
+        error.addErrorLabel(error_1.MongoErrorLabel.RetryableWriteError);
+      }
+    } else {
+      if ((isRetryableWritesEnabled(this.topology) || (0, transactions_1.isTransactionCommand)(cmd)) && (0, error_1.needsRetryableWriteLabel)(error, (0, utils_1.maxWireVersion)(this), this.description.type) && !inActiveTransaction(session, cmd)) {
+        error.addErrorLabel(error_1.MongoErrorLabel.RetryableWriteError);
+      }
+    }
+
+    if (session && session.isPinned && error.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError)) {
+      session.unpin({
+        force: true
+      });
+    }
+
+    this.handleError(error, connection);
+    return error;
+  }
+  /**
+   * Decrement the operation count, returning the new count.
+   */
+
+
+  decrementOperationCount() {
+    return this.s.operationCount -= 1;
+  }
+  /**
+   * Increment the operation count, returning the new count.
+   */
+
+
+  incrementOperationCount() {
+    return this.s.operationCount += 1;
+  }
+
+}
+
+exports.Server = Server;
+/** @event */
+
+Server.SERVER_HEARTBEAT_STARTED = constants_1.SERVER_HEARTBEAT_STARTED;
+/** @event */
+
+Server.SERVER_HEARTBEAT_SUCCEEDED = constants_1.SERVER_HEARTBEAT_SUCCEEDED;
+/** @event */
+
+Server.SERVER_HEARTBEAT_FAILED = constants_1.SERVER_HEARTBEAT_FAILED;
+/** @event */
+
+Server.CONNECT = constants_1.CONNECT;
+/** @event */
+
+Server.DESCRIPTION_RECEIVED = constants_1.DESCRIPTION_RECEIVED;
+/** @event */
+
+Server.CLOSED = constants_1.CLOSED;
+/** @event */
+
+Server.ENDED = constants_1.ENDED;
+
+function markServerUnknown(server, error) {
+  // Load balancer servers can never be marked unknown.
+  if (server.loadBalanced) {
+    return;
+  }
+
+  if (error instanceof error_1.MongoNetworkError && !(error instanceof error_1.MongoNetworkTimeoutError)) {
+    server.monitor?.reset();
+  }
+
+  server.emit(Server.DESCRIPTION_RECEIVED, new server_description_1.ServerDescription(server.description.hostAddress, undefined, {
+    error
+  }));
+}
+
+function isPinnableCommand(cmd, session) {
+  if (session) {
+    return session.inTransaction() || session.transaction.isCommitted && 'commitTransaction' in cmd || 'aggregate' in cmd || 'find' in cmd || 'getMore' in cmd || 'listCollections' in cmd || 'listIndexes' in cmd || 'bulkWrite' in cmd;
+  }
+
+  return false;
+}
+
+function connectionIsStale(pool, connection) {
+  if (connection.serviceId) {
+    return connection.generation !== pool.serviceGenerations.get(connection.serviceId.toHexString());
+  }
+
+  return connection.generation !== pool.generation;
+}
+
+function shouldHandleStateChangeError(server, err) {
+  const etv = err.topologyVersion;
+  const stv = server.description.topologyVersion;
+  return (0, server_description_1.compareTopologyVersion)(stv, etv) < 0;
+}
+
+function inActiveTransaction(session, cmd) {
+  return session && session.inTransaction() && !(0, transactions_1.isTransactionCommand)(cmd);
+}
+/** this checks the retryWrites option passed down from the client options, it
+ * does not check if the server supports retryable writes */
+
+
+function isRetryableWritesEnabled(topology) {
+  return topology.s.options.retryWrites !== false;
+}

package/transpiled/mongodb/lib/sdam/server_description.js

@@ -0,0 +1,196 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ServerDescription = void 0;
+exports.parseServerType = parseServerType;
+exports.compareTopologyVersion = compareTopologyVersion;
+
+const bson_1 = require("../bson");
+
+const error_1 = require("../error");
+
+const utils_1 = require("../utils");
+
+const common_1 = require("./common");
+
+const WRITABLE_SERVER_TYPES = new Set([common_1.ServerType.RSPrimary, common_1.ServerType.Standalone, common_1.ServerType.Mongos, common_1.ServerType.LoadBalancer]);
+const DATA_BEARING_SERVER_TYPES = new Set([common_1.ServerType.RSPrimary, common_1.ServerType.RSSecondary, common_1.ServerType.Mongos, common_1.ServerType.Standalone, common_1.ServerType.LoadBalancer]);
+/**
+ * The client's view of a single server, based on the most recent hello outcome.
+ *
+ * Internal type, not meant to be directly instantiated
+ * @public
+ */
+
+class ServerDescription {
+  /**
+   * Create a ServerDescription
+   * @internal
+   *
+   * @param address - The address of the server
+   * @param hello - An optional hello response for this server
+   */
+  constructor(address, hello, options = {}) {
+    if (address == null || address === '') {
+      throw new error_1.MongoRuntimeError('ServerDescription must be provided with a non-empty address');
+    }
+
+    this.address = typeof address === 'string' ? utils_1.HostAddress.fromString(address).toString() // Use HostAddress to normalize
+    : address.toString();
+    this.type = parseServerType(hello, options);
+    this.hosts = hello?.hosts?.map(host => host.toLowerCase()) ?? [];
+    this.passives = hello?.passives?.map(host => host.toLowerCase()) ?? [];
+    this.arbiters = hello?.arbiters?.map(host => host.toLowerCase()) ?? [];
+    this.tags = hello?.tags ?? {};
+    this.minWireVersion = hello?.minWireVersion ?? 0;
+    this.maxWireVersion = hello?.maxWireVersion ?? 0;
+    this.roundTripTime = options?.roundTripTime ?? -1;
+    this.minRoundTripTime = options?.minRoundTripTime ?? 0;
+    this.lastUpdateTime = (0, utils_1.now)();
+    this.lastWriteDate = hello?.lastWrite?.lastWriteDate ?? 0; // NOTE: This actually builds the stack string instead of holding onto the getter and all its
+    // associated references. This is done to prevent a memory leak.
+
+    this.error = options.error ?? null;
+    this.error?.stack; // TODO(NODE-2674): Preserve int64 sent from MongoDB
+
+    this.topologyVersion = this.error?.topologyVersion ?? hello?.topologyVersion ?? null;
+    this.setName = hello?.setName ?? null;
+    this.setVersion = hello?.setVersion ?? null;
+    this.electionId = hello?.electionId ?? null;
+    this.logicalSessionTimeoutMinutes = hello?.logicalSessionTimeoutMinutes ?? null;
+    this.maxMessageSizeBytes = hello?.maxMessageSizeBytes ?? null;
+    this.maxWriteBatchSize = hello?.maxWriteBatchSize ?? null;
+    this.maxBsonObjectSize = hello?.maxBsonObjectSize ?? null;
+    this.primary = hello?.primary ?? null;
+    this.me = hello?.me?.toLowerCase() ?? null;
+    this.$clusterTime = hello?.$clusterTime ?? null;
+    this.iscryptd = Boolean(hello?.iscryptd);
+  }
+
+  get hostAddress() {
+    return utils_1.HostAddress.fromString(this.address);
+  }
+
+  get allHosts() {
+    return this.hosts.concat(this.arbiters).concat(this.passives);
+  }
+  /** Is this server available for reads*/
+
+
+  get isReadable() {
+    return this.type === common_1.ServerType.RSSecondary || this.isWritable;
+  }
+  /** Is this server data bearing */
+
+
+  get isDataBearing() {
+    return DATA_BEARING_SERVER_TYPES.has(this.type);
+  }
+  /** Is this server available for writes */
+
+
+  get isWritable() {
+    return WRITABLE_SERVER_TYPES.has(this.type);
+  }
+
+  get host() {
+    const chopLength = `:${this.port}`.length;
+    return this.address.slice(0, -chopLength);
+  }
+
+  get port() {
+    const port = this.address.split(':').pop();
+    return port ? Number.parseInt(port, 10) : 27017;
+  }
+  /**
+   * Determines if another `ServerDescription` is equal to this one per the rules defined in the SDAM specification.
+   * @see https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.md
+   */
+
+
+  equals(other) {
+    // Despite using the comparator that would determine a nullish topologyVersion as greater than
+    // for equality we should only always perform direct equality comparison
+    const topologyVersionsEqual = this.topologyVersion === other?.topologyVersion || compareTopologyVersion(this.topologyVersion, other?.topologyVersion) === 0;
+    const electionIdsEqual = this.electionId != null && other?.electionId != null ? (0, utils_1.compareObjectId)(this.electionId, other.electionId) === 0 : this.electionId === other?.electionId;
+    return other != null && other.iscryptd === this.iscryptd && (0, utils_1.errorStrictEqual)(this.error, other.error) && this.type === other.type && this.minWireVersion === other.minWireVersion && (0, utils_1.arrayStrictEqual)(this.hosts, other.hosts) && tagsStrictEqual(this.tags, other.tags) && this.setName === other.setName && this.setVersion === other.setVersion && electionIdsEqual && this.primary === other.primary && this.logicalSessionTimeoutMinutes === other.logicalSessionTimeoutMinutes && topologyVersionsEqual;
+  }
+
+}
+
+exports.ServerDescription = ServerDescription; // Parses a `hello` message and determines the server type
+
+function parseServerType(hello, options) {
+  if (options?.loadBalanced) {
+    return common_1.ServerType.LoadBalancer;
+  }
+
+  if (!hello || !hello.ok) {
+    return common_1.ServerType.Unknown;
+  }
+
+  if (hello.isreplicaset) {
+    return common_1.ServerType.RSGhost;
+  }
+
+  if (hello.msg && hello.msg === 'isdbgrid') {
+    return common_1.ServerType.Mongos;
+  }
+
+  if (hello.setName) {
+    if (hello.hidden) {
+      return common_1.ServerType.RSOther;
+    } else if (hello.isWritablePrimary) {
+      return common_1.ServerType.RSPrimary;
+    } else if (hello.secondary) {
+      return common_1.ServerType.RSSecondary;
+    } else if (hello.arbiterOnly) {
+      return common_1.ServerType.RSArbiter;
+    } else {
+      return common_1.ServerType.RSOther;
+    }
+  }
+
+  return common_1.ServerType.Standalone;
+}
+
+function tagsStrictEqual(tags, tags2) {
+  const tagsKeys = Object.keys(tags);
+  const tags2Keys = Object.keys(tags2);
+  return tagsKeys.length === tags2Keys.length && tagsKeys.every(key => tags2[key] === tags[key]);
+}
+/**
+ * Compares two topology versions.
+ *
+ * 1. If the response topologyVersion is unset or the ServerDescription's
+ *    topologyVersion is null, the client MUST assume the response is more recent.
+ * 1. If the response's topologyVersion.processId is not equal to the
+ *    ServerDescription's, the client MUST assume the response is more recent.
+ * 1. If the response's topologyVersion.processId is equal to the
+ *    ServerDescription's, the client MUST use the counter field to determine
+ *    which topologyVersion is more recent.
+ *
+ * ```ts
+ * currentTv <   newTv === -1
+ * currentTv === newTv === 0
+ * currentTv >   newTv === 1
+ * ```
+ */
+
+
+function compareTopologyVersion(currentTv, newTv) {
+  if (currentTv == null || newTv == null) {
+    return -1;
+  }
+
+  if (!currentTv.processId.equals(newTv.processId)) {
+    return -1;
+  } // TODO(NODE-2674): Preserve int64 sent from MongoDB
+
+
+  const currentCounter = typeof currentTv.counter === 'bigint' ? bson_1.Long.fromBigInt(currentTv.counter) : bson_1.Long.isLong(currentTv.counter) ? currentTv.counter : bson_1.Long.fromNumber(currentTv.counter);
+  const newCounter = typeof newTv.counter === 'bigint' ? bson_1.Long.fromBigInt(newTv.counter) : bson_1.Long.isLong(newTv.counter) ? newTv.counter : bson_1.Long.fromNumber(newTv.counter);
+  return currentCounter.compare(newCounter);
+}