oxygen-cli 1.40.2-beta.1 → 1.41.0

package/transpiled/mongodb/lib/gridfs/index.js

@@ -1,240 +0,0 @@
-"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';

package/transpiled/mongodb/lib/gridfs/upload.js

@@ -1,446 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.GridFSBucketWriteStream = void 0;
-
-const stream_1 = require("stream");
-
-const bson_1 = require("../bson");
-
-const abstract_cursor_1 = require("../cursor/abstract_cursor");
-
-const error_1 = require("../error");
-
-const timeout_1 = require("../timeout");
-
-const utils_1 = require("../utils");
-
-const write_concern_1 = require("./../write_concern");
-/**
- * A writable stream that enables you to write buffers to GridFS.
- *
- * Do not instantiate this class directly. Use `openUploadStream()` instead.
- * @public
- */
-
-
-class GridFSBucketWriteStream extends stream_1.Writable {
-  /**
-   * @param bucket - Handle for this stream's corresponding bucket
-   * @param filename - The value of the 'filename' key in the files doc
-   * @param options - Optional settings.
-   * @internal
-   */
-  constructor(bucket, filename, options) {
-    super();
-    /**
-     * The document containing information about the inserted file.
-     * This property is defined _after_ the finish event has been emitted.
-     * It will remain `null` if an error occurs.
-     *
-     * @example
-     * ```ts
-     * fs.createReadStream('file.txt')
-     *   .pipe(bucket.openUploadStream('file.txt'))
-     *   .on('finish', function () {
-     *     console.log(this.gridFSFile)
-     *   })
-     * ```
-     */
-
-    this.gridFSFile = null;
-    options = options ?? {};
-    this.bucket = bucket;
-    this.chunks = bucket.s._chunksCollection;
-    this.filename = filename;
-    this.files = bucket.s._filesCollection;
-    this.options = options;
-    this.writeConcern = write_concern_1.WriteConcern.fromOptions(options) || bucket.s.options.writeConcern; // Signals the write is all done
-
-    this.done = false;
-    this.id = options.id ? options.id : new bson_1.ObjectId(); // properly inherit the default chunksize from parent
-
-    this.chunkSizeBytes = options.chunkSizeBytes || this.bucket.s.options.chunkSizeBytes;
-    this.bufToStore = Buffer.alloc(this.chunkSizeBytes);
-    this.length = 0;
-    this.n = 0;
-    this.pos = 0;
-    this.state = {
-      streamEnd: false,
-      outstandingRequests: 0,
-      errored: false,
-      aborted: false
-    };
-    if (options.timeoutMS != null) this.timeoutContext = new timeout_1.CSOTTimeoutContext({
-      timeoutMS: options.timeoutMS,
-      serverSelectionTimeoutMS: (0, utils_1.resolveTimeoutOptions)(this.bucket.s.db.client, {}).serverSelectionTimeoutMS
-    });
-  }
-  /**
-   * @internal
-   *
-   * The stream is considered constructed when the indexes are done being created
-   */
-
-
-  _construct(callback) {
-    if (!this.bucket.s.calledOpenUploadStream) {
-      this.bucket.s.calledOpenUploadStream = true;
-      checkIndexes(this).then(() => {
-        this.bucket.s.checkedIndexes = true;
-        this.bucket.emit('index');
-        callback();
-      }, error => {
-        if (error instanceof error_1.MongoOperationTimeoutError) {
-          return handleError(this, error, callback);
-        }
-
-        (0, utils_1.squashError)(error);
-        callback();
-      });
-    } else {
-      return process.nextTick(callback);
-    }
-  }
-  /**
-   * @internal
-   * Write a buffer to the stream.
-   *
-   * @param chunk - Buffer to write
-   * @param encoding - Optional encoding for the buffer
-   * @param callback - Function to call when the chunk was added to the buffer, or if the entire chunk was persisted to MongoDB if this chunk caused a flush.
-   */
-
-
-  _write(chunk, encoding, callback) {
-    doWrite(this, chunk, encoding, callback);
-  }
-  /** @internal */
-
-
-  _final(callback) {
-    if (this.state.streamEnd) {
-      return process.nextTick(callback);
-    }
-
-    this.state.streamEnd = true;
-    writeRemnant(this, callback);
-  }
-  /**
-   * Places this write stream into an aborted state (all future writes fail)
-   * and deletes all chunks that have already been written.
-   */
-
-
-  async abort() {
-    if (this.state.streamEnd) {
-      // TODO(NODE-3485): Replace with MongoGridFSStreamClosed
-      throw new error_1.MongoAPIError('Cannot abort a stream that has already completed');
-    }
-
-    if (this.state.aborted) {
-      // TODO(NODE-3485): Replace with MongoGridFSStreamClosed
-      throw new error_1.MongoAPIError('Cannot call abort() on a stream twice');
-    }
-
-    this.state.aborted = true;
-    const remainingTimeMS = this.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${this.timeoutContext?.timeoutMS}ms`);
-    await this.chunks.deleteMany({
-      files_id: this.id
-    }, {
-      timeoutMS: remainingTimeMS
-    });
-  }
-
-}
-
-exports.GridFSBucketWriteStream = GridFSBucketWriteStream;
-
-function handleError(stream, error, callback) {
-  if (stream.state.errored) {
-    process.nextTick(callback);
-    return;
-  }
-
-  stream.state.errored = true;
-  process.nextTick(callback, error);
-}
-
-function createChunkDoc(filesId, n, data) {
-  return {
-    _id: new bson_1.ObjectId(),
-    files_id: filesId,
-    n,
-    data
-  };
-}
-
-async function checkChunksIndex(stream) {
-  const index = {
-    files_id: 1,
-    n: 1
-  };
-  let remainingTimeMS;
-  remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`);
-  let indexes;
-
-  try {
-    indexes = await stream.chunks.listIndexes({
-      timeoutMode: remainingTimeMS != null ? abstract_cursor_1.CursorTimeoutMode.LIFETIME : undefined,
-      timeoutMS: remainingTimeMS
-    }).toArray();
-  } catch (error) {
-    if (error instanceof error_1.MongoError && error.code === error_1.MONGODB_ERROR_CODES.NamespaceNotFound) {
-      indexes = [];
-    } else {
-      throw error;
-    }
-  }
-
-  const hasChunksIndex = !!indexes.find(index => {
-    const keys = Object.keys(index.key);
-
-    if (keys.length === 2 && index.key.files_id === 1 && index.key.n === 1) {
-      return true;
-    }
-
-    return false;
-  });
-
-  if (!hasChunksIndex) {
-    remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`);
-    await stream.chunks.createIndex(index, { ...stream.writeConcern,
-      background: true,
-      unique: true,
-      timeoutMS: remainingTimeMS
-    });
-  }
-}
-
-function checkDone(stream, callback) {
-  if (stream.done) {
-    return process.nextTick(callback);
-  }
-
-  if (stream.state.streamEnd && stream.state.outstandingRequests === 0 && !stream.state.errored) {
-    // Set done so we do not trigger duplicate createFilesDoc
-    stream.done = true; // Create a new files doc
-
-    const gridFSFile = createFilesDoc(stream.id, stream.length, stream.chunkSizeBytes, stream.filename, stream.options.contentType, stream.options.aliases, stream.options.metadata);
-
-    if (isAborted(stream, callback)) {
-      return;
-    }
-
-    const remainingTimeMS = stream.timeoutContext?.remainingTimeMS;
-
-    if (remainingTimeMS != null && remainingTimeMS <= 0) {
-      return handleError(stream, new error_1.MongoOperationTimeoutError(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`), callback);
-    }
-
-    stream.files.insertOne(gridFSFile, {
-      writeConcern: stream.writeConcern,
-      timeoutMS: remainingTimeMS
-    }).then(() => {
-      stream.gridFSFile = gridFSFile;
-      callback();
-    }, error => {
-      return handleError(stream, error, callback);
-    });
-    return;
-  }
-
-  process.nextTick(callback);
-}
-
-async function checkIndexes(stream) {
-  let remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`);
-  const doc = await stream.files.findOne({}, {
-    projection: {
-      _id: 1
-    },
-    timeoutMS: remainingTimeMS
-  });
-
-  if (doc != null) {
-    // If at least one document exists assume the collection has the required index
-    return;
-  }
-
-  const index = {
-    filename: 1,
-    uploadDate: 1
-  };
-  let indexes;
-  remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`);
-  const listIndexesOptions = {
-    timeoutMode: remainingTimeMS != null ? abstract_cursor_1.CursorTimeoutMode.LIFETIME : undefined,
-    timeoutMS: remainingTimeMS
-  };
-
-  try {
-    indexes = await stream.files.listIndexes(listIndexesOptions).toArray();
-  } catch (error) {
-    if (error instanceof error_1.MongoError && error.code === error_1.MONGODB_ERROR_CODES.NamespaceNotFound) {
-      indexes = [];
-    } else {
-      throw error;
-    }
-  }
-
-  const hasFileIndex = !!indexes.find(index => {
-    const keys = Object.keys(index.key);
-
-    if (keys.length === 2 && index.key.filename === 1 && index.key.uploadDate === 1) {
-      return true;
-    }
-
-    return false;
-  });
-
-  if (!hasFileIndex) {
-    remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`);
-    await stream.files.createIndex(index, {
-      background: false,
-      timeoutMS: remainingTimeMS
-    });
-  }
-
-  await checkChunksIndex(stream);
-}
-
-function createFilesDoc(_id, length, chunkSize, filename, contentType, aliases, metadata) {
-  const ret = {
-    _id,
-    length,
-    chunkSize,
-    uploadDate: new Date(),
-    filename
-  };
-
-  if (contentType) {
-    ret.contentType = contentType;
-  }
-
-  if (aliases) {
-    ret.aliases = aliases;
-  }
-
-  if (metadata) {
-    ret.metadata = metadata;
-  }
-
-  return ret;
-}
-
-function doWrite(stream, chunk, encoding, callback) {
-  if (isAborted(stream, callback)) {
-    return;
-  }
-
-  const inputBuf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
-  stream.length += inputBuf.length; // Input is small enough to fit in our buffer
-
-  if (stream.pos + inputBuf.length < stream.chunkSizeBytes) {
-    inputBuf.copy(stream.bufToStore, stream.pos);
-    stream.pos += inputBuf.length;
-    process.nextTick(callback);
-    return;
-  } // Otherwise, buffer is too big for current chunk, so we need to flush
-  // to MongoDB.
-
-
-  let inputBufRemaining = inputBuf.length;
-  let spaceRemaining = stream.chunkSizeBytes - stream.pos;
-  let numToCopy = Math.min(spaceRemaining, inputBuf.length);
-  let outstandingRequests = 0;
-
-  while (inputBufRemaining > 0) {
-    const inputBufPos = inputBuf.length - inputBufRemaining;
-    inputBuf.copy(stream.bufToStore, stream.pos, inputBufPos, inputBufPos + numToCopy);
-    stream.pos += numToCopy;
-    spaceRemaining -= numToCopy;
-    let doc;
-
-    if (spaceRemaining === 0) {
-      doc = createChunkDoc(stream.id, stream.n, Buffer.from(stream.bufToStore));
-      const remainingTimeMS = stream.timeoutContext?.remainingTimeMS;
-
-      if (remainingTimeMS != null && remainingTimeMS <= 0) {
-        return handleError(stream, new error_1.MongoOperationTimeoutError(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`), callback);
-      }
-
-      ++stream.state.outstandingRequests;
-      ++outstandingRequests;
-
-      if (isAborted(stream, callback)) {
-        return;
-      }
-
-      stream.chunks.insertOne(doc, {
-        writeConcern: stream.writeConcern,
-        timeoutMS: remainingTimeMS
-      }).then(() => {
-        --stream.state.outstandingRequests;
-        --outstandingRequests;
-
-        if (!outstandingRequests) {
-          checkDone(stream, callback);
-        }
-      }, error => {
-        return handleError(stream, error, callback);
-      });
-      spaceRemaining = stream.chunkSizeBytes;
-      stream.pos = 0;
-      ++stream.n;
-    }
-
-    inputBufRemaining -= numToCopy;
-    numToCopy = Math.min(spaceRemaining, inputBufRemaining);
-  }
-}
-
-function writeRemnant(stream, callback) {
-  // Buffer is empty, so don't bother to insert
-  if (stream.pos === 0) {
-    return checkDone(stream, callback);
-  } // Create a new buffer to make sure the buffer isn't bigger than it needs
-  // to be.
-
-
-  const remnant = Buffer.alloc(stream.pos);
-  stream.bufToStore.copy(remnant, 0, 0, stream.pos);
-  const doc = createChunkDoc(stream.id, stream.n, remnant); // If the stream was aborted, do not write remnant
-
-  if (isAborted(stream, callback)) {
-    return;
-  }
-
-  const remainingTimeMS = stream.timeoutContext?.remainingTimeMS;
-
-  if (remainingTimeMS != null && remainingTimeMS <= 0) {
-    return handleError(stream, new error_1.MongoOperationTimeoutError(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`), callback);
-  }
-
-  ++stream.state.outstandingRequests;
-  stream.chunks.insertOne(doc, {
-    writeConcern: stream.writeConcern,
-    timeoutMS: remainingTimeMS
-  }).then(() => {
-    --stream.state.outstandingRequests;
-    checkDone(stream, callback);
-  }, error => {
-    return handleError(stream, error, callback);
-  });
-}
-
-function isAborted(stream, callback) {
-  if (stream.state.aborted) {
-    process.nextTick(callback, new error_1.MongoAPIError('Stream has been aborted'));
-    return true;
-  }
-
-  return false;
-}