@entity-access/entity-access 1.0.306 → 1.0.308

package/src/drivers/base/BaseDriver.ts

@@ -47,41 +47,75 @@ export interface IQueryResult {
     updated?: number;
 }
 
-export interface IBaseTransaction {
-    commit(): Promise<any>;
-    rollback(): Promise<any>;
-    dispose(): Promise<void>;
-}
+const currentTransaction = Symbol("currentTrnsaction");
+
+export abstract class EntityTransaction {
 
-export class EntityTransaction {
+    private committedOrRolledBack = false;
 
-    committedOrRolledBack = false;
+    private disposed = false;
+
+    constructor(protected conn: BaseConnection) {
+        conn[currentTransaction] = this;
+    }
 
-    constructor(private tx: IBaseTransaction) {}
+    begin() {
+        return this.beginTransaction();
+    }
 
     commit() {
         this.committedOrRolledBack = true;
-        return this.tx.commit();
+        return this.commitTransaction();
     }
 
     rollback() {
         this.committedOrRolledBack = true;
-        return this.tx.rollback();
+        return this.rollbackTransaction();
     }
 
     async dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
         if(!this.committedOrRolledBack) {
-            await this.tx.rollback();
+            await this.rollbackTransaction();
         }
-        await this.tx.dispose();
+        await this.disposeTransaction();
     }
 
-    async [Symbol.asyncDispose]() {
-        if(!this.committedOrRolledBack) {
-            await this.tx.rollback();
-        }
-        await this.tx.dispose();
+    [Symbol.asyncDispose]() {
+        return this.dispose();
+    }
+
+    protected abstract disposeTransaction(): Promise<void>;
+
+    protected abstract commitTransaction(): Promise<void>;
+
+    protected abstract rollbackTransaction(): Promise<void>;
+
+    protected abstract beginTransaction(): Promise<void>;
+
+}
+
+const emptyResolve = Promise.resolve();
+
+class EmptyTransaction extends EntityTransaction {
+
+    protected disposeTransaction() {
+        return emptyResolve;
+    }
+    protected commitTransaction() {
+        return emptyResolve;
+    }
+    protected rollbackTransaction() {
+        return emptyResolve;
     }
+
+    protected beginTransaction() {
+        return emptyResolve;
+    }
+
 }
 
 export abstract class BaseConnection {
@@ -90,7 +124,7 @@ export abstract class BaseConnection {
 
     protected connectionString: IDbConnectionString;
 
-    private currentTransaction: EntityTransaction;
+    private [currentTransaction]: EntityTransaction;
 
 
     constructor(public driver: BaseDriver) {
@@ -106,35 +140,30 @@ export abstract class BaseConnection {
      */
     public abstract automaticMigrations(): Migrations;
 
+    public async runInTransaction<T = any>(fx?: () => Promise<T>) {
+        await using tx = await this.createTransaction();
+        const result = await fx();
+        await tx.commit();
+        return result;
+    }
+
 
     public abstract executeReader(command: IQuery, signal?: AbortSignal): Promise<IDbReader>;
 
     public abstract executeQuery(command: IQuery, signal?: AbortSignal): Promise<IQueryResult>;
 
-    public abstract createTransaction(): Promise<EntityTransaction>;
-
-    public async runInTransaction<T = any>(fx?: () => Promise<T>) {
-        if(this.currentTransaction) {
-            // nested transactions... do not worry
-            // just pass through
-            return await fx();
-        }
-        let failed = true;
-        let tx: EntityTransaction;
-        try {
-            tx = this.currentTransaction = await this.createTransaction();
-            const result = await fx();
-            await tx.commit();
-            failed = false;
-            return result;
-        } finally {
-            if (failed) {
-                await tx?.rollback();
-            }
-            await tx?.[Symbol.asyncDispose]();
-            this.currentTransaction = null;
+    public async createTransaction() {
+        if (this[currentTransaction]) {
+            // return fake one...
+            return new EmptyTransaction(this);
         }
+        const tx = this[currentTransaction] = await this.createDbTransaction();
+        await tx.begin();
+        return tx;
     }
+
+    protected abstract createDbTransaction(): Promise<EntityTransaction>;
+
 }
 
 export type DirectSaveType =

package/src/drivers/postgres/PostgreSqlDriver.ts

@@ -3,7 +3,7 @@ import ObjectPool, { IPooledObject } from "../../common/ObjectPool.js";
 import QueryCompiler from "../../compiler/QueryCompiler.js";
 import Migrations from "../../migrations/Migrations.js";
 import PostgresAutomaticMigrations from "../../migrations/postgres/PostgresAutomaticMigrations.js";
-import { BaseConnection, BaseDriver, EntityTransaction, IBaseTransaction, IDbConnectionString, IDbReader, IQuery, IRecord, toQuery } from "../base/BaseDriver.js";
+import { BaseConnection, BaseDriver, EntityTransaction, IDbConnectionString, IDbReader, IQuery, toQuery } from "../base/BaseDriver.js";
 import pg from "pg";
 import Cursor from "pg-cursor";
 export interface IPgSqlConnectionString extends IDbConnectionString {
@@ -118,6 +118,28 @@ export default class PostgreSqlDriver extends BaseDriver {
     }
 }
 
+class PostgresTransaction extends EntityTransaction {
+
+    constructor(conn: PostgreSqlConnection, private tx: IPooledObject<pg.Client>) {
+        super(conn);
+    }
+
+    protected disposeTransaction() {
+        (this.conn as any).transaction = null;
+        return this.tx[Symbol.asyncDispose]();
+    }
+    protected commitTransaction() {
+        return this.tx.query("COMMIT") as any;
+    }
+    protected rollbackTransaction() {
+        return this.tx.query("ROLLBACK") as any;
+    }
+    protected beginTransaction() {
+        return this.tx.query("BEGIN") as any;
+    }
+
+}
+
 class PostgreSqlConnection extends BaseConnection {
 
     public get isInTransaction() {
@@ -134,18 +156,6 @@ class PostgreSqlConnection extends BaseConnection {
         super(driver);
     }
 
-    public async createTransaction(): Promise<EntityTransaction> {
-        const tx = await this.getConnection();
-        await tx.query("BEGIN");
-        return new EntityTransaction({
-            commit: () => tx.query("COMMIT"),
-            rollback: () => tx.query("ROLLBACK"),
-            dispose: () => {
-                this.transaction = null;
-                return tx[Symbol.asyncDispose]();
-            }
-        });
-    }
 
     public automaticMigrations(): Migrations {
         return new PostgresAutomaticMigrations(this.compiler);
@@ -226,6 +236,11 @@ class PostgreSqlConnection extends BaseConnection {
         return client;
     }
 
+    protected async createDbTransaction(): Promise<EntityTransaction> {
+        const tx = this.transaction = await this.getConnection();
+        return new PostgresTransaction(this, tx);
+    }
+
     private async kill(id) {
         const client = new pg.Client(this.config);
         try {

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 { BaseConnection, BaseDriver, EntityTransaction, IBaseTransaction, IDbConnectionString, IDbReader, IQuery, IRecord, toQuery } from "../base/BaseDriver.js";
+import { BaseConnection, BaseDriver, EntityTransaction, IDbConnectionString, IDbReader, IQuery, toQuery } from "../base/BaseDriver.js";
 import sql from "mssql";
 import SqlServerQueryCompiler from "./SqlServerQueryCompiler.js";
 import SqlServerAutomaticMigrations from "../../migrations/sql-server/SqlServerAutomaticMigrations.js";
@@ -34,6 +34,39 @@ export default class SqlServerDriver extends BaseDriver {
     }
 }
 
+const emptyResolve = Promise.resolve();
+
+class SqlEntityTransaction extends EntityTransaction {
+
+    rolledBack: any;
+
+    constructor(conn: SqlServerConnection, private tx: sql.Transaction) {
+        super(conn);
+        tx.on("rollback", (aborted) => {
+            this.rolledBack = aborted;
+        });
+    }
+
+    protected async beginTransaction() {
+        this.tx = await this.tx.begin();
+    }
+
+    protected disposeTransaction(): Promise<void> {
+        (this.conn as any).transaction = null;
+        return emptyResolve;
+    }
+    protected async commitTransaction() {
+        return this.tx.commit();
+    }
+    protected async rollbackTransaction() {
+        if(this.rolledBack) {
+            return;
+        }
+        await this.tx.rollback();
+    }
+
+}
+
 export class SqlServerConnection extends BaseConnection {
 
     private transaction: sql.Transaction;
@@ -114,22 +147,15 @@ export class SqlServerConnection extends BaseConnection {
         return value;
     }
 
-    public async createTransaction(): Promise<EntityTransaction> {
-        this.transaction = new sql.Transaction(await this.newConnection());
-        let rolledBack = false;
-        this.transaction.on("rollback", (aborted) => rolledBack = aborted);
-        await this.transaction.begin();
-        return new EntityTransaction({
-            commit: () => this.transaction.commit(),
-            rollback: async () => !rolledBack && await this.transaction.rollback(),
-            dispose: () => this.transaction = void 0
-        });
-    }
-
     public automaticMigrations(): Migrations {
         return new SqlServerAutomaticMigrations(this.sqlQueryCompiler);
     }
 
+    protected async createDbTransaction(): Promise<EntityTransaction> {
+        const tx = this.transaction = new sql.Transaction(await this.newConnection());
+        return new SqlEntityTransaction(this, tx);
+    }
+
     protected async newRequest(signal: AbortSignal) {
         let request: sql.Request;
         if (this.transaction) {

package/src/model/EntityContext.ts

@@ -12,6 +12,7 @@ import Inject, { ServiceProvider } from "../di/di.js";
 import EntityAccessError from "../common/EntityAccessError.js";
 import Logger from "../common/Logger.js";
 import { FilteredExpression } from "./events/FilteredExpression.js";
+import { traceSymbol } from "../common/symbols/symbols.js";
 
 const isChanging = Symbol("isChanging");
 
@@ -121,32 +122,37 @@ export default class EntityContext {
             return 0;
         }
 
-        return this.connection.runInTransaction(async () => {
-            try {
+        await using tx = await this.connection.createTransaction();
+        const oldTraceSymbol = this[traceSymbol];
+        this[traceSymbol] = options?.trace;
+        try {
 
-                if(!this.raiseEvents) {
-                    return await this.saveChangesInternalWithoutEvents(options);
-                }
+            if(!this.raiseEvents) {
+                const rx = await this.saveChangesInternalWithoutEvents(options);
+                await tx.commit();
+                return rx;
+            }
 
-                this[isChanging] = true;
-                const r = await this.saveChangesInternal(options);
-                const postSaveChanges = this.postSaveChangesQueue;
-                this.postSaveChangesQueue = void 0;
-                this[isChanging] = false;
-                if (postSaveChanges?.length) {
-                    postSaveChanges.sort((a, b) => a.order - b.order);
-                    for (const { task } of postSaveChanges) {
-                        const p = task();
-                        if (p?.then) {
-                            await p;
-                        }
+            this[isChanging] = true;
+            const r = await this.saveChangesInternal(options);
+            const postSaveChanges = this.postSaveChangesQueue;
+            this.postSaveChangesQueue = void 0;
+            this[isChanging] = false;
+            if (postSaveChanges?.length) {
+                postSaveChanges.sort((a, b) => a.order - b.order);
+                for (const { task } of postSaveChanges) {
+                    const p = task();
+                    if (p?.then) {
+                        await p;
                     }
                 }
-                return r;
-            } finally {
-                this[isChanging] = false;
             }
-        });
+            await tx.commit();
+            return r;
+        } finally {
+            this[isChanging] = false;
+            this[traceSymbol] = oldTraceSymbol;
+        }
     }
 
     public queuePostSaveTask(task: () => any, order = Number.MAX_SAFE_INTEGER) {

package/src/model/EntitySource.ts

@@ -2,7 +2,7 @@ import type EntityContext from "./EntityContext.js";
 import type EntityType from "../entity-query/EntityType.js";
 import type { IBaseQuery, IEntityQuery, IFilterExpression } from "./IFilterWithParameter.js";
 import EntityQuery from "./EntityQuery.js";
-import { contextSymbol, modelSymbol } from "../common/symbols/symbols.js";
+import { contextSymbol, modelSymbol, traceSymbol } from "../common/symbols/symbols.js";
 import { Expression, ExpressionAs, Identifier, InsertStatement, TableLiteral } from "../query/ast/Expressions.js";
 import { DirectSaveType } from "../drivers/base/BaseDriver.js";
 import IdentityService from "./identity/IdentityService.js";
@@ -233,6 +233,7 @@ export class EntitySource<T = any> {
         selectStatement.model = model;
         return new EntityQuery<T>({
             context,
+            trace: context[traceSymbol],
             type: model,
             selectStatement
         }) as any as IEntityQuery<T>;

package/src/workflows/WorkflowStorage.ts

@@ -224,32 +224,17 @@ export default class WorkflowStorage {
     async save(state: Partial<WorkflowItem>) {
         const db = new WorkflowContext(this.driver);
         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);
-            //     w.taskGroup ||= "default";
-            // }
-
-            // for (const key in state) {
-            //     if (Object.prototype.hasOwnProperty.call(state, key)) {
-            //         const element = state[key];
-            //         w[key] = element;
-            //     }
-            // }
-
-            // w.state ||= "queued";
-            // w.updated ??= DateTime.now;
-            state.state ||= "queued";
-            state.updated ??= DateTime.now;
-            state.taskGroup ||= "default";
-            // await db.saveChanges();
-            if(state[loadedFromDb]) {
-                await db.workflows.saveDirect({ mode: "update", changes: state });
-            } else {
-                await db.workflows.saveDirect({ mode: "upsert", changes: state });
-            }
-        });
+        await using tx = await connection.createTransaction();
+        state.state ||= "queued";
+        state.updated ??= DateTime.now;
+        state.taskGroup ||= "default";
+        // await db.saveChanges();
+        if(state[loadedFromDb]) {
+            await db.workflows.saveDirect({ mode: "update", changes: state });
+        } else {
+            await db.workflows.saveDirect({ mode: "upsert", changes: state });
+        }
+        await tx.commit();
     }
 
     async dequeue(taskGroup: string, signal?: AbortSignal) {