@entity-access/entity-access 1.0.95 → 1.0.96

package/src/migrations/sql-server/SqlServerAutomaticMigrations.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 { SqlServerLiteral } from "../../drivers/sql-server/SqlServerLiteral.js";
 import EntityType from "../../entity-query/EntityType.js";
 import EntityContext from "../../model/EntityContext.js";
@@ -16,7 +16,7 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
         const nonKeyColumns = type.nonKeys;
         const keys = type.keys;
 
-        const driver = context.driver;
+        const driver = context.connection;
 
         await this.createTable(driver, type, keys);
 
@@ -43,7 +43,7 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
         }
     }
 
-    async createColumns(driver: BaseDriver, type: EntityType, nonKeyColumns: IColumn[]) {
+    async createColumns(driver: BaseConnection, type: EntityType, nonKeyColumns: IColumn[]) {
 
         const name = type.schema
         ? type.schema + "." + type.name
@@ -70,7 +70,7 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
 
     }
 
-    async createTable(driver: BaseDriver, type: EntityType, keys: IColumn[]) {
+    async createTable(driver: BaseConnection, type: EntityType, keys: IColumn[]) {
 
         const name = type.schema
             ? type.schema + "." + type.name
@@ -102,7 +102,7 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
     }
 
     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;

package/src/model/EntityContext.ts

@@ -1,4 +1,4 @@
-import { BaseDriver } from "../drivers/base/BaseDriver.js";
+import { BaseConnection, BaseDriver } from "../drivers/base/BaseDriver.js";
 import ChangeSet from "./changes/ChangeSet.js";
 import EntityModel from "./EntityModel.js";
 import { Expression } from "../query/ast/Expressions.js";
@@ -28,8 +28,14 @@ export default class EntityContext {
         return this[isChanging];
     }
 
+    public get connection() {
+        return this._connection ??= this.driver.newConnection();
+    }
+
     private postSaveChangesQueue: { task: () => any, order: number }[];
 
+    private _connection: BaseConnection;
+
     constructor(
         @Inject
         public driver: BaseDriver,
@@ -180,7 +186,7 @@ export default class EntityContext {
     }
 
     protected async saveChangesWithoutEvents(signal: AbortSignal) {
-        return this.driver.runInTransaction(async () => {
+        return this.connection.runInTransaction(async () => {
             const copy = Array.from(this.changeSet.getChanges()) as ChangeEntry[];
             for (const iterator of copy) {
                 switch (iterator.status) {
@@ -212,7 +218,7 @@ export default class EntityContext {
 
     private async executeExpression(expression: Expression, signal: AbortSignal) {
         const { text, values } = this.driver.compiler.compileExpression(null, expression);
-        const r = await this.driver.executeQuery({ text, values }, signal);
+        const r = await this.connection.executeQuery({ text, values }, signal);
         return r.rows?.[0];
     }
 

package/src/model/EntityQuery.ts

@@ -93,7 +93,7 @@ export default class EntityQuery<T = any>
             signal?.throwIfAborted();
 
             query = this.context.driver.compiler.compileExpression(this, this.selectStatement);
-            const reader = await this.context.driver.executeReader(query, signal);
+            const reader = await this.context.connection.executeReader(query, signal);
             scope.register(reader);
             for await (const iterator of reader.next(10, signal)) {
                 if (type) {
@@ -120,7 +120,7 @@ export default class EntityQuery<T = any>
         let reader: IDbReader;
         try {
             query = this.context.driver.compiler.compileExpression(this, select);
-            reader = await this.context.driver.executeReader(query, signal);
+            reader = await this.context.connection.executeReader(query, signal);
             for await (const iterator of reader.next(10, signal)) {
                 const item = select.model?.map(iterator) ?? iterator;
                 const entry = this.context.changeSet.getEntry(item, item);
@@ -200,7 +200,7 @@ export default class EntityQuery<T = any>
         let query;
         try {
             query = this.context.driver.compiler.compileExpression(nq, select);
-            const reader = await this.context.driver.executeReader(query);
+            const reader = await this.context.connection.executeReader(query);
             scope.register(reader);
             for await (const iterator of reader.next()) {
                 return iterator.c1 as number;

package/src/model/verification/VerificationSession.ts

@@ -152,7 +152,7 @@ export default class VerificationSession {
         const logger = ServiceProvider.resolve(this.context, Logger);
         const session = logger.newSession();
         try {
-            const { rows: [ { error }]} = await this.context.driver.executeQuery(query);
+            const { rows: [ { error }]} = await this.context.connection.executeQuery(query);
             if (error) {
                 session.error(`Failed executing ${query.text}\n[${query.values.join(",")}]\n${error?.stack ?? error}`);
                 EntityAccessError.throw(error);

package/src/query/ast/ExpressionToSql.ts

@@ -239,7 +239,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             }
 
             if (identifier?.value === "Sql") {
-                const argList = e.arguments.map((x) => this.visit(x));
+                const argList = e.arguments?.map((x) => this.visit(x)) ?? [];
                 const transformedCallee = this.compiler.sqlMethodTransformer(this.compiler, chain, argList as any[]);
                 if (transformedCallee) {
                     return prepare `${transformedCallee}`;
@@ -269,27 +269,29 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         const propertyChain = this.getPropertyChain(me);
         if (propertyChain) {
             const { parameter, identifier, chain } = propertyChain;
-            if (parameter === this.root) {
-                // we have a parameter...
-                return [(p) => p[chain[0]]];
-            }
-            if (parameter.value) {
-                const value = parameter.value;
-                return [() => value[chain[0]]];
-            }
-            const scope = this.scope.get(parameter);
-            if (scope.isRuntimeParam) {
-                return [(p) => p[chain[0]]];
-            }
-            const name = this.scope.nameOf(parameter);
+            if (parameter) {
+                if (parameter === this.root) {
+                    // we have a parameter...
+                    return [(p) => p[chain[0]]];
+                }
+                if (parameter.value) {
+                    const value = parameter.value;
+                    return [() => value[chain[0]]];
+                }
+                const scope = this.scope.get(parameter);
+                if (scope.isRuntimeParam) {
+                    return [(p) => p[chain[0]]];
+                }
+                const name = this.scope.nameOf(parameter);
 
-            // need to change name as per naming convention here...
-            const namingConvention = this.compiler.namingConvention;
-            if (scope.model && namingConvention) {
-                chain[0] = namingConvention(chain[0]);
-            }
+                // need to change name as per naming convention here...
+                const namingConvention = this.compiler.namingConvention;
+                if (scope.model && namingConvention) {
+                    chain[0] = namingConvention(chain[0]);
+                }
 
-            return [ QueryParameter.create(() => name) , "." , chain.join(".")];
+                return [ QueryParameter.create(() => name) , "." , chain.join(".")];
+            }
         }
 
         const { target, computed, property } = me;

package/src/query/ast/Expressions.ts

@@ -73,6 +73,10 @@ export abstract class Expression {
         return BinaryExpression.create({ left, right, operator: "="});
     }
 
+    static assign(left: Expression, right: Expression) {
+        return BinaryExpression.create({ left, right, operator: "="});
+    }
+
     static create<T extends Expression>(this: IClassOf<T>, p: Partial<Omit<T, "type">>) {
         (p as any).type = (this as any).name;
         Object.setPrototypeOf(p, this.prototype);

package/src/sql/ISql.ts

@@ -1,3 +1,5 @@
+import DateTime from "../types/DateTime.js";
+
 export interface ISql {
 
     in<T>(a: T, array: T[]): boolean;
@@ -55,6 +57,7 @@ export interface ISql {
     },
 
     date: {
+        now(): DateTime,
         yearOf(d: Date): number;
         monthOf(d: Date): number;
         dayOf(d: Date): number;

package/src/tests/drivers/postgres/connection-test.ts

@@ -9,7 +9,7 @@ export default async function (this: TestConfig) {
         return;
     }
 
-    const connection = this.driver;
+    const connection = this.driver.newConnection();
 
     await connection.ensureDatabase();
     // create table...

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

@@ -0,0 +1,119 @@
+import assert from "assert";
+import Inject, { Register, RegisterSingleton, ServiceProvider } from "../../di/di.js";
+import EternityContext from "../../eternity/EternityContext.js";
+import Workflow, { Activity, UniqueActivity } 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 CallTracker {
+    track: number = 0;
+}
+
+class ChildWorkflow extends Workflow<[string, string], string> {
+
+    async run() {
+        await this.delay(TimeSpan.fromSeconds(30));
+        return await this.add("Name:", this.input);
+    }
+
+    @UniqueActivity
+    async add(a: string, b: string[], @Inject tracker?: CallTracker) {
+        tracker.track++;
+        return a + " " + b.join(" ");
+    }
+}
+
+class ParentWorkflow extends Workflow<string, string> {
+
+    public async run(): Promise<any> {
+        const all = await this.all([
+            this.runChild(ChildWorkflow, [this.input, "1"]),
+            this.runChild(ChildWorkflow, [this.input, "2"])
+        ]);
+
+        return all.join(",");
+    }
+
+}
+
+export default async function(this: TestConfig) {
+
+    const mockClock = new MockClock();
+
+    const tracker = new CallTracker();
+
+    const scope = new ServiceProvider();
+    scope.add(WorkflowClock, mockClock);
+    scope.add(BaseDriver, this.driver);
+    scope.add(CallTracker, tracker);
+    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(ChildWorkflow);
+    c.register(ParentWorkflow);
+
+    await storage.seed();
+
+    const id = await c.queue(ParentWorkflow, "a");
+
+    mockClock.add(TimeSpan.fromSeconds(15));
+
+    await c.processQueueOnce();
+
+    assert.equal(0, tracker.track);
+
+    mockClock.add(TimeSpan.fromSeconds(20));
+
+    await c.processQueueOnce();
+
+    mockClock.add(TimeSpan.fromSeconds(20));
+
+    await c.processQueueOnce();
+
+    mockClock.add(TimeSpan.fromSeconds(20));
+
+    await c.processQueueOnce();
+
+    assert.notEqual(0, tracker.track);
+
+    await c.processQueueOnce();
+
+    mockClock.add(TimeSpan.fromSeconds(5));
+
+    await c.processQueueOnce();
+    mockClock.add(TimeSpan.fromSeconds(5));
+    await c.processQueueOnce();
+    mockClock.add(TimeSpan.fromSeconds(5));
+    await c.processQueueOnce();
+
+    const r = await storage.get(id);
+    assert.equal("done", r.state);
+}

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

@@ -106,4 +106,5 @@ export default async function (this: TestConfig) {
 
     // throw new Error("Preserve");
 
+ 
 }

package/src/tests/model/createContext.ts

@@ -11,9 +11,9 @@ export async function createContext(driver: BaseDriver) {
     Object.setPrototypeOf(copy, Object.getPrototypeOf(driver));
     const context = new ShoppingContext(copy);
 
-    await context.driver.ensureDatabase();
+    await context.connection.ensureDatabase();
 
-    await context.driver.automaticMigrations().migrate(context);
+    await context.connection.automaticMigrations().migrate(context);
 
     await seed(context);