@zbm1/nuxt-ssr-cache - npm Package Compare versions

Comparing version 1.5.3 to 1.5.4

lib/cache-builders.js

@@ -1,25 +0,10 @@
-"use strict";
+const Promise = require('bluebird');
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+const cacheManager = require('cache-manager');
 
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
-
-function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
-
-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) { _defineProperty(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; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var Promise = require('bluebird');
-
-var cacheManager = require('cache-manager');
-
 function memoryCache(config) {
-  return cacheManager.caching(_objectSpread({
-    store: 'memory'
-  }, config));
+  return cacheManager.caching({
+    store: 'memory',
+    ...config
+  });
 }
@@ -29,40 +14,42 @@
   if (config && Array.isArray(config.configure)) {
-    var redis = require('redis');
+    const redis = require('redis');
 
-    var client = redis.createClient(_objectSpread({
-      retry_strategy: function retry_strategy() {}
-    }, config));
-    Promise.all(config.configure.map(function (options) {
-      return new Promise(function (resolve, reject) {
-        client.config.apply(client, ['SET'].concat(_toConsumableArray(options), [function (err, result) {
-          if (err || result !== 'OK') {
-            reject(err);
-          } else {
-            resolve(result);
-          }
-        }]));
+    const client = redis.createClient({
+      retry_strategy() {},
+
+      ...config
+    });
+    Promise.all(config.configure.map(options => new Promise((resolve, reject) => {
+      client.config('SET', ...options, function (err, result) {
+        if (err || result !== 'OK') {
+          reject(err);
+        } else {
+          resolve(result);
+        }
       });
-    })).then(function () {
-      return client.quit();
-    });
+    }))).then(() => client.quit());
   }
 
-  return cacheManager.caching(_objectSpread({
+  return cacheManager.caching({
     store: require('cache-manager-redis'),
-    retry_strategy: function retry_strategy() {}
-  }, config));
+
+    retry_strategy() {},
+
+    ...config
+  });
 }
 
 function memcachedCache(config) {
-  return cacheManager.caching(_objectSpread({
-    store: require('cache-manager-memcached-store')
-  }, config));
+  return cacheManager.caching({
+    store: require('cache-manager-memcached-store'),
+    ...config
+  });
 }
 
 function multiCache(config) {
-  var stores = config.stores.map(makeCache);
+  const stores = config.stores.map(makeCache);
   return cacheManager.multiCaching(stores);
 }
 
-var cacheBuilders = {
+const cacheBuilders = {
   memory: memoryCache,
@@ -74,7 +61,6 @@ multi: multiCache,
 
-function makeCache() {
-  var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
-    type: 'memory'
-  };
-  var builder = cacheBuilders[config.type];
+function makeCache(config = {
+  type: 'memory'
+}) {
+  const builder = cacheBuilders[config.type];
 
@@ -81,0 +67,0 @@ if (!builder) {

lib/middleware.js

@@ -1,13 +0,10 @@
-"use strict";
+const path = require('path');
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+const {
+  serialize,
+  deserialize
+} = require('./serializer');
 
-var path = require('path');
+const makeCache = require('./cache-builders');
 
-var _require = require('./serializer'),
-    serialize = _require.serialize,
-    deserialize = _require.deserialize;
-
-var makeCache = require('./cache-builders');
-
 function cleanIfNewVersion(cache, version) {
@@ -17,3 +14,3 @@ if (!version) return;
     if (oldVersion !== version) {
-      console.log("Cache updated from ".concat(oldVersion, " to ").concat(version));
+      console.log(`Cache updated from ${oldVersion} to ${version}`);
       return cache.resetAsync(); // unfortunately multi cache doesn't return a promise
@@ -30,3 +27,3 @@ // and we can't await for it so as to store new version
     ttl: null
-  }).then(function () {
+  }).then(() => {
     cache.versionSaved = true;
@@ -53,5 +50,3 @@ });
 
-    return !context.res.spa && config.cache.pages.some(function (pat) {
-      return pat instanceof RegExp ? pat.test(path) : path.startsWith(pat);
-    });
+    return !context.res.spa && config.cache.pages.some(pat => pat instanceof RegExp ? pat.test(path) : path.startsWith(pat));
   }
@@ -62,13 +57,13 @@
     if (!hostname) return;
-    var cacheKey = config.cache.useHostPrefix === true && hostname ? path.join(hostname, route) : route;
+    const cacheKey = config.cache.useHostPrefix === true && hostname ? path.join(hostname, route) : route;
     if (isCacheFriendly(route, context)) return cacheKey;
   }
 
-  var currentVersion = config.version || config.cache.version;
-  var cache = makeCache(config.cache.store);
+  const currentVersion = config.version || config.cache.version;
+  const cache = makeCache(config.cache.store);
   cleanIfNewVersion(cache, currentVersion);
-  var renderer = nuxt.renderer;
-  var renderRoute = renderer.renderRoute.bind(renderer);
-  var hookName = 'vue-renderer:ssr:context';
-  var hookCaches = {// '0': {
+  const renderer = nuxt.renderer;
+  const renderRoute = renderer.renderRoute.bind(renderer);
+  const hookName = 'vue-renderer:ssr:context';
+  const hookCaches = {// '0': {
     //   [hookName]: {
@@ -83,10 +78,12 @@ //     resolve: resolve
   };
-  var hookCacheIndexes = [];
-  var hookCacheIndex = -1;
+  const hookCacheIndexes = [];
+  let hookCacheIndex = -1;
 
   function createHookPromise(hookCacheIndex) {
-    var promise = new Promise(function (resolve, reject) {
-      hookCaches[hookCacheIndex] = _defineProperty({}, hookName, {
-        resolve: resolve
-      });
+    let promise = new Promise(function (resolve, reject) {
+      hookCaches[hookCacheIndex] = {
+        [hookName]: {
+          resolve
+        }
+      };
     });
@@ -97,6 +94,6 @@ return promise;
   function createCachedPromise(hookCacheIndex) {
-    var promise = new Promise(function (resolve, reject) {
+    let promise = new Promise(function (resolve, reject) {
       hookCaches[hookCacheIndex].routeCachedPromise = {
-        resolve: resolve,
-        reject: reject
+        resolve,
+        reject
       };
@@ -106,3 +103,3 @@ });
   } // SSRRenderer.render @nuxt/vue-renderer/dist/vue-renderer.js
-  // 执行到此 hook 时，已获取部分内容 css、js 等
+  // 执行到此 hook 时，实际已获取部分全局 css、js 等
 
@@ -113,9 +110,9 @@
     // console.log('renderContext.req.url', renderContext.req.url)
-    var _hookCacheIndex = renderContext[hookName];
-    var hookCache = hookCaches[_hookCacheIndex];
-    var hookCachePromise = hookCache[hookName];
+    const _hookCacheIndex = renderContext[hookName];
+    const hookCache = hookCaches[_hookCacheIndex];
+    const hookCachePromise = hookCache[hookName];
 
     if (renderContext.redirected) {
       // console.log('renderContext.redirected', renderContext.redirected)
-      var redirectedResult = {
+      let redirectedResult = {
         html: '',
@@ -128,4 +125,3 @@ cspScriptSrcHashes: [],
       };
-      hookCachePromise.resolve(redirectedResult);
-      return Promise.reject(renderContext.redirected);
+      hookCachePromise.resolve(redirectedResult); // return Promise.reject(renderContext.redirected); // nerver use
     } else {
@@ -137,37 +133,39 @@ hookCachePromise.resolve();
 
-  renderer.renderRoute = function (route, context) {
+  renderer.renderRoute = async function (route, context) {
     // hopefully cache reset is finished up to this point.
     tryStoreVersion(cache, currentVersion);
-    var cacheKey = (config.cache.key || defaultCacheKeyBuilder)(route, context);
+    const cacheKey = (config.cache.key || defaultCacheKeyBuilder)(route, context);
     if (!cacheKey) return renderRoute(route, context);
 
-    var _hookCacheIndex = hookCacheIndexes.pop();
+    let _hookCacheIndex = hookCacheIndexes.pop();
 
     context[hookName] = _hookCacheIndex > -1 ? _hookCacheIndex : _hookCacheIndex = ++hookCacheIndex;
-    var hookPromise = createHookPromise(_hookCacheIndex);
-    var renderRoutePromise = renderRoute(route, context)["catch"](function (err) {
-      return err;
-    });
-    return hookPromise.then(function (redirectedResult) {
-      if (redirectedResult) {
-        clearHookCache();
-        return redirectedResult;
-      }
+    let hookPromise = createHookPromise(_hookCacheIndex);
+    let renderRoutePromise = renderRoute(route, context);
+    const redirectedResult = await hookPromise;
 
-      return cache.getAsync(cacheKey).then(function (cachedResult) {
-        var hookCache = hookCaches[_hookCacheIndex];
-        var routeCachedPromise = hookCache.routeCachedPromise;
+    if (redirectedResult) {
+      clearHookCache();
+      return redirectedResult;
+    }
 
-        if (cachedResult) {
-          routeCachedPromise.reject(route + ' cached.'); // renderRoutePromise.then(function (result) { console.log(result.redirected) })
+    const cachedResult = await cache.getAsync(cacheKey).catch(err => err);
 
-          clearHookCache();
-          return deserialize(cachedResult);
-        }
+    if (cachedResult && !(cachedResult instanceof Error)) {
+      clearHookCache();
+      return deserialize(cachedResult);
+    } else {
+      const hookCache = hookCaches[_hookCacheIndex];
+      const routeCachedPromise = hookCache.routeCachedPromise;
+      routeCachedPromise.resolve(route + ' not cached.');
+      const result = await renderRoutePromise.catch(err => err);
 
-        routeCachedPromise.resolve(route + ' not cached.');
-        return renderSetCache();
-      })["catch"](renderSetCache);
-    });
+      if (result && !(result instanceof Error) && !result.error) {
+        cache.setAsync(cacheKey, serialize(result));
+      }
 
+      clearHookCache();
+      return result;
+    }
+
     function clearHookCache() {
@@ -180,13 +178,2 @@ hookCacheIndexes.push(_hookCacheIndex);
     }
-
-    function renderSetCache() {
-      return renderRoutePromise.then(function (result) {
-        if (!result.error) {
-          cache.setAsync(cacheKey, serialize(result));
-        }
-
-        clearHookCache();
-        return result;
-      });
-    }
   };
@@ -193,0 +180,0 @@

lib/serializer.js

@@ -1,22 +0,10 @@
-"use strict";
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
-
-function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
 module.exports = {
   // renderer's result contains a Set and Function,
   // here we are handling their serializations
-  serialize: function serialize(result) {
-    return JSON.stringify(result, function (key, value) {
-      if (_typeof(value) === 'object' && value instanceof Set) {
+  serialize(result) {
+    return JSON.stringify(result, (key, value) => {
+      if (typeof value === 'object' && value instanceof Set) {
         return {
           _t: 'set',
-          _v: _toConsumableArray(value)
+          _v: [...value]
         };
@@ -35,4 +23,5 @@ }
   },
-  deserialize: function deserialize(jsoned) {
-    return JSON.parse(jsoned, function (key, value) {
+
+  deserialize(jsoned) {
+    return JSON.parse(jsoned, (key, value) => {
       if (value && value._v) {
@@ -44,6 +33,4 @@ if (value._t === 'set') {
         if (value._t === 'func') {
-          var result = value._v;
-          return function () {
-            return result;
-          };
+          const result = value._v;
+          return () => result;
         }
@@ -55,2 +42,3 @@ }
   }
+
 };

package.json

 {
   "name": "@zbm1/nuxt-ssr-cache",
-  "version": "1.5.3",
+  "version": "1.5.4",
   "description": "Cache middleware for nuxt's SSR rendering.",
@@ -5,0 +5,0 @@ "main": "lib/middleware.js",

No alert changes

Worsened metrics

Total package byte prevSize

15477

decreased by-18.53%

Lines of code

320

decreased by-8.57%

No dependency changes