@nullix/zod-mongoose-studio 0.0.1

package/.output/server/node_modules/mongodb/lib/explain.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Explain = exports.ExplainVerbosity = void 0;
+exports.validateExplainTimeoutOptions = validateExplainTimeoutOptions;
+exports.decorateWithExplain = decorateWithExplain;
+const error_1 = require("./error");
+/** @public */
+exports.ExplainVerbosity = Object.freeze({
+    queryPlanner: 'queryPlanner',
+    queryPlannerExtended: 'queryPlannerExtended',
+    executionStats: 'executionStats',
+    allPlansExecution: 'allPlansExecution'
+});
+/** @internal */
+class Explain {
+    constructor(verbosity, maxTimeMS) {
+        if (typeof verbosity === 'boolean') {
+            this.verbosity = verbosity
+                ? exports.ExplainVerbosity.allPlansExecution
+                : exports.ExplainVerbosity.queryPlanner;
+        }
+        else {
+            this.verbosity = verbosity;
+        }
+        this.maxTimeMS = maxTimeMS;
+    }
+    static fromOptions({ explain } = {}) {
+        if (explain == null)
+            return;
+        if (typeof explain === 'boolean' || typeof explain === 'string') {
+            return new Explain(explain);
+        }
+        const { verbosity, maxTimeMS } = explain;
+        return new Explain(verbosity, maxTimeMS);
+    }
+}
+exports.Explain = Explain;
+function validateExplainTimeoutOptions(options, explain) {
+    const { maxTimeMS, timeoutMS } = options;
+    if (timeoutMS != null && (maxTimeMS != null || explain?.maxTimeMS != null)) {
+        throw new error_1.MongoAPIError('Cannot use maxTimeMS with timeoutMS for explain commands.');
+    }
+}
+/**
+ * Applies an explain to a given command.
+ * @internal
+ *
+ * @param command - the command on which to apply the explain
+ * @param options - the options containing the explain verbosity
+ */
+function decorateWithExplain(command, explain) {
+    const { verbosity, maxTimeMS } = explain;
+    const baseCommand = { explain: command, verbosity };
+    if (typeof maxTimeMS === 'number') {
+        baseCommand.maxTimeMS = maxTimeMS;
+    }
+    return baseCommand;
+}
+//# sourceMappingURL=explain.js.map

