kareem 2.3.2 → 2.3.5

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+<a name="2.3.4"></a>
+## 2.3.4 (2022-02-10)
+
+* perf: various performance improvements #27 #24 #23 #22 #21 #20
+
+<a name="2.3.3"></a>
+## 2.3.3 (2021-12-26)
+
+* fix: handle sync errors in `wrap()`
+
 <a name="2.3.2"></a>
 ## 2.3.2 (2020-12-08)
 

package/index.js

@@ -10,7 +10,7 @@ Kareem.prototype.execPre = function(name, context, args, callback) {
     callback = args;
     args = [];
   }
-  var pres = get(this._pres, name, []);
+  var pres = this._pres.get(name) || [];
   var numPres = pres.length;
   var numAsyncPres = pres.numAsync || 0;
   var currentPre = 0;
@@ -19,7 +19,7 @@ Kareem.prototype.execPre = function(name, context, args, callback) {
   var $args = args;
 
   if (!numPres) {
-    return process.nextTick(function() {
+    return nextTick(function() {
       callback(null);
     });
   }
@@ -57,24 +57,24 @@ Kareem.prototype.execPre = function(name, context, args, callback) {
 
       callMiddlewareFunction(pre.fn, context, args, args[0]);
     } else {
-      let maybePromise = null;
+      let maybePromiseLike = null;
       try {
-        maybePromise = pre.fn.call(context);
+        maybePromiseLike = pre.fn.call(context);
       } catch (err) {
         if (err != null) {
           return callback(err);
         }
       }
 
-      if (isPromise(maybePromise)) {
-        maybePromise.then(() => _next(), err => _next(err));
+      if (isPromiseLike(maybePromiseLike)) {
+        maybePromiseLike.then(() => _next(), err => _next(err));
       } else {
         if (++currentPre >= numPres) {
           if (asyncPresLeft > 0) {
             // Leave parallel hooks to run
             return;
           } else {
-            return process.nextTick(function() {
+            return nextTick(function() {
               callback(null);
             });
           }
@@ -109,7 +109,7 @@ Kareem.prototype.execPre = function(name, context, args, callback) {
 };
 
 Kareem.prototype.execPreSync = function(name, context, args) {
-  var pres = get(this._pres, name, []);
+  var pres = this._pres.get(name) || [];
   var numPres = pres.length;
 
   for (var i = 0; i < numPres; ++i) {
@@ -122,7 +122,7 @@ Kareem.prototype.execPost = function(name, context, args, options, callback) {
     callback = options;
     options = null;
   }
-  var posts = get(this._posts, name, []);
+  var posts = this._posts.get(name) || [];
   var numPosts = posts.length;
   var currentPost = 0;
 
@@ -132,7 +132,7 @@ Kareem.prototype.execPost = function(name, context, args, options, callback) {
   }
 
   if (!numPosts) {
-    return process.nextTick(function() {
+    return nextTick(function() {
       callback.apply(null, [firstError].concat(args));
     });
   }
@@ -151,7 +151,7 @@ Kareem.prototype.execPost = function(name, context, args, options, callback) {
 
     if (firstError) {
       if (post.length === numArgs + 2) {
-        var _cb = decorateNextFn(function(error) {
+        const _cb = decorateNextFn(function(error) {
           if (error) {
             firstError = error;
           }
@@ -194,23 +194,23 @@ Kareem.prototype.execPost = function(name, context, args, options, callback) {
         callMiddlewareFunction(post, context, newArgs.concat([_cb]), _cb);
       } else {
         let error;
-        let maybePromise;
+        let maybePromiseLike;
         try {
-          maybePromise = post.apply(context, newArgs);
+          maybePromiseLike = post.apply(context, newArgs);
         } catch (err) {
           error = err;
           firstError = err;
         }
 
-        if (isPromise(maybePromise)) {
-          return maybePromise.then(() => _cb(), err => _cb(err));
+        if (isPromiseLike(maybePromiseLike)) {
+          return maybePromiseLike.then(() => _cb(), err => _cb(err));
         }
 
         if (++currentPost >= numPosts) {
           return callback.apply(null, [error].concat(args));
         }
 
-        next(error);
+        next();
       }
     }
   };
@@ -219,7 +219,7 @@ Kareem.prototype.execPost = function(name, context, args, options, callback) {
 };
 
 Kareem.prototype.execPostSync = function(name, context, args) {
-  const posts = get(this._posts, name, []);
+  const posts = this._posts.get(name) || [];
   const numPosts = posts.length;
 
   for (let i = 0; i < numPosts; ++i) {
@@ -242,22 +242,18 @@ Kareem.prototype.createWrapperSync = function(name, fn) {
 
 function _handleWrapError(instance, error, name, context, args, options, callback) {
   if (options.useErrorHandlers) {
-    var _options = { error: error };
-    return instance.execPost(name, context, args, _options, function(error) {
+    return instance.execPost(name, context, args, { error: error }, function(error) {
       return typeof callback === 'function' && callback(error);
     });
   } else {
-    return typeof callback === 'function' ?
-      callback(error) :
-      undefined;
+    return typeof callback === 'function' && callback(error);
   }
 }
 
 Kareem.prototype.wrap = function(name, fn, context, args, options) {
   const lastArg = (args.length > 0 ? args[args.length - 1] : null);
-  const argsWithoutCb = typeof lastArg === 'function' ?
-    args.slice(0, args.length - 1) :
-    args;
+  const argsWithoutCb = Array.from(args);
+  typeof lastArg === 'function' && argsWithoutCb.pop();
   const _this = this;
 
   options = options || {};
@@ -274,12 +270,16 @@ Kareem.prototype.wrap = function(name, fn, context, args, options) {
         options, lastArg);
     }
 
-    const end = (typeof lastArg === 'function' ? args.length - 1 : args.length);
     const numParameters = fn.length;
-    const ret = fn.apply(context, args.slice(0, end).concat(_cb));
+    let ret;
+    try {
+      ret = fn.apply(context, argsWithoutCb.concat(_cb));
+    } catch (err) {
+      return _cb(err);
+    }
 
     if (checkForPromise) {
-      if (ret != null && typeof ret.then === 'function') {
+      if (isPromiseLike(ret)) {
         // Thenable, use it
         return ret.then(
           res => _cb(null, res),
@@ -289,14 +289,14 @@ Kareem.prototype.wrap = function(name, fn, context, args, options) {
 
       // If `fn()` doesn't have a callback argument and doesn't return a
       // promise, assume it is sync
-      if (numParameters < end + 1) {
+      if (numParameters < argsWithoutCb.length + 1) {
         return _cb(null, ret);
       }
     }
 
     function _cb() {
-      const args = arguments;
-      const argsWithoutError = Array.prototype.slice.call(arguments, 1);
+      const argsWithoutError = Array.from(arguments);
+      argsWithoutError.shift();
       if (options.nullResultByDefault && argsWithoutError.length === 0) {
         argsWithoutError.push(null);
       }
@@ -306,15 +306,12 @@ Kareem.prototype.wrap = function(name, fn, context, args, options) {
           argsWithoutError, options, lastArg);
       } else {
         _this.execPost(name, context, argsWithoutError, function() {
-          if (arguments[0]) {
-            return typeof lastArg === 'function' ?
-              lastArg(arguments[0]) :
-              undefined;
+          if (lastArg === null) {
+            return;
           }
-
-          return typeof lastArg === 'function' ?
-            lastArg.apply(context, arguments) :
-            undefined;
+          arguments[0]
+            ? lastArg(arguments[0])
+            : lastArg.apply(context, arguments)
         });
       }
     }
@@ -367,28 +364,26 @@ Kareem.prototype.createWrapper = function(name, fn, context, options) {
     // Fast path: if there's no hooks for this function, just return the
     // function wrapped in a nextTick()
     return function() {
-      process.nextTick(() => fn.apply(this, arguments));
+      nextTick(() => fn.apply(this, arguments));
     };
   }
   return function() {
     var _context = context || this;
-    var args = Array.prototype.slice.call(arguments);
-    _this.wrap(name, fn, _context, args, options);
+    _this.wrap(name, fn, _context, Array.from(arguments), options);
   };
 };
 
 Kareem.prototype.pre = function(name, isAsync, fn, error, unshift) {
   let options = {};
-  if (typeof isAsync === 'object' && isAsync != null) {
+  if (typeof isAsync === 'object' && isAsync !== null) {
     options = isAsync;
     isAsync = options.isAsync;
   } else if (typeof arguments[1] !== 'boolean') {
-    error = fn;
     fn = isAsync;
     isAsync = false;
   }
 
-  const pres = get(this._pres, name, []);
+  const pres = this._pres.get(name) || [];
   this._pres.set(name, pres);
 
   if (isAsync) {
@@ -410,7 +405,7 @@ Kareem.prototype.pre = function(name, isAsync, fn, error, unshift) {
 };
 
 Kareem.prototype.post = function(name, options, fn, unshift) {
-  const hooks = get(this._posts, name, []);
+  const hooks = this._posts.get(name) || [];
 
   if (typeof options === 'function') {
     unshift = !!fn;
@@ -451,7 +446,7 @@ Kareem.prototype.merge = function(other, clone) {
   var ret = clone ? this.clone() : this;
 
   for (let key of other._pres.keys()) {
-    const sourcePres = get(ret._pres, key, []);
+    const sourcePres = ret._pres.get(key) || [];
     const deduplicated = other._pres.get(key).
       // Deduplicate based on `fn`
       filter(p => sourcePres.map(_p => _p.fn).indexOf(p.fn) === -1);
@@ -461,7 +456,7 @@ Kareem.prototype.merge = function(other, clone) {
     ret._pres.set(key, combined);
   }
   for (let key of other._posts.keys()) {
-    const sourcePosts = get(ret._posts, key, []);
+    const sourcePosts = ret._posts.get(key) || [];
     const deduplicated = other._posts.get(key).
       filter(p => sourcePosts.indexOf(p) === -1);
     ret._posts.set(key, sourcePosts.concat(deduplicated));
@@ -470,28 +465,21 @@ Kareem.prototype.merge = function(other, clone) {
   return ret;
 };
 
-function get(map, key, def) {
-  if (map.has(key)) {
-    return map.get(key);
-  }
-  return def;
-}
-
 function callMiddlewareFunction(fn, context, args, next) {
-  let maybePromise;
+  let maybePromiseLike;
   try {
-    maybePromise = fn.apply(context, args);
+    maybePromiseLike = fn.apply(context, args);
   } catch (error) {
     return next(error);
   }
 
-  if (isPromise(maybePromise)) {
-    maybePromise.then(() => next(), err => next(err));
+  if (isPromiseLike(maybePromiseLike)) {
+    maybePromiseLike.then(() => next(), err => next(err));
   }
 }
 
-function isPromise(v) {
-  return v != null && typeof v.then === 'function';
+function isPromiseLike(v) {
+  return (typeof v === 'object' && v !== null && typeof v.then === 'function');
 }
 
 function decorateNextFn(fn) {
@@ -505,8 +493,12 @@ function decorateNextFn(fn) {
     called = true;
     // Make sure to clear the stack so try/catch doesn't catch errors
     // in subsequent middleware
-    return process.nextTick(() => fn.apply(_this, arguments));
+    return nextTick(() => fn.apply(_this, arguments));
   };
 }
 
+const nextTick = typeof process === 'object' && process !== null && process.nextTick || function nextTick(cb) { 
+  setTimeout(cb, 0); 
+}
+
 module.exports = Kareem;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kareem",
-  "version": "2.3.2",
+  "version": "2.3.5",
   "description": "Next-generation take on pre/post function hooks",
   "main": "index.js",
   "scripts": {
@@ -14,8 +14,8 @@
   "devDependencies": {
     "acquit": "1.x",
     "acquit-ignore": "0.1.x",
-    "nyc": "11.x",
-    "mocha": "5.x"
+    "mocha": "9.2.0",
+    "nyc": "15.1.0"
   },
   "author": "Valeri Karpov <val@karpov.io>",
   "license": "Apache-2.0"

package/test/wrap.test.js

@@ -319,6 +319,30 @@ describe('wrap()', function() {
       25);
   });
 
+  it('catches sync errors', function(done) {
+    hooks.pre('cook', function(done) {
+      done();
+    });
+
+    hooks.post('cook', function(callback) {
+      callback();
+    });
+
+    var args = [];
+    args.push(function(error) {
+      assert.equal(error.message, 'oops!');
+      done();
+    });
+
+    hooks.wrap(
+      'cook',
+      function() {
+        throw new Error('oops!');
+      },
+      null,
+      args);
+  });
+
   it('sync wrappers', function() {
     var calledPre = 0;
     var calledFn = 0;