@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Adapters/Email/MailAdapter.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.MailAdapter = void 0;
+/* eslint-disable unused-imports/no-unused-vars */
+/**
+ * @interface
+ * @memberof module:Adapters
+ * Mail Adapter prototype
+ * A MailAdapter should implement at least sendMail()
+ */
+class MailAdapter {
+  /**
+   * A method for sending mail
+   * @param options would have the parameters
+   * - to: the recipient
+   * - text: the raw text of the message
+   * - subject: the subject of the email
+   */
+  sendMail(options) {}
+
+  /* You can implement those methods if you want
+   * to provide HTML templates etc...
+   */
+  // sendVerificationEmail({ link, appName, user }) {}
+  // sendPasswordResetEmail({ link, appName, user }) {}
+}
+exports.MailAdapter = MailAdapter;
+var _default = exports.default = MailAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJNYWlsQWRhcHRlciIsInNlbmRNYWlsIiwib3B0aW9ucyIsImV4cG9ydHMiLCJfZGVmYXVsdCIsImRlZmF1bHQiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvQWRhcHRlcnMvRW1haWwvTWFpbEFkYXB0ZXIuanMiXSwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgdW51c2VkLWltcG9ydHMvbm8tdW51c2VkLXZhcnMgKi9cbi8qKlxuICogQGludGVyZmFjZVxuICogQG1lbWJlcm9mIG1vZHVsZTpBZGFwdGVyc1xuICogTWFpbCBBZGFwdGVyIHByb3RvdHlwZVxuICogQSBNYWlsQWRhcHRlciBzaG91bGQgaW1wbGVtZW50IGF0IGxlYXN0IHNlbmRNYWlsKClcbiAqL1xuZXhwb3J0IGNsYXNzIE1haWxBZGFwdGVyIHtcbiAgLyoqXG4gICAqIEEgbWV0aG9kIGZvciBzZW5kaW5nIG1haWxcbiAgICogQHBhcmFtIG9wdGlvbnMgd291bGQgaGF2ZSB0aGUgcGFyYW1ldGVyc1xuICAgKiAtIHRvOiB0aGUgcmVjaXBpZW50XG4gICAqIC0gdGV4dDogdGhlIHJhdyB0ZXh0IG9mIHRoZSBtZXNzYWdlXG4gICAqIC0gc3ViamVjdDogdGhlIHN1YmplY3Qgb2YgdGhlIGVtYWlsXG4gICAqL1xuICBzZW5kTWFpbChvcHRpb25zKSB7fVxuXG4gIC8qIFlvdSBjYW4gaW1wbGVtZW50IHRob3NlIG1ldGhvZHMgaWYgeW91IHdhbnRcbiAgICogdG8gcHJvdmlkZSBIVE1MIHRlbXBsYXRlcyBldGMuLi5cbiAgICovXG4gIC8vIHNlbmRWZXJpZmljYXRpb25FbWFpbCh7IGxpbmssIGFwcE5hbWUsIHVzZXIgfSkge31cbiAgLy8gc2VuZFBhc3N3b3JkUmVzZXRFbWFpbCh7IGxpbmssIGFwcE5hbWUsIHVzZXIgfSkge31cbn1cblxuZXhwb3J0IGRlZmF1bHQgTWFpbEFkYXB0ZXI7XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ08sTUFBTUEsV0FBVyxDQUFDO0VBQ3ZCO0FBQ0Y7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0VBQ0VDLFFBQVFBLENBQUNDLE9BQU8sRUFBRSxDQUFDOztFQUVuQjtBQUNGO0FBQ0E7RUFDRTtFQUNBO0FBQ0Y7QUFBQ0MsT0FBQSxDQUFBSCxXQUFBLEdBQUFBLFdBQUE7QUFBQSxJQUFBSSxRQUFBLEdBQUFELE9BQUEsQ0FBQUUsT0FBQSxHQUVjTCxXQUFXIiwiaWdub3JlTGlzdCI6W119

