https://github.com/oliverzy/process-engine.js

Node.js Business Process/Workflow Engine
https://github.com/oliverzy/process-engine.js

Last synced: 3 days ago
JSON representation

Node.js Business Process/Workflow Engine

• Host: GitHub
• URL: https://github.com/oliverzy/process-engine.js
• Owner: oliverzy
• Created: 2014-02-28T06:33:39.000Z (almost 11 years ago)
• Default Branch: master
• Last Pushed: 2021-09-22T08:41:34.000Z (over 3 years ago)
• Last Synced: 2024-12-25T09:54:25.932Z (14 days ago)
• Language: JavaScript
• Size: 988 KB
• Stars: 129
• Watchers: 12
• Forks: 33
• Open Issues: 5
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

• awesome_ai_agents - Process-Engine.Js - Node.js Business Process/Workflow Engine (Building / Workflows)

README

        
__Process automation for Node.js__

### Best For

* Task Orchestration

* Human Task Management

* Process Management and Monitoring via a Node.js web application

### Features

* Start/End/Decision/Parallel/Service/Human Task

* Human Task Management

* Process Definition Management and Visualization

* Process Instance Management and Visualization

### Get Started

`npm install process-engine`

```js

var ProcessEngine = require('process-engine');

// Create a process engine object

var processEngine = ProcessEngine.create();

var simpleDefinition = {

  name: 'simple process',

  tasks: {

    start: {type: 'start'},

    'service1': {type: 'service', action: function (variables, complete) {

        console.log('do work');

        complete();

      }

    },

    end: {type: 'end'}

  },

  flows: [

    {from: 'start', to: 'service1'},

    {from: 'service1', to: 'end'}

  ]

};

// Create process instance from the above process definition

var processDefinition = processEngine.importProcessDefinition(simpleDefinition);

var processInstance = processEngine.createProcessInstance(processDefinition);

// Start the execution of the process instance

processInstance.start();

```

### Guide

`Process definition` describes the workflow using tasks and flows. 

The built-in task types:

* `start`: mark the start of process, must be the first task

*  `end`: mark the end of process.

*  `service`: automatic task type that execute any code in it

*  `decision`: Certain things can only be done under certain circumstances. The decision task is used to mark the fork and join of execution path

*  `human`: manual task type, they are assigned by engine, e.g. place it in the task list, the engine expect confirmation to continue the execution

The flow is something to connect the tasks and can take a condition function if the `from` task is decision task.

human task service is used to manipulate the task list.

__See examples/tests for all usage that process engine supports__

### API

* `ProcessEngine`

  * `importProcessDefinition(definition)`: Create a new process definition based on `definition` object

  * `createProcessDefinition(name)`: Create an empty process definition with `name`

  * `loadProcessDefinition(id)`: Load a process definition by `id`

  * `queryProcessDefinition(conditions, options)`: Query process definitions by conditions and options

  * `createProcessInstance(def)`: Create a new process instance with definition `def `

  * `loadProcessInstance(id)`: Load a process instance by `id`

  * `queryProcessInstance(conditions)`: Query process instances by conditions

  * `completeTask(processId, taskId, variables)`: Complete a task with `processId`, `taskId`, `variables`

* `ProcessInstance` is a Node event emitter. 

  * `Events`

    * `before`: emitted before each task is executed

    * `after`: emitted after each task is executed

    * `end`: emitted when the whole process instance is ended

  * `start(variables)`: Start the process instance with given `variables`

  * `getNode(taskName)`: Get the runtime node with `taskName`

* `HumanTaskService`

  * `complete(taskId, variables)`: Complete the human task `taskId` with `variables`

  * `claim(taskId, user)`: Claim the human task `taskId` with User `user`

  * `startWorking(taskId)`: Start to work on the human task `taskId`

  * `query(conditions)`: Query the human tasks by `conditions`

### UI

![image](https://dl.dropboxusercontent.com/u/54970183/Snip20140301_2.png)

process-engine.js contains a Node.js web application to manage the process instances and human task list.

* Go to `ui` folder

* Run `npm install`

* Run `bower install` 

* Run `npm install -g nodemon`

* Run `brunch watch --server` to launch the server

* Open `http://localhost:3000/#/definitions` in your browser

### Development

* Test Runner: `npm install -g mocha`

* Front End Package Manager: `npm install -g bower`

* Front End Build: `npm install -g brunch`

* Code Coverage: `npm install -g istanbul`

### Roadmap

* Planned

  * Process Diagram Designer via D3(SVG)

  * Human Task Form Builder

  * User Management Service

  * Performance Benchmark

* Future

  * Message/Timer Event Support

  * Separate Running and Histronic Process Instances into different collections

  * Sub Process

  * BPMN 2.0 XML Import/Export