@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Controllers/index.js

@@ -0,0 +1,251 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAnalyticsController = getAnalyticsController;
+exports.getAuthDataManager = getAuthDataManager;
+exports.getCacheController = getCacheController;
+exports.getControllers = getControllers;
+exports.getDatabaseAdapter = getDatabaseAdapter;
+exports.getDatabaseController = getDatabaseController;
+exports.getFilesController = getFilesController;
+exports.getHooksController = getHooksController;
+exports.getLiveQueryController = getLiveQueryController;
+exports.getLoggerController = getLoggerController;
+exports.getParseGraphQLController = getParseGraphQLController;
+exports.getPushController = getPushController;
+exports.getUserController = getUserController;
+var _Auth = _interopRequireDefault(require("../Adapters/Auth"));
+var _Options = require("../Options");
+var _AdapterLoader = require("../Adapters/AdapterLoader");
+var _defaults = _interopRequireDefault(require("../defaults"));
+var _LoggerController = require("./LoggerController");
+var _FilesController = require("./FilesController");
+var _HooksController = require("./HooksController");
+var _UserController = require("./UserController");
+var _CacheController = require("./CacheController");
+var _LiveQueryController = require("./LiveQueryController");
+var _AnalyticsController = require("./AnalyticsController");
+var _PushController = require("./PushController");
+var _PushQueue = require("../Push/PushQueue");
+var _PushWorker = require("../Push/PushWorker");
+var _DatabaseController = _interopRequireDefault(require("./DatabaseController"));
+var _GridFSBucketAdapter = require("../Adapters/Files/GridFSBucketAdapter");
+var _WinstonLoggerAdapter = require("../Adapters/Logger/WinstonLoggerAdapter");
+var _InMemoryCacheAdapter = require("../Adapters/Cache/InMemoryCacheAdapter");
+var _AnalyticsAdapter = require("../Adapters/Analytics/AnalyticsAdapter");
+var _MongoStorageAdapter = _interopRequireDefault(require("../Adapters/Storage/Mongo/MongoStorageAdapter"));
+var _PostgresStorageAdapter = _interopRequireDefault(require("../Adapters/Storage/Postgres/PostgresStorageAdapter"));
+var _ParseGraphQLController = _interopRequireDefault(require("./ParseGraphQLController"));
+var _SchemaCache = _interopRequireDefault(require("../Adapters/Cache/SchemaCache"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Controllers
+
+// Adapters
+
+function getControllers(options) {
+  const loggerController = getLoggerController(options);
+  const filesController = getFilesController(options);
+  const userController = getUserController(options);
+  const cacheController = getCacheController(options);
+  const analyticsController = getAnalyticsController(options);
+  const liveQueryController = getLiveQueryController(options);
+  const databaseController = getDatabaseController(options);
+  const hooksController = getHooksController(options, databaseController);
+  const authDataManager = getAuthDataManager(options);
+  const parseGraphQLController = getParseGraphQLController(options, {
+    databaseController,
+    cacheController
+  });
+  return {
+    loggerController,
+    filesController,
+    userController,
+    analyticsController,
+    cacheController,
+    parseGraphQLController,
+    liveQueryController,
+    databaseController,
+    hooksController,
+    authDataManager,
+    schemaCache: _SchemaCache.default
+  };
+}
+function getLoggerController(options) {
+  const {
+    appId,
+    jsonLogs,
+    logsFolder,
+    verbose,
+    logLevel,
+    logStringTruncateLength,
+    maxLogFiles,
+    silent,
+    loggerAdapter
+  } = options;
+  const loggerOptions = {
+    jsonLogs,
+    logsFolder,
+    verbose,
+    logLevel,
+    logStringTruncateLength,
+    silent,
+    maxLogFiles
+  };
+  const loggerControllerAdapter = (0, _AdapterLoader.loadAdapter)(loggerAdapter, _WinstonLoggerAdapter.WinstonLoggerAdapter, loggerOptions);
+  return new _LoggerController.LoggerController(loggerControllerAdapter, appId, loggerOptions);
+}
+function getFilesController(options) {
+  const {
+    appId,
+    databaseURI,
+    databaseOptions = {},
+    filesAdapter,
+    databaseAdapter,
+    preserveFileName,
+    fileKey
+  } = options;
+  if (!filesAdapter && databaseAdapter) {
+    throw 'When using an explicit database adapter, you must also use an explicit filesAdapter.';
+  }
+  const filesControllerAdapter = (0, _AdapterLoader.loadAdapter)(filesAdapter, () => {
+    return new _GridFSBucketAdapter.GridFSBucketAdapter(databaseURI, databaseOptions, fileKey);
+  });
+  return new _FilesController.FilesController(filesControllerAdapter, appId, {
+    preserveFileName
+  });
+}
+function getUserController(options) {
+  const {
+    appId,
+    emailAdapter,
+    verifyUserEmails
+  } = options;
+  const emailControllerAdapter = (0, _AdapterLoader.loadAdapter)(emailAdapter);
+  return new _UserController.UserController(emailControllerAdapter, appId, {
+    verifyUserEmails
+  });
+}
+function getCacheController(options) {
+  const {
+    appId,
+    cacheAdapter,
+    cacheTTL,
+    cacheMaxSize
+  } = options;
+  const cacheControllerAdapter = (0, _AdapterLoader.loadAdapter)(cacheAdapter, _InMemoryCacheAdapter.InMemoryCacheAdapter, {
+    appId: appId,
+    ttl: cacheTTL,
+    maxSize: cacheMaxSize
+  });
+  return new _CacheController.CacheController(cacheControllerAdapter, appId);
+}
+function getParseGraphQLController(options, controllerDeps) {
+  return new _ParseGraphQLController.default({
+    mountGraphQL: options.mountGraphQL,
+    ...controllerDeps
+  });
+}
+function getAnalyticsController(options) {
+  const {
+    analyticsAdapter
+  } = options;
+  const analyticsControllerAdapter = (0, _AdapterLoader.loadAdapter)(analyticsAdapter, _AnalyticsAdapter.AnalyticsAdapter);
+  return new _AnalyticsController.AnalyticsController(analyticsControllerAdapter);
+}
+function getLiveQueryController(options) {
+  return new _LiveQueryController.LiveQueryController(options.liveQuery);
+}
+function getDatabaseController(options) {
+  const {
+    databaseURI,
+    collectionPrefix,
+    databaseOptions
+  } = options;
+  let {
+    databaseAdapter
+  } = options;
+  if ((databaseOptions || databaseURI && databaseURI !== _defaults.default.databaseURI || collectionPrefix !== _defaults.default.collectionPrefix) && databaseAdapter) {
+    throw 'You cannot specify both a databaseAdapter and a databaseURI/databaseOptions/collectionPrefix.';
+  } else if (!databaseAdapter) {
+    databaseAdapter = getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions);
+  } else {
+    databaseAdapter = (0, _AdapterLoader.loadAdapter)(databaseAdapter);
+  }
+  return new _DatabaseController.default(databaseAdapter, options);
+}
+function getHooksController(options, databaseController) {
+  const {
+    appId,
+    webhookKey
+  } = options;
+  return new _HooksController.HooksController(appId, databaseController, webhookKey);
+}
+async function getPushController(options) {
+  const {
+    scheduledPush,
+    push
+  } = options;
+  const pushOptions = Object.assign({}, push);
+  const pushQueueOptions = pushOptions.queueOptions || {};
+  if (pushOptions.queueOptions) {
+    delete pushOptions.queueOptions;
+  }
+
+  // Pass the push options too as it works with the default
+  const ParsePushAdapter = await (0, _AdapterLoader.loadModule)('@parse/push-adapter');
+  const pushAdapter = (0, _AdapterLoader.loadAdapter)(pushOptions && pushOptions.adapter, ParsePushAdapter, pushOptions);
+  // We pass the options and the base class for the adatper,
+  // Note that passing an instance would work too
+  const pushController = new _PushController.PushController();
+  const hasPushSupport = !!(pushAdapter && push);
+  const hasPushScheduledSupport = hasPushSupport && scheduledPush === true;
+  const {
+    disablePushWorker
+  } = pushQueueOptions;
+  const pushControllerQueue = new _PushQueue.PushQueue(pushQueueOptions);
+  let pushWorker;
+  if (!disablePushWorker) {
+    pushWorker = new _PushWorker.PushWorker(pushAdapter, pushQueueOptions);
+  }
+  return {
+    pushController,
+    hasPushSupport,
+    hasPushScheduledSupport,
+    pushControllerQueue,
+    pushWorker
+  };
+}
+function getAuthDataManager(options) {
+  const {
+    auth,
+    enableAnonymousUsers
+  } = options;
+  return (0, _Auth.default)(auth, enableAnonymousUsers);
+}
+function getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions) {
+  let protocol;
+  try {
+    const parsedURI = new URL(databaseURI);
+    protocol = parsedURI.protocol ? parsedURI.protocol.toLowerCase() : null;
+  } catch {
+    /* */
+  }
+  switch (protocol) {
+    case 'postgres:':
+    case 'postgresql:':
+      return new _PostgresStorageAdapter.default({
+        uri: databaseURI,
+        collectionPrefix,
+        databaseOptions
+      });
+    default:
+      return new _MongoStorageAdapter.default({
+        uri: databaseURI,
+        collectionPrefix,
+        mongoOptions: databaseOptions
+      });
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_Auth","_interopRequireDefault","require","_Options","_AdapterLoader","_defaults","_LoggerController","_FilesController","_HooksController","_UserController","_CacheController","_LiveQueryController","_AnalyticsController","_PushController","_PushQueue","_PushWorker","_DatabaseController","_GridFSBucketAdapter","_WinstonLoggerAdapter","_InMemoryCacheAdapter","_AnalyticsAdapter","_MongoStorageAdapter","_PostgresStorageAdapter","_ParseGraphQLController","_SchemaCache","e","__esModule","default","getControllers","options","loggerController","getLoggerController","filesController","getFilesController","userController","getUserController","cacheController","getCacheController","analyticsController","getAnalyticsController","liveQueryController","getLiveQueryController","databaseController","getDatabaseController","hooksController","getHooksController","authDataManager","getAuthDataManager","parseGraphQLController","getParseGraphQLController","schemaCache","SchemaCache","appId","jsonLogs","logsFolder","verbose","logLevel","logStringTruncateLength","maxLogFiles","silent","loggerAdapter","loggerOptions","loggerControllerAdapter","loadAdapter","WinstonLoggerAdapter","LoggerController","databaseURI","databaseOptions","filesAdapter","databaseAdapter","preserveFileName","fileKey","filesControllerAdapter","GridFSBucketAdapter","FilesController","emailAdapter","verifyUserEmails","emailControllerAdapter","UserController","cacheAdapter","cacheTTL","cacheMaxSize","cacheControllerAdapter","InMemoryCacheAdapter","ttl","maxSize","CacheController","controllerDeps","ParseGraphQLController","mountGraphQL","analyticsAdapter","analyticsControllerAdapter","AnalyticsAdapter","AnalyticsController","LiveQueryController","liveQuery","collectionPrefix","defaults","getDatabaseAdapter","DatabaseController","webhookKey","HooksController","getPushController","scheduledPush","push","pushOptions","Object","assign","pushQueueOptions","queueOptions","ParsePushAdapter","loadModule","pushAdapter","adapter","pushController","PushController","hasPushSupport","hasPushScheduledSupport","disablePushWorker","pushControllerQueue","PushQueue","pushWorker","PushWorker","auth","enableAnonymousUsers","protocol","parsedURI","URL","toLowerCase","PostgresStorageAdapter","uri","MongoStorageAdapter","mongoOptions"],"sources":["../../src/Controllers/index.js"],"sourcesContent":["import authDataManager from '../Adapters/Auth';\nimport { ParseServerOptions } from '../Options';\nimport { loadAdapter, loadModule } from '../Adapters/AdapterLoader';\nimport defaults from '../defaults';\n// Controllers\nimport { LoggerController } from './LoggerController';\nimport { FilesController } from './FilesController';\nimport { HooksController } from './HooksController';\nimport { UserController } from './UserController';\nimport { CacheController } from './CacheController';\nimport { LiveQueryController } from './LiveQueryController';\nimport { AnalyticsController } from './AnalyticsController';\nimport { PushController } from './PushController';\nimport { PushQueue } from '../Push/PushQueue';\nimport { PushWorker } from '../Push/PushWorker';\nimport DatabaseController from './DatabaseController';\n\n// Adapters\nimport { GridFSBucketAdapter } from '../Adapters/Files/GridFSBucketAdapter';\nimport { WinstonLoggerAdapter } from '../Adapters/Logger/WinstonLoggerAdapter';\nimport { InMemoryCacheAdapter } from '../Adapters/Cache/InMemoryCacheAdapter';\nimport { AnalyticsAdapter } from '../Adapters/Analytics/AnalyticsAdapter';\nimport MongoStorageAdapter from '../Adapters/Storage/Mongo/MongoStorageAdapter';\nimport PostgresStorageAdapter from '../Adapters/Storage/Postgres/PostgresStorageAdapter';\nimport ParseGraphQLController from './ParseGraphQLController';\nimport SchemaCache from '../Adapters/Cache/SchemaCache';\n\nexport function getControllers(options: ParseServerOptions) {\n  const loggerController = getLoggerController(options);\n  const filesController = getFilesController(options);\n  const userController = getUserController(options);\n  const cacheController = getCacheController(options);\n  const analyticsController = getAnalyticsController(options);\n  const liveQueryController = getLiveQueryController(options);\n  const databaseController = getDatabaseController(options);\n  const hooksController = getHooksController(options, databaseController);\n  const authDataManager = getAuthDataManager(options);\n  const parseGraphQLController = getParseGraphQLController(options, {\n    databaseController,\n    cacheController,\n  });\n  return {\n    loggerController,\n    filesController,\n    userController,\n    analyticsController,\n    cacheController,\n    parseGraphQLController,\n    liveQueryController,\n    databaseController,\n    hooksController,\n    authDataManager,\n    schemaCache: SchemaCache,\n  };\n}\n\nexport function getLoggerController(options: ParseServerOptions): LoggerController {\n  const {\n    appId,\n    jsonLogs,\n    logsFolder,\n    verbose,\n    logLevel,\n    logStringTruncateLength,\n    maxLogFiles,\n    silent,\n    loggerAdapter,\n  } = options;\n  const loggerOptions = {\n    jsonLogs,\n    logsFolder,\n    verbose,\n    logLevel,\n    logStringTruncateLength,\n    silent,\n    maxLogFiles,\n  };\n  const loggerControllerAdapter = loadAdapter(loggerAdapter, WinstonLoggerAdapter, loggerOptions);\n  return new LoggerController(loggerControllerAdapter, appId, loggerOptions);\n}\n\nexport function getFilesController(options: ParseServerOptions): FilesController {\n  const {\n    appId,\n    databaseURI,\n    databaseOptions = {},\n    filesAdapter,\n    databaseAdapter,\n    preserveFileName,\n    fileKey,\n  } = options;\n  if (!filesAdapter && databaseAdapter) {\n    throw 'When using an explicit database adapter, you must also use an explicit filesAdapter.';\n  }\n  const filesControllerAdapter = loadAdapter(filesAdapter, () => {\n    return new GridFSBucketAdapter(databaseURI, databaseOptions, fileKey);\n  });\n  return new FilesController(filesControllerAdapter, appId, {\n    preserveFileName,\n  });\n}\n\nexport function getUserController(options: ParseServerOptions): UserController {\n  const { appId, emailAdapter, verifyUserEmails } = options;\n  const emailControllerAdapter = loadAdapter(emailAdapter);\n  return new UserController(emailControllerAdapter, appId, {\n    verifyUserEmails,\n  });\n}\n\nexport function getCacheController(options: ParseServerOptions): CacheController {\n  const { appId, cacheAdapter, cacheTTL, cacheMaxSize } = options;\n  const cacheControllerAdapter = loadAdapter(cacheAdapter, InMemoryCacheAdapter, {\n    appId: appId,\n    ttl: cacheTTL,\n    maxSize: cacheMaxSize,\n  });\n  return new CacheController(cacheControllerAdapter, appId);\n}\n\nexport function getParseGraphQLController(\n  options: ParseServerOptions,\n  controllerDeps\n): ParseGraphQLController {\n  return new ParseGraphQLController({\n    mountGraphQL: options.mountGraphQL,\n    ...controllerDeps,\n  });\n}\n\nexport function getAnalyticsController(options: ParseServerOptions): AnalyticsController {\n  const { analyticsAdapter } = options;\n  const analyticsControllerAdapter = loadAdapter(analyticsAdapter, AnalyticsAdapter);\n  return new AnalyticsController(analyticsControllerAdapter);\n}\n\nexport function getLiveQueryController(options: ParseServerOptions): LiveQueryController {\n  return new LiveQueryController(options.liveQuery);\n}\n\nexport function getDatabaseController(options: ParseServerOptions): DatabaseController {\n  const { databaseURI, collectionPrefix, databaseOptions } = options;\n  let { databaseAdapter } = options;\n  if (\n    (databaseOptions ||\n      (databaseURI && databaseURI !== defaults.databaseURI) ||\n      collectionPrefix !== defaults.collectionPrefix) &&\n    databaseAdapter\n  ) {\n    throw 'You cannot specify both a databaseAdapter and a databaseURI/databaseOptions/collectionPrefix.';\n  } else if (!databaseAdapter) {\n    databaseAdapter = getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions);\n  } else {\n    databaseAdapter = loadAdapter(databaseAdapter);\n  }\n  return new DatabaseController(databaseAdapter, options);\n}\n\nexport function getHooksController(\n  options: ParseServerOptions,\n  databaseController: DatabaseController\n): HooksController {\n  const { appId, webhookKey } = options;\n  return new HooksController(appId, databaseController, webhookKey);\n}\n\ninterface PushControlling {\n  pushController: PushController;\n  hasPushScheduledSupport: boolean;\n  pushControllerQueue: PushQueue;\n  pushWorker: PushWorker;\n}\n\nexport async function getPushController(options: ParseServerOptions): PushControlling {\n  const { scheduledPush, push } = options;\n\n  const pushOptions = Object.assign({}, push);\n  const pushQueueOptions = pushOptions.queueOptions || {};\n  if (pushOptions.queueOptions) {\n    delete pushOptions.queueOptions;\n  }\n\n  // Pass the push options too as it works with the default\n  const ParsePushAdapter = await loadModule('@parse/push-adapter');\n  const pushAdapter = loadAdapter(\n    pushOptions && pushOptions.adapter,\n    ParsePushAdapter,\n    pushOptions\n  );\n  // We pass the options and the base class for the adatper,\n  // Note that passing an instance would work too\n  const pushController = new PushController();\n  const hasPushSupport = !!(pushAdapter && push);\n  const hasPushScheduledSupport = hasPushSupport && scheduledPush === true;\n\n  const { disablePushWorker } = pushQueueOptions;\n\n  const pushControllerQueue = new PushQueue(pushQueueOptions);\n  let pushWorker;\n  if (!disablePushWorker) {\n    pushWorker = new PushWorker(pushAdapter, pushQueueOptions);\n  }\n  return {\n    pushController,\n    hasPushSupport,\n    hasPushScheduledSupport,\n    pushControllerQueue,\n    pushWorker,\n  };\n}\n\nexport function getAuthDataManager(options: ParseServerOptions) {\n  const { auth, enableAnonymousUsers } = options;\n  return authDataManager(auth, enableAnonymousUsers);\n}\n\nexport function getDatabaseAdapter(databaseURI, collectionPrefix, databaseOptions) {\n  let protocol;\n  try {\n    const parsedURI = new URL(databaseURI);\n    protocol = parsedURI.protocol ? parsedURI.protocol.toLowerCase() : null;\n  } catch {\n    /* */\n  }\n  switch (protocol) {\n    case 'postgres:':\n    case 'postgresql:':\n      return new PostgresStorageAdapter({\n        uri: databaseURI,\n        collectionPrefix,\n        databaseOptions,\n      });\n    default:\n      return new MongoStorageAdapter({\n        uri: databaseURI,\n        collectionPrefix,\n        mongoOptions: databaseOptions,\n      });\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/Controllers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL0NvbnRyb2xsZXJzL3R5cGVzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIExvYWRTY2hlbWFPcHRpb25zID0ge1xuICBjbGVhckNhY2hlOiBib29sZWFuLFxufTtcblxuZXhwb3J0IHR5cGUgU2NoZW1hRmllbGQgPSB7XG4gIHR5cGU6IHN0cmluZyxcbiAgdGFyZ2V0Q2xhc3M/OiA/c3RyaW5nLFxuICByZXF1aXJlZD86ID9ib29sZWFuLFxuICBkZWZhdWx0VmFsdWU/OiA/YW55LFxufTtcblxuZXhwb3J0IHR5cGUgU2NoZW1hRmllbGRzID0geyBbc3RyaW5nXTogU2NoZW1hRmllbGQgfTtcblxuZXhwb3J0IHR5cGUgU2NoZW1hID0ge1xuICBjbGFzc05hbWU6IHN0cmluZyxcbiAgZmllbGRzOiBTY2hlbWFGaWVsZHMsXG4gIGNsYXNzTGV2ZWxQZXJtaXNzaW9uczogQ2xhc3NMZXZlbFBlcm1pc3Npb25zLFxuICBpbmRleGVzPzogP2FueSxcbn07XG5cbmV4cG9ydCB0eXBlIENsYXNzTGV2ZWxQZXJtaXNzaW9ucyA9IHtcbiAgQUNMPzoge1xuICAgIFtzdHJpbmddOiB7XG4gICAgICBbc3RyaW5nXTogYm9vbGVhbixcbiAgICB9LFxuICB9LFxuICBmaW5kPzogeyBbc3RyaW5nXTogYm9vbGVhbiB9LFxuICBjb3VudD86IHsgW3N0cmluZ106IGJvb2xlYW4gfSxcbiAgZ2V0PzogeyBbc3RyaW5nXTogYm9vbGVhbiB9LFxuICBjcmVhdGU/OiB7IFtzdHJpbmddOiBib29sZWFuIH0sXG4gIHVwZGF0ZT86IHsgW3N0cmluZ106IGJvb2xlYW4gfSxcbiAgZGVsZXRlPzogeyBbc3RyaW5nXTogYm9vbGVhbiB9LFxuICBhZGRGaWVsZD86IHsgW3N0cmluZ106IGJvb2xlYW4gfSxcbiAgcmVhZFVzZXJGaWVsZHM/OiBzdHJpbmdbXSxcbiAgd3JpdGVVc2VyRmllbGRzPzogc3RyaW5nW10sXG4gIHByb3RlY3RlZEZpZWxkcz86IHsgW3N0cmluZ106IHN0cmluZ1tdIH0sXG59O1xuIl0sIm1hcHBpbmdzIjoiIiwiaWdub3JlTGlzdCI6W119

package/lib/Deprecator/Deprecations.js

@@ -0,0 +1,100 @@
+"use strict";
+
+/**
+ * The deprecations.
+ *
+ * Add deprecations to the array using the following keys:
+ * - `optionKey` {String}: The option key incl. its path, e.g. `security.enableCheck`.
+ * - `envKey` {String}: The environment key, e.g. `PARSE_SERVER_SECURITY`.
+ * - `changeNewKey` {String}: Set the new key name if the current key will be replaced,
+ * or set to an empty string if the current key will be removed without replacement.
+ * - `changeNewDefault` {String}: Set the new default value if the key's default value
+ * will change in a future version.
+ * - `resolvedValue` {any}: The option value that suppresses the deprecation warning,
+ * indicating the user has already adopted the future behavior. Only applicable when
+ * `changeNewKey` is an empty string (option will be removed without replacement).
+ * For example, `false` for an option that will be removed, if setting it to `false`
+ * disables the deprecated feature.
+ * - `solution`: The instruction to resolve this deprecation warning. Optional. This
+ * instruction must not include the deprecation warning which is auto-generated.
+ * It should only contain additional instruction regarding the deprecation if
+ * necessary.
+ *
+ * If there are no deprecations, this must return an empty array.
+ */
+module.exports = [{
+  optionKey: 'fileUpload.allowedFileUrlDomains',
+  changeNewDefault: '[]',
+  solution: "Set 'fileUpload.allowedFileUrlDomains' to the domains you want to allow, or to '[]' to block all file URLs."
+}, {
+  optionKey: 'pages.encodePageParamHeaders',
+  changeNewDefault: 'true',
+  solution: "Set 'pages.encodePageParamHeaders' to 'true' to URI-encode non-ASCII characters in page parameter headers."
+}, {
+  optionKey: 'readOnlyMasterKeyIps',
+  changeNewDefault: '["127.0.0.1", "::1"]',
+  solution: "Set 'readOnlyMasterKeyIps' to the IP addresses that should be allowed to use the read-only master key, or to '[\"127.0.0.1\", \"::1\"]' to restrict access to localhost."
+}, {
+  optionKey: 'mountPlayground',
+  changeNewKey: '',
+  solution: "Use Parse Dashboard as GraphQL IDE or configure a third-party GraphQL client such as Apollo Sandbox, GraphiQL, or Insomnia with custom request headers."
+}, {
+  optionKey: 'playgroundPath',
+  changeNewKey: '',
+  solution: "Use Parse Dashboard as GraphQL IDE or configure a third-party GraphQL client such as Apollo Sandbox, GraphiQL, or Insomnia with custom request headers."
+}, {
+  optionKey: 'requestComplexity.includeDepth',
+  changeNewDefault: '10',
+  solution: "Set 'requestComplexity.includeDepth' to a positive integer appropriate for your app to limit include pointer chain depth, or to '-1' to disable."
+}, {
+  optionKey: 'requestComplexity.includeCount',
+  changeNewDefault: '100',
+  solution: "Set 'requestComplexity.includeCount' to a positive integer appropriate for your app to limit the number of include paths per query, or to '-1' to disable."
+}, {
+  optionKey: 'requestComplexity.subqueryDepth',
+  changeNewDefault: '10',
+  solution: "Set 'requestComplexity.subqueryDepth' to a positive integer appropriate for your app to limit subquery nesting depth, or to '-1' to disable."
+}, {
+  optionKey: 'requestComplexity.queryDepth',
+  changeNewDefault: '10',
+  solution: "Set 'requestComplexity.queryDepth' to a positive integer appropriate for your app to limit query condition nesting depth, or to '-1' to disable."
+}, {
+  optionKey: 'requestComplexity.graphQLDepth',
+  changeNewDefault: '20',
+  solution: "Set 'requestComplexity.graphQLDepth' to a positive integer appropriate for your app to limit GraphQL field selection depth, or to '-1' to disable."
+}, {
+  optionKey: 'requestComplexity.graphQLFields',
+  changeNewDefault: '200',
+  solution: "Set 'requestComplexity.graphQLFields' to a positive integer appropriate for your app to limit the number of GraphQL field selections, or to '-1' to disable."
+}, {
+  optionKey: 'requestComplexity.batchRequestLimit',
+  changeNewDefault: '100',
+  solution: "Set 'requestComplexity.batchRequestLimit' to a positive integer appropriate for your app to limit the number of sub-requests per batch request, or to '-1' to disable."
+}, {
+  optionKey: 'enableProductPurchaseLegacyApi',
+  changeNewKey: '',
+  resolvedValue: false,
+  solution: "The product purchase API is an undocumented, unmaintained legacy feature that may not function as expected and will be removed in a future major version. We strongly advise against using it. Set 'enableProductPurchaseLegacyApi' to 'false' to disable it, or remove the option to accept the future removal."
+}, {
+  optionKey: 'allowExpiredAuthDataToken',
+  changeNewKey: '',
+  resolvedValue: false,
+  solution: "Auth providers are always validated on login regardless of this setting. Set 'allowExpiredAuthDataToken' to 'false' or remove the option to accept the future removal."
+}, {
+  optionKey: 'protectedFieldsOwnerExempt',
+  changeNewDefault: 'false',
+  solution: "Set 'protectedFieldsOwnerExempt' to 'false' to apply protectedFields consistently to the user's own _User object (same as all other classes), or to 'true' to keep the current behavior where a user can see all their own fields."
+}, {
+  optionKey: 'protectedFieldsTriggerExempt',
+  changeNewDefault: 'true',
+  solution: "Set 'protectedFieldsTriggerExempt' to 'true' to make Cloud Code triggers (e.g. beforeSave, afterSave) receive the full object including protected fields, or to 'false' to keep the current behavior where protected fields are stripped from trigger objects."
+}, {
+  optionKey: 'protectedFieldsSaveResponseExempt',
+  changeNewDefault: 'false',
+  solution: "Set 'protectedFieldsSaveResponseExempt' to 'false' to strip protected fields from write operation responses (create, update), consistent with how they are stripped from query results. Set to 'true' to keep the current behavior where protected fields are included in write responses."
+}, {
+  optionKey: 'installation.duplicateDeviceTokenActionEnforceAuth',
+  changeNewDefault: 'true',
+  solution: "Set 'installation.duplicateDeviceTokenActionEnforceAuth' to 'true' to enforce the caller's auth context (and the resulting ACL and CLP) when Parse Server deduplicates _Installation records sharing the same deviceToken. Set to 'false' to keep the current behavior of bypassing permissions on the dedup operation."
+}];
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["module","exports","optionKey","changeNewDefault","solution","changeNewKey","resolvedValue"],"sources":["../../src/Deprecator/Deprecations.js"],"sourcesContent":["/**\n * The deprecations.\n *\n * Add deprecations to the array using the following keys:\n * - `optionKey` {String}: The option key incl. its path, e.g. `security.enableCheck`.\n * - `envKey` {String}: The environment key, e.g. `PARSE_SERVER_SECURITY`.\n * - `changeNewKey` {String}: Set the new key name if the current key will be replaced,\n * or set to an empty string if the current key will be removed without replacement.\n * - `changeNewDefault` {String}: Set the new default value if the key's default value\n * will change in a future version.\n * - `resolvedValue` {any}: The option value that suppresses the deprecation warning,\n * indicating the user has already adopted the future behavior. Only applicable when\n * `changeNewKey` is an empty string (option will be removed without replacement).\n * For example, `false` for an option that will be removed, if setting it to `false`\n * disables the deprecated feature.\n * - `solution`: The instruction to resolve this deprecation warning. Optional. This\n * instruction must not include the deprecation warning which is auto-generated.\n * It should only contain additional instruction regarding the deprecation if\n * necessary.\n *\n * If there are no deprecations, this must return an empty array.\n */\nmodule.exports = [\n  {\n    optionKey: 'fileUpload.allowedFileUrlDomains',\n    changeNewDefault: '[]',\n    solution: \"Set 'fileUpload.allowedFileUrlDomains' to the domains you want to allow, or to '[]' to block all file URLs.\",\n  },\n  {\n    optionKey: 'pages.encodePageParamHeaders',\n    changeNewDefault: 'true',\n    solution: \"Set 'pages.encodePageParamHeaders' to 'true' to URI-encode non-ASCII characters in page parameter headers.\",\n  },\n  {\n    optionKey: 'readOnlyMasterKeyIps',\n    changeNewDefault: '[\"127.0.0.1\", \"::1\"]',\n    solution: \"Set 'readOnlyMasterKeyIps' to the IP addresses that should be allowed to use the read-only master key, or to '[\\\"127.0.0.1\\\", \\\"::1\\\"]' to restrict access to localhost.\",\n  },\n  {\n    optionKey: 'mountPlayground',\n    changeNewKey: '',\n    solution: \"Use Parse Dashboard as GraphQL IDE or configure a third-party GraphQL client such as Apollo Sandbox, GraphiQL, or Insomnia with custom request headers.\",\n  },\n  {\n    optionKey: 'playgroundPath',\n    changeNewKey: '',\n    solution: \"Use Parse Dashboard as GraphQL IDE or configure a third-party GraphQL client such as Apollo Sandbox, GraphiQL, or Insomnia with custom request headers.\",\n  },\n  {\n    optionKey: 'requestComplexity.includeDepth',\n    changeNewDefault: '10',\n    solution: \"Set 'requestComplexity.includeDepth' to a positive integer appropriate for your app to limit include pointer chain depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.includeCount',\n    changeNewDefault: '100',\n    solution: \"Set 'requestComplexity.includeCount' to a positive integer appropriate for your app to limit the number of include paths per query, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.subqueryDepth',\n    changeNewDefault: '10',\n    solution: \"Set 'requestComplexity.subqueryDepth' to a positive integer appropriate for your app to limit subquery nesting depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.queryDepth',\n    changeNewDefault: '10',\n    solution: \"Set 'requestComplexity.queryDepth' to a positive integer appropriate for your app to limit query condition nesting depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.graphQLDepth',\n    changeNewDefault: '20',\n    solution: \"Set 'requestComplexity.graphQLDepth' to a positive integer appropriate for your app to limit GraphQL field selection depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.graphQLFields',\n    changeNewDefault: '200',\n    solution: \"Set 'requestComplexity.graphQLFields' to a positive integer appropriate for your app to limit the number of GraphQL field selections, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.batchRequestLimit',\n    changeNewDefault: '100',\n    solution: \"Set 'requestComplexity.batchRequestLimit' to a positive integer appropriate for your app to limit the number of sub-requests per batch request, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'enableProductPurchaseLegacyApi',\n    changeNewKey: '',\n    resolvedValue: false,\n    solution: \"The product purchase API is an undocumented, unmaintained legacy feature that may not function as expected and will be removed in a future major version. We strongly advise against using it. Set 'enableProductPurchaseLegacyApi' to 'false' to disable it, or remove the option to accept the future removal.\",\n  },\n  {\n    optionKey: 'allowExpiredAuthDataToken',\n    changeNewKey: '',\n    resolvedValue: false,\n    solution: \"Auth providers are always validated on login regardless of this setting. Set 'allowExpiredAuthDataToken' to 'false' or remove the option to accept the future removal.\",\n  },\n  {\n    optionKey: 'protectedFieldsOwnerExempt',\n    changeNewDefault: 'false',\n    solution: \"Set 'protectedFieldsOwnerExempt' to 'false' to apply protectedFields consistently to the user's own _User object (same as all other classes), or to 'true' to keep the current behavior where a user can see all their own fields.\",\n  },\n  {\n    optionKey: 'protectedFieldsTriggerExempt',\n    changeNewDefault: 'true',\n    solution: \"Set 'protectedFieldsTriggerExempt' to 'true' to make Cloud Code triggers (e.g. beforeSave, afterSave) receive the full object including protected fields, or to 'false' to keep the current behavior where protected fields are stripped from trigger objects.\",\n  },\n  {\n    optionKey: 'protectedFieldsSaveResponseExempt',\n    changeNewDefault: 'false',\n    solution: \"Set 'protectedFieldsSaveResponseExempt' to 'false' to strip protected fields from write operation responses (create, update), consistent with how they are stripped from query results. Set to 'true' to keep the current behavior where protected fields are included in write responses.\",\n  },\n  {\n    optionKey: 'installation.duplicateDeviceTokenActionEnforceAuth',\n    changeNewDefault: 'true',\n    solution: \"Set 'installation.duplicateDeviceTokenActionEnforceAuth' to 'true' to enforce the caller's auth context (and the resulting ACL and CLP) when Parse Server deduplicates _Installation records sharing the same deviceToken. Set to 'false' to keep the current behavior of bypassing permissions on the dedup operation.\",\n  },\n];\n"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAA,MAAM,CAACC,OAAO,GAAG,CACf;EACEC,SAAS,EAAE,kCAAkC;EAC7CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,8BAA8B;EACzCC,gBAAgB,EAAE,MAAM;EACxBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,sBAAsB;EACjCC,gBAAgB,EAAE,sBAAsB;EACxCC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,iBAAiB;EAC5BG,YAAY,EAAE,EAAE;EAChBD,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gBAAgB;EAC3BG,YAAY,EAAE,EAAE;EAChBD,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CC,gBAAgB,EAAE,KAAK;EACvBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,iCAAiC;EAC5CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,8BAA8B;EACzCC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,iCAAiC;EAC5CC,gBAAgB,EAAE,KAAK;EACvBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,qCAAqC;EAChDC,gBAAgB,EAAE,KAAK;EACvBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CG,YAAY,EAAE,EAAE;EAChBC,aAAa,EAAE,KAAK;EACpBF,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,2BAA2B;EACtCG,YAAY,EAAE,EAAE;EAChBC,aAAa,EAAE,KAAK;EACpBF,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,4BAA4B;EACvCC,gBAAgB,EAAE,OAAO;EACzBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,8BAA8B;EACzCC,gBAAgB,EAAE,MAAM;EACxBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,mCAAmC;EAC9CC,gBAAgB,EAAE,OAAO;EACzBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,oDAAoD;EAC/DC,gBAAgB,EAAE,MAAM;EACxBC,QAAQ,EAAE;AACZ,CAAC,CACF","ignoreList":[]}

package/lib/Deprecator/Deprecator.js

@@ -0,0 +1,140 @@
+"use strict";
+
+var _logger = _interopRequireDefault(require("../logger"));
+var _Deprecations = _interopRequireDefault(require("./Deprecations"));
+var _Utils = _interopRequireDefault(require("../Utils"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * The deprecator class.
+ */
+class Deprecator {
+  /**
+   * Scans the Parse Server for deprecated options.
+   * This needs to be called before setting option defaults, otherwise it
+   * becomes indistinguishable whether an option has been set manually or
+   * by default.
+   * @param {any} options The Parse Server options.
+   */
+  static scanParseServerOptions(options) {
+    // Scan for deprecations
+    for (const deprecation of Deprecator._getDeprecations()) {
+      // Get deprecation properties
+      const solution = deprecation.solution;
+      const optionKey = deprecation.optionKey;
+      const changeNewDefault = deprecation.changeNewDefault;
+      const changeNewKey = deprecation.changeNewKey;
+
+      // If default will change, only throw a warning if option is not set
+      if (changeNewDefault != null && _Utils.default.getNestedProperty(options, optionKey) == null) {
+        Deprecator._logOption({
+          optionKey,
+          changeNewDefault,
+          solution
+        });
+      }
+
+      // If key will be removed or renamed, only throw a warning if option is set;
+      // skip if option is set to the resolved value that suppresses the deprecation
+      const resolvedValue = deprecation.resolvedValue;
+      const optionValue = _Utils.default.getNestedProperty(options, optionKey);
+      if (changeNewKey != null && optionValue != null && optionValue !== resolvedValue) {
+        Deprecator._logOption({
+          optionKey,
+          changeNewKey,
+          solution
+        });
+      }
+    }
+  }
+
+  /**
+   * Logs a deprecation warning for a parameter that can only be determined dynamically
+   * during runtime.
+   *
+   * Note: Do not use this to log deprecations of Parse Server options, but add such
+   * deprecations to `Deprecations.js` instead. See the contribution docs for more
+   * details.
+   *
+   * For consistency, the deprecation warning is composed of the following parts:
+   *
+   * > DeprecationWarning: `usage` is deprecated and will be removed in a future version.
+   * `solution`.
+   *
+   * - `usage`: The deprecated usage.
+   * - `solution`: The instruction to resolve this deprecation warning.
+   *
+   * For example:
+   * > DeprecationWarning: `Prefixing field names with dollar sign ($) in aggregation query`
+   * is deprecated and will be removed in a future version. `Reference field names without
+   * dollar sign prefix.`
+   *
+   * @param {Object} options The deprecation options.
+   * @param {String} options.usage The usage that is deprecated.
+   * @param {String} [options.solution] The instruction to resolve this deprecation warning.
+   * Optional. It is recommended to add an instruction for the convenience of the developer.
+   */
+  static logRuntimeDeprecation(options) {
+    Deprecator._logGeneric(options);
+  }
+
+  /**
+   * Returns the deprecation definitions.
+   * @returns {Array<Object>} The deprecations.
+   */
+  static _getDeprecations() {
+    return _Deprecations.default;
+  }
+
+  /**
+   * Logs a generic deprecation warning.
+   *
+   * @param {Object} options The deprecation options.
+   * @param {String} options.usage The usage that is deprecated.
+   * @param {String} [options.solution] The instruction to resolve this deprecation warning.
+   * Optional. It is recommended to add an instruction for the convenience of the developer.
+   */
+  static _logGeneric({
+    usage,
+    solution
+  }) {
+    // Compose message
+    let output = `DeprecationWarning: ${usage} is deprecated and will be removed in a future version.`;
+    output += solution ? ` ${solution}` : '';
+    _logger.default.warn(output);
+  }
+
+  /**
+   * Logs a deprecation warning for a Parse Server option.
+   *
+   * @param {String} optionKey The option key incl. its path, e.g. `security.enableCheck`.
+   * @param {String} envKey The environment key, e.g. `PARSE_SERVER_SECURITY`.
+   * @param {String} changeNewKey Set the new key name if the current key will be replaced,
+   * or set to an empty string if the current key will be removed without replacement.
+   * @param {String} changeNewDefault Set the new default value if the key's default value
+   * will change in a future version.
+   * @param {String} [solution] The instruction to resolve this deprecation warning. This
+   * message must not include the warning that the parameter is deprecated, that is
+   * automatically added to the message. It should only contain the instruction on how
+   * to resolve this warning.
+   */
+  static _logOption({
+    optionKey,
+    envKey,
+    changeNewKey,
+    changeNewDefault,
+    solution
+  }) {
+    const type = optionKey ? 'option' : 'environment key';
+    const key = optionKey ? optionKey : envKey;
+    const keyAction = changeNewKey == null ? undefined : changeNewKey.length > 0 ? `renamed to '${changeNewKey}'` : `removed`;
+
+    // Compose message
+    let output = `DeprecationWarning: The Parse Server ${type} '${key}' `;
+    output += changeNewKey != null ? `is deprecated and will be ${keyAction} in a future version.` : '';
+    output += changeNewDefault ? `default will change to '${changeNewDefault}' in a future version.` : '';
+    output += solution ? ` ${solution}` : '';
+    _logger.default.warn(output);
+  }
+}
+module.exports = Deprecator;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_logger","_interopRequireDefault","require","_Deprecations","_Utils","e","__esModule","default","Deprecator","scanParseServerOptions","options","deprecation","_getDeprecations","solution","optionKey","changeNewDefault","changeNewKey","Utils","getNestedProperty","_logOption","resolvedValue","optionValue","logRuntimeDeprecation","_logGeneric","Deprecations","usage","output","logger","warn","envKey","type","key","keyAction","undefined","length","module","exports"],"sources":["../../src/Deprecator/Deprecator.js"],"sourcesContent":["import logger from '../logger';\nimport Deprecations from './Deprecations';\nimport Utils from '../Utils';\n\n/**\n * The deprecator class.\n */\nclass Deprecator {\n  /**\n   * Scans the Parse Server for deprecated options.\n   * This needs to be called before setting option defaults, otherwise it\n   * becomes indistinguishable whether an option has been set manually or\n   * by default.\n   * @param {any} options The Parse Server options.\n   */\n  static scanParseServerOptions(options) {\n    // Scan for deprecations\n    for (const deprecation of Deprecator._getDeprecations()) {\n      // Get deprecation properties\n      const solution = deprecation.solution;\n      const optionKey = deprecation.optionKey;\n      const changeNewDefault = deprecation.changeNewDefault;\n      const changeNewKey = deprecation.changeNewKey;\n\n      // If default will change, only throw a warning if option is not set\n      if (changeNewDefault != null && Utils.getNestedProperty(options, optionKey) == null) {\n        Deprecator._logOption({ optionKey, changeNewDefault, solution });\n      }\n\n      // If key will be removed or renamed, only throw a warning if option is set;\n      // skip if option is set to the resolved value that suppresses the deprecation\n      const resolvedValue = deprecation.resolvedValue;\n      const optionValue = Utils.getNestedProperty(options, optionKey);\n      if (changeNewKey != null && optionValue != null && optionValue !== resolvedValue) {\n        Deprecator._logOption({ optionKey, changeNewKey, solution });\n      }\n    }\n  }\n\n  /**\n   * Logs a deprecation warning for a parameter that can only be determined dynamically\n   * during runtime.\n   *\n   * Note: Do not use this to log deprecations of Parse Server options, but add such\n   * deprecations to `Deprecations.js` instead. See the contribution docs for more\n   * details.\n   *\n   * For consistency, the deprecation warning is composed of the following parts:\n   *\n   * > DeprecationWarning: `usage` is deprecated and will be removed in a future version.\n   * `solution`.\n   *\n   * - `usage`: The deprecated usage.\n   * - `solution`: The instruction to resolve this deprecation warning.\n   *\n   * For example:\n   * > DeprecationWarning: `Prefixing field names with dollar sign ($) in aggregation query`\n   * is deprecated and will be removed in a future version. `Reference field names without\n   * dollar sign prefix.`\n   *\n   * @param {Object} options The deprecation options.\n   * @param {String} options.usage The usage that is deprecated.\n   * @param {String} [options.solution] The instruction to resolve this deprecation warning.\n   * Optional. It is recommended to add an instruction for the convenience of the developer.\n   */\n  static logRuntimeDeprecation(options) {\n    Deprecator._logGeneric(options);\n  }\n\n  /**\n   * Returns the deprecation definitions.\n   * @returns {Array<Object>} The deprecations.\n   */\n  static _getDeprecations() {\n    return Deprecations;\n  }\n\n  /**\n   * Logs a generic deprecation warning.\n   *\n   * @param {Object} options The deprecation options.\n   * @param {String} options.usage The usage that is deprecated.\n   * @param {String} [options.solution] The instruction to resolve this deprecation warning.\n   * Optional. It is recommended to add an instruction for the convenience of the developer.\n   */\n  static _logGeneric({ usage, solution }) {\n    // Compose message\n    let output = `DeprecationWarning: ${usage} is deprecated and will be removed in a future version.`;\n    output += solution ? ` ${solution}` : '';\n    logger.warn(output);\n  }\n\n  /**\n   * Logs a deprecation warning for a Parse Server option.\n   *\n   * @param {String} optionKey The option key incl. its path, e.g. `security.enableCheck`.\n   * @param {String} envKey The environment key, e.g. `PARSE_SERVER_SECURITY`.\n   * @param {String} changeNewKey Set the new key name if the current key will be replaced,\n   * or set to an empty string if the current key will be removed without replacement.\n   * @param {String} changeNewDefault Set the new default value if the key's default value\n   * will change in a future version.\n   * @param {String} [solution] The instruction to resolve this deprecation warning. This\n   * message must not include the warning that the parameter is deprecated, that is\n   * automatically added to the message. It should only contain the instruction on how\n   * to resolve this warning.\n   */\n  static _logOption({ optionKey, envKey, changeNewKey, changeNewDefault, solution }) {\n    const type = optionKey ? 'option' : 'environment key';\n    const key = optionKey ? optionKey : envKey;\n    const keyAction =\n      changeNewKey == null\n        ? undefined\n        : changeNewKey.length > 0\n          ? `renamed to '${changeNewKey}'`\n          : `removed`;\n\n    // Compose message\n    let output = `DeprecationWarning: The Parse Server ${type} '${key}' `;\n    output += changeNewKey != null ? `is deprecated and will be ${keyAction} in a future version.` : '';\n    output += changeNewDefault\n      ? `default will change to '${changeNewDefault}' in a future version.`\n      : '';\n    output += solution ? ` ${solution}` : '';\n    logger.warn(output);\n  }\n}\n\nmodule.exports = Deprecator;\n"],"mappings":"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","ignoreList":[]}

package/lib/Error.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSanitizedError = createSanitizedError;
+exports.createSanitizedHttpError = createSanitizedHttpError;
+var _logger = _interopRequireDefault(require("./logger"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Creates a sanitized error that hides detailed information from clients
+ * while logging the detailed message server-side.
+ *
+ * @param {number} errorCode - The Parse.Error code (e.g., Parse.Error.OPERATION_FORBIDDEN)
+ * @param {string} detailedMessage - The detailed error message to log server-side
+ * @param {object} config - Parse Server config with enableSanitizedErrorResponse
+ * @param {string} [sanitizedMessage='Permission denied'] - The sanitized message to return to clients
+ * @returns {Parse.Error} A Parse.Error with sanitized message
+ */
+function createSanitizedError(errorCode, detailedMessage, config, sanitizedMessage = 'Permission denied') {
+  // On testing we need to add a prefix to the message to allow to find the correct call in the TestUtils.js file
+  if (process.env.TESTING) {
+    _logger.default.error('Sanitized error:', detailedMessage);
+  } else {
+    _logger.default.error(detailedMessage);
+  }
+  return new Parse.Error(errorCode, config?.enableSanitizedErrorResponse !== false ? sanitizedMessage : detailedMessage);
+}
+
+/**
+ * Creates a sanitized error from a regular Error object
+ * Used for non-Parse.Error errors (e.g., Express errors)
+ *
+ * @param {number} statusCode - HTTP status code (e.g., 403)
+ * @param {string} detailedMessage - The detailed error message to log server-side
+ * @returns {Error} An Error with sanitized message
+ */
+function createSanitizedHttpError(statusCode, detailedMessage, config) {
+  // On testing we need to add a prefix to the message to allow to find the correct call in the TestUtils.js file
+  if (process.env.TESTING) {
+    _logger.default.error('Sanitized error:', detailedMessage);
+  } else {
+    _logger.default.error(detailedMessage);
+  }
+  const error = new Error();
+  error.status = statusCode;
+  error.message = config?.enableSanitizedErrorResponse !== false ? 'Permission denied' : detailedMessage;
+  return error;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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