0.3.0. (#3)

* 0.3.0.

Author: b4rtaz

CHANGELOG.md

@@ -1,3 +1,30 @@
+## 0.3.0
+
+This version changes the syntax of all `create*Activity` functions. The first argument is the step type, the second argument is the configuration.
+
+```ts
+// Old syntax
+const fooActivity = createAtomActivity<FooStep, MyGlobalState, FooStateState>({
+  stepType: 'foo',
+  init: /* ... */,
+  handler: /* ... */,
+})
+
+// New syntax
+const fooActivity = createAtomActivity<FooStep, MyGlobalState, FooStateState>('some', {
+  init: /* ... */,
+  handler: /* ... */,
+})
+```
+
+Additionally this version introduces the `createAtomActivityFromHandler` function. It allows to create an activity by very short syntax. This function creates an activity without the activity state.
+
+```ts
+const fooActivity = createAtomActivityFromHandler<FooStep, MyGlobalState>('foo', async (step, globalState) => {
+  // handler
+});
+```
+
 ## 0.2.0
 
 **Breaking Changes**

README.md

@@ -86,8 +86,7 @@ interface DownloadHtmlStepState {
   attempt: number;
 }
 
-const downloadHtmlActivity = createAtomActivity<DownloadHtmlStep, WorkflowGlobalState, DownloadHtmlStepState>({
-  stepType: 'downloadHtml',
+const downloadHtmlActivity = createAtomActivity<DownloadHtmlStep, WorkflowGlobalState, DownloadHtmlStepState>('downloadHtml', {
   init: () => ({
     attempt: 0,
   }),
@@ -103,7 +102,7 @@ Now we can create the activity set. The activity set is a collection of all supp
 ```ts
 import { activitySet } from 'sequential-workflow-machine';
 
-const activitySet =  createActivitySet<WorkflowGlobalState>([
+const activitySet = createActivitySet<WorkflowGlobalState>([
   downloadHtmlActivity,
 ]);
 ```

machine/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "sequential-workflow-machine",
 	"description": "Powerful sequential workflow machine for frontend and backend applications.",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"type": "module",
 	"main": "./lib/esm/index.js",
 	"types": "./lib/index.d.ts",
@@ -32,7 +32,7 @@
 	},
 	"scripts": {
 		"prepare": "cp ../LICENSE LICENSE && cp ../README.md README.md",
-		"clean": "rm -rf lib && rm -rf build && rm -rf dist",
+		"clean": "rm -rf lib && rm -rf build && rm -rf dist && rm -rf node_modules/.cache/rollup-plugin-typescript2",
 		"start": "rollup -c --watch",
 		"start:clean": "yarn clean && npm run start",
 		"build": "yarn clean && rollup -c",
@@ -43,12 +43,12 @@
 		"prettier:fix": "prettier --write ./src"
 	},
 	"peerDependencies": {
-		"sequential-workflow-model": "^0.1.1",
-		"xstate": "^4.37.2"
+		"sequential-workflow-model": "^0.1.4",
+		"xstate": "^4.38.1"
 	},
 	"dependencies": {
-		"sequential-workflow-model": "^0.1.1",
-		"xstate": "^4.37.2"
+		"sequential-workflow-model": "^0.1.4",
+		"xstate": "^4.38.1"
 	},
 	"devDependencies": {
 		"@types/jest": "^29.4.0",

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

@@ -6,7 +6,9 @@ import { getStepNodeId } from '../../core/safe-node-id';
 import { Step } from 'sequential-workflow-model';
 import { isInterruptResult } from '../results/interrupt-result';
 
-export class AtomActivityNodeBuilder<TStep extends Step, TGlobalState, TActivityState> implements ActivityNodeBuilder<TGlobalState> {
+export class AtomActivityNodeBuilder<TStep extends Step, TGlobalState, TActivityState extends object>
+	implements ActivityNodeBuilder<TGlobalState>
+{
 	public constructor(private readonly config: AtomActivityConfig<TStep, TGlobalState, TActivityState>) {}
 
 	public build(step: TStep, nextNodeTarget: string): ActivityNodeConfig<TGlobalState> {

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

@@ -1,4 +1,4 @@
-import { createAtomActivity } from './atom-activity';
+import { createAtomActivity, createAtomActivityFromHandler } from './atom-activity';
 import { createActivitySet } from '../../core/activity-set';
 import { createWorkflowMachineBuilder } from '../../workflow-machine-builder';
 import { STATE_FINISHED_ID, STATE_INTERRUPTED_ID, STATE_FAILED_ID } from '../../types';
@@ -17,34 +17,21 @@ interface SetCounterStep extends Step {
 }
 
 const activitySet = createActivitySet<TestGlobalState>([
-	createAtomActivity<SetCounterStep, TestGlobalState, { x: number }>({
-		stepType: 'setCounter',
+	createAtomActivity<SetCounterStep, TestGlobalState, { x: number }>('setCounter', {
 		init: () => ({ x: 987654321 }),
 		handler: async (step, globalState, activityState) => {
 			expect(activityState.x).toBe(987654321);
 			globalState.counter = step.properties.value;
 		}
 	}),
-	createAtomActivity<Step, TestGlobalState, null>({
-		stepType: 'multiply2',
-		init: () => null,
-		handler: async (_, globalState) => {
-			globalState.counter *= 2;
-		}
+	createAtomActivityFromHandler<Step, TestGlobalState>('multiply2', async (_, globalState) => {
+		globalState.counter *= 2;
 	}),
-	createAtomActivity<Step, TestGlobalState, null>({
-		stepType: 'interrupt',
-		init: () => null,
-		handler: async () => {
-			return interrupt();
-		}
+	createAtomActivityFromHandler<Step, TestGlobalState>('interrupt', async () => {
+		return interrupt();
 	}),
-	createAtomActivity<Step, TestGlobalState, null>({
-		stepType: 'error',
-		init: () => null,
-		handler: async () => {
-			throw new Error('TEST_ERROR');
-		}
+	createAtomActivityFromHandler<Step, TestGlobalState>('error', async () => {
+		throw new Error('TEST_ERROR');
 	})
 ]);
 

machine/src/activities/atom-activity/atom-activity.ts

@@ -1,13 +1,24 @@
 import { Activity } from '../../types';
 import { AtomActivityNodeBuilder } from './atom-activity-node-builder';
-import { AtomActivityConfig } from './types';
+import { AtomActivityConfig, AtomActivityHandler } from './types';
 import { Step } from 'sequential-workflow-model';
 
-export function createAtomActivity<TStep extends Step = Step, TGlobalState = object, TActivityState = object>(
+export function createAtomActivity<TStep extends Step = Step, TGlobalState = object, TActivityState extends object = object>(
+	stepType: TStep['type'],
 	config: AtomActivityConfig<TStep, TGlobalState, TActivityState>
 ): Activity<TGlobalState> {
 	return {
-		stepType: config.stepType,
+		stepType: stepType,
 		nodeBuilderFactory: () => new AtomActivityNodeBuilder(config)
 	};
 }
+
+export function createAtomActivityFromHandler<TStep extends Step = Step, TGlobalState = object>(
+	stepType: TStep['type'],
+	handler: AtomActivityHandler<TStep, TGlobalState, Record<string, never>>
+): Activity<TGlobalState> {
+	return createAtomActivity(stepType, {
+		init: () => ({}),
+		handler
+	});
+}

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

@@ -1,5 +1,5 @@
 import { Step } from 'sequential-workflow-model';
-import { ActivityConfig, ActivityStateInitializer } from '../../types';
+import { ActivityStateInitializer } from '../../types';
 import { InterruptResult } from '../results/interrupt-result';
 
 export type AtomActivityHandler<TStep extends Step, TGlobalState, TActivityState> = (
@@ -10,7 +10,7 @@ export type AtomActivityHandler<TStep extends Step, TGlobalState, TActivityState
 
 export type AtomActivityHandlerResult = void | InterruptResult;
 
-export interface AtomActivityConfig<TStep extends Step, TGlobalState, TActivityState> extends ActivityConfig<TStep> {
+export interface AtomActivityConfig<TStep extends Step, TGlobalState, TActivityState extends object> {
 	init: ActivityStateInitializer<TStep, TGlobalState, TActivityState>;
 	handler: AtomActivityHandler<TStep, TGlobalState, TActivityState>;
 }

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

@@ -13,7 +13,9 @@ import { ActivityStateProvider, catchUnhandledError, getStepNodeId } from '../..
 import { isInterruptResult } from '../results';
 import { isBreakResult } from './break-result';
 
-export class BreakActivityNodeBuilder<TStep extends Step, TGlobalState, TActivityState> implements ActivityNodeBuilder<TGlobalState> {
+export class BreakActivityNodeBuilder<TStep extends Step, TGlobalState, TActivityState extends object>
+	implements ActivityNodeBuilder<TGlobalState>
+{
 	public constructor(private readonly config: BreakActivityConfig<TStep, TGlobalState, TActivityState>) {}
 
 	public build(step: TStep, nextNodeTarget: string, buildingContext: BuildingContext): ActivityNodeConfig<TGlobalState> {

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

@@ -53,8 +53,7 @@ const definition: Definition = {
 };
 
 const activitySet = createActivitySet<TestGlobalState>([
-	createLoopActivity<SequentialStep, TestGlobalState>({
-		stepType: 'loop',
+	createLoopActivity<SequentialStep, TestGlobalState>('loop', {
 		loopName: step => String(step.properties['loopName']),
 		init: () => ({}),
 		condition: async (_, globalState) => {
@@ -63,18 +62,16 @@ const activitySet = createActivitySet<TestGlobalState>([
 		}
 	}),
 
-	createAtomActivity({
-		stepType: 'decrement',
-		init: () => null,
+	createAtomActivity('decrement', {
+		init: () => ({}),
 		handler: async (_, globalState) => {
 			globalState.trace += '(decrement)';
 			globalState.alfa--;
 		}
 	}),
 
-	createBreakActivity({
-		stepType: 'breakIfZero',
-		init: () => null,
+	createBreakActivity('breakIfZero', {
+		init: () => ({}),
 		handler: async (_, globalState) => {
 			globalState.trace += '(break)';
 			if (globalState.alfa === 0) {

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

@@ -3,11 +3,12 @@ import { BreakActivityNodeBuilder } from './break-activity-node-builder';
 import { Step } from 'sequential-workflow-model';
 import { Activity } from '../../types';
 
-export function createBreakActivity<TStep extends Step = Step, GlobalState = object, ActivityState = object>(
+export function createBreakActivity<TStep extends Step = Step, GlobalState = object, ActivityState extends object = object>(
+	stepType: TStep['type'],
 	config: BreakActivityConfig<TStep, GlobalState, ActivityState>
 ): Activity<GlobalState> {
 	return {
-		stepType: config.stepType,
+		stepType,
 		nodeBuilderFactory: () => new BreakActivityNodeBuilder(config)
 	};
 }