parse-server 4.10.2 → 5.0.0-alpha.2

package/lib/Routers/PagesRouter.js

@@ -0,0 +1,722 @@
+"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(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// 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 {
+      username,
+      token: rawToken
+    } = req.query;
+    const token = rawToken && typeof rawToken !== 'string' ? rawToken.toString() : rawToken;
+
+    if (!config) {
+      this.invalidRequest();
+    }
+
+    if (!token || !username) {
+      return this.goToPage(req, pages.emailVerificationLinkInvalid);
+    }
+
+    const userController = config.userController;
+    return userController.verifyEmail(username, token).then(() => {
+      const params = {
+        [pageParams.username]: username
+      };
+      return this.goToPage(req, pages.emailVerificationSuccess, params);
+    }, () => {
+      const params = {
+        [pageParams.username]: username
+      };
+      return this.goToPage(req, pages.emailVerificationLinkExpired, params);
+    });
+  }
+
+  resendVerificationEmail(req) {
+    const config = req.config;
+    const username = req.body.username;
+
+    if (!config) {
+      this.invalidRequest();
+    }
+
+    if (!username) {
+      return this.goToPage(req, pages.emailVerificationLinkInvalid);
+    }
+
+    const userController = config.userController;
+    return userController.resendVerificationEmail(username).then(() => {
+      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 {
+      username,
+      token: rawToken
+    } = req.query;
+    const token = rawToken && typeof rawToken !== 'string' ? rawToken.toString() : rawToken;
+
+    if (!username || !token) {
+      return this.goToPage(req, pages.passwordResetLinkInvalid);
+    }
+
+    return config.userController.checkResetTokenValidity(username, token).then(() => {
+      const params = {
+        [pageParams.token]: token,
+        [pageParams.username]: username,
+        [pageParams.appId]: config.applicationId,
+        [pageParams.appName]: config.appName
+      };
+      return this.goToPage(req, pages.passwordReset, params);
+    }, () => {
+      const params = {
+        [pageParams.username]: username
+      };
+      return this.goToPage(req, pages.passwordResetLinkInvalid, params);
+    });
+  }
+
+  resetPassword(req) {
+    const config = req.config;
+
+    if (!config) {
+      this.invalidRequest();
+    }
+
+    const {
+      username,
+      new_password,
+      token: rawToken
+    } = req.body;
+    const token = rawToken && typeof rawToken !== 'string' ? rawToken.toString() : rawToken;
+
+    if ((!username || !token || !new_password) && req.xhr === false) {
+      return this.goToPage(req, pages.passwordResetLinkInvalid);
+    }
+
+    if (!username) {
+      throw new _node.Parse.Error(_node.Parse.Error.USERNAME_MISSING, 'Missing username');
+    }
+
+    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(username, 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.username]: username
+      } : {
+        [pageParams.username]: username,
+        [pageParams.token]: token,
+        [pageParams.appId]: config.applicationId,
+        [pageParams.error]: result.err,
+        [pageParams.appName]: config.appName
+      };
+      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[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 (e) {
+      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 (configPlaceholders instanceof Promise) {
+      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 = Object.entries(params).reduce((m, p) => {
+      if (p[1] !== undefined) {
+        m[`${pageParamHeaderPrefix}${p[0].toLowerCase()}`] = p[1];
+      }
+
+      return m;
+    }, {});
+    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 (e) {
+      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)) {
+      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 (e) {
+      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];
+    return locale;
+  }
+  /**
+   * 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 = Object.entries(params).reduce((m, p) => {
+      if (p[1] !== undefined) {
+        m[`${pageParamHeaderPrefix}${p[0].toLowerCase()}`] = p[1];
+      }
+
+      return m;
+    }, {});
+    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`.
+   */
+
+
+  setConfig(req, failGracefully = false) {
+    req.config = _Config.default.get(req.params.appId || req.query.appId);
+
+    if (!req.config && !failGracefully) {
+      this.invalidRequest();
+    }
+
+    return Promise.resolve();
+  }
+
+  mountPagesRoutes() {
+    this.route('GET', `/${this.pagesEndpoint}/:appId/verify_email`, req => {
+      this.setConfig(req);
+    }, req => {
+      return this.verifyEmail(req);
+    });
+    this.route('POST', `/${this.pagesEndpoint}/:appId/resend_verification_email`, req => {
+      this.setConfig(req);
+    }, req => {
+      return this.resendVerificationEmail(req);
+    });
+    this.route('GET', `/${this.pagesEndpoint}/choose_password`, req => {
+      this.setConfig(req);
+    }, req => {
+      return this.passwordReset(req);
+    });
+    this.route('POST', `/${this.pagesEndpoint}/:appId/request_password_reset`, req => {
+      this.setConfig(req);
+    }, req => {
+      return this.resetPassword(req);
+    });
+    this.route('GET', `/${this.pagesEndpoint}/:appId/request_password_reset`, req => {
+      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 => {
+        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}/(*)?`, req => {
+      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 = PagesRouter;
+exports.default = _default;
+module.exports = {
+  PagesRouter,
+  pageParamHeaderPrefix,
+  pageParams,
+  pages
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Routers/PagesRouter.js"],"names":["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","toString","invalidRequest","goToPage","userController","then","params","resendVerificationEmail","body","publicServerURL","requestResetPassword","checkResetTokenValidity","applicationId","resetPassword","new_password","xhr","Parse","Error","USERNAME_MISSING","OTHER_CAUSE","PASSWORD_MISSING","updatePassword","Promise","success","err","result","status","response","page","responseType","redirect","forceRedirect","undefined","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","e","configPlaceholders","prototype","call","allPlaceholders","paramsAndPlaceholders","headers","entries","reduce","m","p","toLowerCase","text","filePath","normalizedPath","normalize","startsWith","fs","json","require","url","location","URL","forEach","searchParams","set","locationString","file","join","message","setConfig","failGracefully","Config","get","route","customRoutes","handler","expressRouter","router","express","Router","use","module","exports"],"mappings":"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","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 { username, token: rawToken } = req.query;\n    const token = rawToken && typeof rawToken !== 'string' ? rawToken.toString() : rawToken;\n\n    if (!config) {\n      this.invalidRequest();\n    }\n\n    if (!token || !username) {\n      return this.goToPage(req, pages.emailVerificationLinkInvalid);\n    }\n\n    const userController = config.userController;\n    return userController.verifyEmail(username, token).then(\n      () => {\n        const params = {\n          [pageParams.username]: username,\n        };\n        return this.goToPage(req, pages.emailVerificationSuccess, params);\n      },\n      () => {\n        const params = {\n          [pageParams.username]: username,\n        };\n        return this.goToPage(req, pages.emailVerificationLinkExpired, params);\n      }\n    );\n  }\n\n  resendVerificationEmail(req) {\n    const config = req.config;\n    const username = req.body.username;\n\n    if (!config) {\n      this.invalidRequest();\n    }\n\n    if (!username) {\n      return this.goToPage(req, pages.emailVerificationLinkInvalid);\n    }\n\n    const userController = config.userController;\n\n    return userController.resendVerificationEmail(username).then(\n      () => {\n        return this.goToPage(req, pages.emailVerificationSendSuccess);\n      },\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 { username, token: rawToken } = req.query;\n    const token = rawToken && typeof rawToken !== 'string' ? rawToken.toString() : rawToken;\n\n    if (!username || !token) {\n      return this.goToPage(req, pages.passwordResetLinkInvalid);\n    }\n\n    return config.userController.checkResetTokenValidity(username, token).then(\n      () => {\n        const params = {\n          [pageParams.token]: token,\n          [pageParams.username]: username,\n          [pageParams.appId]: config.applicationId,\n          [pageParams.appName]: config.appName,\n        };\n        return this.goToPage(req, pages.passwordReset, params);\n      },\n      () => {\n        const params = {\n          [pageParams.username]: username,\n        };\n        return this.goToPage(req, pages.passwordResetLinkInvalid, params);\n      }\n    );\n  }\n\n  resetPassword(req) {\n    const config = req.config;\n\n    if (!config) {\n      this.invalidRequest();\n    }\n\n    const { username, new_password, token: rawToken } = req.body;\n    const token = rawToken && typeof rawToken !== 'string' ? rawToken.toString() : rawToken;\n\n    if ((!username || !token || !new_password) && req.xhr === false) {\n      return this.goToPage(req, pages.passwordResetLinkInvalid);\n    }\n\n    if (!username) {\n      throw new Parse.Error(Parse.Error.USERNAME_MISSING, 'Missing username');\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(username, 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            [pageParams.username]: username,\n          }\n          : {\n            [pageParams.username]: username,\n            [pageParams.token]: token,\n            [pageParams.appId]: config.applicationId,\n            [pageParams.error]: result.err,\n            [pageParams.appName]: config.appName,\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[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 (e) {\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 (configPlaceholders instanceof Promise) {\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 = Object.entries(params).reduce((m, p) => {\n      if (p[1] !== undefined) {\n        m[`${pageParamHeaderPrefix}${p[0].toLowerCase()}`] = p[1];\n      }\n      return m;\n    }, {});\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 (e) {\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)) {\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 (e) {\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    return locale;\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 = Object.entries(params).reduce((m, p) => {\n      if (p[1] !== undefined) {\n        m[`${pageParamHeaderPrefix}${p[0].toLowerCase()}`] = p[1];\n      }\n      return m;\n    }, {});\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  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    return Promise.resolve();\n  }\n\n  mountPagesRoutes() {\n    this.route(\n      'GET',\n      `/${this.pagesEndpoint}/:appId/verify_email`,\n      req => {\n        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        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        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        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        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          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}/(*)?`,\n      req => {\n        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"]}