hof 22.8.4 → 22.9.0-beta.v1

package/package/middleware/rate-limiter.js

@@ -0,0 +1,98 @@
+
+const moment = require('moment');
+const redis = require('redis');
+const config = require('./../config/hof-defaults');
+
+module.exports = (options, rateLimitType) => {
+  // eslint-disable-next-line no-console
+  const logger = options.logger || { log: (func, msg) => console[func](msg) };
+  const rateLimits = options.rateLimits[rateLimitType];
+  const timestampName = `${rateLimitType}TimeStamp`;
+  const countName = `${rateLimitType}Count`;
+
+  const WINDOW_SIZE_IN_MINUTES = rateLimits.windowSizeInMinutes;
+  const MAX_WINDOW_REQUEST_COUNT = rateLimits.maxWindowRequestCount;
+  const WINDOW_LOG_INTERVAL_IN_MINUTES = rateLimits.windowLogIntervalInMinutes;
+  const ERROR_CODE = rateLimits.errCode;
+
+  return async (req, res, next) => {
+    const redisClient = redis.createClient(config.redis);
+
+    // check that redis client exists
+    if (!redisClient) {
+      logger.log('error', 'Redis client does not exist!');
+      return next();
+    }
+
+    const closeConnection = async err => {
+      await redisClient.quit();
+      return next(err);
+    };
+
+    try {
+      // fetch records of current user using IP address, returns null when no record is found
+      return await redisClient.get(req.ip, async (err, record) => {
+        if (err) {
+          logger.log('error', `Error with requesting redis session for rate limiting: ${err}`);
+          return await closeConnection();
+        }
+        const currentRequestTime = moment();
+        const windowStartTimestamp = moment().subtract(WINDOW_SIZE_IN_MINUTES, 'minutes').unix();
+        let oldRecord = false;
+        let data;
+        //  if no record is found , create a new record for user and store to redis
+        if (record) {
+          data = JSON.parse(record);
+          oldRecord = data[data.length - 1][timestampName] < windowStartTimestamp;
+        }
+
+        if (!record || oldRecord) {
+          const newRecord = [];
+          const requestLog = {
+            [timestampName]: currentRequestTime.unix(),
+            [countName]: 1
+          };
+          newRecord.push(requestLog);
+          await redisClient.set(req.ip, JSON.stringify(newRecord));
+          return await closeConnection();
+        }
+        // if record is found, parse it's value and calculate number of requests users has made within the last window
+        const requestsWithinWindow = data.filter(entry => entry[timestampName] > windowStartTimestamp);
+
+        const totalWindowRequestsCount = requestsWithinWindow.reduce((accumulator, entry) => {
+          return accumulator + entry[countName];
+        }, 0);
+
+        if (!options.rateLimits.env || options.rateLimits.env === 'development') {
+          const requestsRemaining = MAX_WINDOW_REQUEST_COUNT - totalWindowRequestsCount;
+          const msg = `Requests made by client: ${totalWindowRequestsCount}\nRequests remaining: ${requestsRemaining}`;
+          logger.log('info', msg);
+        }
+        // if number of requests made is greater than or equal to the desired maximum, return error
+        if (totalWindowRequestsCount >= MAX_WINDOW_REQUEST_COUNT) {
+          return await closeConnection({ code: ERROR_CODE });
+        }
+        // if number of requests made is less than allowed maximum, log new entry
+        const lastRequestLog = data[data.length - 1];
+        const potentialCurrentWindowIntervalStartTimeStamp = currentRequestTime
+          .subtract(WINDOW_LOG_INTERVAL_IN_MINUTES, 'minutes')
+          .unix();
+        //  if interval has not passed since last request log, increment counter
+        if (lastRequestLog[timestampName] > potentialCurrentWindowIntervalStartTimeStamp) {
+          lastRequestLog[countName]++;
+          data[data.length - 1] = lastRequestLog;
+        } else {
+          //  if interval has passed, log new entry for current user and timestamp
+          data.push({
+            [timestampName]: currentRequestTime.unix(),
+            [countName]: 1
+          });
+        }
+        await redisClient.set(req.ip, JSON.stringify(data));
+        return await closeConnection();
+      });
+    } catch (err) {
+      return await closeConnection(err);
+    }
+  };
+};

package/package/middleware/service-unavailable.js

