oxygen-cli 1.40.1 → 1.40.2-beta.1

package/transpiled/mongodb/lib/mongo_types.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CancellationToken = exports.TypedEventEmitter = void 0;
+
+const events_1 = require("events");
+
+const mongo_logger_1 = require("./mongo_logger");
+
+const utils_1 = require("./utils");
+/**
+ * Typescript type safe event emitter
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+
+
+class TypedEventEmitter extends events_1.EventEmitter {
+  /** @internal */
+  emitAndLog(event, ...args) {
+    this.emit(event, ...args);
+    if (this.component) this.mongoLogger?.debug(this.component, args[0]);
+  }
+  /** @internal */
+
+
+  emitAndLogHeartbeat(event, topologyId, serverConnectionId, ...args) {
+    this.emit(event, ...args);
+
+    if (this.component) {
+      const loggableHeartbeatEvent = {
+        topologyId: topologyId,
+        serverConnectionId: serverConnectionId ?? null,
+        ...args[0]
+      };
+      this.mongoLogger?.debug(this.component, loggableHeartbeatEvent);
+    }
+  }
+  /** @internal */
+
+
+  emitAndLogCommand(monitorCommands, event, databaseName, connectionEstablished, ...args) {
+    if (monitorCommands) {
+      this.emit(event, ...args);
+    }
+
+    if (connectionEstablished) {
+      const loggableCommandEvent = {
+        databaseName: databaseName,
+        ...args[0]
+      };
+      this.mongoLogger?.debug(mongo_logger_1.MongoLoggableComponent.COMMAND, loggableCommandEvent);
+    }
+  }
+
+}
+
+exports.TypedEventEmitter = TypedEventEmitter;
+/** @public */
+
+class CancellationToken extends TypedEventEmitter {
+  constructor(...args) {
+    super(...args);
+    this.on('error', utils_1.noop);
+  }
+
+}
+
+exports.CancellationToken = CancellationToken;

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

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AggregateOperation = exports.DB_AGGREGATE_COLLECTION = void 0;
+
+const responses_1 = require("../cmap/wire_protocol/responses");
+
+const error_1 = require("../error");
+
+const utils_1 = require("../utils");
+
+const write_concern_1 = require("../write_concern");
+
+const command_1 = require("./command");
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+exports.DB_AGGREGATE_COLLECTION = 1;
+const MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT = 8;
+/** @internal */
+
+class AggregateOperation extends command_1.CommandOperation {
+  constructor(ns, pipeline, options) {
+    super(undefined, { ...options,
+      dbName: ns.db
+    });
+    this.options = { ...options
+    }; // Covers when ns.collection is null, undefined or the empty string, use DB_AGGREGATE_COLLECTION
+
+    this.target = ns.collection || exports.DB_AGGREGATE_COLLECTION;
+    this.pipeline = pipeline; // determine if we have a write stage, override read preference if so
+
+    this.hasWriteStage = false;
+
+    if (typeof options?.out === 'string') {
+      this.pipeline = this.pipeline.concat({
+        $out: options.out
+      });
+      this.hasWriteStage = true;
+    } else if (pipeline.length > 0) {
+      const finalStage = pipeline[pipeline.length - 1];
+
+      if (finalStage.$out || finalStage.$merge) {
+        this.hasWriteStage = true;
+      }
+    }
+
+    if (this.hasWriteStage) {
+      this.trySecondaryWrite = true;
+    } else {
+      delete this.options.writeConcern;
+    }
+
+    if (this.explain && this.writeConcern) {
+      throw new error_1.MongoInvalidArgumentError('Option "explain" cannot be used on an aggregate call with writeConcern');
+    }
+
+    if (options?.cursor != null && typeof options.cursor !== 'object') {
+      throw new error_1.MongoInvalidArgumentError('Cursor options must be an object');
+    }
+  }
+
+  get commandName() {
+    return 'aggregate';
+  }
+
+  get canRetryRead() {
+    return !this.hasWriteStage;
+  }
+
+  addToPipeline(stage) {
+    this.pipeline.push(stage);
+  }
+
+  async execute(server, session, timeoutContext) {
+    const options = this.options;
+    const serverWireVersion = (0, utils_1.maxWireVersion)(server);
+    const command = {
+      aggregate: this.target,
+      pipeline: this.pipeline
+    };
+
+    if (this.hasWriteStage && serverWireVersion < MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT) {
+      this.readConcern = undefined;
+    }
+
+    if (this.hasWriteStage && this.writeConcern) {
+      write_concern_1.WriteConcern.apply(command, this.writeConcern);
+    }
+
+    if (options.bypassDocumentValidation === true) {
+      command.bypassDocumentValidation = options.bypassDocumentValidation;
+    }
+
+    if (typeof options.allowDiskUse === 'boolean') {
+      command.allowDiskUse = options.allowDiskUse;
+    }
+
+    if (options.hint) {
+      command.hint = options.hint;
+    }
+
+    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;
+    }
+
+    command.cursor = options.cursor || {};
+
+    if (options.batchSize && !this.hasWriteStage) {
+      command.cursor.batchSize = options.batchSize;
+    }
+
+    return await super.executeCommand(server, session, command, timeoutContext, this.explain ? responses_1.ExplainedCursorResponse : responses_1.CursorResponse);
+  }
+
+}
+
+exports.AggregateOperation = AggregateOperation;
+(0, operation_1.defineAspects)(AggregateOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.RETRYABLE, operation_1.Aspect.EXPLAINABLE, operation_1.Aspect.CURSOR_CREATING]);

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BulkWriteOperation = void 0;
+
+const operation_1 = require("./operation");
+/** @internal */
+
+
+class BulkWriteOperation extends operation_1.AbstractOperation {
+  constructor(collection, operations, options) {
+    super(options);
+    this.options = options;
+    this.collection = collection;
+    this.operations = operations;
+  }
+
+  get commandName() {
+    return 'bulkWrite';
+  }
+
+  async execute(server, session, timeoutContext) {
+    const coll = this.collection;
+    const operations = this.operations;
+    const options = { ...this.options,
+      ...this.bsonOptions,
+      readPreference: this.readPreference,
+      timeoutContext
+    }; // Create the bulk operation
+
+    const bulk = options.ordered === false ? coll.initializeUnorderedBulkOp(options) : coll.initializeOrderedBulkOp(options); // for each op go through and add to the bulk
+
+    for (let i = 0; i < operations.length; i++) {
+      bulk.raw(operations[i]);
+    } // Execute the bulk
+
+
+    return await bulk.execute({ ...options,
+      session
+    });
+  }
+
+}
+
+exports.BulkWriteOperation = BulkWriteOperation;
+(0, operation_1.defineAspects)(BulkWriteOperation, [operation_1.Aspect.WRITE_OPERATION]);

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

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ClientBulkWriteOperation = void 0;
+
+const beta_1 = require("../../beta");
+
+const responses_1 = require("../../cmap/wire_protocol/responses");
+
+const utils_1 = require("../../utils");
+
+const command_1 = require("../command");
+
+const operation_1 = require("../operation");
+/**
+ * Executes a single client bulk write operation within a potential batch.
+ * @internal
+ */
+
+
+class ClientBulkWriteOperation extends command_1.CommandOperation {
+  get commandName() {
+    return 'bulkWrite';
+  }
+
+  constructor(commandBuilder, options) {
+    super(undefined, options);
+    this.commandBuilder = commandBuilder;
+    this.options = options;
+    this.ns = new utils_1.MongoDBNamespace('admin', '$cmd');
+  }
+
+  resetBatch() {
+    return this.commandBuilder.resetBatch();
+  }
+
+  get canRetryWrite() {
+    return this.commandBuilder.isBatchRetryable;
+  }
+  /**
+   * Execute the command. Superclass will handle write concern, etc.
+   * @param server - The server.
+   * @param session - The session.
+   * @returns The response.
+   */
+
+
+  async execute(server, session, timeoutContext) {
+    let command;
+
+    if (server.description.type === beta_1.ServerType.LoadBalancer) {
+      if (session) {
+        let connection;
+
+        if (!session.pinnedConnection) {
+          // Checkout a connection to build the command.
+          connection = await server.pool.checkOut({
+            timeoutContext
+          }); // Pin the connection to the session so it get used to execute the command and we do not
+          // perform a double check-in/check-out.
+
+          session.pin(connection);
+        } else {
+          connection = session.pinnedConnection;
+        }
+
+        command = this.commandBuilder.buildBatch(connection.hello?.maxMessageSizeBytes, connection.hello?.maxWriteBatchSize, connection.hello?.maxBsonObjectSize);
+      } else {
+        throw new beta_1.MongoClientBulkWriteExecutionError('Session provided to the client bulk write operation must be present.');
+      }
+    } else {
+      // At this point we have a server and the auto connect code has already
+      // run in executeOperation, so the server description will be populated.
+      // We can use that to build the command.
+      if (!server.description.maxWriteBatchSize || !server.description.maxMessageSizeBytes || !server.description.maxBsonObjectSize) {
+        throw new beta_1.MongoClientBulkWriteExecutionError('In order to execute a client bulk write, both maxWriteBatchSize, maxMessageSizeBytes and maxBsonObjectSize must be provided by the servers hello response.');
+      }
+
+      command = this.commandBuilder.buildBatch(server.description.maxMessageSizeBytes, server.description.maxWriteBatchSize, server.description.maxBsonObjectSize);
+    } // Check after the batch is built if we cannot retry it and override the option.
+
+
+    if (!this.canRetryWrite) {
+      this.options.willRetryWrite = false;
+    }
+
+    return await super.executeCommand(server, session, command, timeoutContext, responses_1.ClientBulkWriteCursorResponse);
+  }
+
+}
+
+exports.ClientBulkWriteOperation = ClientBulkWriteOperation; // Skipping the collation as it goes on the individual ops.
+
+(0, operation_1.defineAspects)(ClientBulkWriteOperation, [operation_1.Aspect.WRITE_OPERATION, operation_1.Aspect.SKIP_COLLATION, operation_1.Aspect.CURSOR_CREATING, operation_1.Aspect.RETRYABLE, operation_1.Aspect.COMMAND_BATCHING]);