@tstdl/base 0.93.74 → 0.93.76

package/document-management/server/services/document-management-observation.service.js

@@ -34,7 +34,7 @@ let DocumentManagementObservationService = DocumentManagementObservationService_
     collectionChange(ids, transactionOrSession) {
         const transaction = tryGetTstdlTransaction(transactionOrSession);
         if (isDefined(transaction)) {
-            transaction.afterCommit$.subscribe(() => this.collectionChange(ids));
+            transaction.afterCommit(() => this.collectionChange(ids));
         }
         else {
             for (const id of toArray(ids)) {
@@ -45,7 +45,7 @@ let DocumentManagementObservationService = DocumentManagementObservationService_
     documentChange(ids, transactionOrSession) {
         const transaction = tryGetTstdlTransaction(transactionOrSession);
         if (isDefined(transaction)) {
-            transaction.afterCommit$.subscribe(() => this.documentChange(ids));
+            transaction.afterCommit(() => this.documentChange(ids));
         }
         else {
             for (const id of toArray(ids)) {
@@ -56,7 +56,7 @@ let DocumentManagementObservationService = DocumentManagementObservationService_
     workflowChange(ids, transactionOrSession) {
         const transaction = tryGetTstdlTransaction(transactionOrSession);
         if (isDefined(transaction)) {
-            transaction.afterCommit$.subscribe(() => this.workflowChange(ids));
+            transaction.afterCommit(() => this.workflowChange(ids));
         }
         else {
             for (const id of toArray(ids)) {
@@ -67,7 +67,7 @@ let DocumentManagementObservationService = DocumentManagementObservationService_
     requestChange(ids, transactionOrSession) {
         const transaction = tryGetTstdlTransaction(transactionOrSession);
         if (isDefined(transaction)) {
-            transaction.afterCommit$.subscribe(() => this.requestChange(ids));
+            transaction.afterCommit(() => this.requestChange(ids));
         }
         else {
             for (const id of toArray(ids)) {

package/orm/server/transaction.d.ts

@@ -1,5 +1,4 @@
 import { PgTransaction as DrizzlePgTransaction, type PgQueryResultHKT, type PgTransactionConfig } from 'drizzle-orm/pg-core';
-import { DeferredPromise } from '../../promise/deferred-promise.js';
 import type { Record } from '../../types/index.js';
 import type { Database } from './database.js';
 export type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
@@ -7,12 +6,13 @@ export { DrizzlePgTransaction };
 export type TransactionConfig = PgTransactionConfig;
 export declare abstract class Transaction implements AsyncDisposable {
     #private;
-    readonly afterCommit$: import("rxjs").Observable<void>;
+    readonly afterCommit: import("../../utils/async-hook/index.js").AsyncHook<never, never, unknown>;
     manualCommit: boolean;
     [Symbol.asyncDispose](): Promise<void>;
     withManualCommit(): void;
     /**
-     * Enters automatic transaction handling. Transaction will be commited when all use-calls are done or rolled back when one throws.
+     * Executes the handler within the transaction scope.
+     * Commits automatically on success if manual commit is disabled, or rolls back on error.
      */
     use<T>(handler: () => Promise<T>): Promise<T>;
     commit(): Promise<void>;
@@ -21,11 +21,11 @@ export declare abstract class Transaction implements AsyncDisposable {
     protected abstract _rollback(): void | Promise<void>;
 }
 export declare class DrizzleTransaction extends Transaction {
+    #private;
     readonly pgTransaction: PgTransaction;
-    readonly deferPromise: DeferredPromise<void>;
-    readonly pgTransactionPromise: Promise<void>;
-    constructor(pgTransaction: PgTransaction, pgTransactionPromise: Promise<void>);
+    constructor(pgTransaction: PgTransaction);
     static create(session: Database | PgTransaction, config?: TransactionConfig): Promise<DrizzleTransaction>;
     protected _commit(): Promise<void>;
-    protected _rollback(): void;
+    protected _rollback(): Promise<void>;
+    private setTransactionResultPromise;
 }

package/orm/server/transaction.js

@@ -1,12 +1,11 @@
 import { PgTransaction as DrizzlePgTransaction } from 'drizzle-orm/pg-core';
-import { Subject } from 'rxjs';
 import { DeferredPromise } from '../../promise/deferred-promise.js';
+import { asyncHook } from '../../utils/async-hook/index.js';
 export { DrizzlePgTransaction };
 export class Transaction {
-    #afterCommitSubject = new Subject();
     #useCounter = 0;
     #done = false;
-    afterCommit$ = this.#afterCommitSubject.asObservable();
+    afterCommit = asyncHook();
     manualCommit = false;
     async [Symbol.asyncDispose]() {
         if (!this.#done) {
@@ -17,65 +16,92 @@ export class Transaction {
         this.manualCommit = true;
     }
     /**
-     * Enters automatic transaction handling. Transaction will be commited when all use-calls are done or rolled back when one throws.
+     * Executes the handler within the transaction scope.
+     * Commits automatically on success if manual commit is disabled, or rolls back on error.
      */
     async use(handler) {
+        if (this.#done) {
+            throw new Error('Transaction is already closed');
+        }
         this.#useCounter++;
         try {
             return await handler();
         }
+        catch (error) {
+            if (!this.#done) {
+                try {
+                    await this.rollback();
+                }
+                catch { /* ignore */ }
+            }
+            throw error;
+        }
         finally {
             this.#useCounter--;
-            if ((this.#useCounter == 0) && !this.#done && !this.manualCommit) {
+            if (!this.#done && !this.manualCommit && (this.#useCounter == 0)) {
                 await this.commit();
             }
         }
     }
     async commit() {
+        if (this.#done) {
+            throw new Error('Transaction is already closed');
+        }
         this.#done = true;
         await this._commit();
-        this.#afterCommitSubject.next();
-        this.#afterCommitSubject.complete();
+        await this.afterCommit.trigger();
     }
     async rollback() {
+        if (this.#done) {
+            return;
+        }
         this.#done = true;
-        this.#afterCommitSubject.complete();
         await this._rollback();
     }
 }
 export class DrizzleTransaction extends Transaction {
+    #deferPromise = new DeferredPromise();
     pgTransaction;
-    deferPromise = new DeferredPromise();
-    pgTransactionPromise;
-    constructor(pgTransaction, pgTransactionPromise) {
+    #pgTransactionResultPromise;
+    constructor(pgTransaction) {
         super();
         this.pgTransaction = pgTransaction;
-        this.pgTransactionPromise = pgTransactionPromise;
     }
     static async create(session, config) {
-        const transactionPromise = new DeferredPromise();
-        const pgTransactionPromise = session.transaction(async (tx) => {
-            const transaction = new DrizzleTransaction(tx, pgTransactionPromise);
-            transactionPromise.resolve(transaction);
-            await transaction.deferPromise;
+        const instancePromise = new DeferredPromise();
+        const pgTransactionResultPromise = session.transaction(async (tx) => {
+            const transaction = new DrizzleTransaction(tx);
+            instancePromise.resolve(transaction);
+            await transaction.#deferPromise;
         }, config);
-        pgTransactionPromise.catch((error) => {
-            if (transactionPromise.pending) {
-                transactionPromise.reject(error);
+        pgTransactionResultPromise.catch((error) => {
+            if (instancePromise.pending) {
+                instancePromise.reject(error);
             }
         });
-        return await transactionPromise;
+        const transaction = await instancePromise;
+        transaction.setTransactionResultPromise(pgTransactionResultPromise);
+        return transaction;
     }
     async _commit() {
-        this.deferPromise.resolve();
-        await this.pgTransactionPromise;
+        this.#deferPromise.resolve();
+        await this.#pgTransactionResultPromise;
     }
-    _rollback() {
+    async _rollback() {
         try {
             this.pgTransaction.rollback();
         }
         catch (error) {
-            this.deferPromise.reject(error);
+            if (this.#deferPromise.pending) {
+                this.#deferPromise.reject(error);
+            }
         }
+        try {
+            await this.#pgTransactionResultPromise;
+        }
+        catch { /* expect rejection during rollback */ }
+    }
+    setTransactionResultPromise(promise) {
+        this.#pgTransactionResultPromise = promise;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.74",
+  "version": "0.93.76",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/utils/async-hook/async-hook.d.ts

@@ -1,3 +1,26 @@
+/**
+ * Defines the signature for a handler function that can be registered with an `AsyncHook`.
+ * The function can be synchronous (returning `R`) or asynchronous (returning `Promise<R>`).
+ *
+ * The signature is conditional based on the value type `T` and context type `C`.
+ *
+ * @template T The type of the value passed to the handler.
+ * @template C The type of the optional context object.
+ * @template R The expected return type of the handler.
+ */
+export type AsyncHookHandler<T, C, R> = [
+    C
+] extends [never] ? [T] extends [never] ? () => R | Promise<R> : (value: T) => R | Promise<R> : [T] extends [never] ? (value: undefined, context: C) => R | Promise<R> : (value: T, context: C) => R | Promise<R>;
+/**
+ * Defines the signature for the trigger method.
+ *
+ * @template T The type of the value passed to the trigger.
+ * @template C The type of the optional context object.
+ * @template R The return type of an individual handler.
+ */
+export type AsyncHookTrigger<T, C, R> = [
+    C
+] extends [never] ? [T] extends [never] ? () => Promise<R[]> : (value: T) => Promise<R[]> : [T] extends [never] ? (value: undefined, context: C) => Promise<R[]> : (value: T, context: C) => Promise<R[]>;
 /**
  * Represents the public interface for an asynchronous hook.
  *
@@ -6,38 +29,35 @@
  * @template R The return type of an individual handler. Defaults to `unknown`.
  */
 export type AsyncHook<T, C = never, R = unknown> = {
+    /**
+     * Registers a handler function via the callable interface.
+     * @param handler The async handler function to register.
+     */
+    (handler: AsyncHookHandler<T, C, R>): AsyncHookHandlerRegistration;
     /**
      * Registers a handler function to be called when the hook is triggered.
      * @param handler The async handler function to register.
-     * @returns A registration object with an `unregister` method to remove the handler.
      */
     register: (handler: AsyncHookHandler<T, C, R>) => AsyncHookHandlerRegistration;
     /**
      * Triggers the hook, executing all registered handlers in sequence.
+     * If any handler throws an error, execution stops and the promise rejects.
      *
      * The signature of this function is conditional:
-     * - If the context type `C` is `never` (the default), it accepts only the `value` argument.
-     * - If `C` is any other type, it requires both `value` and `context` arguments.
+     * - `T=never, C=never`: `trigger()`
+     * - `T=Type,  C=never`: `trigger(value)`
+     * - `T=never, C=Type`:  `trigger(undefined, context)`
+     * - `T=Type,  C=Type`:  `trigger(value, context)`
      *
-     * @param value The value to pass to all handlers.
-     * @param context The context object to pass to all handlers (only required if `C` is not `never`).
      * @returns A promise that resolves to an array of results from all handlers.
      */
-    trigger: [C] extends [never] ? ((value: T) => Promise<R[]>) : ((value: T, context: C) => Promise<R[]>);
+    trigger: AsyncHookTrigger<T, C, R>;
+    /**
+     * Removes all registered handlers.
+     * Useful for cleanup logic or resetting state in tests.
+     */
+    removeAll: () => void;
 };
-/**
- * Defines the signature for a handler function that can be registered with an `AsyncHook`.
- * The function can be synchronous (returning `R`) or asynchronous (returning `Promise<R>`).
- *
- * The signature is conditional based on the context type `C`:
- * - If `C` is `never`, the handler receives only the `value` argument.
- * - If `C` is any other type, the handler receives both `value` and `context`.
- *
- * @template T The type of the value passed to the handler.
- * @template C The type of the optional context object.
- * @template R The expected return type of the handler.
- */
-export type AsyncHookHandler<T, C, R> = [C] extends [never] ? ((value: T) => R | Promise<R>) : ((value: T, context: C) => R | Promise<R>);
 /**
  * Represents the object returned when a handler is registered,
  * allowing for its subsequent unregistration.
@@ -52,67 +72,40 @@ export type AsyncHookHandlerRegistration = {
  * Creates a new asynchronous hook.
  *
  * An async hook is a system that allows you to register multiple "handler" functions
- * that will be executed in sequence when a "trigger" event occurs. This is useful
- * for creating extensible, plugin-like architectures. Handlers can be synchronous
- * or asynchronous.
+ * that will be executed in **sequential order** when a "trigger" event occurs.
+ * This is useful for creating extensible, plugin-like architectures.
+ * Handlers can be synchronous or asynchronous.
  *
- * @template T The type of the primary value that the hook is triggered with.
+ * @template T The type of the primary value that the hook is triggered with. Defaults to `never` (no value).
  * @template C The type of the optional context object passed to the hook's trigger and handlers. Defaults to `never`.
  * @template R The return type of an individual handler. The `trigger` method will resolve with an array of these values (`R[]`). Defaults to `unknown`.
- * @returns {AsyncHook<T, C, R>} An object with `register` and `trigger` methods.
  *
  * @example
  * ```ts
- * // Simple hook without context
- * async function runSimpleExample() {
- *   const onTaskStart = asyncHook<string>();
- *
- *   onTaskStart.register(taskName => {
- *     console.log(`[Logger] Task started: ${taskName}`);
- *   });
- *
- *   const registration = onTaskStart.register(async taskName => {
- *     await new Promise(resolve => setTimeout(resolve, 50));
- *     console.log(`[Notifier] Notifying that task started: ${taskName}`);
- *   });
- *
- *   await onTaskStart.trigger('Process Data');
- *   // [Logger] Task started: Process Data
- *   // [Notifier] Notifying that task started: Process Data
- *
- *   registration.unregister();
- *   console.log('Notifier unregistered.');
- *
- *   await onTaskStart.trigger('Finalize Report');
- *   // [Logger] Task started: Finalize Report
- * }
+ * // 1. Simple hook (Signal only, no data)
+ * const onInit = asyncHook();
+ * onInit(() => console.log('Initialized'));
+ * await onInit.trigger();
  * ```
  *
  * @example
  * ```ts
- * // Hook with a context object
- * async function runContextExample() {
- *   type TaskContext = { userId: number; transactionId: string };
- *
- *   const onTaskComplete = asyncHook<string, TaskContext, boolean>();
- *
- *   onTaskComplete.register((taskName, context) => {
- *     console.log(`[Audit] Task '${taskName}' completed by user ${context.userId}.`);
- *     return true; // Audit successful
- *   });
+ * // 2. Hook with data, no context
+ * const onMessage = asyncHook<string>();
+ * onMessage((msg) => console.log('Received:', msg));
+ * await onMessage.trigger('Hello');
+ * ```
  *
- *   onTaskComplete.register(async (taskName, context) => {
- *     console.log(`[DB] Logging completion of '${taskName}' for transaction ${context.transactionId}.`);
- *     return true; // DB update successful
- *   });
+ * @example
+ * ```ts
+ * // 3. Hook with context
+ * type Context = { user: string };
+ * const onAction = asyncHook<string, Context>();
  *
- *   const results = await onTaskComplete.trigger(
- *     'SubmitOrder',
- *     { userId: 123, transactionId: 'abc-456' }
- *   );
+ * // Note: Handlers receive context as the second argument
+ * onAction((action, ctx) => console.log(action, ctx.user));
  *
- *   console.log('Handler results:', results); // [true, true]
- * }
+ * await onAction.trigger('Click', { user: 'Alice' });
  * ```
  */
-export declare function asyncHook<T, C = never, R = unknown>(): AsyncHook<T, C, R>;
+export declare function asyncHook<T = never, C = never, R = unknown>(): AsyncHook<T, C, R>;

package/utils/async-hook/async-hook.js

@@ -2,94 +2,71 @@
  * Creates a new asynchronous hook.
  *
  * An async hook is a system that allows you to register multiple "handler" functions
- * that will be executed in sequence when a "trigger" event occurs. This is useful
- * for creating extensible, plugin-like architectures. Handlers can be synchronous
- * or asynchronous.
+ * that will be executed in **sequential order** when a "trigger" event occurs.
+ * This is useful for creating extensible, plugin-like architectures.
+ * Handlers can be synchronous or asynchronous.
  *
- * @template T The type of the primary value that the hook is triggered with.
+ * @template T The type of the primary value that the hook is triggered with. Defaults to `never` (no value).
  * @template C The type of the optional context object passed to the hook's trigger and handlers. Defaults to `never`.
  * @template R The return type of an individual handler. The `trigger` method will resolve with an array of these values (`R[]`). Defaults to `unknown`.
- * @returns {AsyncHook<T, C, R>} An object with `register` and `trigger` methods.
  *
  * @example
  * ```ts
- * // Simple hook without context
- * async function runSimpleExample() {
- *   const onTaskStart = asyncHook<string>();
- *
- *   onTaskStart.register(taskName => {
- *     console.log(`[Logger] Task started: ${taskName}`);
- *   });
- *
- *   const registration = onTaskStart.register(async taskName => {
- *     await new Promise(resolve => setTimeout(resolve, 50));
- *     console.log(`[Notifier] Notifying that task started: ${taskName}`);
- *   });
- *
- *   await onTaskStart.trigger('Process Data');
- *   // [Logger] Task started: Process Data
- *   // [Notifier] Notifying that task started: Process Data
- *
- *   registration.unregister();
- *   console.log('Notifier unregistered.');
- *
- *   await onTaskStart.trigger('Finalize Report');
- *   // [Logger] Task started: Finalize Report
- * }
+ * // 1. Simple hook (Signal only, no data)
+ * const onInit = asyncHook();
+ * onInit(() => console.log('Initialized'));
+ * await onInit.trigger();
  * ```
  *
  * @example
  * ```ts
- * // Hook with a context object
- * async function runContextExample() {
- *   type TaskContext = { userId: number; transactionId: string };
- *
- *   const onTaskComplete = asyncHook<string, TaskContext, boolean>();
- *
- *   onTaskComplete.register((taskName, context) => {
- *     console.log(`[Audit] Task '${taskName}' completed by user ${context.userId}.`);
- *     return true; // Audit successful
- *   });
+ * // 2. Hook with data, no context
+ * const onMessage = asyncHook<string>();
+ * onMessage((msg) => console.log('Received:', msg));
+ * await onMessage.trigger('Hello');
+ * ```
  *
- *   onTaskComplete.register(async (taskName, context) => {
- *     console.log(`[DB] Logging completion of '${taskName}' for transaction ${context.transactionId}.`);
- *     return true; // DB update successful
- *   });
+ * @example
+ * ```ts
+ * // 3. Hook with context
+ * type Context = { user: string };
+ * const onAction = asyncHook<string, Context>();
  *
- *   const results = await onTaskComplete.trigger(
- *     'SubmitOrder',
- *     { userId: 123, transactionId: 'abc-456' }
- *   );
+ * // Note: Handlers receive context as the second argument
+ * onAction((action, ctx) => console.log(action, ctx.user));
  *
- *   console.log('Handler results:', results); // [true, true]
- * }
+ * await onAction.trigger('Click', { user: 'Alice' });
  * ```
  */
 export function asyncHook() {
-    const handlers = [];
-    return {
-        register: (handler) => {
-            handlers.push(handler);
-            return {
+    const handles = new Set();
+    function register(handler) {
+        const handle = {
+            handler,
+            registration: {
                 unregister() {
-                    const index = handlers.indexOf(handler);
-                    if (index > -1) {
-                        handlers.splice(index, 1);
-                    }
+                    handles.delete(handle);
                 },
-            };
-        },
-        // The implementation uses a single function body, but the public type signature
-        // is conditional, ensuring type safety for callers.
-        trigger: async (value, context) => {
-            const returnValues = [];
-            // Create a snapshot of handlers in case one of them unregisters another during its execution.
-            for (const handler of [...handlers]) {
-                // The non-null assertion `context!` is safe due to the conditional public type of `trigger`.
-                const returnValue = await handler(value, context);
-                returnValues.push(returnValue);
-            }
-            return returnValues;
-        },
-    };
+            },
+        };
+        handles.add(handle);
+        return handle.registration;
+    }
+    async function trigger(value, context) {
+        const returnValues = [];
+        // Create a snapshot of handlers to safely handle unregistrations during execution.
+        for (const handle of [...handles]) {
+            const returnValue = await handle.handler(value, context);
+            returnValues.push(returnValue);
+        }
+        return returnValues;
+    }
+    function removeAll() {
+        handles.clear();
+    }
+    const hook = register;
+    hook.register = register;
+    hook.trigger = trigger;
+    hook.removeAll = removeAll;
+    return hook;
 }