@nullix/zod-mongoose-studio 0.0.1

package/.output/server/node_modules/mongodb/lib/operations/drop.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropDatabaseOperation = exports.DropCollectionOperation = void 0;
+exports.dropCollections = dropCollections;
+const __1 = require("..");
+const responses_1 = require("../cmap/wire_protocol/responses");
+const abstract_cursor_1 = require("../cursor/abstract_cursor");
+const error_1 = require("../error");
+const timeout_1 = require("../timeout");
+const command_1 = require("./command");
+const execute_operation_1 = require("./execute_operation");
+const operation_1 = require("./operation");
+/** @internal */
+class DropCollectionOperation extends command_1.CommandOperation {
+    constructor(db, name, options = {}) {
+        super(db, options);
+        this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse;
+        this.options = options;
+        this.name = name;
+    }
+    get commandName() {
+        return 'drop';
+    }
+    buildCommandDocument(_connection, _session) {
+        return { drop: this.name };
+    }
+    handleOk(_response) {
+        return true;
+    }
+}
+exports.DropCollectionOperation = DropCollectionOperation;
+async function dropCollections(db, name, options) {
+    const timeoutContext = timeout_1.TimeoutContext.create({
+        session: options.session,
+        serverSelectionTimeoutMS: db.client.s.options.serverSelectionTimeoutMS,
+        waitQueueTimeoutMS: db.client.s.options.waitQueueTimeoutMS,
+        timeoutMS: options.timeoutMS
+    });
+    const encryptedFieldsMap = db.client.s.options.autoEncryption?.encryptedFieldsMap;
+    let encryptedFields = options.encryptedFields ?? encryptedFieldsMap?.[`${db.databaseName}.${name}`];
+    if (!encryptedFields && encryptedFieldsMap) {
+        // If the MongoClient was configured with an encryptedFieldsMap,
+        // and no encryptedFields config was available in it or explicitly
+        // passed as an argument, the spec tells us to look one up using
+        // listCollections().
+        const listCollectionsResult = await db
+            .listCollections({ name }, {
+            nameOnly: false,
+            session: options.session,
+            timeoutContext: new abstract_cursor_1.CursorTimeoutContext(timeoutContext, Symbol())
+        })
+            .toArray();
+        encryptedFields = listCollectionsResult?.[0]?.options?.encryptedFields;
+    }
+    if (encryptedFields) {
+        const escCollection = encryptedFields.escCollection || `enxcol_.${name}.esc`;
+        const ecocCollection = encryptedFields.ecocCollection || `enxcol_.${name}.ecoc`;
+        for (const collectionName of [escCollection, ecocCollection]) {
+            // Drop auxilliary collections, ignoring potential NamespaceNotFound errors.
+            const dropOp = new DropCollectionOperation(db, collectionName, options);
+            try {
+                await (0, execute_operation_1.executeOperation)(db.client, dropOp, timeoutContext);
+            }
+            catch (err) {
+                if (!(err instanceof __1.MongoServerError) ||
+                    err.code !== error_1.MONGODB_ERROR_CODES.NamespaceNotFound) {
+                    throw err;
+                }
+            }
+        }
+    }
+    return await (0, execute_operation_1.executeOperation)(db.client, new DropCollectionOperation(db, name, options), timeoutContext);
+}
+/** @internal */
+class DropDatabaseOperation extends command_1.CommandOperation {
+    constructor(db, options) {
+        super(db, options);
+        this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse;
+        this.options = options;
+    }
+    get commandName() {
+        return 'dropDatabase';
+    }
+    buildCommandDocument(_connection, _session) {
+        return { dropDatabase: 1 };
+    }
+    handleOk(_response) {
+        return true;
+    }
+}
+exports.DropDatabaseOperation = DropDatabaseOperation;
+(0, operation_1.defineAspects)(DropCollectionOperation, [operation_1.Aspect.WRITE_OPERATION]);
+(0, operation_1.defineAspects)(DropDatabaseOperation, [operation_1.Aspect.WRITE_OPERATION]);
+//# sourceMappingURL=drop.js.map

