@entity-access/entity-access 1.0.136 → 1.0.138

package/src/eternity/EternityStorage.ts

@@ -114,7 +114,8 @@ export default class EternityStorage {
                 queued: r.queued,
                 state: r.state,
                 output: r.output,
-                error: r.error
+                error: r.error,
+                lastID: r.lastID
             };
         }
         return null;
@@ -135,7 +136,8 @@ export default class EternityStorage {
                 queued: r.queued,
                 state: r.state,
                 output: r.output,
-                error: r.error
+                error: r.error,
+                lastID: r.lastID
             };
         }
         return null;
@@ -187,7 +189,7 @@ export default class EternityStorage {
             }
 
             w.state ||= "queued";
-            w.updated = DateTime.utcNow;
+            w.updated ??= DateTime.utcNow;
             await db.saveChanges();
         });
     }

package/src/eternity/Workflow.ts

@@ -65,9 +65,12 @@ export default abstract class Workflow<TIn = any, TOut = any> {
         return Promise.resolve("");
     }
 
-    protected waitForExternalEvent(ts: TimeSpan, ... names: string[]) {
+    protected waitForExternalEvent<T = any, TA extends string[] = string[]>(ts: TimeSpan, ... names: TA) {
         // do nothing...
-        return Promise.resolve("");
+        return Promise.resolve<{
+            name: TA[number] | null | undefined,
+            result: T
+        }>({} as any);
     }
 
     protected async runChild<TChildIn, TChildOut>(type: IClassOf<Workflow<TChildIn, TChildOut>>, input: TChildIn): Promise<TChildOut> {

package/src/tests/eternity/external-event-tests.ts

@@ -0,0 +1,132 @@
+import assert from "assert";
+import Inject, { Register, RegisterScoped, RegisterSingleton, ServiceProvider } from "../../di/di.js";
+import EternityContext from "../../eternity/EternityContext.js";
+import Workflow, { Activity } from "../../eternity/Workflow.js";
+import WorkflowClock from "../../eternity/WorkflowClock.js";
+import DateTime from "../../types/DateTime.js";
+import { TestConfig } from "../TestConfig.js";
+import { BaseDriver } from "../../drivers/base/BaseDriver.js";
+import EternityStorage from "../../eternity/EternityStorage.js";
+import TimeSpan from "../../types/TimeSpan.js";
+import sleep from "../../common/sleep.js";
+
+class MockClock extends WorkflowClock {
+
+    public get utcNow(): DateTime {
+        return this.time;
+    }
+
+    public set utcNow(v: DateTime) {
+        this.time = v;
+    }
+
+    private time: DateTime = DateTime.utcNow;
+
+    public add(ts: TimeSpan) {
+        this.time = this.time.add(ts);
+        return this;
+    }
+}
+
+@RegisterSingleton
+class StateLogger {
+    state: string;
+}
+
+class VerifyWorkflow extends Workflow<string, string> {
+
+    public async run() {
+
+        const ts = TimeSpan.fromSeconds(15);
+
+        for (let index = 0; index < 5; index++) {
+            const { name, result } = await this.waitForExternalEvent(ts, "verify", "resend");
+            switch(name) {
+                case "verify":
+                    await this.log("verify");
+                    if (result === this.input) {
+                        return "ok";
+                    }
+                    break;
+                case "resend":
+                    // do something...
+                    await this.delay(TimeSpan.fromSeconds(1));
+                    await this.log("resend");
+                    break;
+            }
+        }
+
+        return "failed";
+    }
+
+    @Activity
+    async log(
+        state: string,
+        @Inject stateLogger?: StateLogger
+    ) {
+        console.log(`${state} logged`);
+        stateLogger.state = state;
+    }
+
+}
+
+export default async function (this: TestConfig) {
+
+    const mockClock = new MockClock();
+    const stateLogger = new StateLogger();
+    const scope = new ServiceProvider();
+    scope.add(WorkflowClock, mockClock);
+    scope.add(BaseDriver, this.driver);
+    scope.add(StateLogger, stateLogger);
+    const storage = new EternityStorage(this.driver, mockClock);
+    scope.add(EternityStorage, storage);
+
+    const c = new EternityContext(storage);
+    scope.add(EternityContext, c);
+
+    // this is an important step
+    c.register(VerifyWorkflow);
+
+    await storage.seed();
+
+    const id = await c.queue(VerifyWorkflow, "a");
+
+    mockClock.add(TimeSpan.fromSeconds(5));
+
+    await c.processQueueOnce();
+
+    let w = await c.get(VerifyWorkflow, id);
+    assert.equal("queued", w.state);
+
+    mockClock.add(TimeSpan.fromSeconds(5));
+    await c.processQueueOnce();
+
+    w = await c.get(VerifyWorkflow, id);
+    assert.equal("queued", w.state);
+
+    await c.raiseEvent(id, { name: "resend"});
+    mockClock.add(TimeSpan.fromSeconds(5));
+    await c.processQueueOnce();
+
+    assert.equal("resend", stateLogger.state);
+
+    w = await c.get(VerifyWorkflow, id);
+    assert.equal("queued", w.state);
+
+    mockClock.add(TimeSpan.fromSeconds(5));
+    await c.raiseEvent(id, { name: "verify", result: "a"});
+    mockClock.add(TimeSpan.fromSeconds(5));
+    await c.processQueueOnce();
+    assert.equal("verify", stateLogger.state);
+
+    w = await c.get(VerifyWorkflow, id);
+    assert.equal("done", w.state);
+
+    mockClock.add(TimeSpan.fromDays(1));
+    await c.processQueueOnce();
+
+    // make sure workflow is deleted...
+
+    w = await c.get(VerifyWorkflow, id);
+    assert.equal(null, w);
+}