Onion Compose

Simple function inspired by koa compose the difference is that this module accepts any number of arguments as opposed to original which accepts only one argument.

Install

npm i onion-compose

Motivation

Composing functions with onion style execution is a very powerful concept, especially in the HTTP framework for composing middleware functions, and I wanted the same middleware execution style as koa.js but with a middleware signature like expressjs, hence this little module has been created.

If you need a refresher on what is onion style composition, check this out:

test('Run order', async () => {
  const original: number[] = []
  const fn1 = async (arr: number[], next: () => void) => {
    arr.push(1)

    await next()

    arr.push(2)

    return 'done'
  }
  const fn2 = async (arr: number[], next: () => void) => {
    arr.push(3)

    await next()

    arr.push(4)
  }

  const result = await compose([fn1, fn2])([original])

  expect(original).toEqual(expect.arrayContaining([1, 3, 4, 2]))
  expect(result).toBe('done')
})

Usage

import compose from 'compose'

const fn1 = async (a: string, b: number, next: () => void) => {
  await next()
}

const fn2 = async (a: string, b: number, next: () => void) => {
  await next()
}

const fn3 = async (a: string, b: number, next: () => void) => {
  await next()
}

await compose([fn1, fn2, fn3])(['foo', 1])
// or
await compose([fn1, fn2])(['foo', 1], fn3)

You can use compose with any number of arguments.

const fn = (
  a: string,
  b: number,
  c: boolean,
  d: string[],
  e: number[],
  _next: () => void
) => undefined

await compose([fn])(['a', 1, true, ['a', 'b'], [1, 2]])

One difference with koa-compose is that because of the arbitrary number of arguments you cannot nest compose inside another compose (which koa-compose can do), but it's very easy to achieve that with the help of a simple function.

//utility function to wrap compose before passing it to another compose
function nest(composeExec) {
  return (...args) => {
    const next = args[args.length - 1]
    args.pop()
    return composeExec(args, next)
  }
}

const fn1 = (a, next) => {
  next()
}

const fn2 = (a, next) => {
  next()
}

const fn3 = (a: string, next: () => void) => {
  next()
}

const nestedCompose = nest(compose([fn1, fn2]))

// run order: fn3, fn, fn2
await compose([fn3, nestedCompose])(['foo'])

Keep in mind that Typescript types can stop working when nesting compose inside another compose if you know how to make the types work, please make a pull request.

All original koa-compose tests are passing, except for the nested compose test (you can pass that one with the help of the utility function above).