@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Routers/PagesRouter.js

@@ -0,0 +1,676 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.PagesRouter = void 0;
+var _PromiseRouter = _interopRequireDefault(require("../PromiseRouter"));
+var _Config = _interopRequireDefault(require("../Config"));
+var _express = _interopRequireDefault(require("express"));
+var _path = _interopRequireDefault(require("path"));
+var _fs = require("fs");
+var _node = require("parse/node");
+var _Utils = _interopRequireDefault(require("../Utils"));
+var _mustache = _interopRequireDefault(require("mustache"));
+var _Page = _interopRequireDefault(require("../Page"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// All pages with custom page key for reference and file name
+const pages = Object.freeze({
+  passwordReset: new _Page.default({
+    id: 'passwordReset',
+    defaultFile: 'password_reset.html'
+  }),
+  passwordResetSuccess: new _Page.default({
+    id: 'passwordResetSuccess',
+    defaultFile: 'password_reset_success.html'
+  }),
+  passwordResetLinkInvalid: new _Page.default({
+    id: 'passwordResetLinkInvalid',
+    defaultFile: 'password_reset_link_invalid.html'
+  }),
+  emailVerificationSuccess: new _Page.default({
+    id: 'emailVerificationSuccess',
+    defaultFile: 'email_verification_success.html'
+  }),
+  emailVerificationSendFail: new _Page.default({
+    id: 'emailVerificationSendFail',
+    defaultFile: 'email_verification_send_fail.html'
+  }),
+  emailVerificationSendSuccess: new _Page.default({
+    id: 'emailVerificationSendSuccess',
+    defaultFile: 'email_verification_send_success.html'
+  }),
+  emailVerificationLinkInvalid: new _Page.default({
+    id: 'emailVerificationLinkInvalid',
+    defaultFile: 'email_verification_link_invalid.html'
+  }),
+  emailVerificationLinkExpired: new _Page.default({
+    id: 'emailVerificationLinkExpired',
+    defaultFile: 'email_verification_link_expired.html'
+  })
+});
+
+// All page parameters for reference to be used as template placeholders or query params
+const pageParams = Object.freeze({
+  appName: 'appName',
+  appId: 'appId',
+  token: 'token',
+  username: 'username',
+  error: 'error',
+  locale: 'locale',
+  publicServerUrl: 'publicServerUrl'
+});
+
+// The header prefix to add page params as response headers
+const pageParamHeaderPrefix = 'x-parse-page-param-';
+
+// The errors being thrown
+const errors = Object.freeze({
+  jsonFailedFileLoading: 'failed to load JSON file',
+  fileOutsideAllowedScope: 'not allowed to read file outside of pages directory'
+});
+class PagesRouter extends _PromiseRouter.default {
+  /**
+   * Constructs a PagesRouter.
+   * @param {Object} pages The pages options from the Parse Server configuration.
+   */
+  constructor(pages = {}) {
+    super();
+
+    // Set instance properties
+    this.pagesConfig = pages;
+    this.pagesEndpoint = pages.pagesEndpoint ? pages.pagesEndpoint : 'apps';
+    this.pagesPath = pages.pagesPath ? _path.default.resolve('./', pages.pagesPath) : _path.default.resolve(__dirname, '../../public');
+    this.loadJsonResource();
+    this.mountPagesRoutes();
+    this.mountCustomRoutes();
+    this.mountStaticRoute();
+  }
+  verifyEmail(req) {
+    const config = req.config;
+    const {
+      token: rawToken
+    } = req.query;
+    const token = typeof rawToken === 'string' ? rawToken : undefined;
+    if (!config) {
+      this.invalidRequest();
+    }
+    if (!token) {
+      return this.goToPage(req, pages.emailVerificationLinkInvalid);
+    }
+    const userController = config.userController;
+    return userController.verifyEmail(token).then(() => {
+      return this.goToPage(req, pages.emailVerificationSuccess);
+    }, () => {
+      return this.goToPage(req, pages.emailVerificationLinkInvalid);
+    });
+  }
+  resendVerificationEmail(req) {
+    const config = req.config;
+    const username = req.body?.username;
+    const rawToken = req.body?.token;
+    const token = typeof rawToken === 'string' ? rawToken : undefined;
+    if (!config) {
+      this.invalidRequest();
+    }
+    if (!username && !token) {
+      return this.goToPage(req, pages.emailVerificationLinkInvalid);
+    }
+    const userController = config.userController;
+    const suppressError = config.emailVerifySuccessOnInvalidEmail ?? true;
+    return userController.resendVerificationEmail(username, req, token).then(() => {
+      return this.goToPage(req, pages.emailVerificationSendSuccess);
+    }, () => {
+      if (suppressError) {
+        return this.goToPage(req, pages.emailVerificationSendSuccess);
+      }
+      return this.goToPage(req, pages.emailVerificationSendFail);
+    });
+  }
+  passwordReset(req) {
+    const config = req.config;
+    const params = {
+      [pageParams.appId]: req.params.appId,
+      [pageParams.appName]: config.appName,
+      [pageParams.token]: req.query.token,
+      [pageParams.username]: req.query.username,
+      [pageParams.publicServerUrl]: config.publicServerURL
+    };
+    return this.goToPage(req, pages.passwordReset, params);
+  }
+  requestResetPassword(req) {
+    const config = req.config;
+    if (!config) {
+      this.invalidRequest();
+    }
+    const {
+      token: rawToken
+    } = req.query;
+    const token = typeof rawToken === 'string' ? rawToken : undefined;
+    if (!token) {
+      return this.goToPage(req, pages.passwordResetLinkInvalid);
+    }
+    return config.userController.checkResetTokenValidity(token).then(() => {
+      const params = {
+        [pageParams.token]: token,
+        [pageParams.appId]: config.applicationId,
+        [pageParams.appName]: config.appName
+      };
+      return this.goToPage(req, pages.passwordReset, params);
+    }, () => {
+      return this.goToPage(req, pages.passwordResetLinkInvalid);
+    });
+  }
+  resetPassword(req) {
+    const config = req.config;
+    if (!config) {
+      this.invalidRequest();
+    }
+    const {
+      new_password,
+      token: rawToken
+    } = req.body || {};
+    const token = typeof rawToken === 'string' ? rawToken : undefined;
+    if ((!token || !new_password) && req.xhr === false) {
+      return this.goToPage(req, pages.passwordResetLinkInvalid);
+    }
+    if (!token) {
+      throw new _node.Parse.Error(_node.Parse.Error.OTHER_CAUSE, 'Missing token');
+    }
+    if (!new_password) {
+      throw new _node.Parse.Error(_node.Parse.Error.PASSWORD_MISSING, 'Missing password');
+    }
+    return config.userController.updatePassword(token, new_password).then(() => {
+      return Promise.resolve({
+        success: true
+      });
+    }, err => {
+      return Promise.resolve({
+        success: false,
+        err
+      });
+    }).then(result => {
+      if (req.xhr) {
+        if (result.success) {
+          return Promise.resolve({
+            status: 200,
+            response: 'Password successfully reset'
+          });
+        }
+        if (result.err) {
+          throw new _node.Parse.Error(_node.Parse.Error.OTHER_CAUSE, `${result.err}`);
+        }
+      }
+      const query = result.success ? {} : {
+        [pageParams.token]: token,
+        [pageParams.appId]: config.applicationId,
+        [pageParams.error]: result.err,
+        [pageParams.appName]: config.appName
+      };
+      if (result?.err === 'The password reset link has expired') {
+        delete query[pageParams.token];
+        query[pageParams.token] = token;
+      }
+      const page = result.success ? pages.passwordResetSuccess : pages.passwordReset;
+      return this.goToPage(req, page, query, false);
+    });
+  }
+
+  /**
+   * Returns page content if the page is a local file or returns a
+   * redirect to a custom page.
+   * @param {Object} req The express request.
+   * @param {Page} page The page to go to.
+   * @param {Object} [params={}] The query parameters to attach to the URL in case of
+   * HTTP redirect responses for POST requests, or the placeholders to fill into
+   * the response content in case of HTTP content responses for GET requests.
+   * @param {Boolean} [responseType] Is true if a redirect response should be forced,
+   * false if a content response should be forced, undefined if the response type
+   * should depend on the request type by default:
+   * - GET request -> content response
+   * - POST request -> redirect response (PRG pattern)
+   * @returns {Promise<Object>} The PromiseRouter response.
+   */
+  goToPage(req, page, params = {}, responseType) {
+    const config = req.config;
+
+    // Determine redirect either by force, response setting or request method
+    const redirect = config.pages.forceRedirect ? true : responseType !== undefined ? responseType : req.method == 'POST';
+
+    // Include default parameters
+    const defaultParams = this.getDefaultParams(config);
+    if (Object.values(defaultParams).includes(undefined)) {
+      return this.notFound();
+    }
+    params = Object.assign(params, defaultParams);
+
+    // Add locale to params to ensure it is passed on with every request;
+    // that means, once a locale is set, it is passed on to any follow-up page,
+    // e.g. request_password_reset -> password_reset -> password_reset_success
+    const locale = this.getLocale(req);
+    params[pageParams.locale] = locale;
+
+    // Compose paths and URLs
+    const defaultFile = page.defaultFile;
+    const defaultPath = this.defaultPagePath(defaultFile);
+    const defaultUrl = this.composePageUrl(defaultFile, config.publicServerURL);
+
+    // If custom URL is set redirect to it without localization
+    const customUrl = config.pages.customUrls[page.id];
+    if (customUrl && !_Utils.default.isPath(customUrl)) {
+      return this.redirectResponse(customUrl, params);
+    }
+
+    // Get JSON placeholders
+    let placeholders = {};
+    if (config.pages.enableLocalization && config.pages.localizationJsonPath) {
+      placeholders = this.getJsonPlaceholders(locale, params);
+    }
+
+    // Send response
+    if (config.pages.enableLocalization && locale) {
+      return _Utils.default.getLocalizedPath(defaultPath, locale).then(({
+        path,
+        subdir
+      }) => redirect ? this.redirectResponse(this.composePageUrl(defaultFile, config.publicServerURL, subdir), params) : this.pageResponse(path, params, placeholders));
+    } else {
+      return redirect ? this.redirectResponse(defaultUrl, params) : this.pageResponse(defaultPath, params, placeholders);
+    }
+  }
+
+  /**
+   * Serves a request to a static resource and localizes the resource if it
+   * is a HTML file.
+   * @param {Object} req The request object.
+   * @returns {Promise<Object>} The response.
+   */
+  staticRoute(req) {
+    // Get requested path
+    const relativePath = req.params['resource'][0];
+
+    // Resolve requested path to absolute path
+    const absolutePath = _path.default.resolve(this.pagesPath, relativePath);
+
+    // If the requested file is not a HTML file send its raw content
+    if (!absolutePath || !absolutePath.endsWith('.html')) {
+      return this.fileResponse(absolutePath);
+    }
+
+    // Get parameters
+    const params = this.getDefaultParams(req.config);
+    const locale = this.getLocale(req);
+    if (locale) {
+      params.locale = locale;
+    }
+
+    // Get JSON placeholders
+    const placeholders = this.getJsonPlaceholders(locale, params);
+    return this.pageResponse(absolutePath, params, placeholders);
+  }
+
+  /**
+   * Returns a translation from the JSON resource for a given locale. The JSON
+   * resource is parsed according to i18next syntax.
+   *
+   * Example JSON content:
+   * ```js
+   *  {
+   *    "en": {               // resource for language `en` (English)
+   *      "translation": {
+   *        "greeting": "Hello!"
+   *      }
+   *    },
+   *    "de": {               // resource for language `de` (German)
+   *      "translation": {
+   *        "greeting": "Hallo!"
+   *      }
+   *    }
+   *    "de-CH": {            // resource for locale `de-CH` (Swiss German)
+   *      "translation": {
+   *        "greeting": "Grüezi!"
+   *      }
+   *    }
+   *  }
+   * ```
+   * @param {String} locale The locale to translate to.
+   * @returns {Object} The translation or an empty object if no matching
+   * translation was found.
+   */
+  getJsonTranslation(locale) {
+    // If there is no JSON resource
+    if (this.jsonParameters === undefined) {
+      return {};
+    }
+
+    // If locale is not set use the fallback locale
+    locale = locale || this.pagesConfig.localizationFallbackLocale;
+
+    // Get matching translation by locale, language or fallback locale
+    const language = locale.split('-')[0];
+    const resource = this.jsonParameters[locale] || this.jsonParameters[language] || this.jsonParameters[this.pagesConfig.localizationFallbackLocale] || {};
+    const translation = resource.translation || {};
+    return translation;
+  }
+
+  /**
+   * Returns a translation from the JSON resource for a given locale with
+   * placeholders filled in by given parameters.
+   * @param {String} locale The locale to translate to.
+   * @param {Object} params The parameters to fill into any placeholders
+   * within the translations.
+   * @returns {Object} The translation or an empty object if no matching
+   * translation was found.
+   */
+  getJsonPlaceholders(locale, params = {}) {
+    // If localization is disabled or there is no JSON resource
+    if (!this.pagesConfig.enableLocalization || !this.pagesConfig.localizationJsonPath) {
+      return {};
+    }
+
+    // Get JSON placeholders
+    let placeholders = this.getJsonTranslation(locale);
+
+    // Fill in any placeholders in the translation; this allows a translation
+    // to contain default placeholders like {{appName}} which are filled here
+    placeholders = JSON.stringify(placeholders);
+    placeholders = _mustache.default.render(placeholders, params);
+    placeholders = JSON.parse(placeholders);
+    return placeholders;
+  }
+
+  /**
+   * Creates a response with file content.
+   * @param {String} path The path of the file to return.
+   * @param {Object} [params={}] The parameters to be included in the response
+   * header. These will also be used to fill placeholders.
+   * @param {Object} [placeholders={}] The placeholders to fill in the content.
+   * These will not be included in the response header.
+   * @returns {Object} The Promise Router response.
+   */
+  async pageResponse(path, params = {}, placeholders = {}) {
+    // Get file content
+    let data;
+    try {
+      data = await this.readFile(path);
+    } catch {
+      return this.notFound();
+    }
+
+    // Get config placeholders; can be an object, a function or an async function
+    let configPlaceholders = typeof this.pagesConfig.placeholders === 'function' ? this.pagesConfig.placeholders(params) : Object.prototype.toString.call(this.pagesConfig.placeholders) === '[object Object]' ? this.pagesConfig.placeholders : {};
+    if (_Utils.default.isPromise(configPlaceholders)) {
+      configPlaceholders = await configPlaceholders;
+    }
+
+    // Fill placeholders
+    const allPlaceholders = Object.assign({}, configPlaceholders, placeholders);
+    const paramsAndPlaceholders = Object.assign({}, params, allPlaceholders);
+    data = _mustache.default.render(data, paramsAndPlaceholders);
+
+    // Add placeholders in header to allow parsing for programmatic use
+    // of response, instead of having to parse the HTML content.
+    const headers = this.composePageParamHeaders(params);
+    return {
+      text: data,
+      headers: headers
+    };
+  }
+
+  /**
+   * Creates a response with file content.
+   * @param {String} path The path of the file to return.
+   * @returns {Object} The PromiseRouter response.
+   */
+  async fileResponse(path) {
+    // Get file content
+    let data;
+    try {
+      data = await this.readFile(path);
+    } catch {
+      return this.notFound();
+    }
+    return {
+      text: data
+    };
+  }
+
+  /**
+   * Reads and returns the content of a file at a given path. File reading to
+   * serve content on the static route is only allowed from the pages
+   * directory on downwards.
+   * -----------------------------------------------------------------------
+   * **WARNING:** All file reads in the PagesRouter must be executed by this
+   * wrapper because it also detects and prevents common exploits.
+   * -----------------------------------------------------------------------
+   * @param {String} filePath The path to the file to read.
+   * @returns {Promise<String>} The file content.
+   */
+  async readFile(filePath) {
+    // Normalize path to prevent it from containing any directory changing
+    // UNIX patterns which could expose the whole file system, e.g.
+    // `http://example.com/parse/apps/../file.txt` requests a file outside
+    // of the pages directory scope.
+    const normalizedPath = _path.default.normalize(filePath);
+
+    // Abort if the path is outside of the path directory scope
+    if (!normalizedPath.startsWith(this.pagesPath + _path.default.sep)) {
+      throw errors.fileOutsideAllowedScope;
+    }
+    return await _fs.promises.readFile(normalizedPath, 'utf-8');
+  }
+
+  /**
+   * Loads a language resource JSON file that is used for translations.
+   */
+  loadJsonResource() {
+    if (this.pagesConfig.localizationJsonPath === undefined) {
+      return;
+    }
+    try {
+      const json = require(_path.default.resolve('./', this.pagesConfig.localizationJsonPath));
+      this.jsonParameters = json;
+    } catch {
+      throw errors.jsonFailedFileLoading;
+    }
+  }
+
+  /**
+   * Extracts and returns the page default parameters from the Parse Server
+   * configuration. These parameters are made accessible in every page served
+   * by this router.
+   * @param {Object} config The Parse Server configuration.
+   * @returns {Object} The default parameters.
+   */
+  getDefaultParams(config) {
+    return config ? {
+      [pageParams.appId]: config.appId,
+      [pageParams.appName]: config.appName,
+      [pageParams.publicServerUrl]: config.publicServerURL
+    } : {};
+  }
+
+  /**
+   * Extracts and returns the locale from an express request.
+   * @param {Object} req The express request.
+   * @returns {String|undefined} The locale, or undefined if no locale was set.
+   */
+  getLocale(req) {
+    const locale = (req.query || {})[pageParams.locale] || (req.body || {})[pageParams.locale] || (req.params || {})[pageParams.locale] || (req.headers || {})[pageParamHeaderPrefix + pageParams.locale];
+
+    // Validate locale format to prevent path traversal; only allow
+    // standard locale patterns like "en", "en-US", "de-AT", "zh-Hans-CN"
+    if (locale !== undefined && typeof locale !== 'string') {
+      return undefined;
+    }
+    if (typeof locale === 'string' && !/^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$/.test(locale)) {
+      return undefined;
+    }
+    return locale;
+  }
+
+  /**
+   * Composes page parameter headers from the given parameters. Control
+   * characters are always stripped from header values to prevent
+   * ERR_INVALID_CHAR errors. Values are URI-encoded if the
+   * `encodePageParamHeaders` option is enabled.
+   * @param {Object} params The parameters to include in the headers.
+   * @returns {Object} The headers object.
+   */
+  composePageParamHeaders(params) {
+    const encode = this.pagesConfig.encodePageParamHeaders;
+    return Object.entries(params).reduce((m, p) => {
+      if (p[1] !== undefined) {
+        let value = encode ? encodeURIComponent(p[1]) : p[1];
+        if (typeof value === 'string') {
+          // eslint-disable-next-line no-control-regex
+          value = value.replace(/[\x00-\x1f\x7f]/g, '');
+        }
+        m[`${pageParamHeaderPrefix}${p[0].toLowerCase()}`] = value;
+      }
+      return m;
+    }, {});
+  }
+
+  /**
+   * Creates a response with http redirect.
+   * @param {Object} req The express request.
+   * @param {String} path The path of the file to return.
+   * @param {Object} params The query parameters to include.
+   * @returns {Object} The Promise Router response.
+   */
+  async redirectResponse(url, params) {
+    // Remove any parameters with undefined value
+    params = Object.entries(params).reduce((m, p) => {
+      if (p[1] !== undefined) {
+        m[p[0]] = p[1];
+      }
+      return m;
+    }, {});
+
+    // Compose URL with parameters in query
+    const location = new URL(url);
+    Object.entries(params).forEach(p => location.searchParams.set(p[0], p[1]));
+    const locationString = location.toString();
+
+    // Add parameters to header to allow parsing for programmatic use
+    // of response, instead of having to parse the HTML content.
+    const headers = this.composePageParamHeaders(params);
+    return {
+      status: 303,
+      location: locationString,
+      headers: headers
+    };
+  }
+  defaultPagePath(file) {
+    return _path.default.join(this.pagesPath, file);
+  }
+  composePageUrl(file, publicServerUrl, locale) {
+    let url = publicServerUrl;
+    url += url.endsWith('/') ? '' : '/';
+    url += this.pagesEndpoint + '/';
+    url += locale === undefined ? '' : locale + '/';
+    url += file;
+    return url;
+  }
+  notFound() {
+    return {
+      text: 'Not found.',
+      status: 404
+    };
+  }
+  invalidRequest() {
+    const error = new Error();
+    error.status = 403;
+    error.message = 'unauthorized';
+    throw error;
+  }
+
+  /**
+   * Sets the Parse Server configuration in the request object to make it
+   * easily accessible throughtout request processing.
+   * @param {Object} req The request.
+   * @param {Boolean} failGracefully Is true if failing to set the config should
+   * not result in an invalid request response. Default is `false`.
+   */
+  async setConfig(req, failGracefully = false) {
+    req.config = _Config.default.get(req.params.appId || req.query.appId);
+    if (!req.config && !failGracefully) {
+      this.invalidRequest();
+    }
+    if (req.config) {
+      await req.config.loadKeys();
+    }
+  }
+  mountPagesRoutes() {
+    this.route('GET', `/${this.pagesEndpoint}/:appId/verify_email`, req => {
+      return this.setConfig(req);
+    }, req => {
+      return this.verifyEmail(req);
+    });
+    this.route('POST', `/${this.pagesEndpoint}/:appId/resend_verification_email`, req => {
+      return this.setConfig(req);
+    }, req => {
+      return this.resendVerificationEmail(req);
+    });
+    this.route('GET', `/${this.pagesEndpoint}/choose_password`, req => {
+      return this.setConfig(req);
+    }, req => {
+      return this.passwordReset(req);
+    });
+    this.route('POST', `/${this.pagesEndpoint}/:appId/request_password_reset`, req => {
+      return this.setConfig(req);
+    }, req => {
+      return this.resetPassword(req);
+    });
+    this.route('GET', `/${this.pagesEndpoint}/:appId/request_password_reset`, req => {
+      return this.setConfig(req);
+    }, req => {
+      return this.requestResetPassword(req);
+    });
+  }
+  mountCustomRoutes() {
+    for (const route of this.pagesConfig.customRoutes || []) {
+      this.route(route.method, `/${this.pagesEndpoint}/:appId/${route.path}`, req => {
+        return this.setConfig(req);
+      }, async req => {
+        const {
+          file,
+          query = {}
+        } = (await route.handler(req)) || {};
+
+        // If route handler did not return a page send 404 response
+        if (!file) {
+          return this.notFound();
+        }
+
+        // Send page response
+        const page = new _Page.default({
+          id: file,
+          defaultFile: file
+        });
+        return this.goToPage(req, page, query, false);
+      });
+    }
+  }
+  mountStaticRoute() {
+    this.route('GET', `/${this.pagesEndpoint}/*resource`, req => {
+      return this.setConfig(req, true);
+    }, req => {
+      return this.staticRoute(req);
+    });
+  }
+  expressRouter() {
+    const router = _express.default.Router();
+    router.use('/', super.expressRouter());
+    return router;
+  }
+}
+exports.PagesRouter = PagesRouter;
+var _default = exports.default = PagesRouter;
+module.exports = {
+  PagesRouter,
+  pageParamHeaderPrefix,
+  pageParams,
+  pages
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_PromiseRouter","_interopRequireDefault","require","_Config","_express","_path","_fs","_node","_Utils","_mustache","_Page","e","__esModule","default","pages","Object","freeze","passwordReset","Page","id","defaultFile","passwordResetSuccess","passwordResetLinkInvalid","emailVerificationSuccess","emailVerificationSendFail","emailVerificationSendSuccess","emailVerificationLinkInvalid","emailVerificationLinkExpired","pageParams","appName","appId","token","username","error","locale","publicServerUrl","pageParamHeaderPrefix","errors","jsonFailedFileLoading","fileOutsideAllowedScope","PagesRouter","PromiseRouter","constructor","pagesConfig","pagesEndpoint","pagesPath","path","resolve","__dirname","loadJsonResource","mountPagesRoutes","mountCustomRoutes","mountStaticRoute","verifyEmail","req","config","rawToken","query","undefined","invalidRequest","goToPage","userController","then","resendVerificationEmail","body","suppressError","emailVerifySuccessOnInvalidEmail","params","publicServerURL","requestResetPassword","checkResetTokenValidity","applicationId","resetPassword","new_password","xhr","Parse","Error","OTHER_CAUSE","PASSWORD_MISSING","updatePassword","Promise","success","err","result","status","response","page","responseType","redirect","forceRedirect","method","defaultParams","getDefaultParams","values","includes","notFound","assign","getLocale","defaultPath","defaultPagePath","defaultUrl","composePageUrl","customUrl","customUrls","Utils","isPath","redirectResponse","placeholders","enableLocalization","localizationJsonPath","getJsonPlaceholders","getLocalizedPath","subdir","pageResponse","staticRoute","relativePath","absolutePath","endsWith","fileResponse","getJsonTranslation","jsonParameters","localizationFallbackLocale","language","split","resource","translation","JSON","stringify","mustache","render","parse","data","readFile","configPlaceholders","prototype","toString","call","isPromise","allPlaceholders","paramsAndPlaceholders","headers","composePageParamHeaders","text","filePath","normalizedPath","normalize","startsWith","sep","fs","json","test","encode","encodePageParamHeaders","entries","reduce","m","p","value","encodeURIComponent","replace","toLowerCase","url","location","URL","forEach","searchParams","set","locationString","file","join","message","setConfig","failGracefully","Config","get","loadKeys","route","customRoutes","handler","expressRouter","router","express","Router","use","exports","_default","module"],"sources":["../../src/Routers/PagesRouter.js"],"sourcesContent":["import PromiseRouter from '../PromiseRouter';\nimport Config from '../Config';\nimport express from 'express';\nimport path from 'path';\nimport { promises as fs } from 'fs';\nimport { Parse } from 'parse/node';\nimport Utils from '../Utils';\nimport mustache from 'mustache';\nimport Page from '../Page';\n\n// All pages with custom page key for reference and file name\nconst pages = Object.freeze({\n  passwordReset: new Page({ id: 'passwordReset', defaultFile: 'password_reset.html' }),\n  passwordResetSuccess: new Page({\n    id: 'passwordResetSuccess',\n    defaultFile: 'password_reset_success.html',\n  }),\n  passwordResetLinkInvalid: new Page({\n    id: 'passwordResetLinkInvalid',\n    defaultFile: 'password_reset_link_invalid.html',\n  }),\n  emailVerificationSuccess: new Page({\n    id: 'emailVerificationSuccess',\n    defaultFile: 'email_verification_success.html',\n  }),\n  emailVerificationSendFail: new Page({\n    id: 'emailVerificationSendFail',\n    defaultFile: 'email_verification_send_fail.html',\n  }),\n  emailVerificationSendSuccess: new Page({\n    id: 'emailVerificationSendSuccess',\n    defaultFile: 'email_verification_send_success.html',\n  }),\n  emailVerificationLinkInvalid: new Page({\n    id: 'emailVerificationLinkInvalid',\n    defaultFile: 'email_verification_link_invalid.html',\n  }),\n  emailVerificationLinkExpired: new Page({\n    id: 'emailVerificationLinkExpired',\n    defaultFile: 'email_verification_link_expired.html',\n  }),\n});\n\n// All page parameters for reference to be used as template placeholders or query params\nconst pageParams = Object.freeze({\n  appName: 'appName',\n  appId: 'appId',\n  token: 'token',\n  username: 'username',\n  error: 'error',\n  locale: 'locale',\n  publicServerUrl: 'publicServerUrl',\n});\n\n// The header prefix to add page params as response headers\nconst pageParamHeaderPrefix = 'x-parse-page-param-';\n\n// The errors being thrown\nconst errors = Object.freeze({\n  jsonFailedFileLoading: 'failed to load JSON file',\n  fileOutsideAllowedScope: 'not allowed to read file outside of pages directory',\n});\n\nexport class PagesRouter extends PromiseRouter {\n  /**\n   * Constructs a PagesRouter.\n   * @param {Object} pages The pages options from the Parse Server configuration.\n   */\n  constructor(pages = {}) {\n    super();\n\n    // Set instance properties\n    this.pagesConfig = pages;\n    this.pagesEndpoint = pages.pagesEndpoint ? pages.pagesEndpoint : 'apps';\n    this.pagesPath = pages.pagesPath\n      ? path.resolve('./', pages.pagesPath)\n      : path.resolve(__dirname, '../../public');\n    this.loadJsonResource();\n    this.mountPagesRoutes();\n    this.mountCustomRoutes();\n    this.mountStaticRoute();\n  }\n\n  verifyEmail(req) {\n    const config = req.config;\n    const { token: rawToken } = req.query;\n    const token = typeof rawToken === 'string' ? rawToken : undefined;\n\n    if (!config) {\n      this.invalidRequest();\n    }\n\n    if (!token) {\n      return this.goToPage(req, pages.emailVerificationLinkInvalid);\n    }\n\n    const userController = config.userController;\n    return userController.verifyEmail(token).then(\n      () => {\n        return this.goToPage(req, pages.emailVerificationSuccess);\n      },\n      () => {\n        return this.goToPage(req, pages.emailVerificationLinkInvalid);\n      }\n    );\n  }\n\n  resendVerificationEmail(req) {\n    const config = req.config;\n    const username = req.body?.username;\n    const rawToken = req.body?.token;\n    const token = typeof rawToken === 'string' ? rawToken : undefined;\n\n    if (!config) {\n      this.invalidRequest();\n    }\n\n    if (!username && !token) {\n      return this.goToPage(req, pages.emailVerificationLinkInvalid);\n    }\n\n    const userController = config.userController;\n    const suppressError = config.emailVerifySuccessOnInvalidEmail ?? true;\n\n    return userController.resendVerificationEmail(username, req, token).then(\n      () => {\n        return this.goToPage(req, pages.emailVerificationSendSuccess);\n      },\n      () => {\n        if (suppressError) {\n          return this.goToPage(req, pages.emailVerificationSendSuccess);\n        }\n        return this.goToPage(req, pages.emailVerificationSendFail);\n      }\n    );\n  }\n\n  passwordReset(req) {\n    const config = req.config;\n    const params = {\n      [pageParams.appId]: req.params.appId,\n      [pageParams.appName]: config.appName,\n      [pageParams.token]: req.query.token,\n      [pageParams.username]: req.query.username,\n      [pageParams.publicServerUrl]: config.publicServerURL,\n    };\n    return this.goToPage(req, pages.passwordReset, params);\n  }\n\n  requestResetPassword(req) {\n    const config = req.config;\n\n    if (!config) {\n      this.invalidRequest();\n    }\n\n    const { token: rawToken } = req.query;\n    const token = typeof rawToken === 'string' ? rawToken : undefined;\n\n    if (!token) {\n      return this.goToPage(req, pages.passwordResetLinkInvalid);\n    }\n\n    return config.userController.checkResetTokenValidity(token).then(\n      () => {\n        const params = {\n          [pageParams.token]: token,\n          [pageParams.appId]: config.applicationId,\n          [pageParams.appName]: config.appName,\n        };\n        return this.goToPage(req, pages.passwordReset, params);\n      },\n      () => {\n        return this.goToPage(req, pages.passwordResetLinkInvalid);\n      }\n    );\n  }\n\n  resetPassword(req) {\n    const config = req.config;\n\n    if (!config) {\n      this.invalidRequest();\n    }\n\n    const { new_password, token: rawToken } = req.body || {};\n    const token = typeof rawToken === 'string' ? rawToken : undefined;\n\n    if ((!token || !new_password) && req.xhr === false) {\n      return this.goToPage(req, pages.passwordResetLinkInvalid);\n    }\n\n    if (!token) {\n      throw new Parse.Error(Parse.Error.OTHER_CAUSE, 'Missing token');\n    }\n\n    if (!new_password) {\n      throw new Parse.Error(Parse.Error.PASSWORD_MISSING, 'Missing password');\n    }\n\n    return config.userController\n      .updatePassword(token, new_password)\n      .then(\n        () => {\n          return Promise.resolve({\n            success: true,\n          });\n        },\n        err => {\n          return Promise.resolve({\n            success: false,\n            err,\n          });\n        }\n      )\n      .then(result => {\n        if (req.xhr) {\n          if (result.success) {\n            return Promise.resolve({\n              status: 200,\n              response: 'Password successfully reset',\n            });\n          }\n          if (result.err) {\n            throw new Parse.Error(Parse.Error.OTHER_CAUSE, `${result.err}`);\n          }\n        }\n\n        const query = result.success\n          ? {}\n          : {\n            [pageParams.token]: token,\n            [pageParams.appId]: config.applicationId,\n            [pageParams.error]: result.err,\n            [pageParams.appName]: config.appName,\n          };\n\n        if (result?.err === 'The password reset link has expired') {\n          delete query[pageParams.token];\n          query[pageParams.token] = token;\n        }\n        const page = result.success ? pages.passwordResetSuccess : pages.passwordReset;\n\n        return this.goToPage(req, page, query, false);\n      });\n  }\n\n  /**\n   * Returns page content if the page is a local file or returns a\n   * redirect to a custom page.\n   * @param {Object} req The express request.\n   * @param {Page} page The page to go to.\n   * @param {Object} [params={}] The query parameters to attach to the URL in case of\n   * HTTP redirect responses for POST requests, or the placeholders to fill into\n   * the response content in case of HTTP content responses for GET requests.\n   * @param {Boolean} [responseType] Is true if a redirect response should be forced,\n   * false if a content response should be forced, undefined if the response type\n   * should depend on the request type by default:\n   * - GET request -> content response\n   * - POST request -> redirect response (PRG pattern)\n   * @returns {Promise<Object>} The PromiseRouter response.\n   */\n  goToPage(req, page, params = {}, responseType) {\n    const config = req.config;\n\n    // Determine redirect either by force, response setting or request method\n    const redirect = config.pages.forceRedirect\n      ? true\n      : responseType !== undefined\n        ? responseType\n        : req.method == 'POST';\n\n    // Include default parameters\n    const defaultParams = this.getDefaultParams(config);\n    if (Object.values(defaultParams).includes(undefined)) {\n      return this.notFound();\n    }\n    params = Object.assign(params, defaultParams);\n\n    // Add locale to params to ensure it is passed on with every request;\n    // that means, once a locale is set, it is passed on to any follow-up page,\n    // e.g. request_password_reset -> password_reset -> password_reset_success\n    const locale = this.getLocale(req);\n    params[pageParams.locale] = locale;\n\n    // Compose paths and URLs\n    const defaultFile = page.defaultFile;\n    const defaultPath = this.defaultPagePath(defaultFile);\n    const defaultUrl = this.composePageUrl(defaultFile, config.publicServerURL);\n\n    // If custom URL is set redirect to it without localization\n    const customUrl = config.pages.customUrls[page.id];\n    if (customUrl && !Utils.isPath(customUrl)) {\n      return this.redirectResponse(customUrl, params);\n    }\n\n    // Get JSON placeholders\n    let placeholders = {};\n    if (config.pages.enableLocalization && config.pages.localizationJsonPath) {\n      placeholders = this.getJsonPlaceholders(locale, params);\n    }\n\n    // Send response\n    if (config.pages.enableLocalization && locale) {\n      return Utils.getLocalizedPath(defaultPath, locale).then(({ path, subdir }) =>\n        redirect\n          ? this.redirectResponse(\n            this.composePageUrl(defaultFile, config.publicServerURL, subdir),\n            params\n          )\n          : this.pageResponse(path, params, placeholders)\n      );\n    } else {\n      return redirect\n        ? this.redirectResponse(defaultUrl, params)\n        : this.pageResponse(defaultPath, params, placeholders);\n    }\n  }\n\n  /**\n   * Serves a request to a static resource and localizes the resource if it\n   * is a HTML file.\n   * @param {Object} req The request object.\n   * @returns {Promise<Object>} The response.\n   */\n  staticRoute(req) {\n    // Get requested path\n    const relativePath = req.params['resource'][0];\n\n    // Resolve requested path to absolute path\n    const absolutePath = path.resolve(this.pagesPath, relativePath);\n\n    // If the requested file is not a HTML file send its raw content\n    if (!absolutePath || !absolutePath.endsWith('.html')) {\n      return this.fileResponse(absolutePath);\n    }\n\n    // Get parameters\n    const params = this.getDefaultParams(req.config);\n    const locale = this.getLocale(req);\n    if (locale) {\n      params.locale = locale;\n    }\n\n    // Get JSON placeholders\n    const placeholders = this.getJsonPlaceholders(locale, params);\n\n    return this.pageResponse(absolutePath, params, placeholders);\n  }\n\n  /**\n   * Returns a translation from the JSON resource for a given locale. The JSON\n   * resource is parsed according to i18next syntax.\n   *\n   * Example JSON content:\n   * ```js\n   *  {\n   *    \"en\": {               // resource for language `en` (English)\n   *      \"translation\": {\n   *        \"greeting\": \"Hello!\"\n   *      }\n   *    },\n   *    \"de\": {               // resource for language `de` (German)\n   *      \"translation\": {\n   *        \"greeting\": \"Hallo!\"\n   *      }\n   *    }\n   *    \"de-CH\": {            // resource for locale `de-CH` (Swiss German)\n   *      \"translation\": {\n   *        \"greeting\": \"Grüezi!\"\n   *      }\n   *    }\n   *  }\n   * ```\n   * @param {String} locale The locale to translate to.\n   * @returns {Object} The translation or an empty object if no matching\n   * translation was found.\n   */\n  getJsonTranslation(locale) {\n    // If there is no JSON resource\n    if (this.jsonParameters === undefined) {\n      return {};\n    }\n\n    // If locale is not set use the fallback locale\n    locale = locale || this.pagesConfig.localizationFallbackLocale;\n\n    // Get matching translation by locale, language or fallback locale\n    const language = locale.split('-')[0];\n    const resource =\n      this.jsonParameters[locale] ||\n      this.jsonParameters[language] ||\n      this.jsonParameters[this.pagesConfig.localizationFallbackLocale] ||\n      {};\n    const translation = resource.translation || {};\n    return translation;\n  }\n\n  /**\n   * Returns a translation from the JSON resource for a given locale with\n   * placeholders filled in by given parameters.\n   * @param {String} locale The locale to translate to.\n   * @param {Object} params The parameters to fill into any placeholders\n   * within the translations.\n   * @returns {Object} The translation or an empty object if no matching\n   * translation was found.\n   */\n  getJsonPlaceholders(locale, params = {}) {\n    // If localization is disabled or there is no JSON resource\n    if (!this.pagesConfig.enableLocalization || !this.pagesConfig.localizationJsonPath) {\n      return {};\n    }\n\n    // Get JSON placeholders\n    let placeholders = this.getJsonTranslation(locale);\n\n    // Fill in any placeholders in the translation; this allows a translation\n    // to contain default placeholders like {{appName}} which are filled here\n    placeholders = JSON.stringify(placeholders);\n    placeholders = mustache.render(placeholders, params);\n    placeholders = JSON.parse(placeholders);\n\n    return placeholders;\n  }\n\n  /**\n   * Creates a response with file content.\n   * @param {String} path The path of the file to return.\n   * @param {Object} [params={}] The parameters to be included in the response\n   * header. These will also be used to fill placeholders.\n   * @param {Object} [placeholders={}] The placeholders to fill in the content.\n   * These will not be included in the response header.\n   * @returns {Object} The Promise Router response.\n   */\n  async pageResponse(path, params = {}, placeholders = {}) {\n    // Get file content\n    let data;\n    try {\n      data = await this.readFile(path);\n    } catch {\n      return this.notFound();\n    }\n\n    // Get config placeholders; can be an object, a function or an async function\n    let configPlaceholders =\n      typeof this.pagesConfig.placeholders === 'function'\n        ? this.pagesConfig.placeholders(params)\n        : Object.prototype.toString.call(this.pagesConfig.placeholders) === '[object Object]'\n          ? this.pagesConfig.placeholders\n          : {};\n    if (Utils.isPromise(configPlaceholders)) {\n      configPlaceholders = await configPlaceholders;\n    }\n\n    // Fill placeholders\n    const allPlaceholders = Object.assign({}, configPlaceholders, placeholders);\n    const paramsAndPlaceholders = Object.assign({}, params, allPlaceholders);\n    data = mustache.render(data, paramsAndPlaceholders);\n\n    // Add placeholders in header to allow parsing for programmatic use\n    // of response, instead of having to parse the HTML content.\n    const headers = this.composePageParamHeaders(params);\n\n    return { text: data, headers: headers };\n  }\n\n  /**\n   * Creates a response with file content.\n   * @param {String} path The path of the file to return.\n   * @returns {Object} The PromiseRouter response.\n   */\n  async fileResponse(path) {\n    // Get file content\n    let data;\n    try {\n      data = await this.readFile(path);\n    } catch {\n      return this.notFound();\n    }\n\n    return { text: data };\n  }\n\n  /**\n   * Reads and returns the content of a file at a given path. File reading to\n   * serve content on the static route is only allowed from the pages\n   * directory on downwards.\n   * -----------------------------------------------------------------------\n   * **WARNING:** All file reads in the PagesRouter must be executed by this\n   * wrapper because it also detects and prevents common exploits.\n   * -----------------------------------------------------------------------\n   * @param {String} filePath The path to the file to read.\n   * @returns {Promise<String>} The file content.\n   */\n  async readFile(filePath) {\n    // Normalize path to prevent it from containing any directory changing\n    // UNIX patterns which could expose the whole file system, e.g.\n    // `http://example.com/parse/apps/../file.txt` requests a file outside\n    // of the pages directory scope.\n    const normalizedPath = path.normalize(filePath);\n\n    // Abort if the path is outside of the path directory scope\n    if (!normalizedPath.startsWith(this.pagesPath + path.sep)) {\n      throw errors.fileOutsideAllowedScope;\n    }\n\n    return await fs.readFile(normalizedPath, 'utf-8');\n  }\n\n  /**\n   * Loads a language resource JSON file that is used for translations.\n   */\n  loadJsonResource() {\n    if (this.pagesConfig.localizationJsonPath === undefined) {\n      return;\n    }\n    try {\n      const json = require(path.resolve('./', this.pagesConfig.localizationJsonPath));\n      this.jsonParameters = json;\n    } catch {\n      throw errors.jsonFailedFileLoading;\n    }\n  }\n\n  /**\n   * Extracts and returns the page default parameters from the Parse Server\n   * configuration. These parameters are made accessible in every page served\n   * by this router.\n   * @param {Object} config The Parse Server configuration.\n   * @returns {Object} The default parameters.\n   */\n  getDefaultParams(config) {\n    return config\n      ? {\n        [pageParams.appId]: config.appId,\n        [pageParams.appName]: config.appName,\n        [pageParams.publicServerUrl]: config.publicServerURL,\n      }\n      : {};\n  }\n\n  /**\n   * Extracts and returns the locale from an express request.\n   * @param {Object} req The express request.\n   * @returns {String|undefined} The locale, or undefined if no locale was set.\n   */\n  getLocale(req) {\n    const locale =\n      (req.query || {})[pageParams.locale] ||\n      (req.body || {})[pageParams.locale] ||\n      (req.params || {})[pageParams.locale] ||\n      (req.headers || {})[pageParamHeaderPrefix + pageParams.locale];\n\n    // Validate locale format to prevent path traversal; only allow\n    // standard locale patterns like \"en\", \"en-US\", \"de-AT\", \"zh-Hans-CN\"\n    if (locale !== undefined && typeof locale !== 'string') {\n      return undefined;\n    }\n    if (typeof locale === 'string' && !/^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$/.test(locale)) {\n      return undefined;\n    }\n    return locale;\n  }\n\n  /**\n   * Composes page parameter headers from the given parameters. Control\n   * characters are always stripped from header values to prevent\n   * ERR_INVALID_CHAR errors. Values are URI-encoded if the\n   * `encodePageParamHeaders` option is enabled.\n   * @param {Object} params The parameters to include in the headers.\n   * @returns {Object} The headers object.\n   */\n  composePageParamHeaders(params) {\n    const encode = this.pagesConfig.encodePageParamHeaders;\n    return Object.entries(params).reduce((m, p) => {\n      if (p[1] !== undefined) {\n        let value = encode ? encodeURIComponent(p[1]) : p[1];\n        if (typeof value === 'string') {\n          // eslint-disable-next-line no-control-regex\n          value = value.replace(/[\\x00-\\x1f\\x7f]/g, '');\n        }\n        m[`${pageParamHeaderPrefix}${p[0].toLowerCase()}`] = value;\n      }\n      return m;\n    }, {});\n  }\n\n  /**\n   * Creates a response with http redirect.\n   * @param {Object} req The express request.\n   * @param {String} path The path of the file to return.\n   * @param {Object} params The query parameters to include.\n   * @returns {Object} The Promise Router response.\n   */\n  async redirectResponse(url, params) {\n    // Remove any parameters with undefined value\n    params = Object.entries(params).reduce((m, p) => {\n      if (p[1] !== undefined) {\n        m[p[0]] = p[1];\n      }\n      return m;\n    }, {});\n\n    // Compose URL with parameters in query\n    const location = new URL(url);\n    Object.entries(params).forEach(p => location.searchParams.set(p[0], p[1]));\n    const locationString = location.toString();\n\n    // Add parameters to header to allow parsing for programmatic use\n    // of response, instead of having to parse the HTML content.\n    const headers = this.composePageParamHeaders(params);\n\n    return {\n      status: 303,\n      location: locationString,\n      headers: headers,\n    };\n  }\n\n  defaultPagePath(file) {\n    return path.join(this.pagesPath, file);\n  }\n\n  composePageUrl(file, publicServerUrl, locale) {\n    let url = publicServerUrl;\n    url += url.endsWith('/') ? '' : '/';\n    url += this.pagesEndpoint + '/';\n    url += locale === undefined ? '' : locale + '/';\n    url += file;\n    return url;\n  }\n\n  notFound() {\n    return {\n      text: 'Not found.',\n      status: 404,\n    };\n  }\n\n  invalidRequest() {\n    const error = new Error();\n    error.status = 403;\n    error.message = 'unauthorized';\n    throw error;\n  }\n\n  /**\n   * Sets the Parse Server configuration in the request object to make it\n   * easily accessible throughtout request processing.\n   * @param {Object} req The request.\n   * @param {Boolean} failGracefully Is true if failing to set the config should\n   * not result in an invalid request response. Default is `false`.\n   */\n  async setConfig(req, failGracefully = false) {\n    req.config = Config.get(req.params.appId || req.query.appId);\n    if (!req.config && !failGracefully) {\n      this.invalidRequest();\n    }\n    if (req.config) {\n      await req.config.loadKeys();\n    }\n  }\n\n  mountPagesRoutes() {\n    this.route(\n      'GET',\n      `/${this.pagesEndpoint}/:appId/verify_email`,\n      req => {\n        return this.setConfig(req);\n      },\n      req => {\n        return this.verifyEmail(req);\n      }\n    );\n\n    this.route(\n      'POST',\n      `/${this.pagesEndpoint}/:appId/resend_verification_email`,\n      req => {\n        return this.setConfig(req);\n      },\n      req => {\n        return this.resendVerificationEmail(req);\n      }\n    );\n\n    this.route(\n      'GET',\n      `/${this.pagesEndpoint}/choose_password`,\n      req => {\n        return this.setConfig(req);\n      },\n      req => {\n        return this.passwordReset(req);\n      }\n    );\n\n    this.route(\n      'POST',\n      `/${this.pagesEndpoint}/:appId/request_password_reset`,\n      req => {\n        return this.setConfig(req);\n      },\n      req => {\n        return this.resetPassword(req);\n      }\n    );\n\n    this.route(\n      'GET',\n      `/${this.pagesEndpoint}/:appId/request_password_reset`,\n      req => {\n        return this.setConfig(req);\n      },\n      req => {\n        return this.requestResetPassword(req);\n      }\n    );\n  }\n\n  mountCustomRoutes() {\n    for (const route of this.pagesConfig.customRoutes || []) {\n      this.route(\n        route.method,\n        `/${this.pagesEndpoint}/:appId/${route.path}`,\n        req => {\n          return this.setConfig(req);\n        },\n        async req => {\n          const { file, query = {} } = (await route.handler(req)) || {};\n\n          // If route handler did not return a page send 404 response\n          if (!file) {\n            return this.notFound();\n          }\n\n          // Send page response\n          const page = new Page({ id: file, defaultFile: file });\n          return this.goToPage(req, page, query, false);\n        }\n      );\n    }\n  }\n\n  mountStaticRoute() {\n    this.route(\n      'GET',\n      `/${this.pagesEndpoint}/*resource`,\n      req => {\n        return this.setConfig(req, true);\n      },\n      req => {\n        return this.staticRoute(req);\n      }\n    );\n  }\n\n  expressRouter() {\n    const router = express.Router();\n    router.use('/', super.expressRouter());\n    return router;\n  }\n}\n\nexport default PagesRouter;\nmodule.exports = {\n  PagesRouter,\n  pageParamHeaderPrefix,\n  pageParams,\n  pages,\n};\n"],"mappings":"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","ignoreList":[]}