@@ -0,0 +1,64 @@
+/* eslint-disable consistent-return */
+'use strict';
+
+const getTranslations = translate => {
+  const translations = {
+    title: 'Sorry, this service is unavailable',
+    message: 'This service is temporarily unavailable',
+    'answers-saved': 'Your answers have not been saved'
+  };
+
+  if (translate) {
+    const contact = translate('errors.service-unavailable.contact');
+    const alternative = translate('errors.service-unavailable.alternative');
+    translations.serviceName = translate('journey.serviceName') || translate('journey.header');
+    translations.title = translate('errors.service-unavailable.title');
+    translations.message = translate('errors.service-unavailable.message');
+    translations['answers-saved'] = translate('errors.service-unavailable.answers-saved');
+
+    // Only render contact and alternative information if the key has a value set
+    if (contact === 'errors.service-unavailable.contact') {
+      translations.contact = '';
+    } else {
+      translations.contact = translate('errors.service-unavailable.contact');
+    }
+    if (alternative === 'errors.service-unavailable.alternative') {
+      translations.alternative = '';
+    } else {
+      translations.alternative = translate('errors.service-unavailable.alternative');
+    }
+  }
+  return translations;
+};
+
+module.exports = options => {
+  const opts = options || {};
+  const logger = opts.logger;
+  // These are paths that are allowed to bypass the "service unavailable" middleware.
+  // When the service is unavailable (for example, for maintenance), all routes except those listed here
+  // will return a paused response, typically a maintenance page.
+  //
+  // - '/assets': Static assets (CSS, JS, images) must still be served so the paused page displays correctly.
+  // - '/readyz' and '/livez': Health check endpoints must remain available for Kubernetes or other orchestration
+  //   systems to determine if the container is healthy, even during maintenance.
+  const bypassPaths = opts.bypassPaths || ['/readyz', '/health', '/assets'];
+
+  return (req, res, next) => {
+    if (bypassPaths.some(path => req.path.startsWith(path))) {
+      return next();
+    }
+    const translate = opts.translate || req.translate;
+    const translations = getTranslations(translate);
+    if (logger && logger.warn) {
+      logger.warn('Service temporarily unavailable - service paused.');
+    }
+    res.status(503).render('service-unavailable', {
+      serviceName: translations.serviceName,
+      title: translations.title,
+      message: translations.message,
+      'answers-saved': translations['answers-saved'],
+      contact: translations.contact,
+      alternative: translations.alternative
+    });
+  };
+};

package/package/model/apis/axios-settings.js

@@ -0,0 +1,21 @@
+'use strict';
+const { format } = require('url'); // Destructure 'format' from 'url' module
+
+module.exports = (settings = {}, body = null) => {
+  if (typeof settings !== 'object' || settings === null) {
+    throw new TypeError('settings must be a non-null object');
+  }
+
+  const {
+    uri,
+    url,
+    body: settingsBody,
+    data: settingsData,
+    ...restSettings
+  } = settings;
+
+  return Object.assign({}, restSettings, {
+    url: uri || url || format(settings),
+    data: settingsBody || body || settingsData
+  });
+};

package/package/model/apis/html-to-pdf-converter.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const Model = require('..');
+const isPdf = require('is-pdf');
+const config = require('../../config/hof-defaults');
+
+module.exports = class PDFModel extends Model {
+  requestConfig(options) {
+    const settings = super.requestConfig(options);
+    settings.encoding = null;
+    settings.rejectUnauthorized = false;
+    settings.responseType = 'arraybuffer';
+    return settings;
+  }
+
+  url() {
+    return config.apis.pdfConverter;
+  }
+
+  handleResponse(response, callback) {
+    if (isPdf(Buffer.from(response.data))) {
+      return this.parseResponse(response.status, response.data, callback);
+    }
+    const err = new Error();
+
+    if (parseInt(response.status, 10) === 400) {
+      err.title = response.status;
+      err.message = response.statusText;
+    } else {
+      err.body = response.data;
+    }
+    err.status = response.status;
+    return callback(err, null, response.status);
+  }
+};

package/package/model/apis/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  pdfConverter: require('./html-to-pdf-converter')
+};

package/package/model/index.js

