async-runner v4.0.0

Async Runner

Simple Async Runner

Install

npm install --save async-runner

Setup

const { parallel, sequence } = require('async-runner');

Parallel

const result = yield parallel([
    () => sleep(50).then(() => '[X]'),
    () => Promise.reject(ex),
    () => Promise.resolve('[Y]')
]);
t.same(result, ['[X]', ex, '[Y]']);

Sequence

const ex = new Error('[ERR]');
const commands = [
    () => sleep(20).then(() => '[X]'),
    ([previous]) => Promise.resolve() => `${previous}-[Y]`),
    ([first, second]) => Promise.reject(ex),
    ([first, second, third]) => Promise.resolve('${first}-${second}-${third}[Z]')
];
const result = yield parallel(commands);
t.same(result, ['[X]', '[X]-[Y]', ex]);

Combined

const ex = new Error('[First]');
const main1 = () => sequence([
  () => Promise.resolve('[X]'),
  () => Promise.reject(ex)
]);
const main2 = () => sequence([
  () => Promise.reject(ex),
  () => Promise.resolve('[Y]')
]);
const result = yield parallel([main1, main2]);
t.same(result, [['[X]', ex], [ex]]);

Async Executer for tasks

Setup

const { parallel, sequence } = require('async-runner').tasks;

Parallel

const result = yield parallel({
    CreateProduction: () => Promise.reject(new Error('test')),
    CreateStage: () => Promise.resolve('[X]')
});

t.same(result, {
    CreateProduction: {
      result: new Error('test'),
      state: 'rejected'
    },
    CreateStage: {
      result: '[X]',
      state: 'resolved'
    }
});

Sequent

const result = yield sequence({
    CreateProduction: () => Promise.resolve('[X]'),
    CreateOtherThing: () => Promise.reject(new Error('test')),
    CreateStage: () => Promise.resolve('[Y]')
});

t.same(result, {
    CreateProduction: {
      result: '[X]',
      state: 'resolved'
    },
    CreateOtherThing: {
      result: new Error('test'),
      state: 'rejected'
    },
    CreateStage: {
      result: undefined,
      state: 'skipped'
    }
});

Combined

const result = yield parallel({
    mainTask1: () => sequence({
      task1: () => Promise.resolve('[X]'),
      task2: () => Promise.resolve('[Y]')
    }),
    mainTask2: () => sequence({
      task3: () => Promise.reject(new Error('test')),
      task4: () => Promise.resolve('[V]')
    })
});

t.same(result, {
    mainTask1: {
      state: 'resolved',
      result: {
        task1: { result: '[X]', state: 'resolved' },
        task2: { result: '[Y]', state: 'resolved' }
      }
    },
    mainTask2: {
      state: 'rejected',
      result: {
        task3: { result: new Error('test'), state: 'rejected' },
        task4: { result: undefined, state: 'skipped' }
      }
    }
});