Namespace process

async function loadData() {
  // make a data call
}

function processResults() {
  // access this.results.load
  // value returned will be assigned
  // to this.results.process
}

const actions = models.collection();
actions.add(process.action('load', loadData));
actions.add(process.action('process', processResults));

// "load" should transition to "process" automatically:
const criteria = [ ['load', 'process'] ];

export const start = process.create('get data', actions, process.transitions(criteria));

// workflow

import { loadUserInfo } from '../data/user';
import { loadClientData } from '../data/clients';

import { start } from '../path/to/machine';

const actions = models.collection();

actions.add(process.action('loadUserInfo', loadUserInfo));

actions.add(process.action('loadClientData', {
  async execute() {
    const clientId = this.args[0];
    return await loadClientData(clientId)
      .catch(errors.rethrow({ clientId }));
  }
}));

actions.add(process.action('merge', {
  execute() {
    const user = this.results.loadUserInfo;
    const clients = this.results.loadClientData;
    return Object.assign({}, user, { clients });
  }
}));

actions.add(process.action('eula', function execute() {
  const conditions = this.results;
  return start('initial', conditions);
}));

export const dispatch = process.create('load user clients', actions, process.dependencies({
  'eula': ['merge'],
  'merge': ['loadUserInfo', 'loadClientData'],
}));

// USAGE: dispatch(clientId);

// state machine

import { tracker } from '~/tracking';
import { showDialog } from '../some/dialog';
import { dispatch } from '../some/workflow';

const actions = new Set();

// if no start state is explicitly passed to the start()
// method then this first action will be used automatically
actions.add(process.action('start', {
  success() {
    tracker.event(`${this.process} succeeded`);
  },
  failure(err) {
    Object.assign(err, errors.fatal());
    tracker.error(err);
  }
}));

actions.add(process.action('show dialog', {
  execute() {
    return showDialog('accept.cookies');
  }
}));

// we can dispatch a workflow in one of our actions
actions.add(process.action('run workflow', function execute() {
  const cookiesEnabled = this.results['show dialog'];
  const ignoreError = errors.rethrow(errors.ignore({ cookiesEnabled }));
  return dispatch(cookiesEnabled).catch(ignoreError);
}));

actions.add(process.action('stop', function() {
  this.stop(); // stop the machine
}));

const transitions = process.transitions([

  // show the dialog after starting the machine
  ['start', 'show dialog'],

  // only run the workflow if the user has not
  // logged in within the past 2 weeks
  ['show dialog', 'run workflow', function notRecentlyLoggedIn() {
    const TWO_WEEKS = 1000 * 60 * 60 * 24 * 7 * 2;
    const lastLogin = Date.parse(localStorage.getItem('lastLogin'));
    return lastLogin < Date.now() - TWO_WEEKS;
  }],

  // only if the above transition's condition returns
  // false (i.e. the user has recently logged in) will
  // this next transition will be evaluated; and since
  // this next transition always returns true, the machine
  // will always have a path forward
  ['show dialog', 'stop'],

  // if we did get into the "run workflow" state, make
  // sure we stop the workflow afterwards
  ['run workflow', 'stop']

]);

export const start = process.create('intro', actions, transitions);

const dependencies = process.dependencies({
  'step b': ['step a'], // action b runs after action a
  'step c': ['step b', 'step d'] // action c runs after actions b and d
});

const actions = [
  process.action('step a', () => console.log('step a run')),
  process.action('step b', () => console.log('step b run')),
  process.action('step c', () => console.log('step c run')),
  process.action('step d', () => console.log('step d run')),
];

export const dispatch = process.create('my workflow', actions, dependencies);

const actions = [
  process.action('start', function execute() {
    console.log('args:', this.args);
  }),
  process.action('parallel 1', function execute() {
    console.log('in', this.name);
  }),
  process.action('parallel 2', function execute() {
    console.log('in', this.name);
  }),
];

const order = process.dependencies({
  'parallel 1': ['start'],
  'parallel 2': ['start'],
});

export const dispatch = process('my workflow', actions, order);

// USAGE:
// dispatch(123, 'abc');

const step = process.action('something', {
  count: 0,
  init() { this.count = 0; },
  execute() {
    console.log(this.args);
    this.count = this.count + 1;
    return this.count * this.factor;
  },
  success() {}, // must be invoked manually
  failure(err) {}, // must be invoked manually
});

export async function invokeSomething(...args) {
  const context = { args, factor: 3 };
  const promise = process.run(step, context);
  // invoke success and failure methods
  // on separate promise chain than the
  // one we return to callers; we don't
  // care if these fail and we don't want
  // their return values to override the
  // return value from the execute method
  promise.then(
    () => step.success.call(context),
    (err) => step.failure.call(context, err)
  );
  return await promise; // value returned by execute()
}

const states = models.collection();

states.add(process.action('start', () => console.log('start')));
states.add(process.action('next',  () => console.log('next')));
states.add(process.action('stop',  function() {
  this.stop();
}));

const criteria = process.transitions([
  ['start', 'next'],
  ['next', 'stop']
]);

export const start = process('my machine', states, criteria);

// USAGE:
start();
start('next');
start('stop', { initial: 'conditions' });
// you can also just provide initial conditions;
// the first action will still be used as the start action
start({ initial: 'conditions' });