0.5.1. (#8)

Author: b4rtaz

CHANGELOG.md

@@ -1,3 +1,17 @@
+## 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.
+
+```js
+createForkActivity<BranchedStep, TestGlobalState>('if', {
+  init: () => ({ /* ... */ }),
+  handler: async (step, globalState, activityState) => {
+    // ...
+    return skip();
+  }
+})
+```
+
 ## 0.5.0
 
 This version simplifies error handling:

machine/package.json

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

machine/src/activities/fork-activity/fork-activity-node-builder.ts

@@ -14,6 +14,7 @@ import { getBranchNodeId, getStepNodeId } from '../../core/safe-node-id';
 import { BranchedStep } from 'sequential-workflow-model';
 import { isBranchNameResult } from '../results/branch-name-result';
 import { isInterruptResult } from '../results/interrupt-result';
+import { isSkipResult } from '../results';
 
 export class ForkActivityNodeBuilder<TStep extends BranchedStep, TGlobalState, TActivityState extends object>
 	implements ActivityNodeBuilder<TGlobalState>
@@ -55,6 +56,13 @@ export class ForkActivityNodeBuilder<TStep extends BranchedStep, TGlobalState, T
 							throw new Error(`Branch ${result.branchName} does not exist`);
 						}
 						internalState.targetBranchName = result.branchName;
+						internalState.skipped = undefined;
+						return;
+					}
+
+					if (isSkipResult(result)) {
+						internalState.targetBranchName = undefined;
+						internalState.skipped = true;
 						return;
 					}
 
@@ -65,6 +73,13 @@ export class ForkActivityNodeBuilder<TStep extends BranchedStep, TGlobalState, T
 						target: STATE_INTERRUPTED_TARGET,
 						cond: (context: MachineContext<TGlobalState>) => Boolean(context.interrupted)
 					},
+					{
+						target: nextNodeTarget,
+						cond: (context: MachineContext<TGlobalState>) => {
+							const activityState = activityStateProvider.get(context, nodeId);
+							return Boolean(activityState.skipped);
+						}
+					},
 					...branchNames.map(branchName => {
 						return {
 							target: getBranchNodeId(branchName),

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

@@ -5,9 +5,10 @@ import { createForkActivity } from './fork-activity';
 import { BranchedStep, Definition, Step } from 'sequential-workflow-model';
 import { interrupt } from '../results/interrupt-result';
 import { branchName } from '../results/branch-name-result';
+import { skip } from '../results';
 
 interface TestGlobalState {
-	temperature: number;
+	mode: string;
 	message: string;
 }
 
@@ -52,16 +53,22 @@ const activitySet = createActivitySet<TestGlobalState>([
 	createForkActivity<BranchedStep, TestGlobalState>('if', {
 		init: () => ({}),
 		handler: async (_, globalState) => {
-			if (isNaN(globalState.temperature)) {
-				throw new Error('TEST_ERROR');
-			}
-			if (globalState.temperature < 0) {
+			if (globalState.mode === '[interrupt]') {
 				return interrupt();
 			}
-			if (globalState.temperature > 10) {
+			if (globalState.mode === '[fail]') {
+				throw new Error('TEST_ERROR');
+			}
+			if (globalState.mode === '[true]') {
 				return branchName('true');
 			}
-			return branchName('false');
+			if (globalState.mode === '[false]') {
+				return branchName('false');
+			}
+			if (globalState.mode === '[skip]') {
+				return skip();
+			}
+			throw new Error('Unknown mode');
 		}
 	})
 ]);
@@ -77,7 +84,7 @@ function run(definition: Definition, startGlobalState: TestGlobalState) {
 describe('ForkActivity', () => {
 	it('should go by false branch', done => {
 		const startGlobalState: TestGlobalState = {
-			temperature: 0,
+			mode: '[false]',
 			message: ''
 		};
 
@@ -95,7 +102,7 @@ describe('ForkActivity', () => {
 
 	it('should go by true branch', done => {
 		const startGlobalState: TestGlobalState = {
-			temperature: 20,
+			mode: '[true]',
 			message: ''
 		};
 
@@ -114,7 +121,7 @@ describe('ForkActivity', () => {
 
 	it('should interrupt', done => {
 		const startGlobalState: TestGlobalState = {
-			temperature: -20,
+			mode: '[interrupt]',
 			message: ''
 		};
 
@@ -131,9 +138,30 @@ describe('ForkActivity', () => {
 		interpreter.start();
 	});
 
+	it('should skip', done => {
+		const startGlobalState: TestGlobalState = {
+			mode: '[skip]',
+			message: ''
+		};
+
+		const interpreter = run(definition, startGlobalState);
+
+		interpreter.onDone(() => {
+			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)(end)');
+
+			done();
+		});
+		interpreter.start();
+	});
+
 	it('should fail', done => {
 		const startGlobalState: TestGlobalState = {
-			temperature: NaN,
+			mode: '[fail]',
 			message: ''
 		};
 
@@ -143,6 +171,8 @@ describe('ForkActivity', () => {
 			const snapshot = interpreter.getSnapshot();
 
 			expect(snapshot.isFailed()).toBe(true);
+			expect(snapshot.isInterrupted()).toBe(false);
+			expect(snapshot.isFinished()).toBe(false);
 			expect(snapshot.unhandledError?.message).toBe('TEST_ERROR');
 			expect(snapshot.unhandledError?.stepId).toBe('0x002');
 			expect(snapshot.globalState.message).toBe('(start)');

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

@@ -2,8 +2,9 @@ import { BranchedStep } from 'sequential-workflow-model';
 import { ActivityStateInitializer } from '../../types';
 import { InterruptResult } from '../results/interrupt-result';
 import { BranchNameResult } from '../results/branch-name-result';
+import { SkipResult } from '../results';
 
-export type ForkActivityHandlerResult = InterruptResult | BranchNameResult;
+export type ForkActivityHandlerResult = InterruptResult | BranchNameResult | SkipResult;
 export type ForkActivityHandler<TStep extends BranchedStep, TGlobalState, TActivityState> = (
 	step: TStep,
 	globalState: TGlobalState,
@@ -17,5 +18,6 @@ export interface ForkActivityConfig<TStep extends BranchedStep, TGlobalState, TA
 
 export interface ForkActivityState<TActivityState> {
 	targetBranchName?: string;
+	skipped?: true;
 	activityState: TActivityState;
 }

machine/src/activities/results/index.ts

@@ -1,2 +1,3 @@
 export * from './branch-name-result';
 export * from './interrupt-result';
+export * from './skip-result';

machine/src/activities/results/interrupt-result.ts

@@ -3,7 +3,7 @@ export interface InterruptResult {
 }
 
 export function isInterruptResult(result: unknown): result is InterruptResult {
-	return typeof result === 'object' && (result as InterruptResult).interrupt;
+	return typeof result === 'object' && (result as InterruptResult).interrupt === true;
 }
 
 export function interrupt(): InterruptResult {

machine/src/activities/results/skip-result.ts

@@ -0,0 +1,11 @@
+export interface SkipResult {
+	skip: true;
+}
+
+export function isSkipResult(result: unknown): result is SkipResult {
+	return typeof result === 'object' && (result as SkipResult).skip === true;
+}
+
+export function skip(): SkipResult {
+	return { skip: true };
+}

machine/src/index.ts

@@ -1,5 +1,6 @@
 export * from './activities';
 export * from './core';
+export * from './machine-unhandled-error';
 export * from './types';
 export * from './core/activity-set';
 export * from './workflow-machine-builder';