jimpex 7.0.2 → 8.0.0

package/src/services/http/http.js

@@ -1,256 +0,0 @@
-const fetch = require('node-fetch');
-const urijs = require('urijs');
-const { provider } = require('../../utils/wrappers');
-
-/**
- * @typedef {import('../../types').Logger} Logger
- * @typedef {import('../../types').Provider} Provider
- * @typedef {import('node-fetch').Response} Response
- * @typedef {import('../../types').ExpressRequest} ExpressRequest
- */
-
-/**
- * @typedef {Object} HTTPFetchOptions
- * @property {?string}                  method   The request method.
- * @property {?Object.<string, string>} headers  The request headers.
- * @property {?string}                  body     The request body.
- * @property {?Object.<string, string>} qs       The request query string parameters.
- * @property {?ExpressRequest}          req      An Express request object used to get
- *                                               extra infromation (like headers and the
- *                                               IP).
- * @parent module:services
- */
-
-/**
- * A set of utilities to work with HTTP requests and responses.
- *
- * @parent module:services
- */
-class HTTP {
-  /**
-   * @param {boolean} logRequests  Whether or not to log the requests and their responses.
-   * @param {Logger}  appLogger    If `logRequests` is `true`, this will be used to log
-   *                               the requests and responses information.
-   */
-  constructor(logRequests, appLogger) {
-    /**
-     * Whether or not to log the requests and their responses.
-     *
-     * @type {boolean}
-     * @access protected
-     * @ignore
-     */
-    this._logRequests = logRequests;
-    /**
-     * A local reference for the `appLogger` service.
-     *
-     * @type {Logger}
-     * @access protected
-     * @ignore
-     */
-    this._appLogger = appLogger;
-    /**
-     * So it can be sent to other services as a reference.
-     *
-     * @ignore
-     */
-    this.fetch = this.fetch.bind(this);
-  }
-  /**
-   * Make a request.
-   *
-   * @param {string}                    url           The request URL.
-   * @param {Partial<HTTPFetchOptions>} [options={}]  The request options.
-   * @returns {Promise<Response>}
-   */
-  fetch(url, options = {}) {
-    // Get a mutable reference for the URL.
-    let fetchURL = url;
-    // If there are query string parameters...
-    if (options.qs) {
-      // ...use `urijs` to inject them on the URL reference.
-      fetchURL = urijs(url).addSearch(options.qs).toString();
-    }
-    // Define an object that will hold the new set of options.
-    const fetchOptions = {
-      // Set the request method and make it fallback to `GET` if it wasn't set.
-      method: (options.method || 'get').toUpperCase(),
-    };
-    // If there's a body, add it to the new options.
-    if (options.body) {
-      fetchOptions.body = options.body;
-    }
-    // Define the base headers for the request.
-    let defaultHeaders = {};
-    // If there's an Express request object on the `options`...
-    if (options.req) {
-      /**
-       * Overwrite the base headers with the request original IP as `x-forwarded-for` and all the
-       * received custom headers that request may have.
-       */
-      defaultHeaders = {
-        'x-forwarded-for': this.getIPFromRequest(options.req),
-        ...this.getCustomHeadersFromRequest(options.req),
-      };
-    }
-    // Merge the base headers with the ones received on the `options`.
-    const headers = {
-      ...defaultHeaders,
-      ...(options.headers || {}),
-    };
-    /**
-     * If there's at least one header on the dictionary, add it to the new options. This check is
-     * to avoid sending an empty object.
-     */
-    if (Object.keys(headers).length) {
-      fetchOptions.headers = this.normalizeHeaders(headers);
-    }
-    // If the `logRequests` flag is `true`, call the method to log the request.
-    if (this._logRequests) {
-      this._logRequest(fetchURL, fetchOptions);
-    }
-    // Make the request.
-    let result = fetch(fetchURL, fetchOptions);
-    // If the `logRequests` flag is `true`...
-    if (this._logRequests) {
-      // Add an extra step on the promise chain to log the response.
-      result = result.then((response) => {
-        this._logResponse(response);
-        return response;
-      });
-    }
-    // Return the request promise.
-    return result;
-  }
-  /**
-   * Creates a dictionary with all the custom headers a request has. By custom header it
-   * means all the headers which name start with `x-`.
-   * This method doesn't copy `x-forwarded-for` as the `fetch` method generates it by
-   * calling `getIPFromRequest`.
-   *
-   * @param {ExpressRequest} req  The request from which it will try to get the headers.
-   * @returns {Object.<string, string>}
-   */
-  getCustomHeadersFromRequest(req) {
-    const headers = {};
-    Object.keys(req.headers).forEach((headerName) => {
-      if (headerName.startsWith('x-') && !headerName.startsWith('x-forwarded-for')) {
-        headers[headerName] = req.headers[headerName];
-      }
-    });
-
-    return headers;
-  }
-  /**
-   * Try to get the IP from a given request.
-   *
-   * @param {ExpressRequest} req  The request from which it will try to obtain the IP
-   *                              address.
-   * @returns {?string}
-   */
-  getIPFromRequest(req) {
-    return (
-      req.headers['x-forwarded-for'] ||
-      req.connection.remoteAddress ||
-      req.socket.remoteAddress ||
-      req.connection.socket.remoteAddress
-    );
-  }
-  /**
-   * It takes a dictionary of headers and normalize the names so each word will start with
-   * an upper case character. This is helpful in case you added custom headers and didn't
-   * care about the casing, or when copying headers from a server request, in which case
-   * they are all tranformed to lower case.
-   *
-   * @param {Object.<string, string>} headers  The dictionary of headers to normalize.
-   * @returns {Object.<string, string>}
-   */
-  normalizeHeaders(headers) {
-    return Object.keys(headers).reduce((newHeaders, name) => {
-      const newName = name
-        .split('-')
-        .map((part) => part.replace(/^(\w)/, (ignore, letter) => letter.toUpperCase()))
-        .join('-');
-      return {
-        ...newHeaders,
-        [newName]: headers[name],
-      };
-    }, {});
-  }
-  /**
-   * Whether or not to log the requests and their responses.
-   *
-   * @type {boolean}
-   */
-  get logRequests() {
-    return this._logRequests;
-  }
-  /**
-   * Log a a request information using the `appLogger` service.
-   *
-   * @param {string}           url      The request URL.
-   * @param {HTTPFetchOptions} options  The options generated by the `fetch` method.
-   * @access protected
-   * @ignore
-   */
-  _logRequest(url, options) {
-    const prefix = 'REQUEST> ';
-    const lines = ['--->>', `${prefix}${options.method} ${url}`];
-    if (options.headers) {
-      Object.keys(options.headers).forEach((header) => {
-        lines.push(`${prefix}${header}: ${options.headers[header]}`);
-      });
-    }
-
-    if (options.body) {
-      lines.push(`${prefix}body: "${options.body}"`);
-    }
-
-    this._appLogger.info(lines);
-  }
-  /**
-   * Log a a response information using the `appLogger` service.
-   *
-   * @param {Response} response  The response object returned by `node-fetch`.
-   * @access protected
-   * @ignore
-   */
-  _logResponse(response) {
-    const prefix = 'RESPONSE> ';
-    const lines = [
-      '<<---',
-      `${prefix}${response.url}`,
-      `${prefix}status: ${response.status}`,
-    ];
-
-    response.headers.forEach((value, header) => {
-      lines.push(`${prefix}${header}: ${value}`);
-    });
-
-    this._appLogger.info(lines);
-  }
-}
-/**
- * The service provider that once registered on the app container will set an instance of
- * `HTTP` as the `http` service. The provider also checks the `debug.logRequests` setting
- * on the app configuration in order to enable or not the logging of requests.
- *
- * @type {Provider}
- * @example
- *
- *   // Register it on the container
- *   container.register(http);
- *   // Getting access to the service instance
- *   const http = container.get('http');
- *
- * @parent module:services
- */
-const http = provider((app) => {
-  app.set('http', () => {
-    const logRequests = app.get('appConfiguration').get('debug.logRequests') === true;
-    return new HTTP(logRequests, app.get('appLogger'));
-  });
-});
-
-module.exports.HTTP = HTTP;
-module.exports.http = http;