package/.output/server/node_modules/mongodb/lib/gridfs/download.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridFSBucketReadStream = void 0;
+const stream_1 = require("stream");
+const abstract_cursor_1 = require("../cursor/abstract_cursor");
+const error_1 = require("../error");
+const timeout_1 = require("../timeout");
+/**
+ * A readable stream that enables you to read buffers from GridFS.
+ *
+ * Do not instantiate this class directly. Use `openDownloadStream()` instead.
+ * @public
+ */
+class GridFSBucketReadStream extends stream_1.Readable {
+    /**
+     * @param chunks - Handle for chunks collection
+     * @param files - Handle for files collection
+     * @param readPreference - The read preference to use
+     * @param filter - The filter to use to find the file document
+     * @internal
+     */
+    constructor(chunks, files, readPreference, filter, options) {
+        super({ emitClose: true });
+        this.s = {
+            bytesToTrim: 0,
+            bytesToSkip: 0,
+            bytesRead: 0,
+            chunks,
+            expected: 0,
+            files,
+            filter,
+            init: false,
+            expectedEnd: 0,
+            options: {
+                start: 0,
+                end: 0,
+                ...options
+            },
+            readPreference,
+            timeoutContext: options?.timeoutMS != null
+                ? new timeout_1.CSOTTimeoutContext({ timeoutMS: options.timeoutMS, serverSelectionTimeoutMS: 0 })
+                : undefined
+        };
+    }
+    /**
+     * Reads from the cursor and pushes to the stream.
+     * Private Impl, do not call directly
+     * @internal
+     */
+    _read() {
+        if (this.destroyed)
+            return;
+        waitForFile(this, () => doRead(this));
+    }
+    /**
+     * Sets the 0-based offset in bytes to start streaming from. Throws
+     * an error if this stream has entered flowing mode
+     * (e.g. if you've already called `on('data')`)
+     *
+     * @param start - 0-based offset in bytes to start streaming from
+     */
+    start(start = 0) {
+        throwIfInitialized(this);
+        this.s.options.start = start;
+        return this;
+    }
+    /**
+     * Sets the 0-based offset in bytes to start streaming from. Throws
+     * an error if this stream has entered flowing mode
+     * (e.g. if you've already called `on('data')`)
+     *
+     * @param end - Offset in bytes to stop reading at
+     */
+    end(end = 0) {
+        throwIfInitialized(this);
+        this.s.options.end = end;
+        return this;
+    }
+    /**
+     * Marks this stream as aborted (will never push another `data` event)
+     * and kills the underlying cursor. Will emit the 'end' event, and then
+     * the 'close' event once the cursor is successfully killed.
+     */
+    async abort() {
+        this.push(null);
+        this.destroy();
+        const remainingTimeMS = this.s.timeoutContext?.getRemainingTimeMSOrThrow();
+        await this.s.cursor?.close({ timeoutMS: remainingTimeMS });
+    }
+}
+exports.GridFSBucketReadStream = GridFSBucketReadStream;
+/**
+ * Fires when the stream loaded the file document corresponding to the provided id.
+ * @event
+ */
+GridFSBucketReadStream.FILE = 'file';
+function throwIfInitialized(stream) {
+    if (stream.s.init) {
+        throw new error_1.MongoGridFSStreamError('Options cannot be changed after the stream is initialized');
+    }
+}
+function doRead(stream) {
+    if (stream.destroyed)
+        return;
+    if (!stream.s.cursor)
+        return;
+    if (!stream.s.file)
+        return;
+    const handleReadResult = (doc) => {
+        if (stream.destroyed)
+            return;
+        if (!doc) {
+            stream.push(null);
+            stream.s.cursor?.close().then(undefined, error => stream.destroy(error));
+            return;
+        }
+        if (!stream.s.file)
+            return;
+        const bytesRemaining = stream.s.file.length - stream.s.bytesRead;
+        const expectedN = stream.s.expected++;
+        const expectedLength = Math.min(stream.s.file.chunkSize, bytesRemaining);
+        if (doc.n > expectedN) {
+            return stream.destroy(new error_1.MongoGridFSChunkError(`ChunkIsMissing: Got unexpected n: ${doc.n}, expected: ${expectedN}`));
+        }
+        if (doc.n < expectedN) {
+            return stream.destroy(new error_1.MongoGridFSChunkError(`ExtraChunk: Got unexpected n: ${doc.n}, expected: ${expectedN}`));
+        }
+        let buf = Buffer.isBuffer(doc.data) ? doc.data : doc.data.buffer;
+        if (buf.byteLength !== expectedLength) {
+            if (bytesRemaining <= 0) {
+                return stream.destroy(new error_1.MongoGridFSChunkError(`ExtraChunk: Got unexpected n: ${doc.n}, expected file length ${stream.s.file.length} bytes but already read ${stream.s.bytesRead} bytes`));
+            }
+            return stream.destroy(new error_1.MongoGridFSChunkError(`ChunkIsWrongSize: Got unexpected length: ${buf.byteLength}, expected: ${expectedLength}`));
+        }
+        stream.s.bytesRead += buf.byteLength;
+        if (buf.byteLength === 0) {
+            return stream.push(null);
+        }
+        let sliceStart = null;
+        let sliceEnd = null;
+        if (stream.s.bytesToSkip != null) {
+            sliceStart = stream.s.bytesToSkip;
+            stream.s.bytesToSkip = 0;
+        }
+        const atEndOfStream = expectedN === stream.s.expectedEnd - 1;
+        const bytesLeftToRead = stream.s.options.end - stream.s.bytesToSkip;
+        if (atEndOfStream && stream.s.bytesToTrim != null) {
+            sliceEnd = stream.s.file.chunkSize - stream.s.bytesToTrim;
+        }
+        else if (stream.s.options.end && bytesLeftToRead < doc.data.byteLength) {
+            sliceEnd = bytesLeftToRead;
+        }
+        if (sliceStart != null || sliceEnd != null) {
+            buf = buf.slice(sliceStart || 0, sliceEnd || buf.byteLength);
+        }
+        stream.push(buf);
+        return;
+    };
+    stream.s.cursor.next().then(handleReadResult, error => {
+        if (stream.destroyed)
+            return;
+        stream.destroy(error);
+    });
+}
+function init(stream) {
+    const findOneOptions = {};
+    if (stream.s.readPreference) {
+        findOneOptions.readPreference = stream.s.readPreference;
+    }
+    if (stream.s.options && stream.s.options.sort) {
+        findOneOptions.sort = stream.s.options.sort;
+    }
+    if (stream.s.options && stream.s.options.skip) {
+        findOneOptions.skip = stream.s.options.skip;
+    }
+    const handleReadResult = (doc) => {
+        if (stream.destroyed)
+            return;
+        if (!doc) {
+            const identifier = stream.s.filter._id
+                ? stream.s.filter._id.toString()
+                : stream.s.filter.filename;
+            const errmsg = `FileNotFound: file ${identifier} was not found`;
+            // TODO(NODE-3483)
+            const err = new error_1.MongoRuntimeError(errmsg);
+            err.code = 'ENOENT'; // TODO: NODE-3338 set property as part of constructor
+            return stream.destroy(err);
+        }
+        // If document is empty, kill the stream immediately and don't
+        // execute any reads
+        if (doc.length <= 0) {
+            stream.push(null);
+            return;
+        }
+        if (stream.destroyed) {
+            // If user destroys the stream before we have a cursor, wait
+            // until the query is done to say we're 'closed' because we can't
+            // cancel a query.
+            stream.destroy();
+            return;
+        }
+        try {
+            stream.s.bytesToSkip = handleStartOption(stream, doc, stream.s.options);
+        }
+        catch (error) {
+            return stream.destroy(error);
+        }
+        const filter = { files_id: doc._id };
+        // Currently (MongoDB 3.4.4) skip function does not support the index,
+        // it needs to retrieve all the documents first and then skip them. (CS-25811)
+        // As work around we use $gte on the "n" field.
+        if (stream.s.options && stream.s.options.start != null) {
+            const skip = Math.floor(stream.s.options.start / doc.chunkSize);
+            if (skip > 0) {
+                filter['n'] = { $gte: skip };
+            }
+        }
+        let remainingTimeMS;
+        try {
+            remainingTimeMS = stream.s.timeoutContext?.getRemainingTimeMSOrThrow(`Download timed out after ${stream.s.timeoutContext?.timeoutMS}ms`);
+        }
+        catch (error) {
+            return stream.destroy(error);
+        }
+        stream.s.cursor = stream.s.chunks
+            .find(filter, {
+            timeoutMode: stream.s.options.timeoutMS != null ? abstract_cursor_1.CursorTimeoutMode.LIFETIME : undefined,
+            timeoutMS: remainingTimeMS
+        })
+            .sort({ n: 1 });
+        if (stream.s.readPreference) {
+            stream.s.cursor.withReadPreference(stream.s.readPreference);
+        }
+        stream.s.expectedEnd = Math.ceil(doc.length / doc.chunkSize);
+        stream.s.file = doc;
+        try {
+            stream.s.bytesToTrim = handleEndOption(stream, doc, stream.s.cursor, stream.s.options);
+        }
+        catch (error) {
+            return stream.destroy(error);
+        }
+        stream.emit(GridFSBucketReadStream.FILE, doc);
+        return;
+    };
+    let remainingTimeMS;
+    try {
+        remainingTimeMS = stream.s.timeoutContext?.getRemainingTimeMSOrThrow(`Download timed out after ${stream.s.timeoutContext?.timeoutMS}ms`);
+    }
+    catch (error) {
+        if (!stream.destroyed)
+            stream.destroy(error);
+        return;
+    }
+    findOneOptions.timeoutMS = remainingTimeMS;
+    stream.s.files.findOne(stream.s.filter, findOneOptions).then(handleReadResult, error => {
+        if (stream.destroyed)
+            return;
+        stream.destroy(error);
+    });
+}
+function waitForFile(stream, callback) {
+    if (stream.s.file) {
+        return callback();
+    }
+    if (!stream.s.init) {
+        init(stream);
+        stream.s.init = true;
+    }
+    stream.once('file', () => {
+        callback();
+    });
+}
+function handleStartOption(stream, doc, options) {
+    if (options && options.start != null) {
+        if (options.start > doc.length) {
+            throw new error_1.MongoInvalidArgumentError(`Stream start (${options.start}) must not be more than the length of the file (${doc.length})`);
+        }
+        if (options.start < 0) {
+            throw new error_1.MongoInvalidArgumentError(`Stream start (${options.start}) must not be negative`);
+        }
+        if (options.end != null && options.end < options.start) {
+            throw new error_1.MongoInvalidArgumentError(`Stream start (${options.start}) must not be greater than stream end (${options.end})`);
+        }
+        stream.s.bytesRead = Math.floor(options.start / doc.chunkSize) * doc.chunkSize;
+        stream.s.expected = Math.floor(options.start / doc.chunkSize);
+        return options.start - stream.s.bytesRead;
+    }
+    throw new error_1.MongoInvalidArgumentError('Start option must be defined');
+}
+function handleEndOption(stream, doc, cursor, options) {
+    if (options && options.end != null) {
+        if (options.end > doc.length) {
+            throw new error_1.MongoInvalidArgumentError(`Stream end (${options.end}) must not be more than the length of the file (${doc.length})`);
+        }
+        if (options.start == null || options.start < 0) {
+            throw new error_1.MongoInvalidArgumentError(`Stream end (${options.end}) must not be negative`);
+        }
+        const start = options.start != null ? Math.floor(options.start / doc.chunkSize) : 0;
+        cursor.limit(Math.ceil(options.end / doc.chunkSize) - start);
+        stream.s.expectedEnd = Math.ceil(options.end / doc.chunkSize);
+        return Math.ceil(options.end / doc.chunkSize) * doc.chunkSize - options.end;
+    }
+    throw new error_1.MongoInvalidArgumentError('End option must be defined');
+}
+//# sourceMappingURL=download.js.map