package/.output/server/node_modules/mongodb/lib/operations/estimated_document_count.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EstimatedDocumentCountOperation = void 0;
+const responses_1 = require("../cmap/wire_protocol/responses");
+const command_1 = require("./command");
+const operation_1 = require("./operation");
+/** @internal */
+class EstimatedDocumentCountOperation extends command_1.CommandOperation {
+    constructor(collection, options = {}) {
+        super(collection, options);
+        this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse;
+        this.options = options;
+        this.collectionName = collection.collectionName;
+    }
+    get commandName() {
+        return 'count';
+    }
+    buildCommandDocument(_connection, _session) {
+        const cmd = { count: this.collectionName };
+        if (typeof this.options.maxTimeMS === 'number') {
+            cmd.maxTimeMS = this.options.maxTimeMS;
+        }
+        // we check for undefined specifically here to allow falsy values
+        // eslint-disable-next-line no-restricted-syntax
+        if (this.options.comment !== undefined) {
+            cmd.comment = this.options.comment;
+        }
+        return cmd;
+    }
+    handleOk(response) {
+        return response.getNumber('n') ?? 0;
+    }
+}
+exports.EstimatedDocumentCountOperation = EstimatedDocumentCountOperation;
+(0, operation_1.defineAspects)(EstimatedDocumentCountOperation, [
+    operation_1.Aspect.READ_OPERATION,
+    operation_1.Aspect.RETRYABLE,
+    operation_1.Aspect.CURSOR_CREATING,
+    operation_1.Aspect.SUPPORTS_RAW_DATA
+]);
+//# sourceMappingURL=estimated_document_count.js.map

