callback-middleware/lib/core.js

Generic middleware based on continuation passing style callbacks.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var callNext = exports.callNext = function callNext(err) {
  for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    args[_key - 1] = arguments[_key];
  }

  var next = args.pop();
  next.apply(undefined, [err].concat(args));
};

var addErr = exports.addErr = function addErr(fn) {
  return function (err) {
    for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
      args[_key2 - 1] = arguments[_key2];
    }

    return fn.apply(undefined, args);
  };
};

var preserveErr = exports.preserveErr = function preserveErr(fn) {
  return function (err1) {
    for (var _len3 = arguments.length, input = Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
      input[_key3 - 1] = arguments[_key3];
    }

    var next = input.pop();
    return fn.apply(undefined, [err1].concat(input, [function (err2) {
      for (var _len4 = arguments.length, output = Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
        output[_key4 - 1] = arguments[_key4];
      }

      if (!err2) {
        err2 = err1;
      }
      next.apply(undefined, [err2].concat(output));
    }]));
  };
};

// cb: takes an async function
//   (...input, next) => next(...output)
// and makes it an error first callback function
//   (err, ...input, next) => next(...output)
// Since the err parameter is simply ignored,
// it must be preceded by an error treatment function in the
// middleware chain, like this:
//  middleware(
//    ifErr.return,
//    cb(myFunc)
//  )(null, ...input,() => {})
var cb = exports.cb = function cb(fn) {
  return preserveErr(addErr(fn));
};

var toAsync = exports.toAsync = function toAsync(fn) {
  return function () {
    for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
      args[_key5] = arguments[_key5];
    }

    var next = args.pop();
    var result = void 0;
    try {
      result = fn.apply(undefined, args);
    } catch (err) {
      return next(err);
    }
    next(null, result);
  };
};

var middleware = exports.middleware = function middleware(fn) {
  for (var _len6 = arguments.length, fns = Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {
    fns[_key6 - 1] = arguments[_key6];
  }

  if (fn instanceof Array) {
    return middleware.apply(undefined, _toConsumableArray(fn).concat(fns));
  }
  if (!fn) {
    return callNext;
  }
  return function (err1) {
    for (var _len7 = arguments.length, input = Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
      input[_key7 - 1] = arguments[_key7];
    }

    var next = input.pop();
    return fn.apply(undefined, [err1].concat(input, [function (err2) {
      for (var _len8 = arguments.length, output = Array(_len8 > 1 ? _len8 - 1 : 0), _key8 = 1; _key8 < _len8; _key8++) {
        output[_key8 - 1] = arguments[_key8];
      }

      return middleware.apply(undefined, fns).apply(undefined, [err2].concat(output, [next]));
    }]));
  };
};