@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Controllers/LoggerController.js

@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logLevels = exports.default = exports.LoggerController = exports.LogOrder = exports.LogLevel = void 0;
+var _node = require("parse/node");
+var _AdaptableController = _interopRequireDefault(require("./AdaptableController"));
+var _LoggerAdapter = require("../Adapters/Logger/LoggerAdapter");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const MILLISECONDS_IN_A_DAY = 24 * 60 * 60 * 1000;
+const DEFAULT_LOG_STRING_TRUNCATE_LENGTH = 1000;
+const truncationMarker = '... (truncated)';
+const LogLevel = exports.LogLevel = {
+  INFO: 'info',
+  ERROR: 'error'
+};
+const LogOrder = exports.LogOrder = {
+  DESCENDING: 'desc',
+  ASCENDING: 'asc'
+};
+const logLevels = exports.logLevels = ['error', 'warn', 'info', 'debug', 'verbose', 'silly', 'silent'];
+class LoggerController extends _AdaptableController.default {
+  constructor(adapter, appId, options = {
+    logLevel: 'info'
+  }) {
+    super(adapter, appId, options);
+    let level = 'info';
+    if (options.verbose) {
+      level = 'verbose';
+    }
+    if (options.logLevel) {
+      level = options.logLevel;
+    }
+    const index = logLevels.indexOf(level); // info by default
+    logLevels.forEach((level, levelIndex) => {
+      if (levelIndex > index) {
+        // silence the levels that are > maxIndex
+        this[level] = () => {};
+      }
+    });
+    this.logStringTruncateLength = options.logStringTruncateLength ?? DEFAULT_LOG_STRING_TRUNCATE_LENGTH;
+  }
+  maskSensitiveUrl(path) {
+    const urlString = 'http://localhost' + path; // prepend dummy string to make a real URL
+    const urlObj = new URL(urlString);
+    const query = urlObj.searchParams;
+    let sanitizedQuery = '?';
+    for (const [key, value] of query) {
+      if (key !== 'password') {
+        // normal value
+        sanitizedQuery += key + '=' + value + '&';
+      } else {
+        // password value, redact it
+        sanitizedQuery += key + '=' + '********' + '&';
+      }
+    }
+
+    // trim last character, ? or &
+    sanitizedQuery = sanitizedQuery.slice(0, -1);
+
+    // return original path name with sanitized params attached
+    return urlObj.pathname + sanitizedQuery;
+  }
+  maskSensitive(argArray) {
+    return argArray.map(e => {
+      if (!e) {
+        return e;
+      }
+      if (typeof e === 'string') {
+        return e.replace(/(password".?:.?")[^"]*"/g, '$1********"');
+      }
+      // else it is an object...
+
+      // check the url
+      if (e.url) {
+        // for strings
+        if (typeof e.url === 'string') {
+          e.url = this.maskSensitiveUrl(e.url);
+        } else if (Array.isArray(e.url)) {
+          // for strings in array
+          e.url = e.url.map(item => {
+            if (typeof item === 'string') {
+              return this.maskSensitiveUrl(item);
+            }
+            return item;
+          });
+        }
+      }
+      if (e.body) {
+        for (const key of Object.keys(e.body)) {
+          if (key === 'password') {
+            e.body[key] = '********';
+            break;
+          }
+        }
+      }
+      if (e.params) {
+        for (const key of Object.keys(e.params)) {
+          if (key === 'password') {
+            e.params[key] = '********';
+            break;
+          }
+        }
+      }
+      return e;
+    });
+  }
+  log(level, args) {
+    // make the passed in arguments object an array with the spread operator
+    args = this.maskSensitive([...args]);
+    args = [].concat(level, args.map(arg => {
+      if (typeof arg === 'function') {
+        return arg();
+      }
+      return arg;
+    }));
+    this.adapter.log.apply(this.adapter, args);
+  }
+  info() {
+    return this.log('info', arguments);
+  }
+  error() {
+    return this.log('error', arguments);
+  }
+  warn() {
+    return this.log('warn', arguments);
+  }
+  verbose() {
+    return this.log('verbose', arguments);
+  }
+  debug() {
+    return this.log('debug', arguments);
+  }
+  silly() {
+    return this.log('silly', arguments);
+  }
+  logRequest({
+    method,
+    url,
+    headers,
+    body
+  }) {
+    this.verbose(() => {
+      const stringifiedBody = JSON.stringify(body, null, 2);
+      return `REQUEST for [${method}] ${url}: ${stringifiedBody}`;
+    }, {
+      method,
+      url,
+      headers,
+      body
+    });
+  }
+  logResponse({
+    method,
+    url,
+    result
+  }) {
+    this.verbose(() => {
+      const stringifiedResponse = JSON.stringify(result, null, 2);
+      return `RESPONSE from [${method}] ${url}: ${stringifiedResponse}`;
+    }, {
+      result: result
+    });
+  }
+  // check that date input is valid
+  static validDateTime(date) {
+    if (!date) {
+      return null;
+    }
+    date = new Date(date);
+    if (!isNaN(date.getTime())) {
+      return date;
+    }
+    return null;
+  }
+  truncateLogMessage(string) {
+    if (string && string.length > this.logStringTruncateLength) {
+      const truncated = string.substring(0, this.logStringTruncateLength) + truncationMarker;
+      return truncated;
+    }
+    return string;
+  }
+  static parseOptions(options = {}) {
+    const from = LoggerController.validDateTime(options.from) || new Date(Date.now() - 7 * MILLISECONDS_IN_A_DAY);
+    const until = LoggerController.validDateTime(options.until) || new Date();
+    const size = Number(options.size) || 10;
+    const order = options.order || LogOrder.DESCENDING;
+    const level = options.level || LogLevel.INFO;
+    return {
+      from,
+      until,
+      size,
+      order,
+      level
+    };
+  }
+
+  // Returns a promise for a {response} object.
+  // query params:
+  // level (optional) Level of logging you want to query for (info || error)
+  // from (optional) Start time for the search. Defaults to 1 week ago.
+  // until (optional) End time for the search. Defaults to current time.
+  // order (optional) Direction of results returned, either “asc” or “desc”. Defaults to “desc”.
+  // size (optional) Number of rows returned by search. Defaults to 10
+  getLogs(options = {}) {
+    if (!this.adapter) {
+      throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, 'Logger adapter is not available');
+    }
+    if (typeof this.adapter.query !== 'function') {
+      throw new _node.Parse.Error(_node.Parse.Error.PUSH_MISCONFIGURED, 'Querying logs is not supported with this adapter');
+    }
+    options = LoggerController.parseOptions(options);
+    return this.adapter.query(options);
+  }
+  expectedAdapterType() {
+    return _LoggerAdapter.LoggerAdapter;
+  }
+}
+exports.LoggerController = LoggerController;
+var _default = exports.default = LoggerController;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","require","_AdaptableController","_interopRequireDefault","_LoggerAdapter","e","__esModule","default","MILLISECONDS_IN_A_DAY","DEFAULT_LOG_STRING_TRUNCATE_LENGTH","truncationMarker","LogLevel","exports","INFO","ERROR","LogOrder","DESCENDING","ASCENDING","logLevels","LoggerController","AdaptableController","constructor","adapter","appId","options","logLevel","level","verbose","index","indexOf","forEach","levelIndex","logStringTruncateLength","maskSensitiveUrl","path","urlString","urlObj","URL","query","searchParams","sanitizedQuery","key","value","slice","pathname","maskSensitive","argArray","map","replace","url","Array","isArray","item","body","Object","keys","params","log","args","concat","arg","apply","info","arguments","error","warn","debug","silly","logRequest","method","headers","stringifiedBody","JSON","stringify","logResponse","result","stringifiedResponse","validDateTime","date","Date","isNaN","getTime","truncateLogMessage","string","length","truncated","substring","parseOptions","from","now","until","size","Number","order","getLogs","Parse","Error","PUSH_MISCONFIGURED","expectedAdapterType","LoggerAdapter","_default"],"sources":["../../src/Controllers/LoggerController.js"],"sourcesContent":["import { Parse } from 'parse/node';\nimport AdaptableController from './AdaptableController';\nimport { LoggerAdapter } from '../Adapters/Logger/LoggerAdapter';\n\nconst MILLISECONDS_IN_A_DAY = 24 * 60 * 60 * 1000;\nconst DEFAULT_LOG_STRING_TRUNCATE_LENGTH = 1000;\nconst truncationMarker = '... (truncated)';\n\nexport const LogLevel = {\n  INFO: 'info',\n  ERROR: 'error',\n};\n\nexport const LogOrder = {\n  DESCENDING: 'desc',\n  ASCENDING: 'asc',\n};\n\nexport const logLevels = ['error', 'warn', 'info', 'debug', 'verbose', 'silly', 'silent'];\n\nexport class LoggerController extends AdaptableController {\n  constructor(adapter, appId, options = { logLevel: 'info' }) {\n    super(adapter, appId, options);\n    let level = 'info';\n    if (options.verbose) {\n      level = 'verbose';\n    }\n    if (options.logLevel) {\n      level = options.logLevel;\n    }\n    const index = logLevels.indexOf(level); // info by default\n    logLevels.forEach((level, levelIndex) => {\n      if (levelIndex > index) {\n        // silence the levels that are > maxIndex\n        this[level] = () => {};\n      }\n    });\n    this.logStringTruncateLength =\n      options.logStringTruncateLength ?? DEFAULT_LOG_STRING_TRUNCATE_LENGTH;\n  }\n\n  maskSensitiveUrl(path) {\n    const urlString = 'http://localhost' + path; // prepend dummy string to make a real URL\n    const urlObj = new URL(urlString);\n    const query = urlObj.searchParams;\n    let sanitizedQuery = '?';\n\n    for (const [key, value] of query) {\n      if (key !== 'password') {\n        // normal value\n        sanitizedQuery += key + '=' + value + '&';\n      } else {\n        // password value, redact it\n        sanitizedQuery += key + '=' + '********' + '&';\n      }\n    }\n\n    // trim last character, ? or &\n    sanitizedQuery = sanitizedQuery.slice(0, -1);\n\n    // return original path name with sanitized params attached\n    return urlObj.pathname + sanitizedQuery;\n  }\n\n  maskSensitive(argArray) {\n    return argArray.map(e => {\n      if (!e) {\n        return e;\n      }\n\n      if (typeof e === 'string') {\n        return e.replace(/(password\".?:.?\")[^\"]*\"/g, '$1********\"');\n      }\n      // else it is an object...\n\n      // check the url\n      if (e.url) {\n        // for strings\n        if (typeof e.url === 'string') {\n          e.url = this.maskSensitiveUrl(e.url);\n        } else if (Array.isArray(e.url)) {\n          // for strings in array\n          e.url = e.url.map(item => {\n            if (typeof item === 'string') {\n              return this.maskSensitiveUrl(item);\n            }\n\n            return item;\n          });\n        }\n      }\n\n      if (e.body) {\n        for (const key of Object.keys(e.body)) {\n          if (key === 'password') {\n            e.body[key] = '********';\n            break;\n          }\n        }\n      }\n\n      if (e.params) {\n        for (const key of Object.keys(e.params)) {\n          if (key === 'password') {\n            e.params[key] = '********';\n            break;\n          }\n        }\n      }\n\n      return e;\n    });\n  }\n\n  log(level, args) {\n    // make the passed in arguments object an array with the spread operator\n    args = this.maskSensitive([...args]);\n    args = [].concat(\n      level,\n      args.map(arg => {\n        if (typeof arg === 'function') {\n          return arg();\n        }\n        return arg;\n      })\n    );\n    this.adapter.log.apply(this.adapter, args);\n  }\n\n  info() {\n    return this.log('info', arguments);\n  }\n\n  error() {\n    return this.log('error', arguments);\n  }\n\n  warn() {\n    return this.log('warn', arguments);\n  }\n\n  verbose() {\n    return this.log('verbose', arguments);\n  }\n\n  debug() {\n    return this.log('debug', arguments);\n  }\n\n  silly() {\n    return this.log('silly', arguments);\n  }\n\n  logRequest({ method, url, headers, body }) {\n    this.verbose(\n      () => {\n        const stringifiedBody = JSON.stringify(body, null, 2);\n        return `REQUEST for [${method}] ${url}: ${stringifiedBody}`;\n      },\n      {\n        method,\n        url,\n        headers,\n        body,\n      }\n    );\n  }\n\n  logResponse({ method, url, result }) {\n    this.verbose(\n      () => {\n        const stringifiedResponse = JSON.stringify(result, null, 2);\n        return `RESPONSE from [${method}] ${url}: ${stringifiedResponse}`;\n      },\n      { result: result }\n    );\n  }\n  // check that date input is valid\n  static validDateTime(date) {\n    if (!date) {\n      return null;\n    }\n    date = new Date(date);\n\n    if (!isNaN(date.getTime())) {\n      return date;\n    }\n\n    return null;\n  }\n\n  truncateLogMessage(string) {\n    if (string && string.length > this.logStringTruncateLength) {\n      const truncated =\n        string.substring(0, this.logStringTruncateLength) + truncationMarker;\n      return truncated;\n    }\n\n    return string;\n  }\n\n  static parseOptions(options = {}) {\n    const from =\n      LoggerController.validDateTime(options.from) ||\n      new Date(Date.now() - 7 * MILLISECONDS_IN_A_DAY);\n    const until = LoggerController.validDateTime(options.until) || new Date();\n    const size = Number(options.size) || 10;\n    const order = options.order || LogOrder.DESCENDING;\n    const level = options.level || LogLevel.INFO;\n\n    return {\n      from,\n      until,\n      size,\n      order,\n      level,\n    };\n  }\n\n  // Returns a promise for a {response} object.\n  // query params:\n  // level (optional) Level of logging you want to query for (info || error)\n  // from (optional) Start time for the search. Defaults to 1 week ago.\n  // until (optional) End time for the search. Defaults to current time.\n  // order (optional) Direction of results returned, either “asc” or “desc”. Defaults to “desc”.\n  // size (optional) Number of rows returned by search. Defaults to 10\n  getLogs(options = {}) {\n    if (!this.adapter) {\n      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED, 'Logger adapter is not available');\n    }\n    if (typeof this.adapter.query !== 'function') {\n      throw new Parse.Error(\n        Parse.Error.PUSH_MISCONFIGURED,\n        'Querying logs is not supported with this adapter'\n      );\n    }\n    options = LoggerController.parseOptions(options);\n    return this.adapter.query(options);\n  }\n\n  expectedAdapterType() {\n    return LoggerAdapter;\n  }\n}\n\nexport default LoggerController;\n"],"mappings":"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","ignoreList":[]}

package/lib/Controllers/ParseGraphQLController.js

@@ -0,0 +1,294 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.GraphQLConfigKey = exports.GraphQLConfigId = exports.GraphQLConfigClassName = void 0;
+var _requiredParameter = _interopRequireDefault(require("../../lib/requiredParameter"));
+var _Utils = _interopRequireDefault(require("../Utils"));
+var _DatabaseController = _interopRequireDefault(require("./DatabaseController"));
+var _CacheController = _interopRequireDefault(require("./CacheController"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const GraphQLConfigClassName = exports.GraphQLConfigClassName = '_GraphQLConfig';
+const GraphQLConfigId = exports.GraphQLConfigId = '1';
+const GraphQLConfigKey = exports.GraphQLConfigKey = 'config';
+class ParseGraphQLController {
+  constructor(params = {}) {
+    this.databaseController = params.databaseController || (0, _requiredParameter.default)(`ParseGraphQLController requires a "databaseController" to be instantiated.`);
+    this.cacheController = params.cacheController;
+    this.isMounted = !!params.mountGraphQL;
+    this.configCacheKey = GraphQLConfigKey;
+  }
+  async getGraphQLConfig() {
+    if (this.isMounted) {
+      const _cachedConfig = await this._getCachedGraphQLConfig();
+      if (_cachedConfig) {
+        return _cachedConfig;
+      }
+    }
+    const results = await this.databaseController.find(GraphQLConfigClassName, {
+      objectId: GraphQLConfigId
+    }, {
+      limit: 1
+    });
+    let graphQLConfig;
+    if (results.length != 1) {
+      // If there is no config in the database - return empty config.
+      return {};
+    } else {
+      graphQLConfig = results[0][GraphQLConfigKey];
+    }
+    if (this.isMounted) {
+      this._putCachedGraphQLConfig(graphQLConfig);
+    }
+    return graphQLConfig;
+  }
+  async updateGraphQLConfig(graphQLConfig) {
+    // throws if invalid
+    this._validateGraphQLConfig(graphQLConfig || (0, _requiredParameter.default)('You must provide a graphQLConfig!'));
+
+    // Transform in dot notation to make sure it works
+    const update = Object.keys(graphQLConfig).reduce((acc, key) => {
+      return {
+        [GraphQLConfigKey]: {
+          ...acc[GraphQLConfigKey],
+          [key]: graphQLConfig[key]
+        }
+      };
+    }, {
+      [GraphQLConfigKey]: {}
+    });
+    await this.databaseController.update(GraphQLConfigClassName, {
+      objectId: GraphQLConfigId
+    }, update, {
+      upsert: true
+    });
+    if (this.isMounted) {
+      this._putCachedGraphQLConfig(graphQLConfig);
+    }
+    return {
+      response: {
+        result: true
+      }
+    };
+  }
+  _getCachedGraphQLConfig() {
+    return this.cacheController.graphQL.get(this.configCacheKey);
+  }
+  _putCachedGraphQLConfig(graphQLConfig) {
+    return this.cacheController.graphQL.put(this.configCacheKey, graphQLConfig, 60000);
+  }
+  _validateGraphQLConfig(graphQLConfig) {
+    const errorMessages = [];
+    if (!graphQLConfig) {
+      errorMessages.push('cannot be undefined, null or empty');
+    } else if (!isValidSimpleObject(graphQLConfig)) {
+      errorMessages.push('must be a valid object');
+    } else {
+      const {
+        enabledForClasses = null,
+        disabledForClasses = null,
+        classConfigs = null,
+        ...invalidKeys
+      } = graphQLConfig;
+      if (Object.keys(invalidKeys).length) {
+        errorMessages.push(`encountered invalid keys: [${Object.keys(invalidKeys)}]`);
+      }
+      if (enabledForClasses !== null && !isValidStringArray(enabledForClasses)) {
+        errorMessages.push(`"enabledForClasses" is not a valid array`);
+      }
+      if (disabledForClasses !== null && !isValidStringArray(disabledForClasses)) {
+        errorMessages.push(`"disabledForClasses" is not a valid array`);
+      }
+      if (classConfigs !== null) {
+        if (Array.isArray(classConfigs)) {
+          classConfigs.forEach(classConfig => {
+            const errorMessage = this._validateClassConfig(classConfig);
+            if (errorMessage) {
+              errorMessages.push(`classConfig:${classConfig.className} is invalid because ${errorMessage}`);
+            }
+          });
+        } else {
+          errorMessages.push(`"classConfigs" is not a valid array`);
+        }
+      }
+    }
+    if (errorMessages.length) {
+      throw new Error(`Invalid graphQLConfig: ${errorMessages.join('; ')}`);
+    }
+  }
+  _validateClassConfig(classConfig) {
+    if (!isValidSimpleObject(classConfig)) {
+      return 'it must be a valid object';
+    } else {
+      const {
+        className,
+        type = null,
+        query = null,
+        mutation = null,
+        ...invalidKeys
+      } = classConfig;
+      if (Object.keys(invalidKeys).length) {
+        return `"invalidKeys" [${Object.keys(invalidKeys)}] should not be present`;
+      }
+      if (typeof className !== 'string' || !className.trim().length) {
+        // TODO consider checking class exists in schema?
+        return `"className" must be a valid string`;
+      }
+      if (type !== null) {
+        if (!isValidSimpleObject(type)) {
+          return `"type" must be a valid object`;
+        }
+        const {
+          inputFields = null,
+          outputFields = null,
+          constraintFields = null,
+          sortFields = null,
+          ...invalidKeys
+        } = type;
+        if (Object.keys(invalidKeys).length) {
+          return `"type" contains invalid keys, [${Object.keys(invalidKeys)}]`;
+        } else if (outputFields !== null && !isValidStringArray(outputFields)) {
+          return `"outputFields" must be a valid string array`;
+        } else if (constraintFields !== null && !isValidStringArray(constraintFields)) {
+          return `"constraintFields" must be a valid string array`;
+        }
+        if (sortFields !== null) {
+          if (Array.isArray(sortFields)) {
+            let errorMessage;
+            sortFields.every((sortField, index) => {
+              if (!isValidSimpleObject(sortField)) {
+                errorMessage = `"sortField" at index ${index} is not a valid object`;
+                return false;
+              } else {
+                const {
+                  field,
+                  asc,
+                  desc,
+                  ...invalidKeys
+                } = sortField;
+                if (Object.keys(invalidKeys).length) {
+                  errorMessage = `"sortField" at index ${index} contains invalid keys, [${Object.keys(invalidKeys)}]`;
+                  return false;
+                } else {
+                  if (typeof field !== 'string' || field.trim().length === 0) {
+                    errorMessage = `"sortField" at index ${index} did not provide the "field" as a string`;
+                    return false;
+                  } else if (typeof asc !== 'boolean' || typeof desc !== 'boolean') {
+                    errorMessage = `"sortField" at index ${index} did not provide "asc" or "desc" as booleans`;
+                    return false;
+                  }
+                }
+              }
+              return true;
+            });
+            if (errorMessage) {
+              return errorMessage;
+            }
+          } else {
+            return `"sortFields" must be a valid array.`;
+          }
+        }
+        if (inputFields !== null) {
+          if (isValidSimpleObject(inputFields)) {
+            const {
+              create = null,
+              update = null,
+              ...invalidKeys
+            } = inputFields;
+            if (Object.keys(invalidKeys).length) {
+              return `"inputFields" contains invalid keys: [${Object.keys(invalidKeys)}]`;
+            } else {
+              if (update !== null && !isValidStringArray(update)) {
+                return `"inputFields.update" must be a valid string array`;
+              } else if (create !== null) {
+                if (!isValidStringArray(create)) {
+                  return `"inputFields.create" must be a valid string array`;
+                } else if (className === '_User') {
+                  if (!create.includes('username') || !create.includes('password')) {
+                    return `"inputFields.create" must include required fields, username and password`;
+                  }
+                }
+              }
+            }
+          } else {
+            return `"inputFields" must be a valid object`;
+          }
+        }
+      }
+      if (query !== null) {
+        if (isValidSimpleObject(query)) {
+          const {
+            find = null,
+            get = null,
+            findAlias = null,
+            getAlias = null,
+            ...invalidKeys
+          } = query;
+          if (Object.keys(invalidKeys).length) {
+            return `"query" contains invalid keys, [${Object.keys(invalidKeys)}]`;
+          } else if (find !== null && typeof find !== 'boolean') {
+            return `"query.find" must be a boolean`;
+          } else if (get !== null && typeof get !== 'boolean') {
+            return `"query.get" must be a boolean`;
+          } else if (findAlias !== null && typeof findAlias !== 'string') {
+            return `"query.findAlias" must be a string`;
+          } else if (getAlias !== null && typeof getAlias !== 'string') {
+            return `"query.getAlias" must be a string`;
+          }
+        } else {
+          return `"query" must be a valid object`;
+        }
+      }
+      if (mutation !== null) {
+        if (isValidSimpleObject(mutation)) {
+          const {
+            create = null,
+            update = null,
+            destroy = null,
+            createAlias = null,
+            updateAlias = null,
+            destroyAlias = null,
+            ...invalidKeys
+          } = mutation;
+          if (Object.keys(invalidKeys).length) {
+            return `"mutation" contains invalid keys, [${Object.keys(invalidKeys)}]`;
+          }
+          if (create !== null && typeof create !== 'boolean') {
+            return `"mutation.create" must be a boolean`;
+          }
+          if (update !== null && typeof update !== 'boolean') {
+            return `"mutation.update" must be a boolean`;
+          }
+          if (destroy !== null && typeof destroy !== 'boolean') {
+            return `"mutation.destroy" must be a boolean`;
+          }
+          if (createAlias !== null && typeof createAlias !== 'string') {
+            return `"mutation.createAlias" must be a string`;
+          }
+          if (updateAlias !== null && typeof updateAlias !== 'string') {
+            return `"mutation.updateAlias" must be a string`;
+          }
+          if (destroyAlias !== null && typeof destroyAlias !== 'string') {
+            return `"mutation.destroyAlias" must be a string`;
+          }
+        } else {
+          return `"mutation" must be a valid object`;
+        }
+      }
+    }
+  }
+}
+const isValidStringArray = function (array) {
+  return Array.isArray(array) ? !array.some(s => typeof s !== 'string' || s.trim().length < 1) : false;
+};
+/**
+ * Ensures the obj is a simple JSON/{}
+ * object, i.e. not an array, null, date
+ * etc.
+ */
+const isValidSimpleObject = function (obj) {
+  return typeof obj === 'object' && !Array.isArray(obj) && obj !== null && _Utils.default.isDate(obj) !== true && _Utils.default.isPromise(obj) !== true;
+};
+var _default = exports.default = ParseGraphQLController;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_requiredParameter","_interopRequireDefault","require","_Utils","_DatabaseController","_CacheController","e","__esModule","default","GraphQLConfigClassName","exports","GraphQLConfigId","GraphQLConfigKey","ParseGraphQLController","constructor","params","databaseController","requiredParameter","cacheController","isMounted","mountGraphQL","configCacheKey","getGraphQLConfig","_cachedConfig","_getCachedGraphQLConfig","results","find","objectId","limit","graphQLConfig","length","_putCachedGraphQLConfig","updateGraphQLConfig","_validateGraphQLConfig","update","Object","keys","reduce","acc","key","upsert","response","result","graphQL","get","put","errorMessages","push","isValidSimpleObject","enabledForClasses","disabledForClasses","classConfigs","invalidKeys","isValidStringArray","Array","isArray","forEach","classConfig","errorMessage","_validateClassConfig","className","Error","join","type","query","mutation","trim","inputFields","outputFields","constraintFields","sortFields","every","sortField","index","field","asc","desc","create","includes","findAlias","getAlias","destroy","createAlias","updateAlias","destroyAlias","array","some","s","obj","Utils","isDate","isPromise","_default"],"sources":["../../src/Controllers/ParseGraphQLController.js"],"sourcesContent":["import requiredParameter from '../../lib/requiredParameter';\nimport Utils from '../Utils';\nimport DatabaseController from './DatabaseController';\nimport CacheController from './CacheController';\n\nconst GraphQLConfigClassName = '_GraphQLConfig';\nconst GraphQLConfigId = '1';\nconst GraphQLConfigKey = 'config';\n\nclass ParseGraphQLController {\n  databaseController: DatabaseController;\n  cacheController: CacheController;\n  isMounted: boolean;\n  configCacheKey: string;\n\n  constructor(\n    params: {\n      databaseController: DatabaseController,\n      cacheController: CacheController,\n    } = {}\n  ) {\n    this.databaseController =\n      params.databaseController ||\n      requiredParameter(\n        `ParseGraphQLController requires a \"databaseController\" to be instantiated.`\n      );\n    this.cacheController = params.cacheController;\n    this.isMounted = !!params.mountGraphQL;\n    this.configCacheKey = GraphQLConfigKey;\n  }\n\n  async getGraphQLConfig(): Promise<ParseGraphQLConfig> {\n    if (this.isMounted) {\n      const _cachedConfig = await this._getCachedGraphQLConfig();\n      if (_cachedConfig) {\n        return _cachedConfig;\n      }\n    }\n\n    const results = await this.databaseController.find(\n      GraphQLConfigClassName,\n      { objectId: GraphQLConfigId },\n      { limit: 1 }\n    );\n\n    let graphQLConfig;\n    if (results.length != 1) {\n      // If there is no config in the database - return empty config.\n      return {};\n    } else {\n      graphQLConfig = results[0][GraphQLConfigKey];\n    }\n\n    if (this.isMounted) {\n      this._putCachedGraphQLConfig(graphQLConfig);\n    }\n\n    return graphQLConfig;\n  }\n\n  async updateGraphQLConfig(graphQLConfig: ParseGraphQLConfig): Promise<ParseGraphQLConfig> {\n    // throws if invalid\n    this._validateGraphQLConfig(\n      graphQLConfig || requiredParameter('You must provide a graphQLConfig!')\n    );\n\n    // Transform in dot notation to make sure it works\n    const update = Object.keys(graphQLConfig).reduce(\n      (acc, key) => {\n        return {\n          [GraphQLConfigKey]: {\n            ...acc[GraphQLConfigKey],\n            [key]: graphQLConfig[key],\n          },\n        };\n      },\n      { [GraphQLConfigKey]: {} }\n    );\n\n    await this.databaseController.update(\n      GraphQLConfigClassName,\n      { objectId: GraphQLConfigId },\n      update,\n      { upsert: true }\n    );\n\n    if (this.isMounted) {\n      this._putCachedGraphQLConfig(graphQLConfig);\n    }\n\n    return { response: { result: true } };\n  }\n\n  _getCachedGraphQLConfig() {\n    return this.cacheController.graphQL.get(this.configCacheKey);\n  }\n\n  _putCachedGraphQLConfig(graphQLConfig: ParseGraphQLConfig) {\n    return this.cacheController.graphQL.put(this.configCacheKey, graphQLConfig, 60000);\n  }\n\n  _validateGraphQLConfig(graphQLConfig: ?ParseGraphQLConfig): void {\n    const errorMessages: string = [];\n    if (!graphQLConfig) {\n      errorMessages.push('cannot be undefined, null or empty');\n    } else if (!isValidSimpleObject(graphQLConfig)) {\n      errorMessages.push('must be a valid object');\n    } else {\n      const {\n        enabledForClasses = null,\n        disabledForClasses = null,\n        classConfigs = null,\n        ...invalidKeys\n      } = graphQLConfig;\n\n      if (Object.keys(invalidKeys).length) {\n        errorMessages.push(`encountered invalid keys: [${Object.keys(invalidKeys)}]`);\n      }\n      if (enabledForClasses !== null && !isValidStringArray(enabledForClasses)) {\n        errorMessages.push(`\"enabledForClasses\" is not a valid array`);\n      }\n      if (disabledForClasses !== null && !isValidStringArray(disabledForClasses)) {\n        errorMessages.push(`\"disabledForClasses\" is not a valid array`);\n      }\n      if (classConfigs !== null) {\n        if (Array.isArray(classConfigs)) {\n          classConfigs.forEach(classConfig => {\n            const errorMessage = this._validateClassConfig(classConfig);\n            if (errorMessage) {\n              errorMessages.push(\n                `classConfig:${classConfig.className} is invalid because ${errorMessage}`\n              );\n            }\n          });\n        } else {\n          errorMessages.push(`\"classConfigs\" is not a valid array`);\n        }\n      }\n    }\n    if (errorMessages.length) {\n      throw new Error(`Invalid graphQLConfig: ${errorMessages.join('; ')}`);\n    }\n  }\n\n  _validateClassConfig(classConfig: ?ParseGraphQLClassConfig): string | void {\n    if (!isValidSimpleObject(classConfig)) {\n      return 'it must be a valid object';\n    } else {\n      const { className, type = null, query = null, mutation = null, ...invalidKeys } = classConfig;\n      if (Object.keys(invalidKeys).length) {\n        return `\"invalidKeys\" [${Object.keys(invalidKeys)}] should not be present`;\n      }\n      if (typeof className !== 'string' || !className.trim().length) {\n        // TODO consider checking class exists in schema?\n        return `\"className\" must be a valid string`;\n      }\n      if (type !== null) {\n        if (!isValidSimpleObject(type)) {\n          return `\"type\" must be a valid object`;\n        }\n        const {\n          inputFields = null,\n          outputFields = null,\n          constraintFields = null,\n          sortFields = null,\n          ...invalidKeys\n        } = type;\n        if (Object.keys(invalidKeys).length) {\n          return `\"type\" contains invalid keys, [${Object.keys(invalidKeys)}]`;\n        } else if (outputFields !== null && !isValidStringArray(outputFields)) {\n          return `\"outputFields\" must be a valid string array`;\n        } else if (constraintFields !== null && !isValidStringArray(constraintFields)) {\n          return `\"constraintFields\" must be a valid string array`;\n        }\n        if (sortFields !== null) {\n          if (Array.isArray(sortFields)) {\n            let errorMessage;\n            sortFields.every((sortField, index) => {\n              if (!isValidSimpleObject(sortField)) {\n                errorMessage = `\"sortField\" at index ${index} is not a valid object`;\n                return false;\n              } else {\n                const { field, asc, desc, ...invalidKeys } = sortField;\n                if (Object.keys(invalidKeys).length) {\n                  errorMessage = `\"sortField\" at index ${index} contains invalid keys, [${Object.keys(\n                    invalidKeys\n                  )}]`;\n                  return false;\n                } else {\n                  if (typeof field !== 'string' || field.trim().length === 0) {\n                    errorMessage = `\"sortField\" at index ${index} did not provide the \"field\" as a string`;\n                    return false;\n                  } else if (typeof asc !== 'boolean' || typeof desc !== 'boolean') {\n                    errorMessage = `\"sortField\" at index ${index} did not provide \"asc\" or \"desc\" as booleans`;\n                    return false;\n                  }\n                }\n              }\n              return true;\n            });\n            if (errorMessage) {\n              return errorMessage;\n            }\n          } else {\n            return `\"sortFields\" must be a valid array.`;\n          }\n        }\n        if (inputFields !== null) {\n          if (isValidSimpleObject(inputFields)) {\n            const { create = null, update = null, ...invalidKeys } = inputFields;\n            if (Object.keys(invalidKeys).length) {\n              return `\"inputFields\" contains invalid keys: [${Object.keys(invalidKeys)}]`;\n            } else {\n              if (update !== null && !isValidStringArray(update)) {\n                return `\"inputFields.update\" must be a valid string array`;\n              } else if (create !== null) {\n                if (!isValidStringArray(create)) {\n                  return `\"inputFields.create\" must be a valid string array`;\n                } else if (className === '_User') {\n                  if (!create.includes('username') || !create.includes('password')) {\n                    return `\"inputFields.create\" must include required fields, username and password`;\n                  }\n                }\n              }\n            }\n          } else {\n            return `\"inputFields\" must be a valid object`;\n          }\n        }\n      }\n      if (query !== null) {\n        if (isValidSimpleObject(query)) {\n          const {\n            find = null,\n            get = null,\n            findAlias = null,\n            getAlias = null,\n            ...invalidKeys\n          } = query;\n          if (Object.keys(invalidKeys).length) {\n            return `\"query\" contains invalid keys, [${Object.keys(invalidKeys)}]`;\n          } else if (find !== null && typeof find !== 'boolean') {\n            return `\"query.find\" must be a boolean`;\n          } else if (get !== null && typeof get !== 'boolean') {\n            return `\"query.get\" must be a boolean`;\n          } else if (findAlias !== null && typeof findAlias !== 'string') {\n            return `\"query.findAlias\" must be a string`;\n          } else if (getAlias !== null && typeof getAlias !== 'string') {\n            return `\"query.getAlias\" must be a string`;\n          }\n        } else {\n          return `\"query\" must be a valid object`;\n        }\n      }\n      if (mutation !== null) {\n        if (isValidSimpleObject(mutation)) {\n          const {\n            create = null,\n            update = null,\n            destroy = null,\n            createAlias = null,\n            updateAlias = null,\n            destroyAlias = null,\n            ...invalidKeys\n          } = mutation;\n          if (Object.keys(invalidKeys).length) {\n            return `\"mutation\" contains invalid keys, [${Object.keys(invalidKeys)}]`;\n          }\n          if (create !== null && typeof create !== 'boolean') {\n            return `\"mutation.create\" must be a boolean`;\n          }\n          if (update !== null && typeof update !== 'boolean') {\n            return `\"mutation.update\" must be a boolean`;\n          }\n          if (destroy !== null && typeof destroy !== 'boolean') {\n            return `\"mutation.destroy\" must be a boolean`;\n          }\n          if (createAlias !== null && typeof createAlias !== 'string') {\n            return `\"mutation.createAlias\" must be a string`;\n          }\n          if (updateAlias !== null && typeof updateAlias !== 'string') {\n            return `\"mutation.updateAlias\" must be a string`;\n          }\n          if (destroyAlias !== null && typeof destroyAlias !== 'string') {\n            return `\"mutation.destroyAlias\" must be a string`;\n          }\n        } else {\n          return `\"mutation\" must be a valid object`;\n        }\n      }\n    }\n  }\n}\n\nconst isValidStringArray = function (array): boolean {\n  return Array.isArray(array)\n    ? !array.some(s => typeof s !== 'string' || s.trim().length < 1)\n    : false;\n};\n/**\n * Ensures the obj is a simple JSON/{}\n * object, i.e. not an array, null, date\n * etc.\n */\nconst isValidSimpleObject = function (obj): boolean {\n  return (\n    typeof obj === 'object' &&\n    !Array.isArray(obj) &&\n    obj !== null &&\n    Utils.isDate(obj) !== true &&\n    Utils.isPromise(obj) !== true\n  );\n};\n\nexport interface ParseGraphQLConfig {\n  enabledForClasses?: string[];\n  disabledForClasses?: string[];\n  classConfigs?: ParseGraphQLClassConfig[];\n}\n\nexport interface ParseGraphQLClassConfig {\n  className: string;\n  /* The `type` object contains options for how the class types are generated */\n  type: ?{\n    /* Fields that are allowed when creating or updating an object. */\n    inputFields: ?{\n      /* Leave blank to allow all available fields in the schema. */\n      create?: string[],\n      update?: string[],\n    },\n    /* Fields on the edges that can be resolved from a query, i.e. the Result Type. */\n    outputFields: ?(string[]),\n    /* Fields by which a query can be filtered, i.e. the `where` object. */\n    constraintFields: ?(string[]),\n    /* Fields by which a query can be sorted; */\n    sortFields: ?({\n      field: string,\n      asc: boolean,\n      desc: boolean,\n    }[]),\n  };\n  /* The `query` object contains options for which class queries are generated */\n  query: ?{\n    get: ?boolean,\n    find: ?boolean,\n    findAlias: ?String,\n    getAlias: ?String,\n  };\n  /* The `mutation` object contains options for which class mutations are generated */\n  mutation: ?{\n    create: ?boolean,\n    update: ?boolean,\n    // delete is a reserved key word in js\n    destroy: ?boolean,\n    createAlias: ?String,\n    updateAlias: ?String,\n    destroyAlias: ?String,\n  };\n}\n\nexport default ParseGraphQLController;\nexport { GraphQLConfigClassName, GraphQLConfigId, GraphQLConfigKey };\n"],"mappings":"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","ignoreList":[]}