TypeScript logic flow execution engine

readme.md

Async operation procedure execution engine

• Reusable, recoverable operations
• Reusable procedures
• High-level orchestration API

Benefit

• Break down business logic complexity
• Rapid development
• Easy customization to adapt customer requirement
• Built-in command pattern to simplify operation rollback design

example.ts

async function operationOne(context: SharedContext, input: Readonly<Op1Input>): Promise<[Op1Output, RollbackFn]> {
  const id = input.id;
  await saveDb(id, true);
  const result = 'OK';

  const rollback = async (context: SharedContext) => {
    await saveDb(id, false);
  }
  
  return [result, rollback];
}


async function myProc(flow: Flow, input) {
  const x = await flow.runOp(operationOne, input.id);
  const output = await flow.runOp(operationTwo, x);
  return output;
}

const context = { ... };
new Flow(context).run(myProc, {id: 123});

flow_engine.ts

interface SharedContext {
  [propName: string]: any;
}

type RollbackFn = (context: SharedContext) => Promise<void>;
type Operation<Input, Output> = (context: SharedContext,
                                 input: Readonly<Input>) => Promise<[Output, RollbackFn | undefined]>;
type Procedure<Input, Output> = (flow: Flow, input: Readonly<Input>) => Promise<Output>;

class Flow {
  private readonly rollbackStack: RollbackFn[] = [];

  constructor(public context: SharedContext) {
  }

  // call an operation
  async runOp<Input, Output>(operation: Operation<Input, Output>, input: Readonly<Input>): Promise<Output> {
    try {
      const [output, rollback] = await operation(this.context, input);
      if (rollback) {
        this.rollbackStack.push(rollback);
      }
      return output;
    } catch (err) {
      throw err; // RollbackError
    }
  }

  async runProc<Input, Output>(proc: Procedure<Input, Output>, input: Readonly<Input>): Promise<Output> {
    try {
      return await proc(this, input);
    } catch (err) {
      await this.rollback();
      throw err;
    }
  }

  private async rollback(): Promise<void> {
    while (this.rollbackStack.length > 0) {
      const func = this.rollbackStack.pop();
      await func!(this.context);
    }
  }
}

export { SharedContext, RollbackFn, Flow };