package/.output/server/node_modules/mongodb/lib/operations/execute_operation.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeOperation = executeOperation;
+exports.autoConnect = autoConnect;
+const error_1 = require("../error");
+const read_preference_1 = require("../read_preference");
+const server_selection_1 = require("../sdam/server_selection");
+const timeout_1 = require("../timeout");
+const utils_1 = require("../utils");
+const aggregate_1 = require("./aggregate");
+const operation_1 = require("./operation");
+const MMAPv1_RETRY_WRITES_ERROR_CODE = error_1.MONGODB_ERROR_CODES.IllegalOperation;
+const MMAPv1_RETRY_WRITES_ERROR_MESSAGE = 'This MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string.';
+/**
+ * Executes the given operation with provided arguments.
+ * @internal
+ *
+ * @remarks
+ * Allows for a single point of entry to provide features such as implicit sessions, which
+ * are required by the Driver Sessions specification in the event that a ClientSession is
+ * not provided.
+ *
+ * The expectation is that this function:
+ * - Connects the MongoClient if it has not already been connected, see {@link autoConnect}
+ * - Creates a session if none is provided and cleans up the session it creates
+ * - Tries an operation and retries under certain conditions, see {@link tryOperation}
+ *
+ * @typeParam T - The operation's type
+ * @typeParam TResult - The type of the operation's result, calculated from T
+ *
+ * @param client - The MongoClient to execute this operation with
+ * @param operation - The operation to execute
+ */
+async function executeOperation(client, operation, timeoutContext) {
+    if (!(operation instanceof operation_1.AbstractOperation)) {
+        // TODO(NODE-3483): Extend MongoRuntimeError
+        throw new error_1.MongoRuntimeError('This method requires a valid operation instance');
+    }
+    const topology = client.topology == null
+        ? await (0, utils_1.abortable)(autoConnect(client), operation.options)
+        : client.topology;
+    // The driver sessions spec mandates that we implicitly create sessions for operations
+    // that are not explicitly provided with a session.
+    let session = operation.session;
+    let owner;
+    if (session == null) {
+        owner = Symbol();
+        session = client.startSession({ owner, explicit: false });
+    }
+    else if (session.hasEnded) {
+        throw new error_1.MongoExpiredSessionError('Use of expired sessions is not permitted');
+    }
+    else if (session.snapshotEnabled && !topology.capabilities.supportsSnapshotReads) {
+        throw new error_1.MongoCompatibilityError('Snapshot reads require MongoDB 5.0 or later');
+    }
+    else if (session.client !== client) {
+        throw new error_1.MongoInvalidArgumentError('ClientSession must be from the same MongoClient');
+    }
+    operation.session ??= session;
+    const readPreference = operation.readPreference ?? read_preference_1.ReadPreference.primary;
+    const inTransaction = !!session?.inTransaction();
+    const hasReadAspect = operation.hasAspect(operation_1.Aspect.READ_OPERATION);
+    if (inTransaction &&
+        !readPreference.equals(read_preference_1.ReadPreference.primary) &&
+        (hasReadAspect || operation.commandName === 'runCommand')) {
+        throw new error_1.MongoTransactionError(`Read preference in a transaction must be primary, not: ${readPreference.mode}`);
+    }
+    if (session?.isPinned && session.transaction.isCommitted && !operation.bypassPinningCheck) {
+        session.unpin();
+    }
+    timeoutContext ??= timeout_1.TimeoutContext.create({
+        session,
+        serverSelectionTimeoutMS: client.s.options.serverSelectionTimeoutMS,
+        waitQueueTimeoutMS: client.s.options.waitQueueTimeoutMS,
+        timeoutMS: operation.options.timeoutMS
+    });
+    try {
+        return await tryOperation(operation, {
+            topology,
+            timeoutContext,
+            session,
+            readPreference
+        });
+    }
+    finally {
+        if (session?.owner != null && session.owner === owner) {
+            await session.endSession();
+        }
+    }
+}
+/**
+ * Connects a client if it has not yet been connected
+ * @internal
+ */
+async function autoConnect(client) {
+    if (client.topology == null) {
+        if (client.s.hasBeenClosed) {
+            throw new error_1.MongoNotConnectedError('Client must be connected before running operations');
+        }
+        client.s.options.__skipPingOnConnect = true;
+        try {
+            await client.connect();
+            if (client.topology == null) {
+                throw new error_1.MongoRuntimeError('client.connect did not create a topology but also did not throw');
+            }
+            return client.topology;
+        }
+        finally {
+            delete client.s.options.__skipPingOnConnect;
+        }
+    }
+    return client.topology;
+}
+/**
+ * Executes an operation and retries as appropriate
+ * @internal
+ *
+ * @remarks
+ * Implements behaviour described in [Retryable Reads](https://github.com/mongodb/specifications/blob/master/source/retryable-reads/retryable-reads.md) and [Retryable
+ * Writes](https://github.com/mongodb/specifications/blob/master/source/retryable-writes/retryable-writes.md) specification
+ *
+ * This function:
+ * - performs initial server selection
+ * - attempts to execute an operation
+ * - retries the operation if it meets the criteria for a retryable read or a retryable write
+ *
+ * @typeParam T - The operation's type
+ * @typeParam TResult - The type of the operation's result, calculated from T
+ *
+ * @param operation - The operation to execute
+ * */
+async function tryOperation(operation, { topology, timeoutContext, session, readPreference }) {
+    let selector;
+    if (operation.hasAspect(operation_1.Aspect.MUST_SELECT_SAME_SERVER)) {
+        // GetMore and KillCursor operations must always select the same server, but run through
+        // server selection to potentially force monitor checks if the server is
+        // in an unknown state.
+        selector = (0, server_selection_1.sameServerSelector)(operation.server?.description);
+    }
+    else if (operation instanceof aggregate_1.AggregateOperation && operation.hasWriteStage) {
+        // If operation should try to write to secondary use the custom server selector
+        // otherwise provide the read preference.
+        selector = (0, server_selection_1.secondaryWritableServerSelector)(topology.commonWireVersion, readPreference);
+    }
+    else {
+        selector = readPreference;
+    }
+    let server = await topology.selectServer(selector, {
+        session,
+        operationName: operation.commandName,
+        timeoutContext,
+        signal: operation.options.signal
+    });
+    const hasReadAspect = operation.hasAspect(operation_1.Aspect.READ_OPERATION);
+    const hasWriteAspect = operation.hasAspect(operation_1.Aspect.WRITE_OPERATION);
+    const inTransaction = session?.inTransaction() ?? false;
+    const willRetryRead = topology.s.options.retryReads && !inTransaction && operation.canRetryRead;
+    const willRetryWrite = topology.s.options.retryWrites &&
+        !inTransaction &&
+        (0, utils_1.supportsRetryableWrites)(server) &&
+        operation.canRetryWrite;
+    const willRetry = operation.hasAspect(operation_1.Aspect.RETRYABLE) &&
+        session != null &&
+        ((hasReadAspect && willRetryRead) || (hasWriteAspect && willRetryWrite));
+    if (hasWriteAspect && willRetryWrite && session != null) {
+        operation.options.willRetryWrite = true;
+        session.incrementTransactionNumber();
+    }
+    const maxTries = willRetry ? (timeoutContext.csotEnabled() ? Infinity : 2) : 1;
+    let previousOperationError;
+    let previousServer;
+    for (let tries = 0; tries < maxTries; tries++) {
+        if (previousOperationError) {
+            if (hasWriteAspect && previousOperationError.code === MMAPv1_RETRY_WRITES_ERROR_CODE) {
+                throw new error_1.MongoServerError({
+                    message: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
+                    errmsg: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
+                    originalError: previousOperationError
+                });
+            }
+            if (operation.hasAspect(operation_1.Aspect.COMMAND_BATCHING) && !operation.canRetryWrite) {
+                throw previousOperationError;
+            }
+            if (hasWriteAspect && !(0, error_1.isRetryableWriteError)(previousOperationError))
+                throw previousOperationError;
+            if (hasReadAspect && !(0, error_1.isRetryableReadError)(previousOperationError)) {
+                throw previousOperationError;
+            }
+            if (previousOperationError instanceof error_1.MongoNetworkError &&
+                operation.hasAspect(operation_1.Aspect.CURSOR_CREATING) &&
+                session != null &&
+                session.isPinned &&
+                !session.inTransaction()) {
+                session.unpin({ force: true, forceClear: true });
+            }
+            server = await topology.selectServer(selector, {
+                session,
+                operationName: operation.commandName,
+                previousServer,
+                signal: operation.options.signal
+            });
+            if (hasWriteAspect && !(0, utils_1.supportsRetryableWrites)(server)) {
+                throw new error_1.MongoUnexpectedServerResponseError('Selected server does not support retryable writes');
+            }
+        }
+        operation.server = server;
+        try {
+            // If tries > 0 and we are command batching we need to reset the batch.
+            if (tries > 0 && operation.hasAspect(operation_1.Aspect.COMMAND_BATCHING)) {
+                operation.resetBatch();
+            }
+            try {
+                const result = await server.command(operation, timeoutContext);
+                return operation.handleOk(result);
+            }
+            catch (error) {
+                return operation.handleError(error);
+            }
+        }
+        catch (operationError) {
+            if (!(operationError instanceof error_1.MongoError))
+                throw operationError;
+            if (previousOperationError != null &&
+                operationError.hasErrorLabel(error_1.MongoErrorLabel.NoWritesPerformed)) {
+                throw previousOperationError;
+            }
+            previousServer = server.description;
+            previousOperationError = operationError;
+            // Reset timeouts
+            timeoutContext.clear();
+        }
+    }
+    throw (previousOperationError ??
+        new error_1.MongoRuntimeError('Tried to propagate retryability error, but no error was found.'));
+}
+//# sourceMappingURL=execute_operation.js.map

