@entity-access/entity-access 1.0.95 → 1.0.96

package/src/compiler/postgres/PostgreSqlMethodTransformer.ts

@@ -35,6 +35,9 @@ export const PostgreSqlHelper: ISqlHelpers = {
         },
     },
     date: {
+        now() {
+            return prepareAny `NOW()`;
+        },
         addDays(d, n) {
             return prepareAny `(${d} + (${n} * interval '1 day'))`;
         },

package/src/compiler/sql-server/SqlServerSqlMethodTransformer.ts

@@ -33,23 +33,26 @@ export const SqlServerSqlHelper: ISqlHelpers = {
         },
     },
     date: {
+        now() {
+            return prepareAny `GETUTCDATE()`;
+        },
         addDays(d, n) {
-            return prepareAny `DateAdd(DAY, ${d}, ${n})`;
+            return prepareAny `DateAdd(DAY, ${n}, ${d})`;
         },
         addHours(d, n) {
-            return prepareAny `DateAdd(HOUR, ${d}, ${n})`;
+            return prepareAny `DateAdd(HOUR, ${n}, ${d})`;
         },
         addMinutes(d, n) {
-            return prepareAny `DateAdd(MINUTE, ${d}, ${n})`;
+            return prepareAny `DateAdd(MINUTE, ${n}, ${d})`;
         },
         addMonths(d, n) {
-            return prepareAny `DateAdd(MONTH, ${d}, ${n})`;
+            return prepareAny `DateAdd(MONTH, ${n}, ${d})`;
         },
         addSeconds(d, n) {
-            return prepareAny `DateAdd(SECOND, ${d}, ${n})`;
+            return prepareAny `DateAdd(SECOND, ${n}, ${d})`;
         },
         addYears(d, n) {
-            return prepareAny `DateAdd(YEAR, ${d}, ${n})`;
+            return prepareAny `DateAdd(YEAR, ${n}, ${d})`;
         },
         dayOf(d) {
             return prepareAny `DATE_PART(day, ${d})`;

package/src/drivers/base/BaseDriver.ts

@@ -53,19 +53,33 @@ export interface IBaseTransaction {
     dispose(): Promise<any>;
 }
 
-export abstract class BaseDriver {
-    abstract get compiler(): QueryCompiler;
+export abstract class BaseConnection {
+
+    protected compiler: QueryCompiler;
+
+    protected connectionString: IDbConnectionString;
 
     private currentTransaction: IBaseTransaction;
 
-    constructor(public readonly connectionString: IDbConnectionString) {}
+
+    constructor(public driver: BaseDriver) {
+        this.compiler = driver.compiler;
+        this.connectionString = driver.connectionString;
+    }
+
+    public abstract ensureDatabase(): Promise<any>;
+
+    /**
+     * This migrations only support creation of missing items.
+     * However, you can provide events to change existing items.
+     */
+    public abstract automaticMigrations(): Migrations;
+
 
     public abstract executeReader(command: IQuery, signal?: AbortSignal): Promise<IDbReader>;
 
     public abstract executeQuery(command: IQuery, signal?: AbortSignal): Promise<IQueryResult>;
 
-    public abstract ensureDatabase(): Promise<any>;
-
     public abstract createTransaction(): Promise<IBaseTransaction>;
 
     public async runInTransaction<T = any>(fx?: () => Promise<T>) {
@@ -90,12 +104,16 @@ export abstract class BaseDriver {
             this.currentTransaction = null;
         }
     }
+}
+
+export abstract class BaseDriver {
+    abstract get compiler(): QueryCompiler;
+
+
+    constructor(public readonly connectionString: IDbConnectionString) {}
+
+    abstract newConnection(): BaseConnection;
 
-    /**
-     * This migrations only support creation of missing items.
-     * However, you can provide events to change existing items.
-     */
-    public abstract automaticMigrations(): Migrations;
 
     createInsertExpression(type: EntityType, entity: any): InsertStatement {
         const returnFields = [] as Identifier[];

package/src/drivers/postgres/PostgreSqlDriver.ts

@@ -5,7 +5,7 @@ import TimedCache from "../../common/cache/TimedCache.js";
 import QueryCompiler from "../../compiler/QueryCompiler.js";
 import Migrations from "../../migrations/Migrations.js";
 import PostgresAutomaticMigrations from "../../migrations/postgres/PostgresAutomaticMigrations.js";
-import { BaseDriver, IBaseTransaction, IDbConnectionString, IDbReader, IQuery, IRecord, toQuery } from "../base/BaseDriver.js";
+import { BaseConnection, BaseDriver, IBaseTransaction, IDbConnectionString, IDbReader, IQuery, IRecord, toQuery } from "../base/BaseDriver.js";
 import pg from "pg";
 import Cursor from "pg-cursor";
 export interface IPgSqlConnectionString extends IDbConnectionString {
@@ -66,13 +66,25 @@ export default class PostgreSqlDriver extends BaseDriver {
         return this.myCompiler;
     }
 
-    private transaction: IPooledObject<pg.Client>;
     private myCompiler = new QueryCompiler();
 
     constructor(private readonly config: IPgSqlConnectionString) {
         super(config);
     }
 
+    newConnection(): BaseConnection {
+        return new PostgreSqlConnection(this);
+    }
+}
+
+class PostgreSqlConnection extends BaseConnection {
+
+    private transaction: IPooledObject<pg.Client>;
+
+    private get config() {
+        return this.connectionString;
+    }
+
     public async createTransaction(): Promise<IBaseTransaction> {
         const tx = await this.getConnection();
         await tx.query("BEGIN");
@@ -102,6 +114,7 @@ export default class PostgreSqlDriver extends BaseDriver {
             const q = toQuery(command);
             text = q.text;
             const result = await connection.query(q.text, q.values);
+            (result as any).updated = result.rowCount;
             return result;
         } catch (error) {
             throw new Error(`Failed executing ${text}\n${error}`);

package/src/drivers/sql-server/SqlServerDriver.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-console */
 import QueryCompiler from "../../compiler/QueryCompiler.js";
 import Migrations from "../../migrations/Migrations.js";
-import { BaseDriver, IBaseTransaction, IDbConnectionString, IDbReader, IQuery, IRecord, disposableSymbol, toQuery } from "../base/BaseDriver.js";
+import { BaseConnection, BaseDriver, IBaseTransaction, IDbConnectionString, IDbReader, IQuery, IRecord, disposableSymbol, toQuery } from "../base/BaseDriver.js";
 import sql from "mssql";
 import SqlServerQueryCompiler from "./SqlServerQueryCompiler.js";
 import SqlServerAutomaticMigrations from "../../migrations/sql-server/SqlServerAutomaticMigrations.js";
@@ -19,13 +19,29 @@ export default class SqlServerDriver extends BaseDriver {
     }
 
     private sqlQueryCompiler = new SqlServerQueryCompiler();
-    private transaction: sql.Transaction;
 
     constructor(private readonly config: ISqlServerConnectionString) {
         super(config);
         config.server = config.host;
     }
 
+    newConnection(): BaseConnection {
+        return new SqlServerConnection(this, this.config);
+    }
+}
+
+export class SqlServerConnection extends BaseConnection {
+
+    private transaction: sql.Transaction;
+
+    private get sqlQueryCompiler() {
+        return this.compiler as SqlServerQueryCompiler;
+    }
+
+    constructor(driver, private config: ISqlServerConnectionString) {
+        super(driver);
+    }
+
     public async executeReader(command: IQuery, signal?: AbortSignal): Promise<IDbReader> {
         command = toQuery(command);
         let rq = await this.newRequest();
@@ -64,15 +80,10 @@ export default class SqlServerDriver extends BaseDriver {
 
     public ensureDatabase() {
         const create = async () => {
-            const defaultDb = "master";
-
+            const config = { ... this.config, database: "master" };
             const db = this.config.database;
-            this.config.database = defaultDb;
 
-            const connection = await this.newRequest();
-            // @ts-expect-error readonly
-            this.config = { ... this.config };
-            this.config.database = db;
+            const connection = await this.newConnection(config);
 
             const createSql = `IF NOT EXISTS (SELECT name FROM master.dbo.sysdatabases WHERE name = ${SqlServerLiteral.escapeLiteral(db)}) BEGIN
                 CREATE DATABASE ${db};
@@ -137,8 +148,7 @@ export default class SqlServerDriver extends BaseDriver {
         return (await this.newConnection()).request();
     }
 
-    private newConnection() {
-        const config = this.config;
+    private newConnection(config = this.config) {
         const key = config.server + "//" + config.database + "/" + config.user;
         return namedPool.getOrCreateAsync(config.server + "://" + config.database,
             () => {

package/src/eternity/ActivitySuspendedError.ts

@@ -1,3 +1,10 @@
+import TimeSpan from "../types/TimeSpan.js";
 
 
-export class ActivitySuspendedError extends Error { }
+export class ActivitySuspendedError extends Error {
+
+    constructor(public ttl: TimeSpan = TimeSpan.fromDays(1)) {
+        super("Activity Suspended");
+    }
+
+}

package/src/eternity/EternityContext.ts

@@ -40,6 +40,8 @@ function bindStep(context: EternityContext, store: WorkflowStorage, name: string
 
         store.lastID = id;
 
+        let ttl = TimeSpan.fromSeconds(0);
+
         const step: Partial<WorkflowStorage> = {
             id,
             parentID: this.id,
@@ -63,10 +65,13 @@ function bindStep(context: EternityContext, store: WorkflowStorage, name: string
             const eta = this.currentTime.add(maxTS);
             step.eta = eta;
 
+            ttl = maxTS;
+
             if (eta <= start) {
                 // time is up...
                 lastResult = "";
                 step.state = "done";
+                ttl = TimeSpan.fromSeconds(0);
             }
 
         } else {
@@ -74,9 +79,11 @@ function bindStep(context: EternityContext, store: WorkflowStorage, name: string
             try {
 
                 const types = old[injectServiceKeysSymbol] as any[];
-                for (let index = a.length; index < types.length; index++) {
-                    const element = ServiceProvider.resolve(this, types[index]);
-                    a.push(element);
+                if (types) {
+                    for (let index = a.length; index < types.length; index++) {
+                        const element = ServiceProvider.resolve(this, types[index]);
+                        a.push(element);
+                    }
                 }
                 lastResult = (await old.apply(this, a)) ?? 0;
                 step.output = JSON.stringify(lastResult);
@@ -101,7 +108,7 @@ function bindStep(context: EternityContext, store: WorkflowStorage, name: string
             throw lastError;
         }
         if (step.state !== "done") {
-            throw new ActivitySuspendedError();
+            throw new ActivitySuspendedError(ttl);
         }
         return lastResult;
     };
@@ -163,7 +170,12 @@ export default class EternityContext {
     public async queue<T>(
         type: IClassOf<Workflow<T>>,
         input: Partial<T>,
-        { id, throwIfExists, eta }: { id?: string, throwIfExists?: boolean, eta?: DateTime } = {}) {
+        { id, throwIfExists, eta, parentID }: {
+            id?: string,
+            throwIfExists?: boolean,
+            eta?: DateTime,
+            parentID?: string
+        } = {}) {
         const clock = this.storage.clock;
         if (id) {
             const r = await this.storage.get(id);
@@ -193,6 +205,7 @@ export default class EternityContext {
             isWorkflow: true,
             queued: now,
             updated: now,
+            parentID,
             eta
         });
 
@@ -216,6 +229,32 @@ export default class EternityContext {
 
         return pending.length;
     }
+
+    async runChild(w: Workflow, type, input) {
+
+        // there might still be some workflows pending
+        // this will ensure even empty workflow !!
+        const schema = WorkflowRegistry.register(type, void 0);
+
+        const id = w.id + `-child(${schema.name},${JSON.stringify(input)})`;
+
+
+        const result = await this.storage.get(id);
+        if (result) {
+            const { state } = result;
+            if (state === "done") {
+                return JSON.parse(result.output);
+            }
+            if (state === "failed") {
+                throw new Error(result.error);
+            }
+            throw new ActivitySuspendedError();
+        }
+
+        await this.queue(type, input, { id, parentID: w.id });
+        throw new ActivitySuspendedError();
+    }
+
     private async run(workflow: WorkflowStorage) {
 
         const clock = this.storage.clock;
@@ -235,7 +274,7 @@ export default class EternityContext {
             const schema = WorkflowRegistry.getByName(workflow.name);
             const { eta, id, updated } = workflow;
             const input = JSON.parse(workflow.input);
-            const instance = new (schema.type)({ input, eta, id, currentTime: DateTime.from(updated) });
+            const instance = new (schema.type)({ input, eta, id, currentTime: DateTime.from(updated) }, this);
             for (const iterator of schema.activities) {
                 instance[iterator] = bindStep(this, workflow, iterator, instance[iterator]);
             }
@@ -251,6 +290,9 @@ export default class EternityContext {
             } catch (error) {
                 if (error instanceof ActivitySuspendedError) {
                     // this will update last id...
+                    workflow.eta = clock.utcNow.add(error.ttl);
+                    workflow.lockedTTL = null;
+                    workflow.lockToken = null;
                     await this.storage.save(workflow);
                     return;
                 }
@@ -260,8 +302,29 @@ export default class EternityContext {
                 workflow.eta = clock.utcNow.add(instance.failedPreserveTime);
             }
 
+            // in case of child workflow...
+            // eta will be set to one year...
+            if (workflow.parentID) {
+                workflow.eta = clock.utcNow.addYears(1);
+                // since we have finished.. we should
+                // make parent's eta approach now sooner..
+            }
+
+            workflow.lockedTTL = null;
+            workflow.lockToken = null;
             await this.storage.save(workflow);
 
+            if (workflow.parentID) {
+                const parent = await this.storage.get(workflow.parentID);
+                if (parent) {
+                    parent.lockTTL = null;
+                    parent.lockToken = null;
+                    parent.eta = clock.utcNow;
+                    await this.storage.save(parent);
+                }
+            }
+            // workflow finished successfully...
+
         } finally {
             scope.dispose();
         }

package/src/eternity/EternityStorage.ts

@@ -1,11 +1,14 @@
+import { randomUUID } from "crypto";
 import Column from "../decorators/Column.js";
 import Index from "../decorators/Index.js";
 import Table from "../decorators/Table.js";
 import Inject, { RegisterScoped, RegisterSingleton, ServiceProvider } from "../di/di.js";
 import { BaseDriver } from "../drivers/base/BaseDriver.js";
 import EntityContext from "../model/EntityContext.js";
+import { BinaryExpression, CallExpression, Expression, NullExpression, NumberLiteral, UpdateStatement } from "../query/ast/Expressions.js";
 import DateTime from "../types/DateTime.js";
 import WorkflowClock from "./WorkflowClock.js";
+import RawQuery from "../compiler/RawQuery.js";
 
 @Table("Workflows")
 @Index({
@@ -53,6 +56,9 @@ export class WorkflowStorage {
     @Column({ nullable: true })
     public lockedTTL: DateTime;
 
+    @Column({ nullable: true })
+    public lockToken: string;
+
     @Column({ dataType: "AsciiChar", length: 10})
     public state: "queued" | "failed" | "done";
 
@@ -83,6 +89,8 @@ class WorkflowContext extends EntityContext {
 @RegisterSingleton
 export default class EternityStorage {
 
+    private lockQuery: RawQuery;
+
     constructor(
         @Inject
         private driver: BaseDriver,
@@ -97,6 +105,10 @@ export default class EternityStorage {
         const r = await db.workflows.where({ id }, (p) => (x) => x.id === p.id && x.isWorkflow === true).first();
         if (r !== null) {
             return {
+                id,
+                parentID: r.parentID,
+                lockTTL: r.lockedTTL,
+                lockToken: r.lockToken,
                 updated: r.updated,
                 eta: r.eta,
                 queued: r.queued,
@@ -131,7 +143,8 @@ export default class EternityStorage {
 
     async save(state: Partial<WorkflowStorage>) {
         const db = new WorkflowContext(this.driver);
-        await this.driver.runInTransaction(async () => {
+        const connection = db.connection;
+        await connection.runInTransaction(async () => {
             let w = await db.workflows.where(state, (p) => (x) => x.id === p.id).first();
             if (!w) {
                 w = db.workflows.add(state);
@@ -145,6 +158,7 @@ export default class EternityStorage {
             }
 
             w.state ||= "queued";
+            w.updated = DateTime.utcNow;
             await db.saveChanges();
         });
     }
@@ -152,29 +166,75 @@ export default class EternityStorage {
     async dequeue(signal?: AbortSignal) {
         const db = new WorkflowContext(this.driver);
         const now = this.clock.utcNow;
-        const lockedTTL = now.addMinutes(1);
-        return db.driver.runInTransaction(async () => {
-            const list = await db.workflows
-                .where({now}, (p) => (x) => x.eta <= p.now
-                    && (x.lockedTTL === null || x.lockedTTL <= p.now)
-                    && x.isWorkflow === true)
-                .orderBy({}, (p) => (x) => x.eta)
-                .thenBy({}, (p) => (x) => x.priority)
-                .limit(20)
-                .withSignal(signal)
-                .toArray();
-            for (const iterator of list) {
-                iterator.lockedTTL = lockedTTL;
+
+        if(!this.lockQuery) {
+
+            const type = db.model.getEntityType(WorkflowStorage);
+
+            const px = Expression.parameter("x");
+            const lockTokenField = type.getProperty("lockToken").field.columnName;
+            const lockTTLField = type.getProperty("lockedTTL").field.columnName;
+
+            const exp = UpdateStatement.create({
+                table: type.fullyQualifiedName,
+                set: [
+                    Expression.assign(
+                        Expression.identifier(lockTokenField),
+                        Expression.member(px, "lockToken")
+                    ),
+                    Expression.assign(
+                        Expression.identifier(lockTTLField),
+                        CallExpression.create({
+                            callee: Expression.member(Expression.member(Expression.identifier("Sql"), "date"), "addMinutes"),
+                            arguments: [CallExpression.create({
+                                callee: Expression.member(Expression.member(Expression.identifier("Sql"), "date"), "now")
+                            }),
+                            NumberLiteral.create({ value: 5 })
+                        ]
+                        })
+                    )
+                ],
+                where: Expression.logicalAnd(Expression.equal(
+                    Expression.identifier("id"),
+                    Expression.member(px, "id")
+                ), Expression.equal(
+                    Expression.identifier(lockTokenField),
+                    NullExpression.create({})
+                ))
+            });
+
+            this.lockQuery = this.driver.compiler.compileToRawQuery(null, exp, px);
+        }
+
+        const q = this.lockQuery;
+
+        const items = await db.workflows
+            .where({now}, (p) => (x) => x.eta <= p.now
+                && (x.lockedTTL === null || x.lockedTTL <= p.now)
+                && x.lockToken === null
+                && x.isWorkflow === true)
+            .orderBy({}, (p) => (x) => x.eta)
+            .thenBy({}, (p) => (x) => x.priority)
+            .limit(20)
+            .withSignal(signal)
+            .toArray();
+        const list: WorkflowStorage[] = [];
+        const uuid = randomUUID();
+        for (const iterator of items) {
+            // try to acquire lock...
+            iterator.lockToken = uuid;
+            const r = await q.invoke(db.connection, iterator);
+            if (r.updated > 0) {
+                list.push(iterator);
             }
-            await db.saveChanges(signal);
-            return list;
-        });
+        }
+        return list;
     }
 
     async seed() {
         const db = new WorkflowContext(this.driver);
-        await db.driver.ensureDatabase();
-        await db.driver.automaticMigrations().migrate(db);
+        await db.connection.ensureDatabase();
+        await db.connection.automaticMigrations().migrate(db);
     }
 
 }

package/src/eternity/Workflow.ts

@@ -1,6 +1,8 @@
+import { IClassOf } from "../decorators/IClassOf.js";
 import Inject from "../di/di.js";
 import DateTime from "../types/DateTime.js";
 import TimeSpan from "../types/TimeSpan.js";
+import { ActivitySuspendedError } from "./ActivitySuspendedError.js";
 import EternityContext from "./EternityContext.js";
 import { WorkflowRegistry } from "./WorkflowRegistry.js";
 
@@ -34,25 +36,63 @@ export default abstract class Workflow<TIn = any, TOut = any> {
 
     public failedPreserveTime: TimeSpan = TimeSpan.fromDays(1);
 
-    @Inject
-    protected context: EternityContext;
-
-    constructor(p: Partial<Workflow>) {
-        Object.setPrototypeOf(p, new.target.prototype);
-        const w = p as Workflow;
-        w.preserveTime = TimeSpan.fromMinutes(5);
-        w.failedPreserveTime = TimeSpan.fromDays(1);
-        return w;
+    constructor(
+        {
+            sequence,
+            input,
+            id,
+            eta,
+            currentTime
+        }: {
+            sequence: string,
+            input: TIn,
+            id: string,
+            eta: DateTime,
+            currentTime: DateTime
+        },
+        protected context: EternityContext
+    ) {
+        this.input = input;
+        this.id = id;
+        this.eta = eta;
+        this.currentTime = currentTime;
+        this.sequence = sequence;
     }
 
     public abstract run(): Promise<TOut>;
 
-    public delay(ts: TimeSpan) {
+    protected delay(ts: TimeSpan) {
         return Promise.resolve("");
     }
 
-    public waitForExternalEvent(ts: TimeSpan, ... names: string[]) {
+    protected waitForExternalEvent(ts: TimeSpan, ... names: string[]) {
         // do nothing...
         return Promise.resolve("");
     }
+
+    protected async runChild<TChildIn, TChildOut>(type: IClassOf<Workflow<TChildIn, TChildOut>>, input: TChildIn): Promise<TChildOut> {
+        return this.context.runChild(this, type, input);
+    }
+
+    protected async all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>{
+        let suspended: ActivitySuspendedError;
+        try {
+            const r = await Promise.all(values.map(async (x) => {
+                try {
+                    return await x;
+                } catch (error) {
+                    if (error instanceof ActivitySuspendedError) {
+                        suspended = error;
+                    }
+                    throw error;
+                }
+            }));
+            return r as any;
+        } catch (error) {
+            if (suspended) {
+                throw suspended;
+            }
+            throw error;
+        }
+    }
 }

package/src/migrations/postgres/PostgresAutomaticMigrations.ts

@@ -1,6 +1,6 @@
 import { IColumn } from "../../decorators/IColumn.js";
 import { IIndex } from "../../decorators/IIndex.js";
-import { BaseDriver } from "../../drivers/base/BaseDriver.js";
+import { BaseConnection, BaseDriver } from "../../drivers/base/BaseDriver.js";
 import EntityType from "../../entity-query/EntityType.js";
 import EntityContext from "../../model/EntityContext.js";
 import Migrations from "../Migrations.js";
@@ -15,7 +15,7 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
         const nonKeyColumns = type.nonKeys;
         const keys = type.keys;
 
-        const driver = context.driver;
+        const driver = context.connection;
 
         await this.createTable(driver, type, keys);
 
@@ -42,7 +42,7 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
         }
     }
 
-    async createColumns(driver: BaseDriver, type: EntityType, nonKeyColumns: IColumn[]) {
+    async createColumns(driver: BaseConnection, type: EntityType, nonKeyColumns: IColumn[]) {
 
         const name = type.schema
         ? type.schema + "." + type.name
@@ -67,7 +67,7 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
 
     }
 
-    async createTable(driver: BaseDriver, type: EntityType, keys: IColumn[]) {
+    async createTable(driver: BaseConnection, type: EntityType, keys: IColumn[]) {
 
         const name = type.schema
             ? type.schema + "." + type.name
@@ -98,7 +98,7 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
     }
 
     async migrateIndex(context: EntityContext, index: IIndex, type: EntityType) {
-        const driver = context.driver;
+        const driver = context.connection;
         const name = type.schema
         ? type.schema + "." + type.name
         : type.name;