@fadhilp/stateql 0.5.4 → 0.6.0

package/dist/src/mongodb.js

@@ -0,0 +1,868 @@
+import { BSON, MongoClient, } from "mongodb";
+import { AdapterExecutionError, AdapterWriteError, BatchWriteError, } from "./adapters.js";
+const MAX_INSPECTION_ITEMS = 1_000;
+const FIND_OPTIONS = new Set([
+    "projection",
+    "sort",
+    "skip",
+    "limit",
+    "hint",
+    "collation",
+]);
+const AGGREGATE_OPTIONS = new Set(["allowDiskUse", "hint", "collation"]);
+const WRITE_OPTIONS = {
+    insertOne: new Set(),
+    insertMany: new Set(["ordered"]),
+    updateOne: new Set(["upsert", "collation", "hint"]),
+    updateMany: new Set(["upsert", "collation", "hint"]),
+    replaceOne: new Set(["upsert", "collation", "hint"]),
+    deleteOne: new Set(["collation", "hint"]),
+    deleteMany: new Set(["collation", "hint"]),
+};
+const FORBIDDEN_KEYS = new Set([
+    "$out",
+    "$merge",
+    "$changeStream",
+    "$where",
+    "$function",
+    "$accumulator",
+]);
+const UPDATE_PIPELINE_STAGES = new Set([
+    "$addFields",
+    "$set",
+    "$project",
+    "$unset",
+    "$replaceRoot",
+    "$replaceWith",
+]);
+const READ_KEYS = {
+    find: new Set(["operation", "collection", "filter", "options"]),
+    aggregate: new Set(["operation", "collection", "pipeline", "options"]),
+};
+const WRITE_KEYS = {
+    insertOne: new Set(["operation", "collection", "document", "options"]),
+    insertMany: new Set(["operation", "collection", "documents", "options"]),
+    updateOne: new Set(["operation", "collection", "filter", "update", "options"]),
+    updateMany: new Set(["operation", "collection", "filter", "update", "options"]),
+    replaceOne: new Set(["operation", "collection", "filter", "replacement", "options"]),
+    deleteOne: new Set(["operation", "collection", "filter", "options"]),
+    deleteMany: new Set(["operation", "collection", "filter", "options"]),
+};
+export function validateMongoReadCommand(value) {
+    if (!isRecord(value))
+        throw new Error("MongoDB read command must be an object.");
+    const operation = value.operation;
+    if (operation !== "find" && operation !== "aggregate") {
+        throw new Error("MongoDB reads only support find and aggregate.");
+    }
+    rejectUnknownKeys(value, READ_KEYS[operation], "read command");
+    validateCollection(value.collection);
+    validateOptions(value.options, operation === "find" ? FIND_OPTIONS : AGGREGATE_OPTIONS, operation);
+    if (operation === "find") {
+        if (value.filter !== undefined && !isDocument(value.filter)) {
+            throw new Error("MongoDB find filter must be an object.");
+        }
+        validateFindOptions(value.options);
+    }
+    else {
+        if (!Array.isArray(value.pipeline) || !value.pipeline.every(isDocument)) {
+            throw new Error("MongoDB aggregate pipeline must be an array of stage objects.");
+        }
+        for (const stage of value.pipeline) {
+            if (Object.keys(stage).length !== 1) {
+                throw new Error("Each MongoDB aggregate pipeline stage must contain exactly one operator.");
+            }
+        }
+        validateAggregateOptions(value.options);
+    }
+    rejectForbiddenValues(value);
+    return value;
+}
+export function validateMongoWriteCommand(value) {
+    if (!isRecord(value))
+        throw new Error("MongoDB write command must be an object.");
+    const operation = value.operation;
+    if (!isMongoWriteOperation(operation)) {
+        throw new Error(`Unsupported MongoDB write operation "${String(operation)}".`);
+    }
+    rejectUnknownKeys(value, WRITE_KEYS[operation], "write command");
+    validateCollection(value.collection);
+    validateOptions(value.options, WRITE_OPTIONS[operation], operation);
+    validateWriteOptions(value.options, operation);
+    switch (operation) {
+        case "insertOne":
+            requireDocument(value.document, "insertOne document");
+            break;
+        case "insertMany":
+            if (!Array.isArray(value.documents) || value.documents.length === 0 || !value.documents.every(isDocument)) {
+                throw new Error("MongoDB insertMany documents must be a non-empty array of objects.");
+            }
+            break;
+        case "updateOne":
+        case "updateMany":
+            requireDocument(value.filter, `${operation} filter`);
+            validateUpdate(value.update);
+            break;
+        case "replaceOne":
+            requireDocument(value.filter, "replaceOne filter");
+            requireDocument(value.replacement, "replaceOne replacement");
+            if (Object.keys(value.replacement).some((key) => key.startsWith("$"))) {
+                throw new Error("MongoDB replacement documents cannot contain top-level update operators.");
+            }
+            break;
+        case "deleteOne":
+        case "deleteMany":
+            requireDocument(value.filter, `${operation} filter`);
+            break;
+    }
+    rejectForbiddenValues(value);
+    return value;
+}
+export function analyzeMongoWriteSafety(command) {
+    const value = validateMongoWriteCommand(command);
+    switch (value.operation) {
+        case "insertOne":
+        case "insertMany":
+            return { unbounded: false, destructive: false };
+        case "updateOne":
+        case "updateMany":
+            return {
+                unbounded: Object.keys(value.filter).length === 0,
+                destructive: false,
+            };
+        case "replaceOne":
+            return {
+                unbounded: Object.keys(value.filter).length === 0,
+                destructive: true,
+            };
+        case "deleteOne":
+        case "deleteMany":
+            return {
+                unbounded: Object.keys(value.filter).length === 0,
+                destructive: true,
+            };
+    }
+}
+/** Deterministic EJSON preserves BSON types and property order. */
+export function serializeMongoCommand(command) {
+    return BSON.EJSON.stringify(command, { relaxed: false });
+}
+export function deserializeMongoWriteCommand(value) {
+    return validateMongoWriteCommand(parseEjson(value));
+}
+export class MongoAdapter {
+    context;
+    confidence = "ttl_based";
+    client;
+    databaseName;
+    readOnly;
+    connected = false;
+    closed = false;
+    connecting;
+    constructor(connection, context, input) {
+        this.context = context;
+        if (connection.driver !== "mongodb") {
+            throw new Error("MongoAdapter requires a MongoDB connection record.");
+        }
+        if (!connection.database_name || connection.database_name.includes("\0")) {
+            throw new Error("MongoDB connection requires an explicit valid database.");
+        }
+        this.databaseName = connection.database_name;
+        this.readOnly = Boolean(connection.read_only);
+        const timeout = remainingMilliseconds(context);
+        this.client = new MongoClient(input.source, {
+            connectTimeoutMS: timeout,
+            serverSelectionTimeoutMS: timeout,
+            waitQueueTimeoutMS: timeout,
+        });
+    }
+    async ping() {
+        await this.connect();
+        const signal = operationSignal(this.context);
+        try {
+            await this.client.db(this.databaseName).command({ ping: 1 }, {
+                timeoutMS: remainingMilliseconds(this.context),
+                signal,
+            });
+        }
+        catch (error) {
+            throw readError(error, this.context);
+        }
+    }
+    async signature() {
+        throwIfStopped(this.context, false);
+        return "mongodb:ttl";
+    }
+    async read(command, maxRows) {
+        const value = validateMongoReadCommand(command);
+        if (!Number.isSafeInteger(maxRows) || maxRows <= 0) {
+            throw new Error("MongoDB maxRows must be a positive integer.");
+        }
+        await this.connect();
+        const collection = this.client.db(this.databaseName).collection(value.collection);
+        const signal = operationSignal(this.context);
+        let cursor;
+        try {
+            if (value.operation === "find") {
+                const options = findOptions(value.options, this.context, signal, maxRows);
+                cursor = collection.find(value.filter ?? {}, options);
+            }
+            else {
+                const options = aggregateOptions(value.options, this.context, signal);
+                cursor = collection.aggregate(value.pipeline, options).limit(maxRows);
+            }
+            const documents = await collectCursor(cursor, maxRows, this.context);
+            return documentsResult(documents);
+        }
+        catch (error) {
+            throw readError(error, this.context);
+        }
+        finally {
+            await cursor?.close().catch(() => undefined);
+        }
+    }
+    async write(command) {
+        let value;
+        try {
+            value = validateMongoWriteCommand(command);
+        }
+        catch (error) {
+            throw new AdapterWriteError(errorText(error), false);
+        }
+        if (this.readOnly)
+            throw new AdapterWriteError("Connection is read-only.", false);
+        throwIfStopped(this.context, false);
+        try {
+            await this.connect();
+        }
+        catch (error) {
+            if (error instanceof AdapterExecutionError)
+                throw error;
+            throw new AdapterWriteError(errorText(error), false);
+        }
+        try {
+            return await withContext(this.executeWrite(value), this.context, () => this.stop(), true);
+        }
+        catch (error) {
+            const stopped = writeStoppedError(error, this.context, true);
+            if (stopped)
+                throw stopped;
+            throw new AdapterWriteError(errorText(error), knownNoWrite(error) ? false : true);
+        }
+    }
+    async writeBatch(commands, isolation) {
+        if (isolation.toLowerCase() !== "snapshot") {
+            throw new BatchWriteError(`Unsupported MongoDB isolation level "${isolation}".`, false);
+        }
+        let values;
+        try {
+            if (!Array.isArray(commands))
+                throw new Error("MongoDB transaction commands must be an array.");
+            values = commands.map(validateMongoWriteCommand);
+        }
+        catch (error) {
+            throw new BatchWriteError(errorText(error), false);
+        }
+        if (this.readOnly)
+            throw new BatchWriteError("Connection is read-only.", false);
+        throwIfStopped(this.context, false);
+        try {
+            await this.connect();
+        }
+        catch (error) {
+            if (error instanceof AdapterExecutionError)
+                throw error;
+            throw new BatchWriteError(errorText(error), false);
+        }
+        const session = this.client.startSession();
+        let dispatched = false;
+        let committing = false;
+        try {
+            session.startTransaction({
+                readConcern: { level: "snapshot" },
+                writeConcern: { w: "majority" },
+                readPreference: "primary",
+                maxCommitTimeMS: remainingMilliseconds(this.context),
+            });
+            const results = [];
+            for (const command of values) {
+                throwIfStopped(this.context, dispatched);
+                dispatched = true;
+                results.push(await withContext(this.executeWrite(command, session), this.context, () => this.stop(), true));
+            }
+            throwIfStopped(this.context, dispatched);
+            committing = true;
+            await withContext(session.commitTransaction({ timeoutMS: remainingMilliseconds(this.context) }), this.context, () => this.stop(), true);
+            return results;
+        }
+        catch (error) {
+            let aborted = false;
+            if (!committing && session.inTransaction()) {
+                try {
+                    await session.abortTransaction({
+                        timeoutMS: remainingMilliseconds(this.context),
+                    });
+                    aborted = true;
+                }
+                catch {
+                    // Without a confirmed abort, the staged write outcome is unknown.
+                }
+            }
+            const outcomeUnknown = committing || (dispatched && !aborted);
+            const stopped = writeStoppedError(error, this.context, outcomeUnknown);
+            if (stopped)
+                throw stopped;
+            throw new BatchWriteError(errorText(error), outcomeUnknown && !knownNoWrite(error));
+        }
+        finally {
+            await session.endSession().catch(() => undefined);
+        }
+    }
+    async inspect(kind, name) {
+        await this.connect();
+        try {
+            if (kind === "schema" || kind === "collections") {
+                const cursor = this.client.db(this.databaseName).listCollections({}, {
+                    nameOnly: true,
+                    signal: operationSignal(this.context),
+                    maxTimeMS: remainingMilliseconds(this.context),
+                    timeoutMS: remainingMilliseconds(this.context),
+                });
+                const collections = await collectCursor(cursor, MAX_INSPECTION_ITEMS, this.context);
+                return ejsonSafe({
+                    collections: collections.map((collection) => ({
+                        name: collection.name,
+                        type: collection.type ?? "collection",
+                    })),
+                });
+            }
+            validateCollection(name);
+            const collectionName = name;
+            await this.requireCollection(collectionName);
+            if (kind === "constraints") {
+                return { collection: collectionName, constraints: [] };
+            }
+            const columns = await this.sampleColumns(collectionName);
+            if (kind === "columns")
+                return { collection: collectionName, columns };
+            const indexes = await this.collectionIndexes(collectionName);
+            if (kind === "indexes")
+                return { collection: collectionName, indexes };
+            if (kind !== "table" && kind !== "collection") {
+                throw new Error(`Unknown inspection kind "${kind}".`);
+            }
+            return {
+                collection: collectionName,
+                columns,
+                indexes: indexes.length,
+                constraints: 0,
+            };
+        }
+        catch (error) {
+            throw readError(error, this.context);
+        }
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.connected = false;
+        await this.client.close().catch(() => undefined);
+    }
+    async connect() {
+        throwIfStopped(this.context, false);
+        if (this.closed)
+            throw new Error("MongoDB adapter is closed.");
+        if (this.connected)
+            return;
+        if (!this.connecting) {
+            this.connecting = withContext(this.client.connect().then(() => undefined), this.context, () => this.stop(), false).then(() => {
+                this.connected = true;
+            }).finally(() => {
+                this.connecting = undefined;
+            });
+        }
+        await this.connecting;
+    }
+    async executeWrite(command, session) {
+        const collection = this.client.db(this.databaseName).collection(command.collection);
+        const timeoutMS = remainingMilliseconds(this.context);
+        switch (command.operation) {
+            case "insertOne": {
+                const result = await collection.insertOne(command.document, { session, timeoutMS });
+                return {
+                    affectedRows: result.acknowledged ? 1 : 0,
+                    outcome: {
+                        acknowledged: result.acknowledged,
+                        inserted_id: ejsonSafe(result.insertedId),
+                    },
+                };
+            }
+            case "insertMany": {
+                const options = writeOptions(command.options, command.operation, session, timeoutMS);
+                const result = await collection.insertMany(command.documents, options);
+                const insertedIds = Object.entries(result.insertedIds)
+                    .sort(([left], [right]) => Number(left) - Number(right))
+                    .map(([, id]) => ejsonSafe(id));
+                return {
+                    affectedRows: result.insertedCount,
+                    outcome: {
+                        acknowledged: result.acknowledged,
+                        inserted_count: result.insertedCount,
+                        inserted_ids: insertedIds,
+                    },
+                };
+            }
+            case "updateOne":
+            case "updateMany": {
+                const options = writeOptions(command.options, command.operation, session, timeoutMS);
+                const result = command.operation === "updateOne"
+                    ? await collection.updateOne(command.filter, command.update, options)
+                    : await collection.updateMany(command.filter, command.update, options);
+                return updateResult(result);
+            }
+            case "replaceOne": {
+                const options = writeOptions(command.options, command.operation, session, timeoutMS);
+                const result = await collection.replaceOne(command.filter, command.replacement, options);
+                return updateResult(result);
+            }
+            case "deleteOne":
+            case "deleteMany": {
+                const options = writeOptions(command.options, command.operation, session, timeoutMS);
+                const result = command.operation === "deleteOne"
+                    ? await collection.deleteOne(command.filter, options)
+                    : await collection.deleteMany(command.filter, options);
+                return {
+                    affectedRows: result.deletedCount,
+                    outcome: {
+                        acknowledged: result.acknowledged,
+                        deleted_count: result.deletedCount,
+                    },
+                };
+            }
+        }
+    }
+    async requireCollection(name) {
+        const cursor = this.client.db(this.databaseName).listCollections({ name }, {
+            nameOnly: true,
+            signal: operationSignal(this.context),
+            maxTimeMS: remainingMilliseconds(this.context),
+            timeoutMS: remainingMilliseconds(this.context),
+        });
+        const found = await collectCursor(cursor, 1, this.context);
+        if (found.length === 0)
+            throw new Error(`Collection "${name}" was not found.`);
+    }
+    async sampleColumns(name) {
+        const cursor = this.client.db(this.databaseName).collection(name).find({}, {
+            limit: 1,
+            signal: operationSignal(this.context),
+            maxTimeMS: remainingMilliseconds(this.context),
+            timeoutMS: remainingMilliseconds(this.context),
+        });
+        const documents = await collectCursor(cursor, 1, this.context);
+        return inferColumns(documents);
+    }
+    async collectionIndexes(name) {
+        const cursor = this.client.db(this.databaseName).collection(name).listIndexes({
+            maxTimeMS: remainingMilliseconds(this.context),
+            timeoutMS: remainingMilliseconds(this.context),
+        });
+        const indexes = await collectCursor(cursor, MAX_INSPECTION_ITEMS, this.context);
+        return ejsonSafe(indexes);
+    }
+    stop() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.connected = false;
+        void this.client.close().catch(() => undefined);
+    }
+}
+function findOptions(options, context, signal, maxRows) {
+    const source = options ?? {};
+    const requestedLimit = source.limit === undefined ? 0 : numericOption(source.limit, "find limit");
+    const result = {
+        signal,
+        maxTimeMS: remainingMilliseconds(context),
+        timeoutMS: remainingMilliseconds(context),
+        limit: requestedLimit > 0 ? Math.min(requestedLimit, maxRows) : maxRows,
+    };
+    if (source.projection !== undefined)
+        result.projection = source.projection;
+    if (source.sort !== undefined)
+        result.sort = normalizeSort(source.sort);
+    if (source.skip !== undefined)
+        result.skip = numericOption(source.skip, "find skip");
+    if (source.hint !== undefined)
+        result.hint = source.hint;
+    if (source.collation !== undefined)
+        result.collation = source.collation;
+    return result;
+}
+function aggregateOptions(options, context, signal) {
+    const source = options ?? {};
+    const result = {
+        signal,
+        maxTimeMS: remainingMilliseconds(context),
+        timeoutMS: remainingMilliseconds(context),
+    };
+    if (source.allowDiskUse !== undefined)
+        result.allowDiskUse = source.allowDiskUse;
+    if (source.hint !== undefined)
+        result.hint = source.hint;
+    if (source.collation !== undefined)
+        result.collation = source.collation;
+    return result;
+}
+function writeOptions(options, operation, session, timeoutMS) {
+    const result = { session, timeoutMS };
+    for (const key of WRITE_OPTIONS[operation]) {
+        const value = options?.[key];
+        if (value !== undefined)
+            result[key] = value;
+    }
+    return result;
+}
+function updateResult(result) {
+    return {
+        affectedRows: result.modifiedCount + result.upsertedCount,
+        outcome: {
+            acknowledged: result.acknowledged,
+            matched_count: result.matchedCount,
+            modified_count: result.modifiedCount,
+            upserted_count: result.upsertedCount,
+            upserted_id: ejsonSafe(result.upsertedId),
+        },
+    };
+}
+function documentsResult(documents) {
+    return {
+        rows: documents.map((document) => ejsonSafe(document)),
+        columns: inferColumns(documents),
+    };
+}
+function inferColumns(documents) {
+    const types = new Map();
+    for (const document of documents) {
+        for (const [name, value] of Object.entries(document)) {
+            const type = mongoType(value);
+            const previous = types.get(name);
+            if (!previous || previous === "null")
+                types.set(name, type);
+            else if (type !== "null" && previous !== type)
+                types.set(name, "mixed");
+        }
+    }
+    return [...types].map(([name, type]) => ({ name, type }));
+}
+function mongoType(value) {
+    if (value === null || value === undefined)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    if (value instanceof Date)
+        return "date";
+    const bsonType = bsonTypeName(value);
+    if (bsonType)
+        return bsonType.replace(/^[A-Z]/, (letter) => letter.toLowerCase());
+    if (typeof value === "object")
+        return "object";
+    return typeof value;
+}
+async function collectCursor(cursor, limit, context) {
+    const values = [];
+    try {
+        while (values.length < limit) {
+            const value = await withContext(cursor.next(), context, () => void cursor.close().catch(() => undefined), false);
+            if (value === null)
+                break;
+            values.push(value);
+        }
+        return values;
+    }
+    finally {
+        await cursor.close().catch(() => undefined);
+    }
+}
+function validateFindOptions(value) {
+    if (value === undefined)
+        return;
+    const options = value;
+    if (options.limit !== undefined)
+        numericOption(options.limit, "find limit");
+    if (options.skip !== undefined)
+        numericOption(options.skip, "find skip");
+    if (options.projection !== undefined && !isDocument(options.projection)) {
+        throw new Error("MongoDB find projection must be an object.");
+    }
+    if (options.sort !== undefined && !isSort(options.sort)) {
+        throw new Error("MongoDB find sort must be an object or an array.");
+    }
+    validateHintAndCollation(options, "find");
+}
+function validateAggregateOptions(value) {
+    if (value === undefined)
+        return;
+    const options = value;
+    if (options.allowDiskUse !== undefined && typeof options.allowDiskUse !== "boolean") {
+        throw new Error("MongoDB aggregate allowDiskUse must be boolean.");
+    }
+    validateHintAndCollation(options, "aggregate");
+}
+function validateWriteOptions(value, operation) {
+    if (value === undefined)
+        return;
+    const options = value;
+    for (const key of ["upsert", "ordered"]) {
+        if (options[key] !== undefined && typeof options[key] !== "boolean") {
+            throw new Error(`MongoDB ${operation} ${key} must be boolean.`);
+        }
+    }
+    validateHintAndCollation(options, operation);
+}
+function validateHintAndCollation(options, operation) {
+    if (options.hint !== undefined &&
+        typeof options.hint !== "string" &&
+        !isDocument(options.hint)) {
+        throw new Error(`MongoDB ${operation} hint must be a string or object.`);
+    }
+    if (options.collation !== undefined && !isDocument(options.collation)) {
+        throw new Error(`MongoDB ${operation} collation must be an object.`);
+    }
+}
+function validateUpdate(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0 || !value.every(isDocument)) {
+            throw new Error("MongoDB update pipeline must be a non-empty array of stage objects.");
+        }
+        for (const stage of value) {
+            const keys = Object.keys(stage);
+            if (keys.length !== 1 || !UPDATE_PIPELINE_STAGES.has(keys[0])) {
+                throw new Error("MongoDB update pipeline contains an unsupported stage.");
+            }
+        }
+        return;
+    }
+    requireDocument(value, "update document");
+    const keys = Object.keys(value);
+    if (keys.length === 0 || keys.some((key) => !key.startsWith("$"))) {
+        throw new Error("MongoDB update documents must contain only top-level update operators.");
+    }
+}
+function validateOptions(value, allowed, operation) {
+    if (value === undefined)
+        return;
+    if (!isDocument(value))
+        throw new Error(`MongoDB ${operation} options must be an object.`);
+    rejectUnknownKeys(value, allowed, `${operation} options`);
+}
+function validateCollection(value) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.includes("\0") ||
+        value.includes("$") ||
+        value.startsWith("system.")) {
+        throw new Error("Invalid MongoDB collection name.");
+    }
+}
+function requireDocument(value, name) {
+    if (!isDocument(value))
+        throw new Error(`MongoDB ${name} must be an object.`);
+}
+function rejectUnknownKeys(value, allowed, name) {
+    const key = Object.keys(value).find((candidate) => !allowed.has(candidate));
+    if (key)
+        throw new Error(`Unknown MongoDB ${name} field "${key}".`);
+}
+function rejectForbiddenValues(value) {
+    const seen = new WeakSet();
+    const visit = (item) => {
+        if (typeof item === "function")
+            throw new Error("MongoDB server-side JavaScript is forbidden.");
+        if (!item || typeof item !== "object")
+            return;
+        const object = item;
+        const bsonType = bsonTypeName(item);
+        if (bsonType === "Code")
+            throw new Error("MongoDB server-side JavaScript is forbidden.");
+        if (bsonType || item instanceof Date || item instanceof RegExp || Buffer.isBuffer(item))
+            return;
+        if (seen.has(object))
+            throw new Error("MongoDB commands cannot contain circular values.");
+        seen.add(object);
+        if (item instanceof Map) {
+            for (const [key, child] of item) {
+                if (FORBIDDEN_KEYS.has(String(key)))
+                    forbiddenOperator(String(key));
+                visit(child);
+            }
+        }
+        else if (item instanceof Set || Array.isArray(item)) {
+            for (const child of item)
+                visit(child);
+        }
+        else {
+            for (const [key, child] of Object.entries(item)) {
+                if (FORBIDDEN_KEYS.has(key))
+                    forbiddenOperator(key);
+                visit(child);
+            }
+        }
+        seen.delete(object);
+    };
+    visit(value);
+}
+function forbiddenOperator(key) {
+    throw new Error(`MongoDB operator "${key}" is forbidden.`);
+}
+function numericOption(value, name) {
+    const number = typeof value === "number"
+        ? value
+        : bsonTypeName(value) === "Int32" || bsonTypeName(value) === "Long" || bsonTypeName(value) === "Double"
+            ? Number(value.valueOf())
+            : Number.NaN;
+    if (!Number.isSafeInteger(number) || number < 0 || number > 2_147_483_647) {
+        throw new Error(`MongoDB ${name} must be an integer from 0 through 2147483647.`);
+    }
+    return number;
+}
+function normalizeSort(value) {
+    if (!Array.isArray(value))
+        return value;
+    return value.map((item) => {
+        if (!Array.isArray(item))
+            return item;
+        return item.map((part, index) => index === 1 ? numericBsonValue(part) : part);
+    });
+}
+function numericBsonValue(value) {
+    const type = bsonTypeName(value);
+    return type === "Int32" || type === "Long" || type === "Double"
+        ? Number(value.valueOf())
+        : value;
+}
+function isSort(value) {
+    return typeof value === "string" || Array.isArray(value) || isDocument(value);
+}
+function isDocument(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value) && !bsonTypeName(value);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isMongoWriteOperation(value) {
+    return value === "insertOne" || value === "insertMany" ||
+        value === "updateOne" || value === "updateMany" ||
+        value === "replaceOne" || value === "deleteOne" || value === "deleteMany";
+}
+function bsonTypeName(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const type = value._bsontype;
+    return typeof type === "string" ? type : undefined;
+}
+function parseEjson(value) {
+    try {
+        return BSON.EJSON.parse(value, { relaxed: false });
+    }
+    catch {
+        throw new Error("Stored MongoDB command is not valid EJSON.");
+    }
+}
+function ejsonSafe(value) {
+    if (value === undefined)
+        return null;
+    return JSON.parse(BSON.EJSON.stringify(value, { relaxed: false }));
+}
+function remainingMilliseconds(context) {
+    return Math.max(1, Math.min(2_147_483_647, Math.ceil(context.deadline - Date.now())));
+}
+function operationSignal(context) {
+    const deadlineSignal = AbortSignal.timeout(remainingMilliseconds(context));
+    return context.signal ? AbortSignal.any([context.signal, deadlineSignal]) : deadlineSignal;
+}
+function throwIfStopped(context, outcomeUnknown) {
+    if (context.signal?.aborted || context.deadline <= Date.now()) {
+        throw stoppedError(context, outcomeUnknown);
+    }
+}
+function stoppedError(context, outcomeUnknown) {
+    const aborted = context.signal?.aborted ?? false;
+    return new AdapterExecutionError(aborted ? "Database operation cancelled." : "Database operation timed out.", aborted ? "aborted" : "timeout", outcomeUnknown);
+}
+function withContext(promise, context, onStop, outcomeUnknown) {
+    try {
+        throwIfStopped(context, outcomeUnknown);
+    }
+    catch (error) {
+        return Promise.reject(error);
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (action) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            context.signal?.removeEventListener("abort", stop);
+            action();
+        };
+        const stop = () => finish(() => {
+            try {
+                onStop();
+            }
+            catch {
+                // Preserve cancellation/deadline error.
+            }
+            reject(stoppedError(context, outcomeUnknown));
+        });
+        const timer = setTimeout(stop, remainingMilliseconds(context));
+        context.signal?.addEventListener("abort", stop, { once: true });
+        promise.then((result) => context.signal?.aborted || context.deadline <= Date.now()
+            ? stop()
+            : finish(() => resolve(result)), (error) => context.signal?.aborted || context.deadline <= Date.now()
+            ? stop()
+            : finish(() => reject(error)));
+    });
+}
+function readError(error, context) {
+    if (error instanceof AdapterExecutionError)
+        return error;
+    if (isTimeoutError(error) || context.signal?.aborted || context.deadline <= Date.now()) {
+        return stoppedError(context, false);
+    }
+    return error;
+}
+function writeStoppedError(error, context, outcomeUnknown) {
+    if (error instanceof AdapterExecutionError) {
+        return new AdapterExecutionError(error.message, error.reason, outcomeUnknown);
+    }
+    if (isTimeoutError(error) || context.signal?.aborted || context.deadline <= Date.now()) {
+        return stoppedError(context, outcomeUnknown);
+    }
+    return undefined;
+}
+function isTimeoutError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const name = error.name;
+    const code = error.code;
+    return name === "MongoOperationTimeoutError" || name === "MongoNetworkTimeoutError" ||
+        code === 50 || code === "ETIMEDOUT";
+}
+function knownNoWrite(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const name = String(error.name ?? "");
+    const code = error.code;
+    if (["MongoInvalidArgumentError", "MongoParseError", "MongoCompatibilityError"].includes(name))
+        return true;
+    if ([2, 9, 14, 20, 59, 72, 303].includes(code))
+        return true;
+    const message = errorText(error);
+    return /transaction numbers are only allowed|does not support transactions|transactions are not supported/i.test(message);
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}