package/.output/server/node_modules/mongodb/lib/operations/find.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindOperation = void 0;
+const responses_1 = require("../cmap/wire_protocol/responses");
+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 */
+class FindOperation extends command_1.CommandOperation {
+    constructor(ns, filter = {}, options = {}) {
+        super(undefined, options);
+        this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.CursorResponse;
+        this.options = { ...options };
+        delete this.options.writeConcern;
+        this.ns = ns;
+        if (typeof filter !== 'object' || Array.isArray(filter)) {
+            throw new error_1.MongoInvalidArgumentError('Query filter must be a plain object or ObjectId');
+        }
+        // special case passing in an ObjectId as a filter
+        this.filter = filter != null && filter._bsontype === 'ObjectId' ? { _id: filter } : filter;
+        this.SERVER_COMMAND_RESPONSE_TYPE = this.explain ? responses_1.ExplainedCursorResponse : responses_1.CursorResponse;
+    }
+    get commandName() {
+        return 'find';
+    }
+    buildOptions(timeoutContext) {
+        return {
+            ...this.options,
+            ...this.bsonOptions,
+            documentsReturnedIn: 'firstBatch',
+            session: this.session,
+            timeoutContext
+        };
+    }
+    handleOk(response) {
+        return response;
+    }
+    buildCommandDocument() {
+        return makeFindCommand(this.ns, this.filter, this.options);
+    }
+}
+exports.FindOperation = FindOperation;
+function makeFindCommand(ns, filter, options) {
+    const findCommand = {
+        find: ns.collection,
+        filter
+    };
+    if (options.sort) {
+        findCommand.sort = (0, sort_1.formatSort)(options.sort);
+    }
+    if (options.projection) {
+        let projection = options.projection;
+        if (projection && Array.isArray(projection)) {
+            projection = projection.length
+                ? projection.reduce((result, field) => {
+                    result[field] = 1;
+                    return result;
+                }, {})
+                : { _id: 1 };
+        }
+        findCommand.projection = projection;
+    }
+    if (options.hint) {
+        findCommand.hint = (0, utils_1.normalizeHintField)(options.hint);
+    }
+    if (typeof options.skip === 'number') {
+        findCommand.skip = options.skip;
+    }
+    if (typeof options.limit === 'number') {
+        if (options.limit < 0) {
+            findCommand.limit = -options.limit;
+            findCommand.singleBatch = true;
+        }
+        else {
+            findCommand.limit = options.limit;
+        }
+    }
+    if (typeof options.batchSize === 'number') {
+        if (options.batchSize < 0) {
+            findCommand.limit = -options.batchSize;
+        }
+        else {
+            if (options.batchSize === options.limit) {
+                // Spec dictates that if these are equal the batchSize should be one more than the
+                // limit to avoid leaving the cursor open.
+                findCommand.batchSize = options.batchSize + 1;
+            }
+            else {
+                findCommand.batchSize = options.batchSize;
+            }
+        }
+    }
+    if (typeof options.singleBatch === 'boolean') {
+        findCommand.singleBatch = options.singleBatch;
+    }
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (options.comment !== undefined) {
+        findCommand.comment = options.comment;
+    }
+    if (options.max) {
+        findCommand.max = options.max;
+    }
+    if (options.min) {
+        findCommand.min = options.min;
+    }
+    if (typeof options.returnKey === 'boolean') {
+        findCommand.returnKey = options.returnKey;
+    }
+    if (typeof options.showRecordId === 'boolean') {
+        findCommand.showRecordId = options.showRecordId;
+    }
+    if (typeof options.tailable === 'boolean') {
+        findCommand.tailable = options.tailable;
+    }
+    if (typeof options.oplogReplay === 'boolean') {
+        findCommand.oplogReplay = options.oplogReplay;
+    }
+    if (typeof options.timeout === 'boolean') {
+        findCommand.noCursorTimeout = !options.timeout;
+    }
+    else if (typeof options.noCursorTimeout === 'boolean') {
+        findCommand.noCursorTimeout = options.noCursorTimeout;
+    }
+    if (typeof options.awaitData === 'boolean') {
+        findCommand.awaitData = options.awaitData;
+    }
+    if (typeof options.allowPartialResults === 'boolean') {
+        findCommand.allowPartialResults = options.allowPartialResults;
+    }
+    if (typeof options.allowDiskUse === 'boolean') {
+        findCommand.allowDiskUse = options.allowDiskUse;
+    }
+    if (options.let) {
+        findCommand.let = options.let;
+    }
+    return findCommand;
+}
+(0, operation_1.defineAspects)(FindOperation, [
+    operation_1.Aspect.READ_OPERATION,
+    operation_1.Aspect.RETRYABLE,
+    operation_1.Aspect.EXPLAINABLE,
+    operation_1.Aspect.CURSOR_CREATING,
+    operation_1.Aspect.SUPPORTS_RAW_DATA
+]);
+//# sourceMappingURL=find.js.map

