anbaric-state-machine 1.10.0 → 1.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anbaric-state-machine",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "This is the state machine library that one can use to add state management to an application. It will, by default, be locally runnable but can deployed to the Anbaric Cloud via the CLI",
   "license": "MIT",
   "author": "chris@anbaric.ai",
@@ -15,8 +15,8 @@
     "typescript": "^7.0.2"
   },
   "dependencies": {
-    "anbaric-impl-cloud": "^1.10.0",
-    "anbaric-tsapi": "^1.10.0"
+    "anbaric-impl-cloud": "^1.12.0",
+    "anbaric-tsapi": "^1.12.0"
   },
   "files": [
     "src"

package/src/StateMachine.ts

@@ -15,16 +15,18 @@ import {Code} from "./actors/Code";
 
 class StateMachine {
 
-    private workflowId: string;
-    private states: Map<string, State>;
-    private startState: string;
-    private dataSchema: Map<string, PropertyDefinition>;
+    readonly workflowId: string;
+    readonly states: Map<string, State>;
+    readonly startState: string;
+    readonly dataSchema: Map<string, PropertyDefinition>;
+
     private persistence: JobPersistence;
     private queue: Queue;
     private consumer: Consumer;
     private machineActor: Code;
+    private sameStateDelayMs: number;
 
-    constructor(workflowId : string, states : Array<State>, startState : string, dataSchema : Array<PropertyDefinition>, persistence : JobPersistence = JobPersistenceFactory.instance(), queue : Queue = QueueFactory.instance()) {
+    constructor(workflowId : string, states : Array<State>, startState : string, dataSchema : Array<PropertyDefinition>, persistence : JobPersistence = JobPersistenceFactory.instance(), queue : Queue = QueueFactory.instance(), sameStateDelayMs : number = 5 * 60_000) {
 
         this.workflowId = workflowId;
         this.states = new Map(states.map(state => [state.id, state]));
@@ -33,6 +35,7 @@ class StateMachine {
         this.persistence = persistence;
         this.queue = queue;
         this.machineActor = new Code(workflowId, "state-machine");
+        this.sameStateDelayMs = sameStateDelayMs;
 
         this.consumer = ConsumerFactory.instance(queue)
         this.consumer.subscribe(workflowId, jobId => this.progressJob(jobId));
@@ -87,8 +90,7 @@ class StateMachine {
 
     private validateProperties(properties : Map<string, any>, isNew : boolean) : boolean {
         for (const [key, value] of properties) {
-            const definition = this.dataSchema.get(key);
-            if (! definition || ! definition.validation(value)) return false;
+            if (this.propertyProblem(key, value)) return false;
         }
 
         if (! isNew) return true;
@@ -100,12 +102,21 @@ class StateMachine {
         return true;
     }
 
+    private propertyProblem(key : string, value : any) : string | undefined {
+        const definition = this.dataSchema.get(key);
+        if (! definition) return "is not declared in the data schema";
+        if (! definition.validation(value)) return "failed its validation";
+        return undefined;
+    }
+
     private async progressJob(jobId : string) : Promise<void> {
         let pristine = true;
 
         const job = await this.persistence.retrieve(jobId, this.machineActor);
         const currentState = this.states.get(job.state);
 
+        if (currentState?.isTerminal) return;
+
         const involvedActors : Actor[] = [];
 
         for (const action of currentState?.actions ?? []) {
@@ -114,14 +125,20 @@ class StateMachine {
 
             const newProperties = await action.run(job);
 
-            if (! this.validateProperties(newProperties, false)) continue;
-
-            involvedActors.push(action.actor);
-
-            newProperties.forEach((value, key) => {
-                pristine = false;
+            let applied = false;
+            for (const [key, value] of newProperties) {
+                const problem = this.propertyProblem(key, value);
+                if (problem) {
+                    console.warn(`[${this.workflowId}] action "${action.name}" set "${key}", which ${problem}, on job ${job.id} — skipping that property.`);
+                    continue;
+                }
+                if (job.properties.has(key) && this.sameValue(job.properties.get(key), value)) continue;
                 job.properties.set(key, value);
-            });
+                pristine = false;
+                applied = true;
+            }
+
+            if (applied) involvedActors.push(action.actor);
         }
 
         let newState : string | undefined = undefined;
@@ -134,13 +151,23 @@ class StateMachine {
             }
         }
 
-        if (! pristine) {
-            // TODO: persistence.save should have the ability to accept multiple actors for this case.
-            await this.persistence.save(involvedActors[0] ?? this.machineActor, `Job ${job.id} progressed automatically`, job, job.properties, newState);
+        if (pristine) return;
+
+        // TODO: persistence.save should have the ability to accept multiple actors for this case.
+        await this.persistence.save(involvedActors[0] ?? this.machineActor, `Job ${job.id} progressed automatically`, job, job.properties, newState);
+
+        if (this.states.get(newState ?? job.state)?.isTerminal) return;
+        if (newState !== undefined) {
             await this.queue.enqueue(job.id, this.workflowId);
+        } else {
+            await this.queue.schedule(job.id, this.workflowId, new Date(Date.now() + this.sameStateDelayMs));
         }
     }
 
+    private sameValue(a : any, b : any) : boolean {
+        return a === b || JSON.stringify(a) === JSON.stringify(b);
+    }
+
     async cleanUp() : Promise<void> {
         await this.consumer.cleanUp();
     }