0.2.0.

CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.2.0
+
+**Breaking Changes**
+
+The activity state initializer has one new argument. The order of arguments is not backward compatible. The first argument is a step, the second argument is a global state.
+
 ## 0.1.3
 
 Added two new activities: `LoopActivity` and `BreakActivity`.

machine/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "sequential-workflow-machine",
 	"description": "Powerful sequential workflow machine for frontend and backend applications.",
-	"version": "0.1.3",
+	"version": "0.2.0",
 	"type": "module",
 	"main": "./lib/esm/index.js",
 	"types": "./lib/index.d.ts",
@@ -46,6 +46,10 @@
 		"sequential-workflow-model": "^0.1.1",
 		"xstate": "^4.37.2"
 	},
+	"dependencies": {
+		"sequential-workflow-model": "^0.1.1",
+		"xstate": "^4.37.2"
+	},
 	"devDependencies": {
 		"@types/jest": "^29.4.0",
 		"@typescript-eslint/eslint-plugin": "^5.54.0",
@@ -58,9 +62,7 @@
 		"rollup": "^3.18.0",
 		"rollup-plugin-dts": "^5.2.0",
 		"rollup-plugin-typescript2": "^0.34.1",
-		"@rollup/plugin-node-resolve": "^15.0.1",
-		"sequential-workflow-model": "^0.1.1",
-		"xstate": "^4.37.2"
+		"@rollup/plugin-node-resolve": "^15.0.1"
 	},
 	"keywords": [
 		"workflow",

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

@@ -1,24 +1,23 @@
 import { ActivityNodeBuilder, MachineContext, ActivityNodeConfig, STATE_FAILED_TARGET, STATE_INTERRUPTED_TARGET } from '../../types';
-import { ActivityStateAccessor } from '../../core/activity-context-accessor';
+import { ActivityStateProvider } from '../../core/activity-context-provider';
 import { AtomActivityConfig } from './types';
 import { catchUnhandledError } from '../../core/catch-unhandled-error';
 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, GlobalState, ActivityState> implements ActivityNodeBuilder<GlobalState> {
-	public constructor(
-		private readonly activityStateAccessor: ActivityStateAccessor<GlobalState, ActivityState>,
-		private readonly config: AtomActivityConfig<TStep, GlobalState, ActivityState>
-	) {}
+export class AtomActivityNodeBuilder<TStep extends Step, TGlobalState, TActivityState> implements ActivityNodeBuilder<TGlobalState> {
+	public constructor(private readonly config: AtomActivityConfig<TStep, TGlobalState, TActivityState>) {}
 
-	public build(step: TStep, nextNodeTarget: string): ActivityNodeConfig<GlobalState> {
+	public build(step: TStep, nextNodeTarget: string): ActivityNodeConfig<TGlobalState> {
+		const activityStateProvider = new ActivityStateProvider(step, this.config.init);
 		const nodeId = getStepNodeId(step.id);
+
 		return {
 			id: nodeId,
 			invoke: {
-				src: catchUnhandledError(async (context: MachineContext<GlobalState>) => {
-					const activityState = this.activityStateAccessor.get(context, nodeId);
+				src: catchUnhandledError(async (context: MachineContext<TGlobalState>) => {
+					const activityState = activityStateProvider.get(context, nodeId);
 
 					const result = await this.config.handler(step, context.globalState, activityState);
 					if (isInterruptResult(result)) {
@@ -29,7 +28,7 @@ export class AtomActivityNodeBuilder<TStep extends Step, GlobalState, ActivitySt
 				onDone: [
 					{
 						target: STATE_INTERRUPTED_TARGET,
-						cond: (context: MachineContext<GlobalState>) => Boolean(context.interrupted)
+						cond: (context: MachineContext<TGlobalState>) => Boolean(context.interrupted)
 					},
 					{
 						target: nextNodeTarget

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

@@ -1,16 +1,13 @@
 import { Activity } from '../../types';
-import { ActivityStateAccessor } from '../../core/activity-context-accessor';
 import { AtomActivityNodeBuilder } from './atom-activity-node-builder';
 import { AtomActivityConfig } from './types';
 import { Step } from 'sequential-workflow-model';
 
-export function createAtomActivity<TStep extends Step = Step, GlobalState = object, ActivityState = object>(
-	config: AtomActivityConfig<TStep, GlobalState, ActivityState>
-): Activity<GlobalState> {
-	const activityStateAccessor = new ActivityStateAccessor(config.init);
-
+export function createAtomActivity<TStep extends Step = Step, TGlobalState = object, TActivityState = object>(
+	config: AtomActivityConfig<TStep, TGlobalState, TActivityState>
+): Activity<TGlobalState> {
 	return {
 		stepType: config.stepType,
-		nodeBuilderFactory: () => new AtomActivityNodeBuilder(activityStateAccessor, config)
+		nodeBuilderFactory: () => new AtomActivityNodeBuilder(config)
 	};
 }

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

@@ -2,15 +2,15 @@ import { Step } from 'sequential-workflow-model';
 import { ActivityConfig, ActivityStateInitializer } from '../../types';
 import { InterruptResult } from '../results/interrupt-result';
 
-export type AtomActivityHandler<TStep extends Step, GlobalState, ActivityState> = (
+export type AtomActivityHandler<TStep extends Step, TGlobalState, TActivityState> = (
 	step: TStep,
-	globalState: GlobalState,
-	activityState: ActivityState
+	globalState: TGlobalState,
+	activityState: TActivityState
 ) => Promise<AtomActivityHandlerResult>;
 
 export type AtomActivityHandlerResult = void | InterruptResult;
 
-export interface AtomActivityConfig<TStep extends Step, GlobalState, ActivityState> extends ActivityConfig<TStep> {
-	init: ActivityStateInitializer<GlobalState, ActivityState>;
-	handler: AtomActivityHandler<TStep, GlobalState, ActivityState>;
+export interface AtomActivityConfig<TStep extends Step, TGlobalState, TActivityState> extends ActivityConfig<TStep> {
+	init: ActivityStateInitializer<TStep, TGlobalState, TActivityState>;
+	handler: AtomActivityHandler<TStep, TGlobalState, TActivityState>;
 }

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

@@ -9,17 +9,19 @@ import {
 	STATE_FAILED_TARGET,
 	STATE_INTERRUPTED_TARGET
 } from '../../types';
-import { ActivityStateAccessor, catchUnhandledError, getStepNodeId } from '../../core';
+import { ActivityStateProvider, catchUnhandledError, getStepNodeId } from '../../core';
 import { isInterruptResult } from '../results';
 import { isBreakResult } from './break-result';
 
-export class BreakActivityNodeBuilder<TStep extends Step, GlobalState, ActivityState> implements ActivityNodeBuilder<GlobalState> {
-	public constructor(
-		private readonly activityStateAccessor: ActivityStateAccessor<GlobalState, BreakActivityState<ActivityState>>,
-		private readonly config: BreakActivityConfig<TStep, GlobalState, ActivityState>
-	) {}
+export class BreakActivityNodeBuilder<TStep extends Step, TGlobalState, TActivityState> implements ActivityNodeBuilder<TGlobalState> {
+	public constructor(private readonly config: BreakActivityConfig<TStep, TGlobalState, TActivityState>) {}
 
-	public build(step: TStep, nextNodeTarget: string, buildingContext: BuildingContext): ActivityNodeConfig<GlobalState> {
+	public build(step: TStep, nextNodeTarget: string, buildingContext: BuildingContext): ActivityNodeConfig<TGlobalState> {
+		const activityStateProvider = new ActivityStateProvider<TStep, TGlobalState, BreakActivityState<TActivityState>>(step, (s, g) => {
+			return {
+				activityState: this.config.init(s, g)
+			};
+		});
 		const nodeId = getStepNodeId(step.id);
 
 		const loopName = this.config.loopName(step);
@@ -28,8 +30,8 @@ export class BreakActivityNodeBuilder<TStep extends Step, GlobalState, ActivityS
 		return {
 			id: nodeId,
 			invoke: {
-				src: catchUnhandledError(async (context: MachineContext<GlobalState>) => {
-					const internalState = this.activityStateAccessor.get(context, nodeId);
+				src: catchUnhandledError(async (context: MachineContext<TGlobalState>) => {
+					const internalState = activityStateProvider.get(context, nodeId);
 
 					const result = await this.config.handler(step, context.globalState, internalState.activityState);
 					if (isInterruptResult(result)) {
@@ -42,12 +44,12 @@ export class BreakActivityNodeBuilder<TStep extends Step, GlobalState, ActivityS
 				onDone: [
 					{
 						target: STATE_INTERRUPTED_TARGET,
-						cond: (context: MachineContext<GlobalState>) => Boolean(context.interrupted)
+						cond: (context: MachineContext<TGlobalState>) => Boolean(context.interrupted)
 					},
 					{
 						target: leaveNodeTarget,
-						cond: (context: MachineContext<GlobalState>) => {
-							const internalState = this.activityStateAccessor.get(context, nodeId);
+						cond: (context: MachineContext<TGlobalState>) => {
+							const internalState = activityStateProvider.get(context, nodeId);
 							return Boolean(internalState.break);
 						}
 					},

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

@@ -1,18 +1,13 @@
-import { BreakActivityConfig, BreakActivityState } from './types';
+import { BreakActivityConfig } from './types';
 import { BreakActivityNodeBuilder } from './break-activity-node-builder';
 import { Step } from 'sequential-workflow-model';
 import { Activity } from '../../types';
-import { ActivityStateAccessor } from '../../core';
 
 export function createBreakActivity<TStep extends Step = Step, GlobalState = object, ActivityState = object>(
 	config: BreakActivityConfig<TStep, GlobalState, ActivityState>
 ): Activity<GlobalState> {
-	const activityStateAccessor = new ActivityStateAccessor<GlobalState, BreakActivityState<ActivityState>>(globalState => ({
-		activityState: config.init(globalState)
-	}));
-
 	return {
 		stepType: config.stepType,
-		nodeBuilderFactory: () => new BreakActivityNodeBuilder(activityStateAccessor, config)
+		nodeBuilderFactory: () => new BreakActivityNodeBuilder(config)
 	};
 }

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

@@ -3,21 +3,21 @@ import { ActivityConfig, ActivityStateInitializer } from '../../types';
 import { InterruptResult } from '../results';
 import { BreakResult } from './break-result';
 
-export type BreakActivityHandler<TStep extends Step, GlobalState, ActivityState> = (
+export type BreakActivityHandler<TStep extends Step, TGlobalState, TActivityState> = (
 	step: TStep,
-	globalState: GlobalState,
-	activityState: ActivityState
+	globalState: TGlobalState,
+	activityState: TActivityState
 ) => Promise<BreakActivityHandlerResult>;
 
 export type BreakActivityHandlerResult = void | InterruptResult | BreakResult;
 
-export interface BreakActivityConfig<TStep extends Step, GlobalState, ActivityState> extends ActivityConfig<TStep> {
+export interface BreakActivityConfig<TStep extends Step, TGlobalState, TActivityState> extends ActivityConfig<TStep> {
 	loopName: (step: TStep) => string;
-	init: ActivityStateInitializer<GlobalState, ActivityState>;
-	handler: BreakActivityHandler<TStep, GlobalState, ActivityState>;
+	init: ActivityStateInitializer<TStep, TGlobalState, TActivityState>;
+	handler: BreakActivityHandler<TStep, TGlobalState, TActivityState>;
 }
 
-export interface BreakActivityState<ActivityState> {
+export interface BreakActivityState<TActivityState> {
 	break?: boolean;
-	activityState: ActivityState;
+	activityState: TActivityState;
 }

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

@@ -6,24 +6,24 @@ import {
 	STATE_INTERRUPTED_TARGET,
 	BuildingContext
 } from '../../types';
-import { ActivityStateAccessor } from '../../core/activity-context-accessor';
+import { ActivityStateProvider } from '../../core/activity-context-provider';
 import { catchUnhandledError } from '../../core/catch-unhandled-error';
 import { getStepNodeId } from '../../core/safe-node-id';
 import { SequentialStep } from 'sequential-workflow-model';
 import { ContainerActivityConfig, ContainerActivityHandler } from './types';
 import { SequenceNodeBuilder } from '../../core';
 import { isInterruptResult } from '../results/interrupt-result';
 
-export class ContainerActivityNodeBuilder<TStep extends SequentialStep, GlobalState, ActivityState>
-	implements ActivityNodeBuilder<GlobalState>
+export class ContainerActivityNodeBuilder<TStep extends SequentialStep, TGlobalState, TActivityState>
+	implements ActivityNodeBuilder<TGlobalState>
 {
 	public constructor(
-		private readonly sequenceNodeBuilder: SequenceNodeBuilder<GlobalState>,
-		private readonly activityStateAccessor: ActivityStateAccessor<GlobalState, ActivityState>,
-		private readonly config: ContainerActivityConfig<TStep, GlobalState, ActivityState>
+		private readonly sequenceNodeBuilder: SequenceNodeBuilder<TGlobalState>,
+		private readonly config: ContainerActivityConfig<TStep, TGlobalState, TActivityState>
 	) {}
 
-	public build(step: TStep, nextNodeTarget: string, buildingContext: BuildingContext): ActivityNodeConfig<GlobalState> {
+	public build(step: TStep, nextNodeTarget: string, buildingContext: BuildingContext): ActivityNodeConfig<TGlobalState> {
+		const activityStateProvider = new ActivityStateProvider<TStep, TGlobalState, TActivityState>(step, this.config.init);
 		const nodeId = getStepNodeId(step.id);
 
 		const enterNodeId = `ENTER.${nodeId}`;
@@ -32,15 +32,15 @@ export class ContainerActivityNodeBuilder<TStep extends SequentialStep, GlobalSt
 
 		const createState = (
 			id: string,
-			handle: ContainerActivityHandler<TStep, GlobalState, ActivityState> | undefined,
+			handle: ContainerActivityHandler<TStep, TGlobalState, TActivityState> | undefined,
 			nextStateNodeTarget: string
 		) => {
 			return {
 				id,
 				invoke: {
-					src: catchUnhandledError(async (context: MachineContext<GlobalState>) => {
+					src: catchUnhandledError(async (context: MachineContext<TGlobalState>) => {
 						if (handle) {
-							const activityState = this.activityStateAccessor.get(context, nodeId);
+							const activityState = activityStateProvider.get(context, nodeId);
 
 							const result = await handle(step, context.globalState, activityState);
 							if (isInterruptResult(result)) {
@@ -52,7 +52,7 @@ export class ContainerActivityNodeBuilder<TStep extends SequentialStep, GlobalSt
 					onDone: [
 						{
 							target: STATE_INTERRUPTED_TARGET,
-							cond: (context: MachineContext<GlobalState>) => Boolean(context.interrupted)
+							cond: (context: MachineContext<TGlobalState>) => Boolean(context.interrupted)
 						},
 						{
 							target: nextStateNodeTarget

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

@@ -1,16 +1,13 @@
 import { Activity } from '../../types';
-import { ActivityStateAccessor } from '../../core/activity-context-accessor';
 import { SequentialStep } from 'sequential-workflow-model';
 import { ContainerActivityConfig } from './types';
 import { ContainerActivityNodeBuilder } from './container-activity-node-builder';
 
-export function createContainerActivity<TStep extends SequentialStep = SequentialStep, GlobalState = object, ActivityState = object>(
-	config: ContainerActivityConfig<TStep, GlobalState, ActivityState>
-): Activity<GlobalState> {
-	const activityStateAccessor = new ActivityStateAccessor(config.init);
-
+export function createContainerActivity<TStep extends SequentialStep = SequentialStep, TGlobalState = object, TActivityState = object>(
+	config: ContainerActivityConfig<TStep, TGlobalState, TActivityState>
+): Activity<TGlobalState> {
 	return {
 		stepType: config.stepType,
-		nodeBuilderFactory: sequenceNodeBuilder => new ContainerActivityNodeBuilder(sequenceNodeBuilder, activityStateAccessor, config)
+		nodeBuilderFactory: sequenceNodeBuilder => new ContainerActivityNodeBuilder(sequenceNodeBuilder, config)
 	};
 }

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

@@ -2,16 +2,16 @@ import { Step } from 'sequential-workflow-model';
 import { ActivityConfig, ActivityStateInitializer } from '../../types';
 import { InterruptResult } from '../results/interrupt-result';
 
-export type ContainerActivityHandler<TStep extends Step, GlobalState, ActivityState> = (
+export type ContainerActivityHandler<TStep extends Step, TGlobalState, TActivityState> = (
 	step: TStep,
-	globalState: GlobalState,
-	activityState: ActivityState
+	globalState: TGlobalState,
+	activityState: TActivityState
 ) => Promise<ContainerActivityHandlerResult>;
 
 export type ContainerActivityHandlerResult = void | InterruptResult;
 
-export interface ContainerActivityConfig<TStep extends Step, GlobalState, ActivityState> extends ActivityConfig<TStep> {
-	init: ActivityStateInitializer<GlobalState, ActivityState>;
-	onEnter?: ContainerActivityHandler<TStep, GlobalState, ActivityState>;
-	onLeave?: ContainerActivityHandler<TStep, GlobalState, ActivityState>;
+export interface ContainerActivityConfig<TStep extends Step, TGlobalState, TActivityState> extends ActivityConfig<TStep> {
+	init: ActivityStateInitializer<TStep, TGlobalState, TActivityState>;
+	onEnter?: ContainerActivityHandler<TStep, TGlobalState, TActivityState>;
+	onLeave?: ContainerActivityHandler<TStep, TGlobalState, TActivityState>;
 }