next-redis-cache/dist/index.js

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

"use strict";

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

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

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

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

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

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

var caching = require('./caching');

var _require = require("path-to-regexp"),
    pathToRegexp = _require.pathToRegexp;
/**
 * 
 * @param {string} path url 
 */


function refactorPath(path) {
  if (path === '*') {
    return '(.*)';
  }

  return path;
}

var opts = {
  strict: false,
  sensitive: false,
  end: true
};

var NextCache = /*#__PURE__*/function () {
  /**
   * 
   * @param {object} redisClient redisInstance
   * @param {object} app next app
   * @param {object} config custom configuration
   */
  function NextCache(redisClient, app) {
    var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
    (0, _classCallCheck2["default"])(this, NextCache);
    var _config$includes = config.includes,
        includes = _config$includes === void 0 ? [] : _config$includes,
        _config$excludes = config.excludes,
        excludes = _config$excludes === void 0 ? ["*"] : _config$excludes,
        restConfig = (0, _objectWithoutProperties2["default"])(config, ["includes", "excludes"]);
    includes = includes.length && includes.map(function (path) {
      var newPath = refactorPath(path);
      return pathToRegexp(newPath, [], opts);
    });
    excludes = excludes.length && excludes.map(function (path) {
      var newPath = refactorPath(path);
      if (includes.length && newPath === "(.*)") return null;
      return pathToRegexp(newPath, [], opts);
    });
    this.redis = redisClient || null;
    this.app = app;
    this.config = _objectSpread({
      includes: includes,
      // array
      excludes: excludes,
      // array
      defaultExpire: null,
      // seconds
      expire: {},
      // object of path and seconds pair
      log: false,
      //boolean
      cache: true,
      //boolean
      prefix: "__next-redis-cache__"
    }, restConfig);
  }
  /**
   *
   * @param {object} redisClient redisInstance
   * set redis client with manually by calling init method.
   * Warning - if client is already set through instance creation.
   * Error - if client isn't exist in argument.
   */


  (0, _createClass2["default"])(NextCache, [{
    key: "init",
    value: function init(redisClient) {
      if (!redisClient) {
        throw new Error("Redis client is require!! NextCache is triggering init without passing client.");
      }

      if (this.redis) {
        console.warn("Redis client is already defined once, setting up new client will shadow previous client!");
      }

      this.redis = redisClient;
    }
    /**
     * middleware
     * @param {object} req request
     * @param {object} res response
     * @param {function} next callback
     */

  }, {
    key: "middleware",
    value: function middleware(req, res, next) {
      return caching({
        redis: this.redis,
        config: this.config,
        app: this.app,
        req: req,
        res: res,
        next: next
      });
    }
    /**
     * 
     * @param {object} req request
     * @param {object} res response
     */

  }, {
    key: "handler",
    value: function handler(req, res) {
      return caching({
        redis: this.redis,
        config: this.config,
        app: this.app,
        req: req,
        res: res
      });
    }
  }]);
  return NextCache;
}();

module.exports = NextCache;