package/.output/server/node_modules/mongodb/lib/operations/find_and_modify.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindOneAndUpdateOperation = exports.FindOneAndReplaceOperation = exports.FindOneAndDeleteOperation = exports.FindAndModifyOperation = exports.ReturnDocument = void 0;
+const responses_1 = require("../cmap/wire_protocol/responses");
+const error_1 = require("../error");
+const read_preference_1 = require("../read_preference");
+const sort_1 = require("../sort");
+const utils_1 = require("../utils");
+const command_1 = require("./command");
+const operation_1 = require("./operation");
+/** @public */
+exports.ReturnDocument = Object.freeze({
+    BEFORE: 'before',
+    AFTER: 'after'
+});
+function configureFindAndModifyCmdBaseUpdateOpts(cmdBase, options) {
+    cmdBase.new = options.returnDocument === exports.ReturnDocument.AFTER;
+    cmdBase.upsert = options.upsert === true;
+    if (options.bypassDocumentValidation === true) {
+        cmdBase.bypassDocumentValidation = options.bypassDocumentValidation;
+    }
+    return cmdBase;
+}
+/** @internal */
+class FindAndModifyOperation extends command_1.CommandOperation {
+    constructor(collection, query, options) {
+        super(collection, options);
+        this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse;
+        this.options = options;
+        // force primary read preference
+        this.readPreference = read_preference_1.ReadPreference.primary;
+        this.collection = collection;
+        this.query = query;
+    }
+    get commandName() {
+        return 'findAndModify';
+    }
+    buildCommandDocument(connection, _session) {
+        const options = this.options;
+        const command = {
+            findAndModify: this.collection.collectionName,
+            query: this.query,
+            remove: false,
+            new: false,
+            upsert: false
+        };
+        options.includeResultMetadata ??= false;
+        const sort = (0, sort_1.formatSort)(options.sort);
+        if (sort) {
+            command.sort = sort;
+        }
+        if (options.projection) {
+            command.fields = options.projection;
+        }
+        if (options.maxTimeMS) {
+            command.maxTimeMS = options.maxTimeMS;
+        }
+        // Decorate the findAndModify command with the write Concern
+        if (options.writeConcern) {
+            command.writeConcern = options.writeConcern;
+        }
+        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;
+        }
+        (0, utils_1.decorateWithCollation)(command, options);
+        if (options.hint) {
+            const unacknowledgedWrite = this.writeConcern?.w === 0;
+            if (unacknowledgedWrite && (0, utils_1.maxWireVersion)(connection) < 9) {
+                throw new error_1.MongoCompatibilityError('hint for the findAndModify command is only supported on MongoDB 4.4+');
+            }
+            command.hint = options.hint;
+        }
+        return command;
+    }
+    handleOk(response) {
+        const result = super.handleOk(response);
+        return this.options.includeResultMetadata ? result : (result.value ?? null);
+    }
+}
+exports.FindAndModifyOperation = FindAndModifyOperation;
+/** @internal */
+class FindOneAndDeleteOperation extends FindAndModifyOperation {
+    constructor(collection, filter, options) {
+        // Basic validation
+        if (filter == null || typeof filter !== 'object') {
+            throw new error_1.MongoInvalidArgumentError('Argument "filter" must be an object');
+        }
+        super(collection, filter, options);
+    }
+    buildCommandDocument(connection, session) {
+        const document = super.buildCommandDocument(connection, session);
+        document.remove = true;
+        return document;
+    }
+}
+exports.FindOneAndDeleteOperation = FindOneAndDeleteOperation;
+/** @internal */
+class FindOneAndReplaceOperation extends FindAndModifyOperation {
+    constructor(collection, filter, replacement, options) {
+        if (filter == null || typeof filter !== 'object') {
+            throw new error_1.MongoInvalidArgumentError('Argument "filter" must be an object');
+        }
+        if (replacement == null || typeof replacement !== 'object') {
+            throw new error_1.MongoInvalidArgumentError('Argument "replacement" must be an object');
+        }
+        if ((0, utils_1.hasAtomicOperators)(replacement)) {
+            throw new error_1.MongoInvalidArgumentError('Replacement document must not contain atomic operators');
+        }
+        super(collection, filter, options);
+        this.replacement = replacement;
+    }
+    buildCommandDocument(connection, session) {
+        const document = super.buildCommandDocument(connection, session);
+        document.update = this.replacement;
+        configureFindAndModifyCmdBaseUpdateOpts(document, this.options);
+        return document;
+    }
+}
+exports.FindOneAndReplaceOperation = FindOneAndReplaceOperation;
+/** @internal */
+class FindOneAndUpdateOperation extends FindAndModifyOperation {
+    constructor(collection, filter, update, options) {
+        if (filter == null || typeof filter !== 'object') {
+            throw new error_1.MongoInvalidArgumentError('Argument "filter" must be an object');
+        }
+        if (update == null || typeof update !== 'object') {
+            throw new error_1.MongoInvalidArgumentError('Argument "update" must be an object');
+        }
+        if (!(0, utils_1.hasAtomicOperators)(update, options)) {
+            throw new error_1.MongoInvalidArgumentError('Update document requires atomic operators');
+        }
+        super(collection, filter, options);
+        this.update = update;
+        this.options = options;
+    }
+    buildCommandDocument(connection, session) {
+        const document = super.buildCommandDocument(connection, session);
+        document.update = this.update;
+        configureFindAndModifyCmdBaseUpdateOpts(document, this.options);
+        if (this.options.arrayFilters) {
+            document.arrayFilters = this.options.arrayFilters;
+        }
+        return document;
+    }
+}
+exports.FindOneAndUpdateOperation = FindOneAndUpdateOperation;
+(0, operation_1.defineAspects)(FindAndModifyOperation, [
+    operation_1.Aspect.WRITE_OPERATION,
+    operation_1.Aspect.RETRYABLE,
+    operation_1.Aspect.EXPLAINABLE,
+    operation_1.Aspect.SUPPORTS_RAW_DATA
+]);
+//# sourceMappingURL=find_and_modify.js.map