package/src/services/http/index.js

@@ -1,25 +0,0 @@
-const { apiClient } = require('./apiClient');
-const { http } = require('./http');
-const { responsesBuilder } = require('./responsesBuilder');
-const { providers } = require('../../utils/wrappers');
-
-/**
- * @typedef {import('../../types').Provider} Provider
- */
-
-/**
- * The providers collection for the HTTP services.
- *
- * @type {Provider}
- * @property {Provider} apiClient         The provider for {@link APIClient}.
- * @property {Provider} http              The provider for {@link HTTP}.
- * @property {Provider} responsesBuilder  The provider for {@link ResponsesBuilder}.
- * @parent module:services
- */
-const httpServices = providers({
-  apiClient,
-  http,
-  responsesBuilder,
-});
-
-module.exports = httpServices;

package/src/services/http/responsesBuilder.js

@@ -1,193 +0,0 @@
-const { code: statuses } = require('statuses');
-const { provider } = require('../../utils/wrappers');
-
-/**
- * @typedef {import('../../types').Provider} Provider
- * @typedef {import('../../types').AppConfiguration} AppConfiguration
- * @typedef {import('../../types').ExpressResponse} ExpressResponse
- */
-
-/**
- * It allows customization of a post message HTML template.
- *
- * @typedef {Object} ResponsesBuilderPostMessageOptions
- * @property {?string} target
- * The target that will emit the `postMessage`.
- * Default `'window.opener'`.
- * @property {?boolean} close
- * Whether or not to do a `window.close` after sending the message.
- * Default `true`.
- * @property {?number} closeDelay
- * How many ms should it wait before closing the window, if `options.close` is `true`.
- * Default `700`.
- * @parent module:services
- */
-
-/**
- * A utility service to build server responses.
- *
- * @parent module:services
- */
-class ResponsesBuilder {
-  /**
-   * @param {AppConfiguration} appConfiguration  To get the app version.
-   */
-  constructor(appConfiguration) {
-    /**
-     * A local reference for the `appConfiguration` service.
-     *
-     * @type {AppConfiguration}
-     * @access protected
-     * @ignore
-     */
-    this._appConfiguration = appConfiguration;
-  }
-  /**
-   * Generates and send an HTML response that emits a post message.
-   * The post message will be prefixed with the value of the configuration setting
-   * `postMessagesPrefix`.
-   *
-   * @param {ExpressResponse} res
-   * The Express response object necessary to write the HTML.
-   * @param {string} title
-   * The title for the HTML.
-   * @param {string} message
-   * The contents of the post message.
-   * @param {number} [status=200]
-   * The HTTP status.
-   * @param {Partial<ResponsesBuilderPostMessageOptions>} [options={}]
-   * Options to customize the HTML.
-   */
-  htmlPostMessage(res, title, message, status = statuses.ok, options = {}) {
-    const prefix = this._appConfiguration.get('postMessagesPrefix') || '';
-    const target = options.target || 'window.opener';
-    const close = typeof options.close !== 'undefined' ? options.close : true;
-    const defaultCloseDelay = 700;
-    const closeDelay = options.closeDelay || defaultCloseDelay;
-    const closeCode = close
-      ? `setTimeout(function() { window.close(); }, ${closeDelay});`
-      : '';
-    const html = this._htmlTemplate(
-      title,
-      `
-      (function() {
-        if (${target}) {
-          ${target}.postMessage('${prefix}${message}', '*');
-          ${closeCode}
-        }
-      })();
-      `,
-    );
-
-    res.setHeader('Content-Type', 'text/html');
-    res.setHeader('Cache-Control', 'no-cache, max-age=0, must-revalidate, no-store');
-    res.status(this._normalizeStatus(status));
-    res.write(html);
-    res.end();
-  }
-  /**
-   * Generates and sends a JSON response.
-   *
-   * @example
-   *
-   * <caption>The generated looks like this.</caption>
-   *
-   * {
-   * metadata: {
-   * version: '[app-version]',
-   * status: [http-status],
-   * },
-   * data: [...],
-   * }
-   *
-   * @param {ExpressResponse} res            The Express response object necessary to
-   *                                         write the JSON.
-   * @param {Object}          data           The information for the `data` key.
-   * @param {number}          [status=200]   The HTTP status.
-   * @param {Object}          [metadata={}]  Extra information to include on the
-   *                                         `metadata` key.
-   */
-  json(res, data, status = statuses.ok, metadata = {}) {
-    const useStatus = this._normalizeStatus(status);
-    res
-      .status(useStatus)
-      .json({
-        metadata: {
-          version: this._appConfiguration.get('version'),
-          status: useStatus,
-          ...metadata,
-        },
-        data,
-      })
-      .end();
-  }
-  /**
-   * Generates a basic HTML template for other services to use.
-   *
-   * @param {string} title  The HTML `<title />` attribute.
-   * @param {string} code   Javascript code to be wrapped on a `<script />` tag.
-   * @returns {string}
-   * @access protected
-   * @ignore
-   */
-  _htmlTemplate(title, code) {
-    return `
-      <!DOCTYPE html>
-      <html>
-        <head>
-          <meta charset="utf-8" />
-          <meta http-equiv="x-ua-compatible" content="ie=edge" />
-          <meta name="viewport" content="width=device-width, initial-scale=1" />
-          <title>${title}</title>
-        </head>
-        <body>
-          <script type="text/javascript">
-          ${code}
-        </script>
-      </body>
-    </html>
-    `;
-  }
-  /**
-   * Utility method used to make sure a recevied status is a valid status code. If the
-   * status is a string, the method will try to find the code from the `statuses` package.
-   *
-   * @param {string | number} status  The status to normalize.
-   * @returns {string | number} If `status` is a string, but there's no valid code, it
-   *                            will return it as it was received.
-   * @access protected
-   * @ignore
-   * @todo On the next breaking version, if there's no valid code, it will be
-   *       transformed to `200`.
-   */
-  _normalizeStatus(status) {
-    let result;
-    if (typeof status === 'string') {
-      result = statuses[status] || status;
-    } else {
-      result = status;
-    }
-
-    return result;
-  }
-}
-/**
- * The service provider that once registered on the app container will set an instance of
- * `ResponsesBuilder` as the `responsesBuilder` service.
- *
- * @type {Provider}
- * @example
- *
- *   // Register it on the container
- *   container.register(responsesBuilder);
- *   // Getting access to the service instance
- *   const responsesBuilder = container.get('responsesBuilder');
- *
- * @parent module:services
- */
-const responsesBuilder = provider((app) => {
-  app.set('responsesBuilder', () => new ResponsesBuilder(app.get('appConfiguration')));
-});
-
-module.exports.ResponsesBuilder = ResponsesBuilder;
-module.exports.responsesBuilder = responsesBuilder;

