oxygen-cli 1.40.1 → 1.40.2-beta.1

package/transpiled/mongodb/lib/resource_management.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configureResourceManagement = configureResourceManagement;
+exports.configureExplicitResourceManagement = configureExplicitResourceManagement;
+/** @internal */
+
+function configureResourceManagement(target) {
+  Symbol.asyncDispose && Object.defineProperty(target, Symbol.asyncDispose, {
+    value: async function asyncDispose() {
+      await this.asyncDispose();
+    },
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+}
+/**
+ * @beta
+ * @experimental
+ *
+ * Attaches `Symbol.asyncDispose` methods to the MongoClient, Cursors, sessions and change streams
+ * if Symbol.asyncDispose is defined.
+ *
+ * It's usually not necessary to call this method - the driver attempts to attach these methods
+ * itself when its loaded.  However, sometimes the driver may be loaded before `Symbol.asyncDispose`
+ * is defined, in which case it is necessary to call this method directly.  This can happen if the
+ * application is polyfilling `Symbol.asyncDispose`.
+ *
+ * Example:
+ *
+ * ```typescript
+ * import { configureExplicitResourceManagement, MongoClient } from 'mongodb/lib/beta';
+ *
+ * Symbol.asyncDispose ??= Symbol('dispose');
+ * load();
+ *
+ * await using client = new MongoClient(...);
+ * ```
+ */
+
+
+function configureExplicitResourceManagement() {
+  // We must import lazily here, because there's a circular dependency between the resource management
+  // file and each resources' file.  We could move `configureResourceManagement` to a separate
+  // function, but keeping all resource-management related code together seemed preferable and I chose
+  // lazy requiring of resources instead.
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const {
+    MongoClient
+  } = require('./mongo_client'); // eslint-disable-next-line @typescript-eslint/no-require-imports
+
+
+  const {
+    ClientSession
+  } = require('./sessions'); // eslint-disable-next-line @typescript-eslint/no-require-imports
+
+
+  const {
+    AbstractCursor
+  } = require('./cursor/abstract_cursor'); // eslint-disable-next-line @typescript-eslint/no-require-imports
+
+
+  const {
+    ChangeStream
+  } = require('./change_stream');
+
+  configureResourceManagement(MongoClient.prototype);
+  configureResourceManagement(ClientSession.prototype);
+  configureResourceManagement(AbstractCursor.prototype);
+  configureResourceManagement(ChangeStream.prototype);
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ServerType = exports.TopologyType = exports.STATE_CONNECTED = exports.STATE_CONNECTING = exports.STATE_CLOSED = exports.STATE_CLOSING = void 0;
+exports._advanceClusterTime = _advanceClusterTime; // shared state names
+
+exports.STATE_CLOSING = 'closing';
+exports.STATE_CLOSED = 'closed';
+exports.STATE_CONNECTING = 'connecting';
+exports.STATE_CONNECTED = 'connected';
+/**
+ * An enumeration of topology types we know about
+ * @public
+ */
+
+exports.TopologyType = Object.freeze({
+  Single: 'Single',
+  ReplicaSetNoPrimary: 'ReplicaSetNoPrimary',
+  ReplicaSetWithPrimary: 'ReplicaSetWithPrimary',
+  Sharded: 'Sharded',
+  Unknown: 'Unknown',
+  LoadBalanced: 'LoadBalanced'
+});
+/**
+ * An enumeration of server types we know about
+ * @public
+ */
+
+exports.ServerType = Object.freeze({
+  Standalone: 'Standalone',
+  Mongos: 'Mongos',
+  PossiblePrimary: 'PossiblePrimary',
+  RSPrimary: 'RSPrimary',
+  RSSecondary: 'RSSecondary',
+  RSArbiter: 'RSArbiter',
+  RSOther: 'RSOther',
+  RSGhost: 'RSGhost',
+  Unknown: 'Unknown',
+  LoadBalancer: 'LoadBalancer'
+});
+/** Shared function to determine clusterTime for a given topology or session */
+
+function _advanceClusterTime(entity, $clusterTime) {
+  if (entity.clusterTime == null) {
+    entity.clusterTime = $clusterTime;
+  } else {
+    if ($clusterTime.clusterTime.greaterThan(entity.clusterTime.clusterTime)) {
+      entity.clusterTime = $clusterTime;
+    }
+  }
+}

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

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ServerHeartbeatFailedEvent = exports.ServerHeartbeatSucceededEvent = exports.ServerHeartbeatStartedEvent = exports.TopologyClosedEvent = exports.TopologyOpeningEvent = exports.TopologyDescriptionChangedEvent = exports.ServerClosedEvent = exports.ServerOpeningEvent = exports.ServerDescriptionChangedEvent = void 0;
+
+const constants_1 = require("../constants");
+/**
+ * Emitted when server description changes, but does NOT include changes to the RTT.
+ * @public
+ * @category Event
+ */
+
+
+class ServerDescriptionChangedEvent {
+  /** @internal */
+  constructor(topologyId, address, previousDescription, newDescription) {
+    this.name = constants_1.SERVER_DESCRIPTION_CHANGED;
+    this.topologyId = topologyId;
+    this.address = address;
+    this.previousDescription = previousDescription;
+    this.newDescription = newDescription;
+  }
+
+}
+
+exports.ServerDescriptionChangedEvent = ServerDescriptionChangedEvent;
+/**
+ * Emitted when server is initialized.
+ * @public
+ * @category Event
+ */
+
+class ServerOpeningEvent {
+  /** @internal */
+  constructor(topologyId, address) {
+    /** @internal */
+    this.name = constants_1.SERVER_OPENING;
+    this.topologyId = topologyId;
+    this.address = address;
+  }
+
+}
+
+exports.ServerOpeningEvent = ServerOpeningEvent;
+/**
+ * Emitted when server is closed.
+ * @public
+ * @category Event
+ */
+
+class ServerClosedEvent {
+  /** @internal */
+  constructor(topologyId, address) {
+    /** @internal */
+    this.name = constants_1.SERVER_CLOSED;
+    this.topologyId = topologyId;
+    this.address = address;
+  }
+
+}
+
+exports.ServerClosedEvent = ServerClosedEvent;
+/**
+ * Emitted when topology description changes.
+ * @public
+ * @category Event
+ */
+
+class TopologyDescriptionChangedEvent {
+  /** @internal */
+  constructor(topologyId, previousDescription, newDescription) {
+    /** @internal */
+    this.name = constants_1.TOPOLOGY_DESCRIPTION_CHANGED;
+    this.topologyId = topologyId;
+    this.previousDescription = previousDescription;
+    this.newDescription = newDescription;
+  }
+
+}
+
+exports.TopologyDescriptionChangedEvent = TopologyDescriptionChangedEvent;
+/**
+ * Emitted when topology is initialized.
+ * @public
+ * @category Event
+ */
+
+class TopologyOpeningEvent {
+  /** @internal */
+  constructor(topologyId) {
+    /** @internal */
+    this.name = constants_1.TOPOLOGY_OPENING;
+    this.topologyId = topologyId;
+  }
+
+}
+
+exports.TopologyOpeningEvent = TopologyOpeningEvent;
+/**
+ * Emitted when topology is closed.
+ * @public
+ * @category Event
+ */
+
+class TopologyClosedEvent {
+  /** @internal */
+  constructor(topologyId) {
+    /** @internal */
+    this.name = constants_1.TOPOLOGY_CLOSED;
+    this.topologyId = topologyId;
+  }
+
+}
+
+exports.TopologyClosedEvent = TopologyClosedEvent;
+/**
+ * Emitted when the server monitor’s hello command is started - immediately before
+ * the hello command is serialized into raw BSON and written to the socket.
+ *
+ * @public
+ * @category Event
+ */
+
+class ServerHeartbeatStartedEvent {
+  /** @internal */
+  constructor(connectionId, awaited) {
+    /** @internal */
+    this.name = constants_1.SERVER_HEARTBEAT_STARTED;
+    this.connectionId = connectionId;
+    this.awaited = awaited;
+  }
+
+}
+
+exports.ServerHeartbeatStartedEvent = ServerHeartbeatStartedEvent;
+/**
+ * Emitted when the server monitor’s hello succeeds.
+ * @public
+ * @category Event
+ */
+
+class ServerHeartbeatSucceededEvent {
+  /** @internal */
+  constructor(connectionId, duration, reply, awaited) {
+    /** @internal */
+    this.name = constants_1.SERVER_HEARTBEAT_SUCCEEDED;
+    this.connectionId = connectionId;
+    this.duration = duration;
+    this.reply = reply ?? {};
+    this.awaited = awaited;
+  }
+
+}
+
+exports.ServerHeartbeatSucceededEvent = ServerHeartbeatSucceededEvent;
+/**
+ * Emitted when the server monitor’s hello fails, either with an “ok: 0” or a socket exception.
+ * @public
+ * @category Event
+ */
+
+class ServerHeartbeatFailedEvent {
+  /** @internal */
+  constructor(connectionId, duration, failure, awaited) {
+    /** @internal */
+    this.name = constants_1.SERVER_HEARTBEAT_FAILED;
+    this.connectionId = connectionId;
+    this.duration = duration;
+    this.failure = failure;
+    this.awaited = awaited;
+  }
+
+}
+
+exports.ServerHeartbeatFailedEvent = ServerHeartbeatFailedEvent;