@nullix/zod-mongoose-studio 0.0.1

package/.output/server/node_modules/mongodb/lib/cmap/wire_protocol/compression.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uncompressibleCommands = exports.Compressor = void 0;
+exports.compress = compress;
+exports.decompress = decompress;
+exports.compressCommand = compressCommand;
+exports.decompressResponse = decompressResponse;
+const util_1 = require("util");
+const zlib = require("zlib");
+const constants_1 = require("../../constants");
+const deps_1 = require("../../deps");
+const error_1 = require("../../error");
+const commands_1 = require("../commands");
+const constants_2 = require("./constants");
+/** @public */
+exports.Compressor = Object.freeze({
+    none: 0,
+    snappy: 1,
+    zlib: 2,
+    zstd: 3
+});
+exports.uncompressibleCommands = new Set([
+    constants_1.LEGACY_HELLO_COMMAND,
+    'saslStart',
+    'saslContinue',
+    'getnonce',
+    'authenticate',
+    'createUser',
+    'updateUser',
+    'copydbSaslStart',
+    'copydbgetnonce',
+    'copydb'
+]);
+const ZSTD_COMPRESSION_LEVEL = 3;
+const zlibInflate = (0, util_1.promisify)(zlib.inflate.bind(zlib));
+const zlibDeflate = (0, util_1.promisify)(zlib.deflate.bind(zlib));
+let zstd;
+let Snappy = null;
+function loadSnappy() {
+    if (Snappy == null) {
+        const snappyImport = (0, deps_1.getSnappy)();
+        if ('kModuleError' in snappyImport) {
+            throw snappyImport.kModuleError;
+        }
+        Snappy = snappyImport;
+    }
+    return Snappy;
+}
+// Facilitate compressing a message using an agreed compressor
+async function compress(options, dataToBeCompressed) {
+    const zlibOptions = {};
+    switch (options.agreedCompressor) {
+        case 'snappy': {
+            Snappy ??= loadSnappy();
+            return await Snappy.compress(dataToBeCompressed);
+        }
+        case 'zstd': {
+            loadZstd();
+            if ('kModuleError' in zstd) {
+                throw zstd['kModuleError'];
+            }
+            return await zstd.compress(dataToBeCompressed, ZSTD_COMPRESSION_LEVEL);
+        }
+        case 'zlib': {
+            if (options.zlibCompressionLevel) {
+                zlibOptions.level = options.zlibCompressionLevel;
+            }
+            return await zlibDeflate(dataToBeCompressed, zlibOptions);
+        }
+        default: {
+            throw new error_1.MongoInvalidArgumentError(`Unknown compressor ${options.agreedCompressor} failed to compress`);
+        }
+    }
+}
+// Decompress a message using the given compressor
+async function decompress(compressorID, compressedData) {
+    if (compressorID !== exports.Compressor.snappy &&
+        compressorID !== exports.Compressor.zstd &&
+        compressorID !== exports.Compressor.zlib &&
+        compressorID !== exports.Compressor.none) {
+        throw new error_1.MongoDecompressionError(`Server sent message compressed using an unsupported compressor. (Received compressor ID ${compressorID})`);
+    }
+    switch (compressorID) {
+        case exports.Compressor.snappy: {
+            Snappy ??= loadSnappy();
+            return await Snappy.uncompress(compressedData, { asBuffer: true });
+        }
+        case exports.Compressor.zstd: {
+            loadZstd();
+            if ('kModuleError' in zstd) {
+                throw zstd['kModuleError'];
+            }
+            return await zstd.decompress(compressedData);
+        }
+        case exports.Compressor.zlib: {
+            return await zlibInflate(compressedData);
+        }
+        default: {
+            return compressedData;
+        }
+    }
+}
+/**
+ * Load ZStandard if it is not already set.
+ */
+function loadZstd() {
+    if (!zstd) {
+        zstd = (0, deps_1.getZstdLibrary)();
+    }
+}
+const MESSAGE_HEADER_SIZE = 16;
+/**
+ * @internal
+ *
+ * Compresses an OP_MSG or OP_QUERY message, if compression is configured.  This method
+ * also serializes the command to BSON.
+ */
+async function compressCommand(command, description) {
+    const finalCommand = description.agreedCompressor === 'none' || !commands_1.OpCompressedRequest.canCompress(command)
+        ? command
+        : new commands_1.OpCompressedRequest(command, {
+            agreedCompressor: description.agreedCompressor ?? 'none',
+            zlibCompressionLevel: description.zlibCompressionLevel ?? 0
+        });
+    const data = await finalCommand.toBin();
+    return Buffer.concat(data);
+}
+/**
+ * @internal
+ *
+ * Decompresses an OP_MSG or OP_QUERY response from the server, if compression is configured.
+ *
+ * This method does not parse the response's BSON.
+ */
+async function decompressResponse(message) {
+    const messageHeader = {
+        length: message.readInt32LE(0),
+        requestId: message.readInt32LE(4),
+        responseTo: message.readInt32LE(8),
+        opCode: message.readInt32LE(12)
+    };
+    if (messageHeader.opCode !== constants_2.OP_COMPRESSED) {
+        const ResponseType = messageHeader.opCode === constants_2.OP_MSG ? commands_1.OpMsgResponse : commands_1.OpReply;
+        const messageBody = message.subarray(MESSAGE_HEADER_SIZE);
+        return new ResponseType(message, messageHeader, messageBody);
+    }
+    const header = {
+        ...messageHeader,
+        fromCompressed: true,
+        opCode: message.readInt32LE(MESSAGE_HEADER_SIZE),
+        length: message.readInt32LE(MESSAGE_HEADER_SIZE + 4)
+    };
+    const compressorID = message[MESSAGE_HEADER_SIZE + 8];
+    const compressedBuffer = message.slice(MESSAGE_HEADER_SIZE + 9);
+    // recalculate based on wrapped opcode
+    const ResponseType = header.opCode === constants_2.OP_MSG ? commands_1.OpMsgResponse : commands_1.OpReply;
+    const messageBody = await decompress(compressorID, compressedBuffer);
+    if (messageBody.length !== header.length) {
+        throw new error_1.MongoDecompressionError('Message body and message header must be the same length');
+    }
+    return new ResponseType(message, header, messageBody);
+}
+//# sourceMappingURL=compression.js.map