package/lib/Adapters/Files/FilesAdapter.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.FilesAdapter = void 0;
+exports.validateFilename = validateFilename;
+var _node = _interopRequireDefault(require("parse/node"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/* eslint-disable unused-imports/no-unused-vars */
+// Files Adapter
+//
+// Allows you to change the file storage mechanism.
+//
+// Adapter classes must implement the following functions:
+// * createFile(filename, data, contentType)
+// * deleteFile(filename)
+// * getFileData(filename)
+// * getFileLocation(config, filename)
+// Adapter classes should implement the following functions:
+// * validateFilename(filename)
+// * handleFileStream(filename, req, res, contentType)
+//
+// Default is GridFSBucketAdapter, which requires mongo
+// and for the API server to be using the DatabaseController with Mongo
+// database adapter.
+
+/**
+ * @interface
+ * @memberof module:Adapters
+ */
+class FilesAdapter {
+  /** Responsible for storing the file in order to be retrieved later by its filename
+   *
+   * @param {string} filename - the filename to save
+   * @param {Buffer|Readable} data - the file data as a Buffer, or a Readable stream if the adapter supports streaming (see supportsStreaming)
+   * @param {string} contentType - the supposed contentType
+   * @discussion the contentType can be undefined if the controller was not able to determine it
+   * @param {object} options - (Optional) options to be passed to file adapter (S3 File Adapter Only)
+   * - tags: object containing key value pairs that will be stored with file
+   * - metadata: object containing key value pairs that will be sotred with file (https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-object-metadata.html)
+   * @discussion options are not supported by all file adapters. Check the your adapter's documentation for compatibility
+   *
+   * @return {Promise} a promise that should fail if the storage didn't succeed
+   */
+  createFile(filename, data, contentType, options) {}
+
+  /** Whether this adapter supports receiving Readable streams in createFile().
+   * If false (default), streams are buffered to a Buffer before being passed.
+   * Override and return true to receive Readable streams directly.
+   *
+   * @return {boolean}
+   */
+  get supportsStreaming() {
+    return false;
+  }
+
+  /** Responsible for deleting the specified file
+   *
+   * @param {string} filename - the filename to delete
+   *
+   * @return {Promise} a promise that should fail if the deletion didn't succeed
+   */
+  deleteFile(filename) {}
+
+  /** Responsible for retrieving the data of the specified file
+   *
+   * @param {string} filename - the name of file to retrieve
+   *
+   * @return {Promise} a promise that should pass with the file data or fail on error
+   */
+  getFileData(filename) {}
+
+  /** Returns an absolute URL where the file can be accessed
+   *
+   * @param {Config} config - server configuration
+   * @param {string} filename
+   *
+   * @return {string | Promise<string>} Absolute URL
+   */
+  getFileLocation(config, filename) {}
+
+  /** Validate a filename for this adapter type
+   *
+   * @param {string} filename
+   *
+   * @returns {null|Parse.Error} null if there are no errors
+   */
+  // validateFilename(filename: string): ?Parse.Error {}
+
+  /** Handles Byte-Range Requests for Streaming
+   *
+   * @param {string} filename
+   * @param {object} req
+   * @param {object} res
+   * @param {string} contentType
+   *
+   * @returns {Promise} Data for byte range
+   */
+  // handleFileStream(filename: string, res: any, req: any, contentType: string): Promise
+
+  /** Responsible for retrieving metadata and tags
+   *
+   * @param {string} filename - the filename to retrieve metadata
+   *
+   * @return {Promise} a promise that should pass with metadata
+   */
+  // getMetadata(filename: string): Promise<any> {}
+}
+
+/**
+ * Simple filename validation
+ *
+ * @param filename
+ * @returns {null|Parse.Error}
+ */
+exports.FilesAdapter = FilesAdapter;
+function validateFilename(filename) {
+  if (filename.length > 128) {
+    return new _node.default.Error(_node.default.Error.INVALID_FILE_NAME, 'Filename too long.');
+  }
+  const regx = /^[_a-zA-Z0-9][a-zA-Z0-9@. ~_-]*$/;
+  if (!filename.match(regx)) {
+    return new _node.default.Error(_node.default.Error.INVALID_FILE_NAME, 'Filename contains invalid characters.');
+  }
+  return null;
+}
+var _default = exports.default = FilesAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","_interopRequireDefault","require","e","__esModule","default","FilesAdapter","createFile","filename","data","contentType","options","supportsStreaming","deleteFile","getFileData","getFileLocation","config","exports","validateFilename","length","Parse","Error","INVALID_FILE_NAME","regx","match","_default"],"sources":["../../../src/Adapters/Files/FilesAdapter.js"],"sourcesContent":["/* eslint-disable unused-imports/no-unused-vars */\n// Files Adapter\n//\n// Allows you to change the file storage mechanism.\n//\n// Adapter classes must implement the following functions:\n// * createFile(filename, data, contentType)\n// * deleteFile(filename)\n// * getFileData(filename)\n// * getFileLocation(config, filename)\n// Adapter classes should implement the following functions:\n// * validateFilename(filename)\n// * handleFileStream(filename, req, res, contentType)\n//\n// Default is GridFSBucketAdapter, which requires mongo\n// and for the API server to be using the DatabaseController with Mongo\n// database adapter.\n\nimport type { Config } from '../../Config';\nimport Parse from 'parse/node';\n/**\n * @interface\n * @memberof module:Adapters\n */\nexport class FilesAdapter {\n  /** Responsible for storing the file in order to be retrieved later by its filename\n   *\n   * @param {string} filename - the filename to save\n   * @param {Buffer|Readable} data - the file data as a Buffer, or a Readable stream if the adapter supports streaming (see supportsStreaming)\n   * @param {string} contentType - the supposed contentType\n   * @discussion the contentType can be undefined if the controller was not able to determine it\n   * @param {object} options - (Optional) options to be passed to file adapter (S3 File Adapter Only)\n   * - tags: object containing key value pairs that will be stored with file\n   * - metadata: object containing key value pairs that will be sotred with file (https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-object-metadata.html)\n   * @discussion options are not supported by all file adapters. Check the your adapter's documentation for compatibility\n   *\n   * @return {Promise} a promise that should fail if the storage didn't succeed\n   */\n  createFile(filename: string, data, contentType: string, options: Object): Promise {}\n\n  /** Whether this adapter supports receiving Readable streams in createFile().\n   * If false (default), streams are buffered to a Buffer before being passed.\n   * Override and return true to receive Readable streams directly.\n   *\n   * @return {boolean}\n   */\n  get supportsStreaming() {\n    return false;\n  }\n\n  /** Responsible for deleting the specified file\n   *\n   * @param {string} filename - the filename to delete\n   *\n   * @return {Promise} a promise that should fail if the deletion didn't succeed\n   */\n  deleteFile(filename: string): Promise {}\n\n  /** Responsible for retrieving the data of the specified file\n   *\n   * @param {string} filename - the name of file to retrieve\n   *\n   * @return {Promise} a promise that should pass with the file data or fail on error\n   */\n  getFileData(filename: string): Promise<any> {}\n\n  /** Returns an absolute URL where the file can be accessed\n   *\n   * @param {Config} config - server configuration\n   * @param {string} filename\n   *\n   * @return {string | Promise<string>} Absolute URL\n   */\n  getFileLocation(config: Config, filename: string): string | Promise<string> {}\n\n  /** Validate a filename for this adapter type\n   *\n   * @param {string} filename\n   *\n   * @returns {null|Parse.Error} null if there are no errors\n   */\n  // validateFilename(filename: string): ?Parse.Error {}\n\n  /** Handles Byte-Range Requests for Streaming\n   *\n   * @param {string} filename\n   * @param {object} req\n   * @param {object} res\n   * @param {string} contentType\n   *\n   * @returns {Promise} Data for byte range\n   */\n  // handleFileStream(filename: string, res: any, req: any, contentType: string): Promise\n\n  /** Responsible for retrieving metadata and tags\n   *\n   * @param {string} filename - the filename to retrieve metadata\n   *\n   * @return {Promise} a promise that should pass with metadata\n   */\n  // getMetadata(filename: string): Promise<any> {}\n}\n\n/**\n * Simple filename validation\n *\n * @param filename\n * @returns {null|Parse.Error}\n */\nexport function validateFilename(filename): ?Parse.Error {\n  if (filename.length > 128) {\n    return new Parse.Error(Parse.Error.INVALID_FILE_NAME, 'Filename too long.');\n  }\n\n  const regx = /^[_a-zA-Z0-9][a-zA-Z0-9@. ~_-]*$/;\n  if (!filename.match(regx)) {\n    return new Parse.Error(Parse.Error.INVALID_FILE_NAME, 'Filename contains invalid characters.');\n  }\n  return null;\n}\n\nexport default FilesAdapter;\n"],"mappings":";;;;;;;AAmBA,IAAAA,KAAA,GAAAC,sBAAA,CAAAC,OAAA;AAA+B,SAAAD,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAnB/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACO,MAAMG,YAAY,CAAC;EACxB;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,UAAUA,CAACC,QAAgB,EAAEC,IAAI,EAAEC,WAAmB,EAAEC,OAAe,EAAW,CAAC;;EAEnF;AACF;AACA;AACA;AACA;AACA;EACE,IAAIC,iBAAiBA,CAAA,EAAG;IACtB,OAAO,KAAK;EACd;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEC,UAAUA,CAACL,QAAgB,EAAW,CAAC;;EAEvC;AACF;AACA;AACA;AACA;AACA;EACEM,WAAWA,CAACN,QAAgB,EAAgB,CAAC;;EAE7C;AACF;AACA;AACA;AACA;AACA;AACA;EACEO,eAAeA,CAACC,MAAc,EAAER,QAAgB,EAA4B,CAAC;;EAE7E;AACF;AACA;AACA;AACA;AACA;EACE;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE;;EAEA;AACF;AACA;AACA;AACA;AACA;EACE;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AALAS,OAAA,CAAAX,YAAA,GAAAA,YAAA;AAMO,SAASY,gBAAgBA,CAACV,QAAQ,EAAgB;EACvD,IAAIA,QAAQ,CAACW,MAAM,GAAG,GAAG,EAAE;IACzB,OAAO,IAAIC,aAAK,CAACC,KAAK,CAACD,aAAK,CAACC,KAAK,CAACC,iBAAiB,EAAE,oBAAoB,CAAC;EAC7E;EAEA,MAAMC,IAAI,GAAG,kCAAkC;EAC/C,IAAI,CAACf,QAAQ,CAACgB,KAAK,CAACD,IAAI,CAAC,EAAE;IACzB,OAAO,IAAIH,aAAK,CAACC,KAAK,CAACD,aAAK,CAACC,KAAK,CAACC,iBAAiB,EAAE,uCAAuC,CAAC;EAChG;EACA,OAAO,IAAI;AACb;AAAC,IAAAG,QAAA,GAAAR,OAAA,CAAAZ,OAAA,GAEcC,YAAY","ignoreList":[]}

package/lib/Adapters/Files/GridFSBucketAdapter.js

@@ -0,0 +1,280 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.GridFSBucketAdapter = void 0;
+var _mongodb = require("mongodb");
+var _FilesAdapter = require("./FilesAdapter");
+var _defaults = _interopRequireWildcard(require("../../defaults"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ GridFSBucketAdapter
+ Stores files in Mongo using GridFS
+ Requires the database adapter to be based on mongoclient
+
+ 
+ */
+
+// -disable-next
+
+const crypto = require('crypto');
+class GridFSBucketAdapter extends _FilesAdapter.FilesAdapter {
+  constructor(mongoDatabaseURI = _defaults.default.DefaultMongoURI, mongoOptions = {}, encryptionKey = undefined) {
+    super();
+    this._databaseURI = mongoDatabaseURI;
+    this._algorithm = 'aes-256-gcm';
+    this._encryptionKey = encryptionKey !== undefined ? crypto.createHash('sha256').update(String(encryptionKey)).digest('base64').substring(0, 32) : null;
+    const defaultMongoOptions = {};
+    const _mongoOptions = Object.assign(defaultMongoOptions, mongoOptions);
+    this._clientMetadata = mongoOptions.clientMetadata;
+    this._batchSize = mongoOptions.batchSize;
+    // Remove Parse Server-specific options that should not be passed to MongoDB client
+    for (const key of _defaults.ParseServerDatabaseOptions) {
+      delete _mongoOptions[key];
+    }
+    this._mongoOptions = _mongoOptions;
+  }
+  get supportsStreaming() {
+    return true;
+  }
+  _connect() {
+    if (!this._connectionPromise) {
+      // Only use driverInfo if clientMetadata option is set
+      const options = {
+        ...this._mongoOptions
+      };
+      if (this._clientMetadata) {
+        options.driverInfo = {
+          name: this._clientMetadata.name,
+          version: this._clientMetadata.version
+        };
+      }
+      this._connectionPromise = _mongodb.MongoClient.connect(this._databaseURI, options).then(client => {
+        this._client = client;
+        return client.db(client.s.options.dbName);
+      });
+    }
+    return this._connectionPromise;
+  }
+  _getBucket() {
+    return this._connect().then(database => new _mongodb.GridFSBucket(database));
+  }
+
+  // For a given config object, filename, and data, store a file
+  // Returns a promise
+  async createFile(filename, data, contentType, options = {}) {
+    const bucket = await this._getBucket();
+    const stream = await bucket.openUploadStream(filename, {
+      metadata: options.metadata
+    });
+
+    // If data is a stream and encryption is enabled, buffer first
+    // (AES-256-GCM needs complete data for format: [encrypted][IV][authTag])
+    if (typeof data?.pipe === 'function' && this._encryptionKey !== null) {
+      data = await new Promise((resolve, reject) => {
+        const chunks = [];
+        data.on('data', chunk => chunks.push(chunk));
+        data.on('end', () => resolve(Buffer.concat(chunks)));
+        data.on('error', reject);
+      });
+    }
+    if (typeof data?.pipe === 'function') {
+      // Pipe readable stream directly into GridFS upload stream
+      return new Promise((resolve, reject) => {
+        data.pipe(stream);
+        stream.on('finish', resolve);
+        stream.on('error', reject);
+        data.on('error', err => {
+          stream.destroy(err);
+          reject(err);
+        });
+      });
+    }
+
+    // Buffer path (existing behavior)
+    if (this._encryptionKey !== null) {
+      try {
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv(this._algorithm, this._encryptionKey, iv);
+        const encryptedResult = Buffer.concat([cipher.update(data), cipher.final(), iv, cipher.getAuthTag()]);
+        await stream.write(encryptedResult);
+      } catch (err) {
+        return new Promise((resolve, reject) => {
+          return reject(err);
+        });
+      }
+    } else {
+      await stream.write(data);
+    }
+    stream.end();
+    return new Promise((resolve, reject) => {
+      stream.on('finish', resolve);
+      stream.on('error', reject);
+    });
+  }
+  async deleteFile(filename) {
+    const bucket = await this._getBucket();
+    const documents = await bucket.find({
+      filename
+    }, {
+      batchSize: this._batchSize
+    }).toArray();
+    if (documents.length === 0) {
+      throw new Error('FileNotFound');
+    }
+    return Promise.all(documents.map(doc => {
+      return bucket.delete(doc._id);
+    }));
+  }
+  async getFileData(filename) {
+    const bucket = await this._getBucket();
+    const stream = bucket.openDownloadStreamByName(filename);
+    stream.read();
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      stream.on('data', data => {
+        chunks.push(data);
+      });
+      stream.on('end', () => {
+        const data = Buffer.concat(chunks);
+        if (this._encryptionKey !== null) {
+          try {
+            const authTagLocation = data.length - 16;
+            const ivLocation = data.length - 32;
+            const authTag = data.slice(authTagLocation);
+            const iv = data.slice(ivLocation, authTagLocation);
+            const encrypted = data.slice(0, ivLocation);
+            const decipher = crypto.createDecipheriv(this._algorithm, this._encryptionKey, iv);
+            decipher.setAuthTag(authTag);
+            const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+            return resolve(decrypted);
+          } catch (err) {
+            return reject(err);
+          }
+        }
+        resolve(data);
+      });
+      stream.on('error', err => {
+        reject(err);
+      });
+    });
+  }
+  async rotateEncryptionKey(options = {}) {
+    let fileNames = [];
+    let oldKeyFileAdapter = {};
+    const bucket = await this._getBucket();
+    if (options.oldKey !== undefined) {
+      oldKeyFileAdapter = new GridFSBucketAdapter(this._databaseURI, this._mongoOptions, options.oldKey);
+    } else {
+      oldKeyFileAdapter = new GridFSBucketAdapter(this._databaseURI, this._mongoOptions);
+    }
+    if (options.fileNames !== undefined) {
+      fileNames = options.fileNames;
+    } else {
+      const fileNamesIterator = await bucket.find({}, {
+        batchSize: this._batchSize
+      }).toArray();
+      fileNamesIterator.forEach(file => {
+        fileNames.push(file.filename);
+      });
+    }
+    let fileNamesNotRotated = fileNames;
+    const fileNamesRotated = [];
+    for (const fileName of fileNames) {
+      try {
+        const plainTextData = await oldKeyFileAdapter.getFileData(fileName);
+        // Overwrite file with data encrypted with new key
+        await this.createFile(fileName, plainTextData);
+        fileNamesRotated.push(fileName);
+        fileNamesNotRotated = fileNamesNotRotated.filter(function (value) {
+          return value !== fileName;
+        });
+      } catch {
+        continue;
+      }
+    }
+    return {
+      rotated: fileNamesRotated,
+      notRotated: fileNamesNotRotated
+    };
+  }
+  getFileLocation(config, filename) {
+    const encodedFilename = filename.split('/').map(encodeURIComponent).join('/');
+    return config.mount + '/files/' + config.applicationId + '/' + encodedFilename;
+  }
+  async getMetadata(filename) {
+    const bucket = await this._getBucket();
+    const files = await bucket.find({
+      filename
+    }, {
+      batchSize: this._batchSize
+    }).toArray();
+    if (files.length === 0) {
+      return {};
+    }
+    const {
+      metadata
+    } = files[0];
+    return {
+      metadata
+    };
+  }
+  async handleFileStream(filename, req, res, contentType) {
+    const bucket = await this._getBucket();
+    const files = await bucket.find({
+      filename
+    }, {
+      batchSize: this._batchSize
+    }).toArray();
+    if (files.length === 0) {
+      throw new Error('FileNotFound');
+    }
+    const parts = req.get('Range').replace(/bytes=/, '').split('-');
+    const partialstart = parts[0];
+    const partialend = parts[1];
+    const fileLength = files[0].length;
+    const fileStart = parseInt(partialstart, 10);
+    const fileEnd = partialend ? parseInt(partialend, 10) : fileLength;
+    let start = Math.min(fileStart || 0, fileEnd, fileLength);
+    let end = Math.max(fileStart || 0, fileEnd) + 1 || fileLength;
+    if (isNaN(fileStart)) {
+      start = fileLength - end + 1;
+      end = fileLength;
+    }
+    end = Math.min(end, fileLength);
+    start = Math.max(start, 0);
+    res.status(206);
+    res.header('Accept-Ranges', 'bytes');
+    res.header('Content-Length', end - start);
+    res.header('Content-Range', 'bytes ' + start + '-' + end + '/' + fileLength);
+    res.header('Content-Type', contentType);
+    const stream = bucket.openDownloadStreamByName(filename);
+    stream.start(start);
+    if (end) {
+      stream.end(end);
+    }
+    stream.on('data', chunk => {
+      res.write(chunk);
+    });
+    stream.on('error', e => {
+      res.status(404);
+      res.send(e.message);
+    });
+    stream.on('end', () => {
+      res.end();
+    });
+  }
+  handleShutdown() {
+    if (!this._client) {
+      return Promise.resolve();
+    }
+    return this._client.close(false);
+  }
+  validateFilename(filename) {
+    return (0, _FilesAdapter.validateFilename)(filename);
+  }
+}
+exports.GridFSBucketAdapter = GridFSBucketAdapter;
+var _default = exports.default = GridFSBucketAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_mongodb","require","_FilesAdapter","_defaults","_interopRequireWildcard","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","crypto","GridFSBucketAdapter","FilesAdapter","constructor","mongoDatabaseURI","defaults","DefaultMongoURI","mongoOptions","encryptionKey","undefined","_databaseURI","_algorithm","_encryptionKey","createHash","update","String","digest","substring","defaultMongoOptions","_mongoOptions","assign","_clientMetadata","clientMetadata","_batchSize","batchSize","key","ParseServerDatabaseOptions","supportsStreaming","_connect","_connectionPromise","options","driverInfo","name","version","MongoClient","connect","then","client","_client","db","s","dbName","_getBucket","database","GridFSBucket","createFile","filename","data","contentType","bucket","stream","openUploadStream","metadata","pipe","Promise","resolve","reject","chunks","on","chunk","push","Buffer","concat","err","destroy","iv","randomBytes","cipher","createCipheriv","encryptedResult","final","getAuthTag","write","end","deleteFile","documents","find","toArray","length","Error","all","map","doc","delete","_id","getFileData","openDownloadStreamByName","read","authTagLocation","ivLocation","authTag","slice","encrypted","decipher","createDecipheriv","setAuthTag","decrypted","rotateEncryptionKey","fileNames","oldKeyFileAdapter","oldKey","fileNamesIterator","forEach","file","fileNamesNotRotated","fileNamesRotated","fileName","plainTextData","filter","value","rotated","notRotated","getFileLocation","config","encodedFilename","split","encodeURIComponent","join","mount","applicationId","getMetadata","files","handleFileStream","req","res","parts","replace","partialstart","partialend","fileLength","fileStart","parseInt","fileEnd","start","Math","min","max","isNaN","status","header","send","message","handleShutdown","close","validateFilename","exports","_default"],"sources":["../../../src/Adapters/Files/GridFSBucketAdapter.js"],"sourcesContent":["/**\n GridFSBucketAdapter\n Stores files in Mongo using GridFS\n Requires the database adapter to be based on mongoclient\n\n @flow weak\n */\n\n// @flow-disable-next\nimport { MongoClient, GridFSBucket, Db } from 'mongodb';\nimport { FilesAdapter, validateFilename } from './FilesAdapter';\nimport defaults, { ParseServerDatabaseOptions } from '../../defaults';\nconst crypto = require('crypto');\n\nexport class GridFSBucketAdapter extends FilesAdapter {\n  _databaseURI: string;\n  _connectionPromise: Promise<Db>;\n  _mongoOptions: Object;\n  _algorithm: string;\n  _clientMetadata: ?{ name: string, version: string };\n\n  constructor(\n    mongoDatabaseURI = defaults.DefaultMongoURI,\n    mongoOptions = {},\n    encryptionKey = undefined\n  ) {\n    super();\n    this._databaseURI = mongoDatabaseURI;\n    this._algorithm = 'aes-256-gcm';\n    this._encryptionKey =\n      encryptionKey !== undefined\n        ? crypto\n          .createHash('sha256')\n          .update(String(encryptionKey))\n          .digest('base64')\n          .substring(0, 32)\n        : null;\n    const defaultMongoOptions = {};\n    const _mongoOptions = Object.assign(defaultMongoOptions, mongoOptions);\n    this._clientMetadata = mongoOptions.clientMetadata;\n    this._batchSize = mongoOptions.batchSize;\n    // Remove Parse Server-specific options that should not be passed to MongoDB client\n    for (const key of ParseServerDatabaseOptions) {\n      delete _mongoOptions[key];\n    }\n    this._mongoOptions = _mongoOptions;\n  }\n\n  get supportsStreaming() {\n    return true;\n  }\n\n  _connect() {\n    if (!this._connectionPromise) {\n      // Only use driverInfo if clientMetadata option is set\n      const options = { ...this._mongoOptions };\n      if (this._clientMetadata) {\n        options.driverInfo = {\n          name: this._clientMetadata.name,\n          version: this._clientMetadata.version\n        };\n      }\n\n      this._connectionPromise = MongoClient.connect(this._databaseURI, options).then(\n        client => {\n          this._client = client;\n          return client.db(client.s.options.dbName);\n        }\n      );\n    }\n    return this._connectionPromise;\n  }\n\n  _getBucket() {\n    return this._connect().then(database => new GridFSBucket(database));\n  }\n\n  // For a given config object, filename, and data, store a file\n  // Returns a promise\n  async createFile(filename: string, data, contentType, options = {}) {\n    const bucket = await this._getBucket();\n    const stream = await bucket.openUploadStream(filename, {\n      metadata: options.metadata,\n    });\n\n    // If data is a stream and encryption is enabled, buffer first\n    // (AES-256-GCM needs complete data for format: [encrypted][IV][authTag])\n    if (typeof data?.pipe === 'function' && this._encryptionKey !== null) {\n      data = await new Promise((resolve, reject) => {\n        const chunks = [];\n        data.on('data', chunk => chunks.push(chunk));\n        data.on('end', () => resolve(Buffer.concat(chunks)));\n        data.on('error', reject);\n      });\n    }\n\n    if (typeof data?.pipe === 'function') {\n      // Pipe readable stream directly into GridFS upload stream\n      return new Promise((resolve, reject) => {\n        data.pipe(stream);\n        stream.on('finish', resolve);\n        stream.on('error', reject);\n        data.on('error', (err) => {\n          stream.destroy(err);\n          reject(err);\n        });\n      });\n    }\n\n    // Buffer path (existing behavior)\n    if (this._encryptionKey !== null) {\n      try {\n        const iv = crypto.randomBytes(16);\n        const cipher = crypto.createCipheriv(this._algorithm, this._encryptionKey, iv);\n        const encryptedResult = Buffer.concat([\n          cipher.update(data),\n          cipher.final(),\n          iv,\n          cipher.getAuthTag(),\n        ]);\n        await stream.write(encryptedResult);\n      } catch (err) {\n        return new Promise((resolve, reject) => {\n          return reject(err);\n        });\n      }\n    } else {\n      await stream.write(data);\n    }\n    stream.end();\n    return new Promise((resolve, reject) => {\n      stream.on('finish', resolve);\n      stream.on('error', reject);\n    });\n  }\n\n  async deleteFile(filename: string) {\n    const bucket = await this._getBucket();\n    const documents = await bucket.find({ filename }, { batchSize: this._batchSize }).toArray();\n    if (documents.length === 0) {\n      throw new Error('FileNotFound');\n    }\n    return Promise.all(\n      documents.map(doc => {\n        return bucket.delete(doc._id);\n      })\n    );\n  }\n\n  async getFileData(filename: string) {\n    const bucket = await this._getBucket();\n    const stream = bucket.openDownloadStreamByName(filename);\n    stream.read();\n    return new Promise((resolve, reject) => {\n      const chunks = [];\n      stream.on('data', data => {\n        chunks.push(data);\n      });\n      stream.on('end', () => {\n        const data = Buffer.concat(chunks);\n        if (this._encryptionKey !== null) {\n          try {\n            const authTagLocation = data.length - 16;\n            const ivLocation = data.length - 32;\n            const authTag = data.slice(authTagLocation);\n            const iv = data.slice(ivLocation, authTagLocation);\n            const encrypted = data.slice(0, ivLocation);\n            const decipher = crypto.createDecipheriv(this._algorithm, this._encryptionKey, iv);\n            decipher.setAuthTag(authTag);\n            const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);\n            return resolve(decrypted);\n          } catch (err) {\n            return reject(err);\n          }\n        }\n        resolve(data);\n      });\n      stream.on('error', err => {\n        reject(err);\n      });\n    });\n  }\n\n  async rotateEncryptionKey(options = {}) {\n    let fileNames = [];\n    let oldKeyFileAdapter = {};\n    const bucket = await this._getBucket();\n    if (options.oldKey !== undefined) {\n      oldKeyFileAdapter = new GridFSBucketAdapter(\n        this._databaseURI,\n        this._mongoOptions,\n        options.oldKey\n      );\n    } else {\n      oldKeyFileAdapter = new GridFSBucketAdapter(this._databaseURI, this._mongoOptions);\n    }\n    if (options.fileNames !== undefined) {\n      fileNames = options.fileNames;\n    } else {\n      const fileNamesIterator = await bucket.find({}, { batchSize: this._batchSize }).toArray();\n      fileNamesIterator.forEach(file => {\n        fileNames.push(file.filename);\n      });\n    }\n    let fileNamesNotRotated = fileNames;\n    const fileNamesRotated = [];\n    for (const fileName of fileNames) {\n      try {\n        const plainTextData = await oldKeyFileAdapter.getFileData(fileName);\n        // Overwrite file with data encrypted with new key\n        await this.createFile(fileName, plainTextData);\n        fileNamesRotated.push(fileName);\n        fileNamesNotRotated = fileNamesNotRotated.filter(function (value) {\n          return value !== fileName;\n        });\n      } catch {\n        continue;\n      }\n    }\n    return { rotated: fileNamesRotated, notRotated: fileNamesNotRotated };\n  }\n\n  getFileLocation(config, filename) {\n    const encodedFilename = filename.split('/').map(encodeURIComponent).join('/');\n    return config.mount + '/files/' + config.applicationId + '/' + encodedFilename;\n  }\n\n  async getMetadata(filename) {\n    const bucket = await this._getBucket();\n    const files = await bucket.find({ filename }, { batchSize: this._batchSize }).toArray();\n    if (files.length === 0) {\n      return {};\n    }\n    const { metadata } = files[0];\n    return { metadata };\n  }\n\n  async handleFileStream(filename: string, req, res, contentType) {\n    const bucket = await this._getBucket();\n    const files = await bucket.find({ filename }, { batchSize: this._batchSize }).toArray();\n    if (files.length === 0) {\n      throw new Error('FileNotFound');\n    }\n    const parts = req\n      .get('Range')\n      .replace(/bytes=/, '')\n      .split('-');\n    const partialstart = parts[0];\n    const partialend = parts[1];\n\n    const fileLength = files[0].length;\n    const fileStart = parseInt(partialstart, 10);\n    const fileEnd = partialend ? parseInt(partialend, 10) : fileLength;\n\n    let start = Math.min(fileStart || 0, fileEnd, fileLength);\n    let end = Math.max(fileStart || 0, fileEnd) + 1 || fileLength;\n    if (isNaN(fileStart)) {\n      start = fileLength - end + 1;\n      end = fileLength;\n    }\n    end = Math.min(end, fileLength);\n    start = Math.max(start, 0);\n\n    res.status(206);\n    res.header('Accept-Ranges', 'bytes');\n    res.header('Content-Length', end - start);\n    res.header('Content-Range', 'bytes ' + start + '-' + end + '/' + fileLength);\n    res.header('Content-Type', contentType);\n    const stream = bucket.openDownloadStreamByName(filename);\n    stream.start(start);\n    if (end) {\n      stream.end(end);\n    }\n    stream.on('data', chunk => {\n      res.write(chunk);\n    });\n    stream.on('error', e => {\n      res.status(404);\n      res.send(e.message);\n    });\n    stream.on('end', () => {\n      res.end();\n    });\n  }\n\n  handleShutdown() {\n    if (!this._client) {\n      return Promise.resolve();\n    }\n    return this._client.close(false);\n  }\n\n  validateFilename(filename) {\n    return validateFilename(filename);\n  }\n}\n\nexport default GridFSBucketAdapter;\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Files/GridStoreAdapter.js

@@ -0,0 +1,5 @@
+"use strict";
+
+// Note: GridStore was replaced by GridFSBucketAdapter by default in 2018 by @flovilmart
+throw new Error('GridStoreAdapter: GridStore is no longer supported by parse server and mongodb, use GridFSBucketAdapter instead.');
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJFcnJvciJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9GaWxlcy9HcmlkU3RvcmVBZGFwdGVyLmpzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIE5vdGU6IEdyaWRTdG9yZSB3YXMgcmVwbGFjZWQgYnkgR3JpZEZTQnVja2V0QWRhcHRlciBieSBkZWZhdWx0IGluIDIwMTggYnkgQGZsb3ZpbG1hcnRcbnRocm93IG5ldyBFcnJvcihcbiAgJ0dyaWRTdG9yZUFkYXB0ZXI6IEdyaWRTdG9yZSBpcyBubyBsb25nZXIgc3VwcG9ydGVkIGJ5IHBhcnNlIHNlcnZlciBhbmQgbW9uZ29kYiwgdXNlIEdyaWRGU0J1Y2tldEFkYXB0ZXIgaW5zdGVhZC4nXG4pO1xuIl0sIm1hcHBpbmdzIjoiOztBQUFBO0FBQ0EsTUFBTSxJQUFJQSxLQUFLLENBQ2Isa0hBQ0YsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

package/lib/Adapters/Logger/LoggerAdapter.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.LoggerAdapter = void 0;
+/* eslint-disable unused-imports/no-unused-vars */
+/**
+ * @interface
+ * @memberof module:Adapters
+ * Logger Adapter
+ * Allows you to change the logger mechanism
+ * Default is WinstonLoggerAdapter.js
+ */
+class LoggerAdapter {
+  constructor(options) {}
+  /**
+   * log
+   * @param {String} level
+   * @param {String} message
+   * @param {Object} metadata
+   */
+  log(level, message /* meta */) {}
+}
+exports.LoggerAdapter = LoggerAdapter;
+var _default = exports.default = LoggerAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJMb2dnZXJBZGFwdGVyIiwiY29uc3RydWN0b3IiLCJvcHRpb25zIiwibG9nIiwibGV2ZWwiLCJtZXNzYWdlIiwiZXhwb3J0cyIsIl9kZWZhdWx0IiwiZGVmYXVsdCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9Mb2dnZXIvTG9nZ2VyQWRhcHRlci5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSB1bnVzZWQtaW1wb3J0cy9uby11bnVzZWQtdmFycyAqL1xuLyoqXG4gKiBAaW50ZXJmYWNlXG4gKiBAbWVtYmVyb2YgbW9kdWxlOkFkYXB0ZXJzXG4gKiBMb2dnZXIgQWRhcHRlclxuICogQWxsb3dzIHlvdSB0byBjaGFuZ2UgdGhlIGxvZ2dlciBtZWNoYW5pc21cbiAqIERlZmF1bHQgaXMgV2luc3RvbkxvZ2dlckFkYXB0ZXIuanNcbiAqL1xuZXhwb3J0IGNsYXNzIExvZ2dlckFkYXB0ZXIge1xuICBjb25zdHJ1Y3RvcihvcHRpb25zKSB7fVxuICAvKipcbiAgICogbG9nXG4gICAqIEBwYXJhbSB7U3RyaW5nfSBsZXZlbFxuICAgKiBAcGFyYW0ge1N0cmluZ30gbWVzc2FnZVxuICAgKiBAcGFyYW0ge09iamVjdH0gbWV0YWRhdGFcbiAgICovXG4gIGxvZyhsZXZlbCwgbWVzc2FnZSAvKiBtZXRhICovKSB7fVxufVxuXG5leHBvcnQgZGVmYXVsdCBMb2dnZXJBZGFwdGVyO1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ08sTUFBTUEsYUFBYSxDQUFDO0VBQ3pCQyxXQUFXQSxDQUFDQyxPQUFPLEVBQUUsQ0FBQztFQUN0QjtBQUNGO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7RUFDRUMsR0FBR0EsQ0FBQ0MsS0FBSyxFQUFFQyxPQUFPLENBQUMsWUFBWSxDQUFDO0FBQ2xDO0FBQUNDLE9BQUEsQ0FBQU4sYUFBQSxHQUFBQSxhQUFBO0FBQUEsSUFBQU8sUUFBQSxHQUFBRCxPQUFBLENBQUFFLE9BQUEsR0FFY1IsYUFBYSIsImlnbm9yZUxpc3QiOltdfQ==