@entity-access/entity-access 1.0.287 → 1.0.289

package/src/tests/eternity/throttle-tests.ts

@@ -0,0 +1,100 @@
+import assert from "assert";
+import Inject, { Register, RegisterSingleton, ServiceProvider } from "../../di/di.js";
+import WorkflowContext from "../../workflows/WorkflowContext.js";
+import Workflow, { Activity } from "../../workflows/Workflow.js";
+import WorkflowClock from "../../workflows/WorkflowClock.js";
+import DateTime from "../../types/DateTime.js";
+import { TestConfig } from "../TestConfig.js";
+import { BaseDriver } from "../../drivers/base/BaseDriver.js";
+import WorkflowStorage from "../../workflows/WorkflowStorage.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.now;
+
+    public add(ts: TimeSpan) {
+        this.time = this.time.add(ts);
+        return this;
+    }
+}
+
+@RegisterSingleton
+class Mailer {
+
+    public items: any[] = [];
+}
+
+class SendWorkflow extends Workflow<string, string> {
+
+    public async run(): Promise<any> {
+
+        await this.delay(TimeSpan.fromHours(1));
+
+        await this.sendMail("a", "b", "c");
+        return "1";
+    }
+
+    @Activity
+    public async sendMail(
+        from: string,
+        to: string,
+        message: string,
+        @Inject logger?: Mailer) {
+        await sleep(10);
+        logger.items.push({ from, to, message });
+    }
+
+}
+
+export default async function (this: TestConfig) {
+
+    const mockClock = new MockClock();
+    const mailer = new Mailer();
+
+    const scope = new ServiceProvider();
+    scope.add(WorkflowClock, mockClock);
+    scope.add(BaseDriver, this.driver);
+    const storage = new WorkflowStorage(this.driver, mockClock);
+    scope.add(Mailer, mailer);
+    scope.add(WorkflowStorage, storage);
+
+    const c = new WorkflowContext(storage);
+    scope.add(WorkflowContext, c);
+
+    // this is an important step
+    c.register(SendWorkflow);
+
+    await storage.seed();
+
+    const id = await c.queue(SendWorkflow, "a", {
+        throttle: {
+            group: "a",
+            maxPerSecond: 1/15
+        }
+    });
+
+    const result = await storage.getWorkflow(id);
+
+    const next = await c.queue(SendWorkflow, "b", {
+        throttle: {
+            group: "a",
+            maxPerSecond: 1/15
+        }
+    });
+
+    const resultNext = await storage.getWorkflow(next);
+    const span = DateTime.from(resultNext.eta).diff(DateTime.from(result.eta));
+    assert(span.totalSeconds > 14);
+
+    // throw new Error("Preserve");
+}

package/src/tests/model/ShoppingContext.ts

@@ -7,6 +7,7 @@ import DateTime from "../../types/DateTime.js";
 import { UserFile } from "./UseFile.js";
 import Sql from "../../sql/Sql.js";
 import MultiForeignKeys from "../../decorators/ForeignKey.js";
+import CheckConstraint from "../../decorators/CheckConstraint.js";
 
 export const statusPublished = "published";
 
@@ -285,6 +286,10 @@ export class ProductCategory {
 }
 
 @Table("ProductPrices")
+@CheckConstraint({
+    name: "CX_ProductPrices_PositivePrice",
+    filter: (x) => x.amount > 0
+})
 export class ProductPrice {
 
     @Column({ key: true, generated: "identity", dataType: "BigInt"})

package/src/workflows/WorkflowContext.ts

@@ -138,6 +138,10 @@ export interface IWorkflowQueueParameter {
     eta?: DateTime;
     parentID?: string;
     taskGroup?: string;
+    throttle?: {
+        group: string;
+        maxPerSecond: number;
+    }
 }
 
 export interface IWorkflowStartParams {
@@ -189,7 +193,8 @@ export default class WorkflowContext {
             throwIfExists,
             eta,
             parentID,
-            taskGroup = "default"
+            taskGroup = "default",
+            throttle
         }: IWorkflowQueueParameter = {}) {
         const clock = this.storage.clock;
         let tries = 1;
@@ -207,10 +212,21 @@ export default class WorkflowContext {
             throw new EntityAccessError(`ID cannot be more than 400 characters`);
         }
 
+        const now = align(clock.utcNow);
+
+        let queued = now;
+
+        let throttleGroup = null;
+
+        if (throttle) {
+            eta = await this.storage.getNextEta(throttle);
+            queued = eta;
+            throttleGroup = throttle.group;
+        }
+
         // this will ensure even empty workflow !!
         const schema = WorkflowRegistry.register(type, void 0);
 
-        const now = align(clock.utcNow);
 
         let lastError = null;
         while(tries--) {
@@ -229,10 +245,11 @@ export default class WorkflowContext {
                 await this.storage.save({
                     id,
                     taskGroup,
+                    throttleGroup,
                     name: schema.name,
                     input: JSON.stringify(input),
                     isWorkflow: true,
-                    queued: now,
+                    queued,
                     updated: now,
                     parentID,
                     eta

package/src/workflows/WorkflowStorage.ts

@@ -27,6 +27,14 @@ const loadedFromDb = Symbol("loadedFromDB");
     ],
     filter: (x) => x.isWorkflow === true
 })
+@Index({
+    name: "IX_Workflows_Throttle_Group",
+    columns: [
+        { name: (x) => x.throttleGroup, descending: false },
+        { name: (x) => x.queued, descending: false }
+    ],
+    filter: (x) => x.isWorkflow === true && x.throttleGroup !== null
+})
 export class WorkflowItem {
 
     @Column({ dataType: "Char", length: 400, key: true })
@@ -62,6 +70,11 @@ export class WorkflowItem {
     })
     public taskGroup: string;
 
+    @Column({
+        dataType: "Char", length: 200, nullable: true
+    })
+    public throttleGroup: string;
+
     @Column({ dataType: "Int", default: () => 0})
     public priority: number;
 
@@ -112,6 +125,24 @@ export default class WorkflowStorage {
 
     }
 
+    async getNextEta(throttle: { group: string, maxPerSecond: number }) {
+
+        const db = new WorkflowContext(this.driver);
+        const last = await db.workflows.where(throttle, (p) => (x) => x.throttleGroup === p.group
+            && x.isWorkflow === true)
+            .orderByDescending(void 0, (p) => (x) => x.queued)
+            .first();
+
+        if (last) {
+            if (throttle.maxPerSecond <= 0) {
+                throttle.maxPerSecond = 1;
+            }
+            return DateTime.from(last.queued).addSeconds(1 / throttle.maxPerSecond);
+        }
+
+        return DateTime.now;
+    }
+
     async getWorkflow(id: string) {
         const db = new WorkflowContext(this.driver);
         const r = await db.workflows.where({ id }, (p) => (x) => x.id === p.id && x.isWorkflow === true).first();