package/.output/server/node_modules/mongodb/lib/cmap/wire_protocol/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OP_MSG = exports.OP_COMPRESSED = exports.OP_DELETE = exports.OP_QUERY = exports.OP_INSERT = exports.OP_UPDATE = exports.OP_REPLY = exports.MIN_SUPPORTED_RAW_DATA_SERVER_VERSION = exports.MIN_SUPPORTED_RAW_DATA_WIRE_VERSION = exports.MIN_SUPPORTED_QE_SERVER_VERSION = exports.MIN_SUPPORTED_QE_WIRE_VERSION = exports.MAX_SUPPORTED_WIRE_VERSION = exports.MIN_SUPPORTED_WIRE_VERSION = exports.MAX_SUPPORTED_SERVER_VERSION = exports.MIN_SUPPORTED_SERVER_VERSION = void 0;
+exports.MIN_SUPPORTED_SERVER_VERSION = '4.2';
+exports.MAX_SUPPORTED_SERVER_VERSION = '8.2';
+exports.MIN_SUPPORTED_WIRE_VERSION = 8;
+exports.MAX_SUPPORTED_WIRE_VERSION = 27;
+exports.MIN_SUPPORTED_QE_WIRE_VERSION = 21;
+exports.MIN_SUPPORTED_QE_SERVER_VERSION = '7.0';
+exports.MIN_SUPPORTED_RAW_DATA_WIRE_VERSION = 27;
+exports.MIN_SUPPORTED_RAW_DATA_SERVER_VERSION = '8.2';
+exports.OP_REPLY = 1;
+exports.OP_UPDATE = 2001;
+exports.OP_INSERT = 2002;
+exports.OP_QUERY = 2004;
+exports.OP_DELETE = 2006;
+exports.OP_COMPRESSED = 2012;
+exports.OP_MSG = 2013;
+//# sourceMappingURL=constants.js.map