@@ -0,0 +1,348 @@
+/* eslint-disable node/no-deprecated-api, no-param-reassign */
+'use strict';
+
+const _ = require('lodash');
+const axios = require('axios').default;
+const url = require('url');
+const EventEmitter = require('events').EventEmitter;
+const axiosSetting = require('./apis/axios-settings');
+const REFERENCE = /^\$ref:/;
+
+function timeDiff(from, to, d) {
+  let digits = d;
+  if (digits === undefined) {
+    digits = 3;
+  }
+  const ms = (to[0] - from[0]) * 1e3 + (to[1] - from[1]) * 1e-6;
+  return +ms.toFixed(digits);
+}
+
+const urlKeys = Object.keys(url.parse(''));
+
+module.exports = class Model extends EventEmitter {
+  constructor(attributes, options) {
+    super(attributes, options);
+    this.options = options || {};
+    this.attributes = {};
+    this.set(attributes, {
+      silent: true
+    });
+    this._request = axios;
+  }
+
+  async save(options, callback) {
+    if (typeof options === 'function' && arguments.length === 1) {
+      callback = options;
+      options = {};
+    } else if (!options) {
+      options = {};
+    }
+
+    let data = await this.prepare();
+    data = JSON.stringify(data);
+    const reqConf = this.requestConfig(options);
+    reqConf.method = options.method || 'POST';
+    reqConf.headers = Object.assign({
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(data)
+    }, reqConf.headers || {});
+    return await this.request(reqConf, data, callback);
+  }
+
+  async fetch(options, callback) {
+    if (typeof options === 'function' && arguments.length === 1) {
+      callback = options;
+      options = {};
+    } else if (!options) {
+      options = {};
+    }
+    const reqConf = this.requestConfig(options);
+    reqConf.method = options.method || 'GET';
+    return await this.request(reqConf, callback);
+  }
+
+  async delete(options, callback) {
+    if (typeof options === 'function' && arguments.length === 1) {
+      callback = options;
+      options = {};
+    } else if (!options) {
+      options = {};
+    }
+    const reqConf = this.requestConfig(options);
+    reqConf.method = options.method || 'DELETE';
+    return await this.request(reqConf, callback);
+  }
+
+  requestConfig(options) {
+    let reqConf = this.url(options);
+    if (typeof reqConf === 'string') {
+      reqConf = url.parse(reqConf);
+    }
+    return Object.assign(reqConf, {
+      headers: options.headers || reqConf.headers || this.options.headers
+    });
+  }
+
+  async request(originalSettings, body, callback) {
+    if (typeof body === 'function' && arguments.length === 2) {
+      callback = body;
+      body = undefined;
+    }
+
+    let settings = Object.assign({}, originalSettings);
+    settings.timeout = settings.timeout || this.options.timeout;
+    settings = axiosSetting(settings, body);
+    settings = _.omit(settings, urlKeys);
+    this.emit('sync', originalSettings);
+
+    try {
+      const authData = await this.auth();
+      let authVal = authData;
+      if (typeof authVal === 'string') {
+        const [user, ...rest] = authVal.split(':');
+        authVal = {
+          user,
+          pass: rest.join(':'),
+          sendImmediately: true
+        };
+      }
+      if (authVal) {
+        settings.headers = {
+          ...settings.headers,
+          Authorization: `Bearer ${authVal.bearer}`
+        };
+      }
+
+      const startTime = process.hrtime();
+      let timeoutTimer;
+
+      if (timeoutTimer) {
+        clearTimeout(timeoutTimer);
+        timeoutTimer = null;
+      }
+
+      const data = await new Promise((resolve, reject) => {
+        const _callback = (err, responseData, statusCode) => {
+          if (timeoutTimer) {
+            clearTimeout(timeoutTimer);
+            timeoutTimer = null;
+          }
+
+          const endTime = process.hrtime();
+          const responseTime = timeDiff(startTime, endTime);
+          if (err) {
+            this.emit('fail', err, responseData, originalSettings, statusCode, responseTime);
+            reject(err);
+          } else {
+            this.emit('success', responseData, originalSettings, statusCode, responseTime);
+            resolve(responseData);
+          }
+        };
+
+        this._request(settings)
+          .then(response => {
+            return this.handleResponse(response)
+              .then(responseData => _callback(null, responseData, response.status))
+              .catch(error => {
+                error.headers = response.headers;
+                _callback(error, null, response.status);
+              });
+          })
+          .catch(err => {
+            if (err.code === 'ETIMEDOUT' || err.code === 'ESOCKETTIMEDOUT') {
+              err.message = 'Connection timed out';
+              err.status = 504;
+            }
+            err.status = err.status || 503;
+            return _callback(err, null, err.status);
+          });
+      });
+
+      if (typeof callback === 'function') {
+        callback(null, data);
+      }
+      return data;
+    } catch (error) {
+      if (typeof callback === 'function') {
+        callback(error);
+      }
+      return error;
+    }
+  }
+
+  async handleResponse(response) {
+    let data = null;
+    try {
+      if (typeof response.data === 'object') {
+        data = response.data;
+      } else if (typeof response.data === 'string' && response.data.trim() !== '') {
+        data = JSON.parse(response.data);
+      } else {
+        data = {};
+      }
+    } catch (err) {
+      err.message = 'Failed to parse response data';
+      err.status = response.status;
+      err.body = response.data;
+      throw err;
+    }
+    return await this.parseResponse(response.status, data);
+  }
+
+  async parseResponse(statusCode, data) {
+    if (statusCode < 400) {
+      try {
+        data = await this.parse(data);
+        return data;
+      } catch (err) {
+        throw err;
+      }
+    } else {
+      throw this.parseError(statusCode, data);
+    }
+  }
+
+  prepare() {
+    return Promise.resolve(this.toJSON());
+  }
+
+  parse(data) {
+    return data;
+  }
+
+  parseError(statusCode, data) {
+    return Object.assign({
+      status: statusCode
+    }, data);
+  }
+
+  resolveReference(value, map) {
+    if (typeof value === 'string' && value.match(REFERENCE)) {
+      const key = value.replace(REFERENCE, '');
+      return _.cloneDeep(map[key]);
+    }
+    return value;
+  }
+
+  get(key) {
+    const value = _.cloneDeep(this.attributes[key]);
+    return this.resolveReference(value, this.attributes);
+  }
+
+  set(key, value, options) {
+    let attrs = {};
+
+    if (typeof key === 'string') {
+      attrs[key] = value;
+    } else {
+      attrs = key;
+      options = value;
+    }
+    options = options || {};
+
+    const old = this.toJSON();
+    const changed = _.pickBy(attrs, (attr, attrKey) => attr !== old[attrKey] || attr !== this.attributes[attrKey]);
+
+    Object.assign(this.attributes, attrs);
+
+    const references = _.reduce(this.attributes, (map, val, k) => {
+      if (typeof val === 'string' && val.match(REFERENCE)) {
+        const reffed = val.replace(REFERENCE, '');
+        map[reffed] = map[reffed] || [];
+        map[reffed].push(k);
+      }
+      return map;
+    }, {});
+
+    if (!options.silent && _.size(changed)) {
+      _.each(changed, (changedValue, changedKey) => {
+        this.emit(`change:${changedKey}`, this.get(changedKey), old[changedKey]);
+        // emit change events for referenced fields
+        if (references[changedKey]) {
+          references[changedKey].forEach(k => {
+            this.emit(`change:${k}`, this.get(changedKey), old[k]);
+          });
+        }
+      });
+      // add references to changed field map
+      _.each(references, (fields, ref) => {
+        fields.forEach(f => {
+          changed[f] = changed[ref];
+        });
+      });
+      this.emit('change', changed);
+    }
+
+    return this;
+  }
+
+  unset(fields, options) {
+    options = options || {};
+    if (typeof fields === 'string') {
+      fields = [fields];
+    }
+
+    const old = this.toJSON();
+    const changed = fields.reduce((obj, key) => {
+      if (old[key] !== undefined) {
+        obj[key] = undefined;
+        delete this.attributes[key];
+      }
+      return obj;
+    }, {});
+
+    if (!options.silent && _.size(changed)) {
+      _.each(changed, (value, key) => {
+        this.emit('change:' + key, undefined, old[key]);
+      });
+      this.emit('change', changed);
+    }
+
+    return this;
+  }
+
+  increment(property, amount) {
+    if (!property || typeof property !== 'string') {
+      throw new Error('Trying to increment undefined property');
+    }
+    const val = this.get(property) || 0;
+    amount = amount || 1;
+    this.set(property, val + amount);
+  }
+
+  reset(options) {
+    options = options || {};
+    const keys = Object.keys(this.attributes);
+    this.attributes = {};
+    if (!options.silent) {
+      _.each(keys, key => {
+        this.emit('change:' + key, undefined);
+      });
+      this.emit('reset');
+    }
+  }
+
+  url(options) {
+    options = options || {};
+
+    // falback to this.options.url
+    options.url = options.url || this.options.url;
+
+    let opts = {};
+    if (options.url) {
+      opts = url.parse(options.url);
+    }
+    // passing a host to url.format overrides other options, so remove it
+    delete opts.host;
+    Object.assign(opts, options);
+    return url.format(opts);
+  }
+
+  auth() {
+    return;
+  }
+
+  toJSON() {
+    return _.mapValues(_.cloneDeep(this.attributes), (value, key, attrs) => this.resolveReference(value, attrs));
+  }
+};