@entity-access/entity-access 1.0.45 → 1.0.47

package/src/di/di.ts

@@ -14,39 +14,43 @@ const registrationsSymbol = Symbol("registrations");
 
 const serviceProvider = Symbol("serviceProvider");
 
-const parentServiceProvider = Symbol("parentServiceProvider");
+const globalServiceProvider = Symbol("globalInstance");
 
 export class ServiceProvider implements IDisposable {
 
-    public static get global() {
-        return this.globalInstance ??= new ServiceProvider();
+    public static from(owner: any) {
+        return (owner[serviceProvider]) as ServiceProvider;
     }
 
-
     public static resolve<T>(serviceOwner: any, type: IClassOf<T>): T {
-        const sp = (serviceOwner[serviceProvider] ?? this.global) as ServiceProvider;
+        const sp = serviceOwner[serviceProvider] as ServiceProvider;
         return sp.resolve(type);
     }
 
     static create<T>(serviceOwner, type: IClassOf<T>): T {
-        const sp = (serviceOwner[serviceProvider] ?? this.global) as ServiceProvider;
+        const sp = serviceOwner[serviceProvider] as ServiceProvider;
         return sp.createFromType(type);
     }
 
-    private static globalInstance: ServiceProvider;
+    static createScope<T>(serviceOwner): ServiceProvider {
+        const sp = serviceOwner[globalServiceProvider] as ServiceProvider;
+        return sp.createScope();
+    }
 
     private map: Map<any,any> = new Map();
     private disposables: IDisposable[];
 
     constructor(parent?: ServiceProvider) {
         this[serviceProvider] = this;
-        this[parentServiceProvider] = parent;
+        this[globalServiceProvider] = parent?.[globalServiceProvider] ?? this;
+        this.map.set(ServiceProvider, this);
     }
 
     add<T1, T extends T1>(type: IAbstractClassOf<T1> | IClassOf<T1>, instance: T) {
         this.getRegistration(type, true);
         this.map.set(type, instance);
         instance[serviceProvider] = this;
+        instance[globalServiceProvider] = this[globalServiceProvider];
         this.resolveProperties(instance);
         return instance;
     }
@@ -66,7 +70,7 @@ export class ServiceProvider implements IDisposable {
         const sd = this.getRegistration(type);
         switch(sd.kind) {
             case "Scoped":
-                if (!this[parentServiceProvider]) {
+                if (this[globalServiceProvider] === this) {
                     throw new Error(`Unable to create scoped service ${type?.name ?? type} in global scope.`);
                 }
                 instance = this.map.get(type);
@@ -74,20 +78,19 @@ export class ServiceProvider implements IDisposable {
                     instance = this.createFromDescriptor(sd);
                     this.map.set(type, instance);
                     instance[serviceProvider] = this;
+                    instance[globalServiceProvider] = this[globalServiceProvider];
                     if (instance[Symbol.disposable] || instance[Symbol.asyncDisposable]) {
                         (this.disposables ??= []).push(instance);
                     }
                 }
                 return  instance;
             case "Singleton":
-                let sp = this;
-                while (sp[parentServiceProvider]) {
-                    sp = sp[parentServiceProvider];
-                }
+                const sp = this[globalServiceProvider];
                 instance = sp.map.get(type);
                 if (!instance) {
                     instance = sp.createFromDescriptor(sd);
-                    instance[serviceProvider] = sp;
+                    instance[serviceProvider] = this;
+                    instance[globalServiceProvider] = sp;
                     sp.map.set(type, instance);
                     if (instance[Symbol.disposable] || instance[Symbol.asyncDisposable]) {
                         (sp.disposables ??= []).push(instance);
@@ -96,7 +99,8 @@ export class ServiceProvider implements IDisposable {
                 return  instance;
             case "Transient":
                 instance = sp.createFromDescriptor(sd);
-                instance[serviceProvider] = sp;
+                instance[serviceProvider] = this;
+                instance[globalServiceProvider] = sp;
                 return instance;
         }
     }
@@ -120,7 +124,7 @@ export class ServiceProvider implements IDisposable {
         if (!sd) {
 
             if (add) {
-                const registration: IServiceDescriptor = { key: type, kind: this[parentServiceProvider] ? "Scoped" : "Singleton" };
+                const registration: IServiceDescriptor = { key: type, kind: this[globalServiceProvider] !== this ? "Scoped" : "Singleton" };
                 registrations.set(type, registration);
                 return registration;
             }
@@ -155,7 +159,7 @@ export class ServiceProvider implements IDisposable {
             for (const key in keys) {
                 if (Object.prototype.hasOwnProperty.call(keys, key)) {
                     const element = keys[key];
-                    instance[key] = this.resolve(element);
+                    instance[key] ??= this.resolve(element);
                 }
             }
         }
@@ -168,6 +172,7 @@ export class ServiceProvider implements IDisposable {
             : [];
         const instance = new type(... injectServices);
         instance[serviceProvider] = this;
+        instance[globalServiceProvider] = this[globalServiceProvider];
         // initialize properties...
         this.resolveProperties(instance, type);
         return instance;
@@ -194,9 +199,21 @@ export const ServiceCollection = {
 export default function Inject(target, key, index?: number) {
 
     if (index !== void 0) {
-        const plist = (Reflect as any).getMetadata("design:paramtypes", target, key);
-        const serviceTypes = target[injectServiceTypesSymbol] ??= [];
-        serviceTypes[index] = plist[index];
+
+        if (key) {
+
+            // this is parameter inside a method...
+            const plist = (Reflect as any).getMetadata("design:paramtypes", target, key);
+            const pTypes = (target[injectServiceKeysSymbol] ??= {})[key] = [];
+            pTypes[index] = plist[index];
+
+        } else {
+
+            const plist = (Reflect as any).getMetadata("design:paramtypes", target, key);
+            const serviceTypes = target[injectServiceTypesSymbol] ??= [];
+            serviceTypes[index] = plist[index];
+        }
+
         return;
     }
 

package/src/drivers/base/BaseDriver.ts

@@ -1,8 +1,9 @@
+import EntityAccessError from "../../common/EntityAccessError.js";
 import QueryCompiler from "../../compiler/QueryCompiler.js";
 import EntityType from "../../entity-query/EntityType.js";
 import Migrations from "../../migrations/Migrations.js";
 import ChangeEntry from "../../model/changes/ChangeEntry.js";
-import { BinaryExpression, Constant, DeleteStatement, Expression, InsertStatement, QuotedLiteral, ReturnUpdated, TableLiteral, UpdateStatement, ValuesStatement } from "../../query/ast/Expressions.js";
+import { BinaryExpression, Constant, DeleteStatement, ExistsExpression, Expression, InsertStatement, NotExits, QuotedLiteral, ReturnUpdated, SelectStatement, TableLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "../../query/ast/Expressions.js";
 
 export const disposableSymbol: unique symbol = (Symbol as any).dispose ??= Symbol("disposable");
 

package/src/drivers/postgres/PostgreSqlDriver.ts

@@ -1,16 +1,13 @@
 /* eslint-disable no-console */
+import EntityAccessError from "../../common/EntityAccessError.js";
+import ObjectPool, { IPooledObject } from "../../common/ObjectPool.js";
+import TimedCache from "../../common/cache/TimedCache.js";
 import QueryCompiler from "../../compiler/QueryCompiler.js";
-import { IColumn } from "../../decorators/IColumn.js";
-import EntityType from "../../entity-query/EntityType.js";
 import Migrations from "../../migrations/Migrations.js";
 import PostgresAutomaticMigrations from "../../migrations/postgres/PostgresAutomaticMigrations.js";
-import { Query } from "../../query/Query.js";
 import { BaseDriver, IDbConnectionString, IDbReader, IQuery, IRecord, toQuery } from "../base/BaseDriver.js";
-import pkg from "pg";
+import pg from "pg";
 import Cursor from "pg-cursor";
-
-const { Client } = pkg;
-
 export interface IPgSqlConnectionString extends IDbConnectionString {
 
     user?: string, // default process.env.PGUSER || process.env.USER
@@ -30,7 +27,7 @@ export interface IPgSqlConnectionString extends IDbConnectionString {
 
 class DbReader implements IDbReader {
 
-    constructor(private cursor, private client) {
+    constructor(private cursor: Cursor, private client: IPooledObject<pg.Client>) {
 
     }
 
@@ -47,27 +44,29 @@ class DbReader implements IDbReader {
     async dispose() {
         try {
             await this.cursor.close();
-        } catch {
-            // intentionally left blank
+        } catch (error) {
+            console.error(error);
         }
 
         try {
             if (this.client) {
-                await this.client.end();
+                await this.client[Symbol.asyncDisposable]();
             }
-        } catch {
-            // intentionally left blank
+        } catch (error) {
+            console.error(error);
         }
     }
 }
 
+const poolCache = new TimedCache<string, ObjectPool<pg.Client>>();
+
 export default class PostgreSqlDriver extends BaseDriver {
 
     public get compiler() {
         return this.myCompiler;
     }
 
-    private transaction: pkg.Client;
+    private transaction: IPooledObject<pg.Client>;
     private myCompiler = new QueryCompiler();
 
     constructor(private readonly config: IPgSqlConnectionString) {
@@ -75,6 +74,9 @@ export default class PostgreSqlDriver extends BaseDriver {
     }
 
     public async runInTransaction<T>(fx?: () => Promise<T>): Promise<T> {
+        if (this.transaction) {
+            throw new EntityAccessError(`Nested Transactions not supported`);
+        }
         const connection = await this.getConnection();
         let result: T;
         try {
@@ -88,7 +90,7 @@ export default class PostgreSqlDriver extends BaseDriver {
             throw error;
         } finally {
             this.transaction = void 0;
-            await connection.end();
+            await connection[Symbol.asyncDisposable]();
         }
     }
 
@@ -112,28 +114,35 @@ export default class PostgreSqlDriver extends BaseDriver {
             return result;
         } finally {
             if (!this.transaction) {
-                await connection.end();
+                await connection[Symbol.asyncDisposable]();
             }
         }
     }
 
     public ensureDatabase() {
         const create = async () => {
-            const defaultDb = "postgres";
-            const db = this.config.database;
-            this.config.database = defaultDb;
-            const connection = await this.getConnection();
-            // @ts-expect-error readonly
-            this.config = { ... this.config };
-            this.config.database = db;
             try {
-                const r = await connection.query("SELECT FROM pg_database WHERE datname = $1", [ db ]);
-                if(r.rowCount === 1) {
-                    return;
+                // const defaultDb = "postgres";
+                const db = this.config.database;
+                // this.config.database = defaultDb;
+                // // const connection = await this.getConnection();
+                // // @ts-expect-error readonly
+                // this.config = { ... this.config };
+                // this.config.database = db;
+                const connection = new pg.Client({ ... this.config, database: "postgres" });
+                await connection.connect();
+                try {
+                    const r = await connection.query("SELECT FROM pg_database WHERE datname = $1", [ db ]);
+                    if(r.rowCount === 1) {
+                        return;
+                    }
+                    await connection.query("CREATE DATABASE " + JSON.stringify(db));
+                } finally {
+                    await connection.end();
                 }
-                await connection.query("CREATE DATABASE " + JSON.stringify(db));
-            } finally {
-                await connection.end();
+            } catch (error) {
+                console.error(error);
+                throw error;
             }
         };
         const value = create();
@@ -153,8 +162,26 @@ export default class PostgreSqlDriver extends BaseDriver {
         if (this.transaction) {
             return this.transaction;
         }
-        const client = new Client(this.config);
-        await client.connect();
+
+        const key = `${this.config.host}:${this.config.port}//${this.config.database}?${this.config.user}&${this.config.password}`;
+
+        const pooledClient = poolCache.getOrCreate(key, 1, () => new ObjectPool({
+            asyncFactory: async () => {
+                const c = new pg.Client(this.config);
+                await c.connect();
+                return c;
+            },
+            destroy(item) {
+                return item.end();
+            },
+            subscribeForRemoval(po, clear) {
+                po.on("end", clear);
+            },
+        }));
+        const client = await pooledClient.acquire();
+
+        // const client = new Client(this.config);
+        // await client.connect();
         const row = await client.query("SELECT pg_backend_pid() as id");
         const clientId = (row.rows as any).id;
         // there is no support to kill the query running inside
@@ -165,7 +192,7 @@ export default class PostgreSqlDriver extends BaseDriver {
     }
 
     private async kill(id) {
-        const client = new Client(this.config);
+        const client = new pg.Client(this.config);
         try {
             await client.connect();
             await client.query("SELECT pg_cancel_backend($1)", [id]);

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

@@ -1,5 +1,5 @@
 import ExpressionToSql from "../../query/ast/ExpressionToSql.js";
-import { Identifier, InsertStatement, OrderByExpression, ReturnUpdated, SelectStatement, ValuesStatement } from "../../query/ast/Expressions.js";
+import { BooleanLiteral, Identifier, InsertStatement, OrderByExpression, ReturnUpdated, SelectStatement, ValuesStatement } from "../../query/ast/Expressions.js";
 import { ITextQuery, prepare } from "../../query/ast/IStringTransformer.js";
 
 export default class ExpressionToSqlServer extends ExpressionToSql {
@@ -100,4 +100,8 @@ export default class ExpressionToSqlServer extends ExpressionToSql {
         return prepare `(VALUES ${rows}) ${fields}`;
 
     }
+
+    visitBooleanLiteral({ value }: BooleanLiteral): ITextQuery {
+        return value ? [ " 1 "] : [ " 0 "];
+    }
 }

package/src/eternity/ActivitySuspendedError.ts

@@ -0,0 +1,3 @@
+
+
+export class ActivitySuspendedError extends Error { }

package/src/eternity/EternityContext.ts

@@ -0,0 +1,254 @@
+/* eslint-disable no-console */
+import { randomUUID } from "crypto";
+import EntityAccessError from "../common/EntityAccessError.js";
+import { IClassOf } from "../decorators/IClassOf.js";
+import Inject, { RegisterSingleton, ServiceProvider, injectServiceKeysSymbol } from "../di/di.js";
+import DateTime from "../types/DateTime.js";
+import EternityStorage, { WorkflowStorage } from "./EternityStorage.js";
+import type Workflow from "./Workflow.js";
+import { ActivitySuspendedError } from "./ActivitySuspendedError.js";
+import { IWorkflowSchema, WorkflowRegistry } from "./WorkflowRegistry.js";
+import crypto from "crypto";
+import TimeSpan from "../types/TimeSpan.js";
+import WorkflowClock from "./WorkflowClock.js";
+
+async function  hash(text) {
+    const sha256 = crypto.createHash("sha256");
+    return sha256.update(text).digest("hex");
+}
+
+function bindStep(context: EternityContext, store: WorkflowStorage, name: string, old: (... a: any[]) => any, unique = false) {
+    return async function runStep(this: Workflow, ... a: any[]) {
+        const input = JSON.stringify(a);
+        const ts = unique ? "0" : Math.floor(this.currentTime.msSinceEpoch);
+        const params = input.length < 150 ? input : await hash(input);
+        const id = `${this.id}(${params},${ts})`;
+
+        const clock = context.storage.clock;
+
+        const existing = await context.storage.get(id);
+        if (existing) {
+            if (existing.state === "failed" && existing.error) {
+                throw new Error(existing.error);
+            }
+            if (existing.state === "done") {
+                (this as any).currentTime = existing.updated;
+                return JSON.parse(existing.output);
+            }
+        }
+
+        store.lastID = id;
+
+        const step: Partial<WorkflowStorage> = {
+            id,
+            parentID: this.id,
+            eta: this.eta,
+            queued: this.eta,
+            updated: this.eta,
+            isWorkflow: false,
+            name,
+            input
+        };
+
+        // execute...
+        const start = clock.utcNow;
+        let lastError: Error;
+        let lastResult: any;
+
+        if (name === "delay" || name === "waitForExternalEvent") {
+
+            // first parameter is the ts
+            const maxTS = a[0] as TimeSpan;
+            const eta = this.currentTime.add(maxTS);
+            step.eta = eta;
+
+            if (eta <= start) {
+                // time is up...
+                lastResult = "";
+                step.state = "done";
+            }
+
+        } else {
+
+            try {
+
+                const types = Object.getPrototypeOf(this)?.[injectServiceKeysSymbol]?.[name] as any[];
+                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);
+                step.state = "done";
+                step.eta = clock.utcNow;
+                (this as any).currentTime = step.eta;
+            } catch (error) {
+                if (error instanceof ActivitySuspendedError) {
+                    return;
+                }
+                lastError = error;
+                step.error = error.stack ?? error.toString();
+                step.state = "failed";
+                step.eta = clock.utcNow;
+                (this as any).currentTime = step.eta;
+            }
+            step.queued = start;
+            step.updated = step.updated;
+        }
+        await this.context.storage.save(step);
+        if (lastError) {
+            throw lastError;
+        }
+        if (step.state !== "done") {
+            throw new ActivitySuspendedError();
+        }
+        return lastResult;
+    };
+}
+
+export interface IWorkflowResult<T> {
+    output: T;
+    state: "done" | "failed" | "queued";
+    error: string;
+}
+
+@RegisterSingleton
+export default class EternityContext {
+
+    private waiter: AbortController;
+
+    private registry: Map<string, IWorkflowSchema> = new Map();
+
+    constructor(
+        @Inject
+        public storage: EternityStorage
+    ) {
+
+    }
+
+    public register(type: IClassOf<Workflow>) {
+        this.registry.set(type.name, WorkflowRegistry.register(type, void 0));
+    }
+
+    public async start(signal?: AbortSignal) {
+        while(!signal?.aborted) {
+            await this.processQueueOnce(signal);
+        }
+    }
+
+    public async get<T = any>(c: IClassOf<Workflow<any, T>> | string, id?: string): Promise<IWorkflowResult<T>> {
+        id ??= (c as string);
+        const s = await this.storage.get(id);
+        if (s) {
+            return {
+                state: s.state,
+                output: s.output ? JSON.parse(s.output): null,
+                error: s.error
+            };
+        }
+        return null;
+    }
+
+    public async queue<T>(
+        type: IClassOf<Workflow<T>>,
+        input: Partial<T>,
+        { id, throwIfExists, eta }: { id?: string, throwIfExists?: boolean, eta?: DateTime } = {}) {
+        const clock = this.storage.clock;
+        if (id) {
+            const r = await this.storage.get(id);
+            if (r) {
+                if (throwIfExists) {
+                    throw new EntityAccessError(`Workflow with ID ${id} already exists`);
+                }
+                return id;
+            }
+        } else {
+            id = randomUUID();
+            while(await this.storage.get(id) !== null) {
+                console.log(`Generating UUID again ${id}`);
+                id = randomUUID();
+            }
+        }
+
+        // this will ensure even empty workflow !!
+        const schema = WorkflowRegistry.register(type, void 0);
+
+        const now = clock.utcNow;
+        eta ??= now;
+        await this.storage.save({
+            id,
+            name: schema.name,
+            input: JSON.stringify(input),
+            isWorkflow: true,
+            queued: now,
+            updated: now,
+            eta
+        });
+
+        if(eta < clock.utcNow) {
+            this.waiter.abort();
+        }
+
+        return id;
+    }
+
+    public async processQueueOnce(signal?: AbortSignal) {
+        const pending = await this.storage.dequeue(signal);
+        // run...
+        for (const iterator of pending) {
+            try {
+                await this.run(iterator);
+            } catch (error) {
+                console.error(error);
+            }
+        }
+    }
+    private async run(workflow: WorkflowStorage) {
+
+        const clock = this.storage.clock;
+
+        if (workflow.state === "failed" || workflow.state === "done") {
+            if (workflow.eta <= clock.utcNow) {
+                // time to delete...
+                await this.storage.delete(workflow.id);
+            }
+            return;
+        }
+
+        const scope = ServiceProvider.from(this).createScope();
+
+        try {
+
+            const schema = WorkflowRegistry.getByName(workflow.name);
+            const { input, eta, id, updated } = workflow;
+            const instance = new (schema.type)({ input, eta, id, currentTime: DateTime.from(updated) });
+            for (const iterator of schema.activities) {
+                instance[iterator] = bindStep(this, workflow, iterator, instance[iterator]);
+            }
+            for (const iterator of schema.uniqueActivities) {
+                instance[iterator] = bindStep(this, workflow, iterator, instance[iterator], true);
+            }
+            scope.add( schema.type, instance);
+            try {
+                const result = await instance.run();
+                workflow.output = JSON.stringify(result ?? 0);
+                workflow.state = "done";
+                workflow.eta = clock.utcNow.add(instance.preserveTime);
+            } catch (error) {
+                if (error instanceof ActivitySuspendedError) {
+                    // this will update last id...
+                    await this.storage.save(workflow);
+                    return;
+                }
+                workflow.error = JSON.stringify(error.stack ?? error);
+                workflow.state = "failed";
+                workflow.eta = clock.utcNow.add(instance.failedPreserveTime);
+            }
+
+            await this.storage.save(workflow);
+
+        } finally {
+            scope.dispose();
+        }
+    }
+}