package/src/services/index.js

@@ -1,15 +0,0 @@
-const common = require('./common');
-const frontend = require('./frontend');
-const html = require('./html');
-const http = require('./http');
-const utils = require('./utils');
-
-/**
- * @module module:services
- */
-
-module.exports.common = common;
-module.exports.frontend = frontend;
-module.exports.html = html;
-module.exports.http = http;
-module.exports.utils = utils;

package/src/services/utils/ensureBearerToken.js

@@ -1,147 +0,0 @@
-const { code: statuses } = require('statuses');
-const ObjectUtils = require('wootils/shared/objectUtils');
-const { providerCreator } = require('../../utils/wrappers');
-
-/**
- * @typedef {import('../../types').ExpressMiddleware} ExpressMiddleware
- */
-
-/**
- * @typedef {import('../../types').ProviderCreator<O>} ProviderCreator<O>
- * @template O
- */
-
-/**
- * These options allow you to modify the error generated by the middleware when the
- * request doesn't have a valid token.
- *
- * @typedef {Object} EnsureBearerTokenErrorOptions
- * @property {string} message   The error message for the response. Default
- *                              `'Unauthorized'`.
- * @property {number} status    The HTTP status that will be added to error context
- *                              information.
- *                              Default `401`.
- * @property {Object} response  Context information that the error handler can read and
- *                              add to the default response. Default `{}`.
- * @parent module:services
- */
-
-/**
- * The options for how to validate the token and, possibly, create the errors.
- *
- * @typedef {Object} EnsureBearerTokenOptions
- * @property {EnsureBearerTokenErrorOptions} error
- * The options to modify the error generated by the middleware when the request doesn't
- * have a valid token.
- * @property {RegExp} expression
- * The regular expression used to extract the token from the request authorization header.
- * @property {string} local
- * The property inside the `res.locals` where the token, if found, will be saved.
- * Default `'token'`.
- * @parent module:services
- */
-
-/**
- * This service gives you a middleware that verifies if a request has an `Authorization`
- * header with a bearer token; if it does, the token will be saved on the `res.locals`,
- * otherwise, it will generate an error.
- *
- * @parent module:services
- */
-class EnsureBearerToken {
-  /**
-   * @param {ClassAppError} AppError
-   * To format the error caused when the request doesn't have a valid token.
-   * @param {Partial<EnsureBearerTokenOptions>} [options={}]
-   * The options to customize the middleware behavior: how to validate the token, how to
-   * save it and what kind of error should generate.
-   */
-  constructor(AppError, options = {}) {
-    /**
-     * A local reference for the class the app uses to generate errors.
-     *
-     * @type {ClassAppError}
-     * @access protected
-     * @ignore
-     */
-    this._AppError = AppError;
-    /**
-     * The options that define how the middleware validates the token, saves it and
-     * generates the possible error.
-     *
-     * @type {EnsureBearerTokenOptions}
-     * @access protected
-     * @ignore
-     */
-    this._options = ObjectUtils.merge(
-      {
-        error: {
-          message: 'Unauthorized',
-          status: statuses.unauthorized,
-          response: {},
-        },
-        expression: /bearer (.*?)(?:$|\s)/i,
-        local: 'token',
-      },
-      options,
-    );
-  }
-  /**
-   * Creates the middleware that will validate the presence of a bearer token on the
-   * request authorization header.
-   *
-   * @returns {ExpressMiddleware}
-   */
-  middleware() {
-    return (req, res, next) => {
-      let unauthorized = true;
-      const {
-        headers: { authorization },
-      } = req;
-      if (authorization) {
-        const matches = this._options.expression.exec(authorization);
-        if (matches) {
-          const [, token] = matches;
-          res.locals[this._options.local] = token;
-          unauthorized = false;
-        }
-      }
-
-      if (unauthorized) {
-        const { error } = this._options;
-        next(
-          new this._AppError(error.message, {
-            status: error.status,
-            response: error.response,
-          }),
-        );
-      } else {
-        next();
-      }
-    };
-  }
-  /**
-   * The options that define how the middleware validates the token, saves it and
-   * generates the possible error.
-   *
-   * @type {EnsureBearerTokenOptions}
-   */
-  get options() {
-    return this._options;
-  }
-}
-/**
- * Generates a "service middleware" that can be used on route controllers in order to
- * validate the presence of a bearer token on the requests authorization header.
- *
- * @type {ProviderCreator<EnsureBearerTokenOptions>}
- * @parent module:services
- */
-const ensureBearerToken = providerCreator((options) => (app) => {
-  app.set('ensureBearerToken', () =>
-    new EnsureBearerToken(app.get('AppError'), options).middleware(),
-  );
-});
-
-module.exports.EnsureBearerToken = EnsureBearerToken;
-module.exports.ensureBearerToken = ensureBearerToken;

package/src/services/utils/index.js

@@ -1,19 +0,0 @@
-const { ensureBearerToken } = require('./ensureBearerToken');
-const { providers } = require('../../utils/wrappers');
-
-/**
- * @typedef {import('../../types').Provider} Provider
- */
-
-/**
- * The providers collection for the utility services.
- *
- * @type {Provider}
- * @property {Provider} ensureBearerToken  The provider for {@link EnsureBearerToken}.
- * @parent module:services
- */
-const utilsServices = providers({
-  ensureBearerToken,
-});
-
-module.exports = utilsServices;