next-redis-cache/dist/caching.js

A package to manage redis caching of genrated pages through next.js .

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var validatePath = require('./validatePath');
/**
 * 
 * @param {boolean} shouldLog wether to show or not
 * @param {string} content printing message
 */


function logger(shouldLog, content) {
  shouldLog && console.log(content);
}
/**
 * 
 * @param {object} req request
 * @param {object} res response
 */


function caching(_ref) {
  var redis = _ref.redis,
      config = _ref.config,
      app = _ref.app,
      req = _ref.req,
      res = _ref.res,
      next = _ref.next;
  var log = config.log,
      includes = config.includes,
      excludes = config.excludes,
      defaultExpire = config.defaultExpire,
      expire = config.expire,
      prefix = config.prefix,
      cache = config.cache;
  var path = req.path,
      query = req.query;

  if (cache) {
    var isPathValidated = validatePath(path, includes, excludes);

    if (isPathValidated) {
      logger(log, "".concat(path, " : ").concat(new Date()));
      var key = "".concat(prefix || "").concat(req.originalUrl || req.url);
      var expireTime = expire[path] || defaultExpire;
      /**
       * try to get already cached page from redis store.
       * if err occur on getting page - will render error component via app
       * if cache found will render page from their directly.
       * else render page as per current route via app and set to redis for future request.
       */

      return redis.get(key, /*#__PURE__*/function () {
        var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(err, cachedHtml) {
          var html;
          return _regenerator["default"].wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  if (!err) {
                    _context.next = 2;
                    break;
                  }

                  return _context.abrupt("return", app.renderError(e, req, res, path, query));

                case 2:
                  if (!cachedHtml) {
                    _context.next = 5;
                    break;
                  }

                  logger(log, "HIT: ".concat(path, " : ").concat(new Date()));
                  return _context.abrupt("return", res.send(cachedHtml));

                case 5:
                  _context.prev = 5;
                  _context.next = 8;
                  return app.renderToHTML(req, res, path, query);

                case 8:
                  html = _context.sent;

                  if (expireTime) {
                    redis.setex(key, expireTime, html);
                  } else {
                    redis.set(key, html);
                  }

                  logger(log, "MISSED: ".concat(path, " : ").concat(new Date()));
                  return _context.abrupt("return", res.send(html));

                case 14:
                  _context.prev = 14;
                  _context.t0 = _context["catch"](5);
                  return _context.abrupt("return", app.renderError(_context.t0, req, res, path, query));

                case 17:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, null, [[5, 14]]);
        }));

        return function (_x, _x2) {
          return _ref2.apply(this, arguments);
        };
      }());
    }
  }

  if (next) {
    return next();
  }

  var handler = app.getRequestHandler();
  return handler(req, res, path, query);
}

module.exports = caching;