kareem

What is kareem?

Kareem is a lightweight middleware framework for handling pre and post hooks in JavaScript. It is often used in conjunction with Mongoose to manage middleware for MongoDB operations, but it can be used independently for any asynchronous control flow.

What are kareem's main functionalities?

Pre Hooks

Pre hooks allow you to run functions before a specified event. In this example, a pre-save hook is defined and executed before the 'save' event.

const Kareem = require('kareem');
const hooks = new Kareem();

hooks.pre('save', function(next) {
  console.log('This is a pre-save hook');
  next();
});

hooks.execPre('save', null, function() {
  console.log('Pre-save hooks executed');
});

Post Hooks

Post hooks allow you to run functions after a specified event. In this example, a post-save hook is defined and executed after the 'save' event.

const Kareem = require('kareem');
const hooks = new Kareem();

hooks.post('save', function() {
  console.log('This is a post-save hook');
});

hooks.execPost('save', null, [function() {
  console.log('Post-save hooks executed');
}]);

Parallel Hooks

Parallel hooks allow you to run multiple hooks in parallel. In this example, two pre-save hooks are defined to run in parallel before the 'save' event.

const Kareem = require('kareem');
const hooks = new Kareem();

hooks.pre('save', true, function(next, done) {
  setTimeout(function() {
    console.log('First parallel pre-save hook');
    done();
  }, 100);
});

hooks.pre('save', true, function(next, done) {
  setTimeout(function() {
    console.log('Second parallel pre-save hook');
    done();
  }, 50);
});

hooks.execPre('save', null, function() {
  console.log('All parallel pre-save hooks executed');
});

Other packages similar to kareem

async

The 'async' package provides powerful utilities for working with asynchronous JavaScript. It offers functions for parallel, series, and waterfall control flows, among others. While it is more general-purpose compared to Kareem, it can be used to achieve similar middleware-like behavior.

middleware

The 'middleware' package is a simple middleware framework for Node.js. It allows you to define and execute middleware functions in a stack-like manner. It is similar to Kareem in that it provides a way to manage pre and post hooks, but it is more focused on HTTP request/response cycles.

hooker

The 'hooker' package is a utility for hooking into JavaScript functions. It allows you to define pre and post hooks for any function, making it similar to Kareem. However, it is more focused on function hooking rather than middleware management.

README

kareem

Next-generation take on the hooks, meant to offer additional flexibility in allowing you to execute hooks whenever necessary, as opposed to simply wrapping a single function.

Named for the NBA's all-time leading scorer Kareem Abdul-Jabbar, known for his mastery of the hook shot

pre hooks

It runs without any hooks specified

    
    hooks.execPre('cook', null, function() {
      done();
    });
  

It runs basic serial pre hooks

    
    var count = 0;

    hooks.pre('cook', function(done) {
      ++count;
      done();
    });

    hooks.execPre('cook', null, function() {
      assert.equal(1, count);
      done();
    });
  

It can run multipe pres

    
    var count1 = 0;
    var count2 = 0;

    hooks.pre('cook', function(done) {
      ++count1;
      done();
    });

    hooks.pre('cook', function(done) {
      ++count2;
      done();
    });

    hooks.execPre('cook', null, function() {
      assert.equal(1, count1);
      assert.equal(1, count2);
      done();
    });
  

It can run fully synchronous pres

    
    var count1 = 0;
    var count2 = 0;

    hooks.pre('cook', function() {
      ++count1;
    });

    hooks.pre('cook', function() {
      ++count2;
    });

    hooks.execPre('cook', null, function() {
      assert.equal(1, count1);
      assert.equal(1, count2);
      done();
    });
  

It properly attaches context to pre hooks

    
    hooks.pre('cook', function(done) {
      this.bacon = 3;
      done();
    });

    hooks.pre('cook', function(done) {
      this.eggs = 4;
      done();
    });

    var obj = { bacon: 0, eggs: 0 };

    hooks.execPre('cook', obj, function() {
      assert.equal(3, obj.bacon);
      assert.equal(4, obj.eggs);
      done();
    });
  

It can execute parallel (async) pre hooks

    
    hooks.pre('cook', true, function(next, done) {
      this.bacon = 3;
      next();
      setTimeout(function() {
        done();
      }, 5);
    });

    hooks.pre('cook', true, function(next, done) {
      next();
      var _this = this;
      setTimeout(function() {
        _this.eggs = 4;
        done();
      }, 10);
    });

    hooks.pre('cook', function(next) {
      this.waffles = false;
      next();
    });

    var obj = { bacon: 0, eggs: 0 };

    hooks.execPre('cook', obj, function() {
      assert.equal(3, obj.bacon);
      assert.equal(4, obj.eggs);
      assert.equal(false, obj.waffles);
      done();
    });
  

post hooks

It runs without any hooks specified

    
    hooks.execPost('cook', null, [], function() {
      done();
    });
  

It executes with parameters passed in

    
    hooks.post('cook', function(eggs, bacon, callback) {
      assert.equal(1, eggs);
      assert.equal(2, bacon);
      callback();
    });

    hooks.execPost('cook', null, [1, 2], function(error, eggs, bacon) {
      assert.ifError(error);
      assert.equal(1, eggs);
      assert.equal(2, bacon);
      done();
    });
  

wrap()

It wraps pre and post calls into one call

    
    hooks.pre('cook', true, function(next, done) {
      this.bacon = 3;
      next();
      setTimeout(function() {
        done();
      }, 5);
    });

    hooks.pre('cook', true, function(next, done) {
      next();
      var _this = this;
      setTimeout(function() {
        _this.eggs = 4;
        done();
      }, 10);
    });

    hooks.pre('cook', function(next) {
      this.waffles = false;
      next();
    });

    hooks.post('cook', function(obj) {
      obj.tofu = 'no';
    });

    var obj = { bacon: 0, eggs: 0 };

    var args = [obj];
    args.push(function(error, result) {
      assert.ifError(error);
      assert.equal(3, obj.bacon);
      assert.equal(4, obj.eggs);
      assert.equal(false, obj.waffles);
      assert.equal('no', obj.tofu);

      assert.equal(obj, result);
      done();
    });

    hooks.wrap(
      'cook',
      function(o, callback) {
        assert.equal(3, obj.bacon);
        assert.equal(4, obj.eggs);
        assert.equal(false, obj.waffles);
        assert.equal(undefined, obj.tofu);
        callback();
      },
      obj,
      args);
  

Changelog

<small>0.0.2 (2014-12-12)</small>

• Add github repo and bump 0.0.2 (59db8be)

<a name="0.0.1"></a>