0.5.2. (#9)

Author: b4rtaz

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.5.2
+
+This version adds a possibility to stop a workflow machine. To stop a workflow machine, you should call the `tryStop()` method of the `WorkflowMachineInterpreter` class.
+
 ## 0.5.1
 
 This version adds a new feature to the `fork` activity. Now it's possible to skip all branches. The handler of the `fork` activity should return a value returned by the `skip()` function.

machine/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "sequential-workflow-machine",
 	"description": "Powerful sequential workflow machine for frontend and backend applications.",
-	"version": "0.5.1",
+	"version": "0.5.2",
 	"type": "module",
 	"main": "./lib/esm/index.js",
 	"types": "./lib/index.d.ts",

machine/src/activities/break-activity/break-activity.spec.ts

@@ -98,6 +98,8 @@ describe('BreakActivity', () => {
 			const snapshot = interpreter.getSnapshot();
 
 			expect(snapshot.isFinished()).toBe(true);
+			expect(snapshot.isInterrupted()).toBe(false);
+			expect(snapshot.isFailed()).toBe(false);
 			expect(snapshot.globalState.trace).toBe(
 				'(condition)(decrement)(break)(condition)(decrement)(break)(condition)(decrement)(break)'
 			);

machine/src/activities/fork-activity/fork-activity.spec.ts

@@ -112,6 +112,8 @@ describe('ForkActivity', () => {
 			const snapshot = interpreter.getSnapshot();
 
 			expect(snapshot.isFinished()).toBe(true);
+			expect(snapshot.isInterrupted()).toBe(false);
+			expect(snapshot.isFailed()).toBe(false);
 			expect(snapshot.globalState.message).toBe('(start)(true)(end)');
 
 			done();
@@ -131,6 +133,8 @@ describe('ForkActivity', () => {
 			const snapshot = interpreter.getSnapshot();
 
 			expect(snapshot.isInterrupted()).toBe(true);
+			expect(snapshot.isFinished()).toBe(false);
+			expect(snapshot.isFailed()).toBe(false);
 			expect(snapshot.globalState.message).toBe('(start)');
 
 			done();

machine/src/workflow-machine-interpreter.spec.ts

@@ -0,0 +1,108 @@
+import { Definition, SequentialStep, Step } from 'sequential-workflow-model';
+import { WorkflowMachineInterpreter } from './workflow-machine-interpreter';
+import { createActivitySet } from './core';
+import { createWorkflowMachineBuilder } from './workflow-machine-builder';
+import { createAtomActivityFromHandler, createLoopActivity } from './activities';
+
+interface TestGlobalState {
+	mode: string;
+	value: number;
+}
+
+const definition: Definition = {
+	properties: {},
+	sequence: [
+		{
+			id: '0xloop',
+			componentType: 'container',
+			name: 'loop',
+			type: 'loop',
+			properties: {},
+			sequence: [
+				{
+					type: 'ping',
+					componentType: 'task',
+					name: 'ping',
+					id: '0xping',
+					properties: {}
+				}
+			]
+		} as SequentialStep
+	]
+};
+
+const loopActivity = createLoopActivity<SequentialStep, TestGlobalState>('loop', {
+	condition: async () => true,
+	init: () => ({}),
+	loopName: () => 'loop'
+});
+
+const pingActivity = createAtomActivityFromHandler<Step, TestGlobalState>('ping', async (_, g) => {
+	await sleep(2);
+	g.value++;
+});
+
+async function sleep(ms: number) {
+	return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+describe('WorkflowMachineInterpreter', () => {
+	describe('tryStop()', () => {
+		let interpreter: WorkflowMachineInterpreter<TestGlobalState>;
+
+		beforeEach(() => {
+			const activitySet = createActivitySet<TestGlobalState>([loopActivity, pingActivity]);
+			const workflowMachine = createWorkflowMachineBuilder(activitySet);
+			const machine = workflowMachine.build(definition);
+
+			interpreter = machine.create({
+				init: () => ({
+					mode: 'increment',
+					value: 0
+				})
+			});
+			interpreter.start();
+		});
+
+		it('can stop from outside', done => {
+			interpreter.onDone(() => {
+				const context = interpreter.getSnapshot();
+
+				expect(context.isFailed()).toBe(false);
+				expect(context.isInterrupted()).toBe(false);
+				expect(context.isFinished()).toBe(false);
+				done();
+			});
+
+			setTimeout(() => {
+				interpreter.tryStop();
+			}, 100);
+		});
+
+		it('can stop from onChange', done => {
+			let onChangeCalledAfterStop = 0;
+
+			interpreter.onChange(() => {
+				const snapshot = interpreter.getSnapshot();
+				if (snapshot.globalState.value > 10) {
+					interpreter.tryStop();
+					onChangeCalledAfterStop++;
+				}
+			});
+			interpreter.onDone(() => {
+				const context = interpreter.getSnapshot();
+
+				expect(context.isFailed()).toBe(false);
+				expect(context.isFinished()).toBe(false);
+				expect(context.isInterrupted()).toBe(false);
+				expect(onChangeCalledAfterStop).toBe(0);
+				done();
+			});
+		});
+
+		it('cannot stop two times', () => {
+			expect(interpreter.tryStop()).toBe(true);
+			expect(interpreter.tryStop()).toBe(false);
+		});
+	});
+});

machine/src/workflow-machine-interpreter.ts

@@ -1,3 +1,4 @@
+import { InterpreterStatus } from 'xstate';
 import { SequentialStateMachineInterpreter } from './types';
 import { WorkflowMachineSnapshot } from './workflow-machine-snapshot';
 
@@ -15,7 +16,7 @@ export class WorkflowMachineInterpreter<GlobalState> {
 	}
 
 	public onDone(callback: () => void): this {
-		this.interpreter.onDone(callback);
+		this.interpreter.onStop(callback);
 		return this;
 	}
 
@@ -24,6 +25,18 @@ export class WorkflowMachineInterpreter<GlobalState> {
 		return this;
 	}
 
+	public isRunning(): boolean {
+		return this.interpreter.status === InterpreterStatus.Running;
+	}
+
+	public tryStop(): boolean {
+		if (this.isRunning()) {
+			this.interpreter.stop();
+			return true;
+		}
+		return false;
+	}
+
 	public sendSignal(signalName: string, params?: Record<string, unknown>): this {
 		this.interpreter.send(signalName, params);
 		return this;