anbaric-state-machine 1.2.2 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anbaric-state-machine",
-  "version": "1.2.2",
+  "version": "1.4.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-cloud": "^1.2.2",
-    "anbaric-tsapi": "^1.2.2"
+    "anbaric-cloud": "^1.4.0",
+    "anbaric-tsapi": "^1.4.0"
   },
   "files": [
     "src"

package/src/StateMachine.ts

@@ -1,8 +1,10 @@
-import {Action, Actor, Consumer, Job, JobPersistence, PropertyDefinition, Queue, State} from "anbaric-tsapi";
+import {Action, Actor, Auditor, Consumer, Job, JobPersistence, PropertyDefinition, Queue, State} from "anbaric-tsapi";
 import {JobPersistenceFactory} from "./persistence/JobPersistenceFactory";
 import {QueueFactory} from "./scheduling/QueueFactory";
 import {ConsumerFactory} from "./scheduling/ConsumerFactory";
-import {Auditor} from "./auditing/Auditor";
+import {Code} from "./actors/Code";
+import {AuditorFactory} from "./auditing/AuditorFactory";
+import {AuditorTransaction} from "./auditing/AuditorTransaction";
 
 class StateMachine {
 
@@ -13,8 +15,10 @@ class StateMachine {
     private persistence: JobPersistence;
     private queue: Queue;
     private consumer: Consumer;
+    private auditor: Auditor;
+    private machineActor: Code;
 
-    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(), auditor : Auditor = AuditorFactory.instance()) {
 
         this.workflowId = workflowId;
         this.states = new Map(states.map(state => [state.id, state]));
@@ -22,6 +26,8 @@ class StateMachine {
         this.dataSchema = new Map(dataSchema.map(property => [property.id, property]));
         this.persistence = persistence;
         this.queue = queue;
+        this.auditor = auditor;
+        this.machineActor = new Code(workflowId, "state-machine");
 
         this.consumer = ConsumerFactory.instance(queue)
         this.consumer.subscribe(workflowId, jobId => this.progressJob(jobId));
@@ -35,11 +41,13 @@ class StateMachine {
         if (! this.validateProperties(properties ?? new Map(), true)) throw new Error("Invalid properties");
 
         if (! this.authorizeActor(actor, job)) {
-            Auditor.instance().audit(job.id, actor, "Unauthorized start", null);
+            await this.auditor.audit(job.id, actor ?? this.machineActor, "CREATE", "Unauthorized start", null);
             throw new Error("Unauthorized");
         }
 
         await this.persistence.save(job);
+        await this.auditor.audit(job.id, actor ?? this.machineActor, "CREATE", "Job started",
+            Object.fromEntries(job.properties));
 
         await this.queue.enqueue(job.id, this.workflowId);
 
@@ -49,14 +57,14 @@ class StateMachine {
     async updateJob(jobId : string, properties : Map<string, any>, actor : Actor) : Promise<void> {
 
         if (! this.authorizeActor(actor, await this.persistence.retrieve(jobId))) {
-            Auditor.instance().audit(jobId, actor, "Unauthorized update", null);
+            await this.auditor.audit(jobId, actor, "UPDATE_PROPERTIES", "Unauthorized update", null);
             throw new Error("Unauthorized");
         }
 
         if (! this.validateProperties(properties, false)) throw new Error("Invalid properties");
 
         await this.persistence.updateProperties(jobId, properties);
-        Auditor.instance().audit(jobId, actor, "Properties updated", Object.fromEntries(properties));
+        await this.auditor.audit(jobId, actor, "UPDATE_PROPERTIES", "Properties updated", Object.fromEntries(properties));
 
         await this.queue.enqueue(jobId, this.workflowId);
     }
@@ -67,19 +75,19 @@ class StateMachine {
         if (! action.predicate(job)) throw new Error("Action predicate unmet");
 
         if (! this.authorizeActor(action.actor, job)) {
-            Auditor.instance().audit(jobId, action.actor, "Unauthorized update", null);
+            await this.auditor.audit(jobId, action.actor, "UPDATE_PROPERTIES", "Unauthorized update", null);
             throw new Error("Actor not authorized to execute action");
         }
 
         const newProperties = await action.run(job);
 
         if (! this.validateProperties(newProperties, false)) {
-            Auditor.instance().audit(jobId, action.actor, "Invalid properties", Object.fromEntries(newProperties));
+            await this.auditor.audit(jobId, action.actor, "UPDATE_PROPERTIES", "Invalid properties", Object.fromEntries(newProperties));
             throw new Error("The action generated invalid properties");
         }
 
         await this.persistence.updateProperties(jobId, newProperties);
-        Auditor.instance().audit(jobId, action.actor, "Properties updated", Object.fromEntries(newProperties));
+        await this.auditor.audit(jobId, action.actor, "UPDATE_PROPERTIES", "Properties updated", Object.fromEntries(newProperties));
 
         await this.queue.enqueue(jobId, this.workflowId);
     }
@@ -100,7 +108,7 @@ class StateMachine {
     }
 
     private async progressJob(jobId : string) : Promise<void> {
-        const auditTransaction = Auditor.instance().transaction();
+        const auditTransaction = new AuditorTransaction(this.auditor);
         let pristine = true;
 
         const job = await this.persistence.retrieve(jobId);
@@ -110,18 +118,18 @@ class StateMachine {
             if (! action.predicate(job)) continue;
 
             if (! this.authorizeActor(action.actor, job)) {
-                auditTransaction.audit(jobId, action.actor, "Unauthorized update", null);
+                auditTransaction.audit(jobId, action.actor, "UPDATE_PROPERTIES", "Unauthorized update", null);
                 continue;
             }
 
             const newProperties = await action.run(job);
 
             if (! this.validateProperties(newProperties, false)) {
-                auditTransaction.audit(jobId, action.actor, "Invalid properties", Object.fromEntries(newProperties));
+                auditTransaction.audit(jobId, action.actor, "UPDATE_PROPERTIES", "Invalid properties", Object.fromEntries(newProperties));
                 continue;
             }
 
-            auditTransaction.audit(jobId, action.actor, "Properties updated", Object.fromEntries(newProperties));
+            auditTransaction.audit(jobId, action.actor, "UPDATE_PROPERTIES", "Properties updated", Object.fromEntries(newProperties));
             newProperties.forEach((value, key) => {
                 pristine = false;
                 job.properties.set(key, value);
@@ -131,7 +139,7 @@ class StateMachine {
         for (const transition of currentState?.transitions ?? []) {
             if (! this.states.has(transition.to)) continue;
             if (job.transition(transition)) {
-                auditTransaction.audit(jobId, undefined, `Transitioned to "${transition.to}"`, null);
+                auditTransaction.audit(jobId, this.machineActor, "CHANGE_STATE", `Transitioned to "${transition.to}"`, null);
                 pristine = false;
                 break;
             }
@@ -142,7 +150,7 @@ class StateMachine {
             await this.queue.enqueue(job.id, this.workflowId);
         }
 
-        auditTransaction.flush();
+        await auditTransaction.flush();
     }
 
     async cleanUp() : Promise<void> {

package/src/auditing/AuditorFactory.ts

@@ -0,0 +1,14 @@
+import {Auditor} from "anbaric-tsapi";
+import {CloudAuditor} from "anbaric-cloud";
+import {ConsoleAuditor} from "./ConsoleAuditor";
+
+const AuditorFactory = {
+
+    instance() : Auditor {
+        if (process.env.ANBARIC_AUDITOR_TYPE === "cloud") return new CloudAuditor();
+        return new ConsoleAuditor();
+    },
+
+};
+
+export { AuditorFactory }

package/src/auditing/AuditorTransaction.ts

@@ -1,27 +1,29 @@
-import {Actor} from "anbaric-tsapi";
-import type {Auditor} from "./Auditor";
+import {Actor, AuditChange, Auditor} from "anbaric-tsapi";
 
-type AuditEntry = {
+type BufferedEntry = {
     jobId : string,
-    actor : Actor | undefined,
+    actor : Actor,
+    change : AuditChange,
     changeDescription : string,
     details : any,
 };
 
 class AuditorTransaction {
 
-    private entries = new Array<AuditEntry>();
+    private entries = new Array<BufferedEntry>();
 
     constructor(private auditor : Auditor) {}
 
-    audit(jobId : string, actor : Actor | undefined, changeDescription : string, details : any) : void {
-        this.entries.push({ jobId, actor, changeDescription, details });
+    audit(jobId : string, actor : Actor, change : AuditChange, changeDescription : string, details : any) : void {
+        this.entries.push({ jobId, actor, change, changeDescription, details });
     }
 
-    flush() : void {
-        this.entries.forEach(entry =>
-            this.auditor.audit(entry.jobId, entry.actor, entry.changeDescription, entry.details));
+    async flush() : Promise<void> {
+        const flushing = this.entries;
         this.entries = [];
+        for (const entry of flushing) {
+            await this.auditor.audit(entry.jobId, entry.actor, entry.change, entry.changeDescription, entry.details);
+        }
     }
 
 }

package/src/auditing/ConsoleAuditor.ts

@@ -0,0 +1,12 @@
+import {Actor, AuditChange, Auditor} from "anbaric-tsapi";
+
+class ConsoleAuditor implements Auditor {
+
+    async audit(jobId : string, actor : Actor, change : AuditChange,
+                changeDescription : string, details : any) : Promise<void> {
+        console.log(`[${jobId}] ${actor.id} ${change} ${changeDescription} ${JSON.stringify(details ?? null)}`);
+    }
+
+}
+
+export { ConsoleAuditor }

package/src/index.ts

@@ -2,8 +2,9 @@ export * from "./StateMachine";
 export * from "./actors/Agent";
 export * from "./actors/Code";
 export * from "./actors/Human";
-export * from "./auditing/Auditor";
+export * from "./auditing/AuditorFactory";
 export * from "./auditing/AuditorTransaction";
+export * from "./auditing/ConsoleAuditor";
 export * from "./persistence/InMemoryJobPersistence";
 export * from "./persistence/JobPersistenceFactory";
 export * from "./scheduling/InMemoryQueue";

package/src/auditing/Auditor.ts

@@ -1,25 +0,0 @@
-import {Actor} from "anbaric-tsapi";
-import {AuditorTransaction} from "./AuditorTransaction";
-
-class Auditor {
-
-    private static singleton? : Auditor;
-
-    static instance() : Auditor {
-        if (!Auditor.singleton) {
-            Auditor.singleton = new Auditor();
-        }
-        return Auditor.singleton;
-    }
-
-    audit(jobId : string, actor : Actor | undefined, changeDescription : string, details : any) : void {
-        console.log(`[${jobId}] ${actor?.id ?? "anonymous"} ${changeDescription} ${JSON.stringify(details ?? null)}`);
-    }
-
-    transaction() : AuditorTransaction {
-        return new AuditorTransaction(this);
-    }
-
-}
-
-export { Auditor }