package/.output/server/node_modules/mongodb/lib/cmap/wire_protocol/on_data.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onData = onData;
+const utils_1 = require("../../utils");
+/**
+ * onData is adapted from Node.js' events.on helper
+ * https://nodejs.org/api/events.html#eventsonemitter-eventname-options
+ *
+ * Returns an AsyncIterator that iterates each 'data' event emitted from emitter.
+ * It will reject upon an error event.
+ */
+function onData(emitter, { timeoutContext, signal }) {
+    signal?.throwIfAborted();
+    // Setup pending events and pending promise lists
+    /**
+     * When the caller has not yet called .next(), we store the
+     * value from the event in this list. Next time they call .next()
+     * we pull the first value out of this list and resolve a promise with it.
+     */
+    const unconsumedEvents = new utils_1.List();
+    /**
+     * When there has not yet been an event, a new promise will be created
+     * and implicitly stored in this list. When an event occurs we take the first
+     * promise in this list and resolve it.
+     */
+    const unconsumedPromises = new utils_1.List();
+    /**
+     * Stored an error created by an error event.
+     * This error will turn into a rejection for the subsequent .next() call
+     */
+    let error = null;
+    /** Set to true only after event listeners have been removed. */
+    let finished = false;
+    const iterator = {
+        next() {
+            // First, we consume all unread events
+            const value = unconsumedEvents.shift();
+            if (value != null) {
+                return Promise.resolve({ value, done: false });
+            }
+            // Then we error, if an error happened
+            // This happens one time if at all, because after 'error'
+            // we stop listening
+            if (error != null) {
+                const p = Promise.reject(error);
+                // Only the first element errors
+                error = null;
+                return p;
+            }
+            // If the iterator is finished, resolve to done
+            if (finished)
+                return closeHandler();
+            // Wait until an event happens
+            const { promise, resolve, reject } = (0, utils_1.promiseWithResolvers)();
+            unconsumedPromises.push({ resolve, reject });
+            return promise;
+        },
+        return() {
+            return closeHandler();
+        },
+        throw(err) {
+            errorHandler(err);
+            return Promise.resolve({ value: undefined, done: true });
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+        // Note this should currently not be used, but is required by the AsyncGenerator interface.
+        async [Symbol.asyncDispose]() {
+            await closeHandler();
+        }
+    };
+    // Adding event handlers
+    emitter.on('data', eventHandler);
+    emitter.on('error', errorHandler);
+    const abortListener = (0, utils_1.addAbortListener)(signal, function () {
+        errorHandler(this.reason);
+    });
+    const timeoutForSocketRead = timeoutContext?.timeoutForSocketRead;
+    timeoutForSocketRead?.throwIfExpired();
+    timeoutForSocketRead?.then(undefined, errorHandler);
+    return iterator;
+    function eventHandler(value) {
+        const promise = unconsumedPromises.shift();
+        if (promise != null)
+            promise.resolve({ value, done: false });
+        else
+            unconsumedEvents.push(value);
+    }
+    function errorHandler(err) {
+        const promise = unconsumedPromises.shift();
+        if (promise != null)
+            promise.reject(err);
+        else
+            error = err;
+        void closeHandler();
+    }
+    function closeHandler() {
+        // Adding event handlers
+        emitter.off('data', eventHandler);
+        emitter.off('error', errorHandler);
+        abortListener?.[utils_1.kDispose]();
+        finished = true;
+        timeoutForSocketRead?.clear();
+        const doneResult = { value: undefined, done: finished };
+        for (const promise of unconsumedPromises) {
+            promise.resolve(doneResult);
+        }
+        return Promise.resolve(doneResult);
+    }
+}
+//# sourceMappingURL=on_data.js.map

package/.output/server/node_modules/mongodb/lib/cmap/wire_protocol/on_demand/document.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnDemandDocument = void 0;
+const bson_1 = require("../../../bson");
+const BSONElementOffset = {
+    type: 0,
+    nameOffset: 1,
+    nameLength: 2,
+    offset: 3,
+    length: 4
+};
+/** @internal */
+class OnDemandDocument {
+    constructor(bson, offset = 0, isArray = false, 
+    /** If elements was already calculated */
+    elements) {
+        /**
+         * Maps JS strings to elements and jsValues for speeding up subsequent lookups.
+         * - If `false` then name does not exist in the BSON document
+         * - If `CachedBSONElement` instance name exists
+         * - If `cache[name].value == null` jsValue has not yet been parsed
+         *   - Null/Undefined values do not get cached because they are zero-length values.
+         */
+        this.cache = Object.create(null);
+        /** Caches the index of elements that have been named */
+        this.indexFound = Object.create(null);
+        this.bson = bson;
+        this.offset = offset;
+        this.isArray = isArray;
+        this.elements = elements ?? (0, bson_1.parseToElementsToArray)(this.bson, offset);
+    }
+    /** Only supports basic latin strings */
+    isElementName(name, element) {
+        const nameLength = element[BSONElementOffset.nameLength];
+        const nameOffset = element[BSONElementOffset.nameOffset];
+        if (name.length !== nameLength)
+            return false;
+        const nameEnd = nameOffset + nameLength;
+        for (let byteIndex = nameOffset, charIndex = 0; charIndex < name.length && byteIndex < nameEnd; charIndex++, byteIndex++) {
+            if (this.bson[byteIndex] !== name.charCodeAt(charIndex))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Seeks into the elements array for an element matching the given name.
+     *
+     * @remarks
+     * Caching:
+     * - Caches the existence of a property making subsequent look ups for non-existent properties return immediately
+     * - Caches names mapped to elements to avoid reiterating the array and comparing the name again
+     * - Caches the index at which an element has been found to prevent rechecking against elements already determined to belong to another name
+     *
+     * @param name - a basic latin string name of a BSON element
+     * @returns
+     */
+    getElement(name) {
+        const cachedElement = this.cache[name];
+        if (cachedElement === false)
+            return null;
+        if (cachedElement != null) {
+            return cachedElement;
+        }
+        if (typeof name === 'number') {
+            if (this.isArray) {
+                if (name < this.elements.length) {
+                    const element = this.elements[name];
+                    const cachedElement = { element, value: undefined };
+                    this.cache[name] = cachedElement;
+                    this.indexFound[name] = true;
+                    return cachedElement;
+                }
+                else {
+                    return null;
+                }
+            }
+            else {
+                return null;
+            }
+        }
+        for (let index = 0; index < this.elements.length; index++) {
+            const element = this.elements[index];
+            // skip this element if it has already been associated with a name
+            if (!(index in this.indexFound) && this.isElementName(name, element)) {
+                const cachedElement = { element, value: undefined };
+                this.cache[name] = cachedElement;
+                this.indexFound[index] = true;
+                return cachedElement;
+            }
+        }
+        this.cache[name] = false;
+        return null;
+    }
+    toJSValue(element, as) {
+        const type = element[BSONElementOffset.type];
+        const offset = element[BSONElementOffset.offset];
+        const length = element[BSONElementOffset.length];
+        if (as !== type) {
+            return null;
+        }
+        switch (as) {
+            case bson_1.BSONType.null:
+            case bson_1.BSONType.undefined:
+                return null;
+            case bson_1.BSONType.double:
+                return (0, bson_1.getFloat64LE)(this.bson, offset);
+            case bson_1.BSONType.int:
+                return (0, bson_1.getInt32LE)(this.bson, offset);
+            case bson_1.BSONType.long:
+                return (0, bson_1.getBigInt64LE)(this.bson, offset);
+            case bson_1.BSONType.bool:
+                return Boolean(this.bson[offset]);
+            case bson_1.BSONType.objectId:
+                return new bson_1.ObjectId(this.bson.subarray(offset, offset + 12));
+            case bson_1.BSONType.timestamp:
+                return new bson_1.Timestamp((0, bson_1.getBigInt64LE)(this.bson, offset));
+            case bson_1.BSONType.string:
+                return (0, bson_1.toUTF8)(this.bson, offset + 4, offset + length - 1, false);
+            case bson_1.BSONType.binData: {
+                const totalBinarySize = (0, bson_1.getInt32LE)(this.bson, offset);
+                const subType = this.bson[offset + 4];
+                if (subType === 2) {
+                    const subType2BinarySize = (0, bson_1.getInt32LE)(this.bson, offset + 1 + 4);
+                    if (subType2BinarySize < 0)
+                        throw new bson_1.BSONError('Negative binary type element size found for subtype 0x02');
+                    if (subType2BinarySize > totalBinarySize - 4)
+                        throw new bson_1.BSONError('Binary type with subtype 0x02 contains too long binary size');
+                    if (subType2BinarySize < totalBinarySize - 4)
+                        throw new bson_1.BSONError('Binary type with subtype 0x02 contains too short binary size');
+                    return new bson_1.Binary(this.bson.subarray(offset + 1 + 4 + 4, offset + 1 + 4 + 4 + subType2BinarySize), 2);
+                }
+                return new bson_1.Binary(this.bson.subarray(offset + 1 + 4, offset + 1 + 4 + totalBinarySize), subType);
+            }
+            case bson_1.BSONType.date:
+                // Pretend this is correct.
+                return new Date(Number((0, bson_1.getBigInt64LE)(this.bson, offset)));
+            case bson_1.BSONType.object:
+                return new OnDemandDocument(this.bson, offset);
+            case bson_1.BSONType.array:
+                return new OnDemandDocument(this.bson, offset, true);
+            default:
+                throw new bson_1.BSONError(`Unsupported BSON type: ${as}`);
+        }
+    }
+    /**
+     * Returns the number of elements in this BSON document
+     */
+    size() {
+        return this.elements.length;
+    }
+    /**
+     * Checks for the existence of an element by name.
+     *
+     * @remarks
+     * Uses `getElement` with the expectation that will populate caches such that a `has` call
+     * followed by a `getElement` call will not repeat the cost paid by the first look up.
+     *
+     * @param name - element name
+     */
+    has(name) {
+        const cachedElement = this.cache[name];
+        if (cachedElement === false)
+            return false;
+        if (cachedElement != null)
+            return true;
+        return this.getElement(name) != null;
+    }
+    get(name, as, required) {
+        const element = this.getElement(name);
+        if (element == null) {
+            if (required === true) {
+                throw new bson_1.BSONError(`BSON element "${name}" is missing`);
+            }
+            else {
+                return null;
+            }
+        }
+        if (element.value == null) {
+            const value = this.toJSValue(element.element, as);
+            if (value == null) {
+                if (required === true) {
+                    throw new bson_1.BSONError(`BSON element "${name}" is missing`);
+                }
+                else {
+                    return null;
+                }
+            }
+            // It is important to never store null
+            element.value = value;
+        }
+        return element.value;
+    }
+    getNumber(name, required) {
+        const maybeBool = this.get(name, bson_1.BSONType.bool);
+        const bool = maybeBool == null ? null : maybeBool ? 1 : 0;
+        const maybeLong = this.get(name, bson_1.BSONType.long);
+        const long = maybeLong == null ? null : Number(maybeLong);
+        const result = bool ?? long ?? this.get(name, bson_1.BSONType.int) ?? this.get(name, bson_1.BSONType.double);
+        if (required === true && result == null) {
+            throw new bson_1.BSONError(`BSON element "${name}" is missing`);
+        }
+        return result;
+    }
+    /**
+     * Deserialize this object, DOES NOT cache result so avoid multiple invocations
+     * @param options - BSON deserialization options
+     */
+    toObject(options) {
+        return (0, bson_1.deserialize)(this.bson, {
+            ...options,
+            index: this.offset,
+            allowObjectSmallerThanBufferSize: true
+        });
+    }
+    /** Returns this document's bytes only */
+    toBytes() {
+        const size = (0, bson_1.getInt32LE)(this.bson, this.offset);
+        return this.bson.subarray(this.offset, this.offset + size);
+    }
+}
+exports.OnDemandDocument = OnDemandDocument;
+//# sourceMappingURL=document.js.map