package/.output/server/node_modules/mongodb/lib/gridfs/index.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridFSBucket = void 0;
+const error_1 = require("../error");
+const mongo_types_1 = require("../mongo_types");
+const timeout_1 = require("../timeout");
+const utils_1 = require("../utils");
+const write_concern_1 = require("../write_concern");
+const download_1 = require("./download");
+const upload_1 = require("./upload");
+const DEFAULT_GRIDFS_BUCKET_OPTIONS = {
+    bucketName: 'fs',
+    chunkSizeBytes: 255 * 1024
+};
+/**
+ * Constructor for a streaming GridFS interface
+ * @public
+ */
+class GridFSBucket extends mongo_types_1.TypedEventEmitter {
+    constructor(db, options) {
+        super();
+        this.on('error', utils_1.noop);
+        this.setMaxListeners(0);
+        const privateOptions = (0, utils_1.resolveOptions)(db, {
+            ...DEFAULT_GRIDFS_BUCKET_OPTIONS,
+            ...options,
+            writeConcern: write_concern_1.WriteConcern.fromOptions(options)
+        });
+        this.s = {
+            db,
+            options: privateOptions,
+            _chunksCollection: db.collection(privateOptions.bucketName + '.chunks'),
+            _filesCollection: db.collection(privateOptions.bucketName + '.files'),
+            checkedIndexes: false,
+            calledOpenUploadStream: false
+        };
+    }
+    /**
+     * Returns a writable stream (GridFSBucketWriteStream) for writing
+     * buffers to GridFS. The stream's 'id' property contains the resulting
+     * file's id.
+     *
+     * @param filename - The value of the 'filename' key in the files doc
+     * @param options - Optional settings.
+     */
+    openUploadStream(filename, options) {
+        return new upload_1.GridFSBucketWriteStream(this, filename, {
+            timeoutMS: this.s.options.timeoutMS,
+            ...options
+        });
+    }
+    /**
+     * Returns a writable stream (GridFSBucketWriteStream) for writing
+     * buffers to GridFS for a custom file id. The stream's 'id' property contains the resulting
+     * file's id.
+     */
+    openUploadStreamWithId(id, filename, options) {
+        return new upload_1.GridFSBucketWriteStream(this, filename, {
+            timeoutMS: this.s.options.timeoutMS,
+            ...options,
+            id
+        });
+    }
+    /** Returns a readable stream (GridFSBucketReadStream) for streaming file data from GridFS. */
+    openDownloadStream(id, options) {
+        return new download_1.GridFSBucketReadStream(this.s._chunksCollection, this.s._filesCollection, this.s.options.readPreference, { _id: id }, { timeoutMS: this.s.options.timeoutMS, ...options });
+    }
+    /**
+     * Deletes a file with the given id
+     *
+     * @param id - The id of the file doc
+     */
+    async delete(id, options) {
+        const { timeoutMS } = (0, utils_1.resolveOptions)(this.s.db, options);
+        let timeoutContext = undefined;
+        if (timeoutMS) {
+            timeoutContext = new timeout_1.CSOTTimeoutContext({
+                timeoutMS,
+                serverSelectionTimeoutMS: this.s.db.client.s.options.serverSelectionTimeoutMS
+            });
+        }
+        const { deletedCount } = await this.s._filesCollection.deleteOne({ _id: id }, { timeoutMS: timeoutContext?.remainingTimeMS });
+        const remainingTimeMS = timeoutContext?.remainingTimeMS;
+        if (remainingTimeMS != null && remainingTimeMS <= 0)
+            throw new error_1.MongoOperationTimeoutError(`Timed out after ${timeoutMS}ms`);
+        // Delete orphaned chunks before returning FileNotFound
+        await this.s._chunksCollection.deleteMany({ files_id: id }, { timeoutMS: remainingTimeMS });
+        if (deletedCount === 0) {
+            // TODO(NODE-3483): Replace with more appropriate error
+            // Consider creating new error MongoGridFSFileNotFoundError
+            throw new error_1.MongoRuntimeError(`File not found for id ${id}`);
+        }
+    }
+    /** Convenience wrapper around find on the files collection */
+    find(filter = {}, options = {}) {
+        return this.s._filesCollection.find(filter, options);
+    }
+    /**
+     * Returns a readable stream (GridFSBucketReadStream) for streaming the
+     * file with the given name from GridFS. If there are multiple files with
+     * the same name, this will stream the most recent file with the given name
+     * (as determined by the `uploadDate` field). You can set the `revision`
+     * option to change this behavior.
+     */
+    openDownloadStreamByName(filename, options) {
+        let sort = { uploadDate: -1 };
+        let skip = undefined;
+        if (options && options.revision != null) {
+            if (options.revision >= 0) {
+                sort = { uploadDate: 1 };
+                skip = options.revision;
+            }
+            else {
+                skip = -options.revision - 1;
+            }
+        }
+        return new download_1.GridFSBucketReadStream(this.s._chunksCollection, this.s._filesCollection, this.s.options.readPreference, { filename }, { timeoutMS: this.s.options.timeoutMS, ...options, sort, skip });
+    }
+    /**
+     * Renames the file with the given _id to the given string
+     *
+     * @param id - the id of the file to rename
+     * @param filename - new name for the file
+     */
+    async rename(id, filename, options) {
+        const filter = { _id: id };
+        const update = { $set: { filename } };
+        const { matchedCount } = await this.s._filesCollection.updateOne(filter, update, options);
+        if (matchedCount === 0) {
+            throw new error_1.MongoRuntimeError(`File with id ${id} not found`);
+        }
+    }
+    /** Removes this bucket's files collection, followed by its chunks collection. */
+    async drop(options) {
+        const { timeoutMS } = (0, utils_1.resolveOptions)(this.s.db, options);
+        let timeoutContext = undefined;
+        if (timeoutMS) {
+            timeoutContext = new timeout_1.CSOTTimeoutContext({
+                timeoutMS,
+                serverSelectionTimeoutMS: this.s.db.client.s.options.serverSelectionTimeoutMS
+            });
+        }
+        if (timeoutContext) {
+            await this.s._filesCollection.drop({ timeoutMS: timeoutContext.remainingTimeMS });
+            const remainingTimeMS = timeoutContext.getRemainingTimeMSOrThrow(`Timed out after ${timeoutMS}ms`);
+            await this.s._chunksCollection.drop({ timeoutMS: remainingTimeMS });
+        }
+        else {
+            await this.s._filesCollection.drop();
+            await this.s._chunksCollection.drop();
+        }
+    }
+}
+exports.GridFSBucket = GridFSBucket;
+/**
+ * When the first call to openUploadStream is made, the upload stream will
+ * check to see if it needs to create the proper indexes on the chunks and
+ * files collections. This event is fired either when 1) it determines that
+ * no index creation is necessary, 2) when it successfully creates the
+ * necessary indexes.
+ * @event
+ */
+GridFSBucket.INDEX = 'index';
+//# sourceMappingURL=index.js.map