@tstdl/base 0.93.97 → 0.93.99

package/notification/server/services/notification.service.js

@@ -0,0 +1,80 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { inject } from '../../../injector/index.js';
+import { injectRepository, Transactional } from '../../../orm/server/index.js';
+import { TaskQueue } from '../../../task-queue/task-queue.js';
+import { currentTimestamp } from '../../../utils/date-time.js';
+import { NotificationStatus } from '../../enums.js';
+import { InAppNotification, NotificationLog, NotificationPreference, WebPushSubscription } from '../../models/index.js';
+import { NotificationSingleton } from './singleton.js';
+let NotificationService = class NotificationService extends Transactional {
+    #notificationLogRepository = injectRepository(NotificationLog);
+    #inAppNotificationRepository = injectRepository(InAppNotification);
+    #preferenceRepository = injectRepository(NotificationPreference);
+    #webPushSubscriptionRepository = injectRepository(WebPushSubscription);
+    #taskQueue = inject((TaskQueue), 'notification');
+    async send(notification) {
+        await this.transaction(async (tx) => {
+            const notificationToInsert = {
+                ...notification,
+                status: NotificationStatus.Pending,
+                currentStep: 0,
+            };
+            const insertedNotification = await this.#notificationLogRepository.withTransaction(tx).insert(notificationToInsert);
+            await this.#taskQueue.withTransaction(tx).enqueue('notification/deliver', { notificationId: insertedNotification.id });
+        });
+    }
+    async listInApp(tenantId, userId, options = {}) {
+        const inAppNotifications = await this.#inAppNotificationRepository.loadManyByQuery({
+            tenantId,
+            userId,
+            archivedAt: options.includeArchived ? undefined : null,
+        }, {
+            limit: options.limit,
+            offset: options.offset,
+            order: { 'metadata.createTimestamp': 'desc' },
+        });
+        const logIds = inAppNotifications.map((n) => n.logId);
+        const logs = await this.#notificationLogRepository.loadMany(logIds);
+        const logsMap = new Map(logs.map((log) => [log.id, log]));
+        return inAppNotifications.map((n) => ({
+            ...n,
+            log: logsMap.get(n.logId),
+        }));
+    }
+    async markRead(tenantId, userId, id) {
+        await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { readAt: currentTimestamp() });
+    }
+    async archive(tenantId, userId, id) {
+        await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { archivedAt: currentTimestamp() });
+    }
+    async getPreferences(tenantId, userId) {
+        return await this.#preferenceRepository.loadManyByQuery({ tenantId, userId });
+    }
+    async updatePreference(tenantId, userId, categoryId, channel, enabled) {
+        await this.#preferenceRepository.upsert(['tenantId', 'userId', 'categoryId', 'channel'], {
+            tenantId,
+            userId,
+            categoryId,
+            channel,
+            enabled,
+        });
+    }
+    async registerWebPush(tenantId, userId, endpoint, p256dh, auth) {
+        await this.#webPushSubscriptionRepository.upsert(['tenantId', 'userId', 'endpoint'], {
+            tenantId,
+            userId,
+            endpoint,
+            p256dh,
+            auth,
+        });
+    }
+};
+NotificationService = __decorate([
+    NotificationSingleton()
+], NotificationService);
+export { NotificationService };

package/notification/server/services/singleton.d.ts

@@ -0,0 +1,3 @@
+export declare const notificationDatabaseConfigFactoryProvider: import("../../../injector/provider.js").FactoryProvider<unknown, unknown, import("../../../types/types.js").Record>;
+export declare const notificationDatabaseConfigProvider: import("../../../injector/injector.js").ProvidersItem<unknown, unknown, import("../../../types/types.js").Record>;
+export declare function NotificationSingleton(): ClassDecorator;

package/notification/server/services/singleton.js

@@ -0,0 +1,10 @@
+import { Singleton } from '../../../injector/decorators.js';
+import { provide } from '../../../injector/injector.js';
+import { factoryProvider } from '../../../injector/provider.js';
+import { DatabaseConfig } from '../../../orm/server/index.js';
+import { NotificationConfiguration } from '../module.js';
+export const notificationDatabaseConfigFactoryProvider = factoryProvider((_, context) => context.resolve(NotificationConfiguration).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }));
+export const notificationDatabaseConfigProvider = provide(DatabaseConfig, notificationDatabaseConfigFactoryProvider);
+export function NotificationSingleton() {
+    return Singleton({ providers: [notificationDatabaseConfigProvider] });
+}

package/notification/tests/notification-category.service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/notification/tests/notification-category.service.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'vitest';
+import { runInInjectionContext } from '../../injector/index.js';
+import { setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
+import { NotificationCategoryService } from '../server/services/notification-category.service.js';
+describe('NotificationCategoryService', () => {
+    test('should initialize categories correctly', async () => {
+        const { injector, database } = await setupIntegrationTest({ modules: { notification: true, authentication: true } });
+        // Cleanup
+        await truncateTables(database, 'notification', ['category']);
+        const service = injector.resolve(NotificationCategoryService);
+        const tenantId = '00000000-0000-0000-0000-000000000001';
+        const categoryData = {
+            CAT1: { label: 'Category 1' },
+            CAT2: { label: 'Category 2', throttling: { limit: 1, intervalMs: 1000 } }
+        };
+        await runInInjectionContext(injector, async () => {
+            const result = await service.initializeCategories(tenantId, categoryData);
+            expect(result.CAT1.label).toBe('Category 1');
+            expect(result.CAT2.key).toBe('CAT2');
+            expect(result.CAT2.throttling?.limit).toBe(1);
+            // Verify persistence
+            const dbCategories = await service.repository.loadManyByQuery({ tenantId });
+            expect(dbCategories).toHaveLength(2);
+            // Update
+            const updatedData = {
+                CAT1: { label: 'Category 1 Updated' },
+                CAT2: { label: 'Category 2', throttling: { limit: 1, intervalMs: 1000 } }
+            };
+            const resultUpdated = await service.initializeCategories(tenantId, updatedData);
+            expect(resultUpdated.CAT1.label).toBe('Category 1 Updated');
+            const dbCategoriesUpdated = await service.repository.loadManyByQuery({ tenantId });
+            expect(dbCategoriesUpdated).toHaveLength(2);
+            expect(dbCategoriesUpdated.find((c) => c.key == 'CAT1')?.label).toBe('Category 1 Updated');
+        });
+    });
+});

package/notification/tests/notification-flow.test.d.ts

@@ -0,0 +1 @@
+export {};

package/notification/tests/notification-flow.test.js

@@ -0,0 +1,112 @@
+import { beforeAll, describe, expect, test, vi } from 'vitest';
+import { SubjectService } from '../../authentication/server/subject.service.js';
+import { runInInjectionContext } from '../../injector/index.js';
+import { MailService } from '../../mail/mail.service.js';
+import { injectRepository } from '../../orm/server/index.js';
+import { setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
+import { NotificationChannel, NotificationStatus } from '../enums.js';
+import { InAppNotification, NotificationLog } from '../models/index.js';
+import { EmailChannelProvider } from '../server/providers/email-channel-provider.js';
+import { NotificationCategoryService } from '../server/services/notification-category.service.js';
+import { NotificationDeliveryWorker } from '../server/services/notification-delivery.worker.js';
+import { NotificationService } from '../server/services/notification.service.js';
+describe('Notification Flow (Integration)', () => {
+    let injector;
+    let database;
+    let notificationService;
+    let worker;
+    let categoryService;
+    let subjectService;
+    let mailServiceMock;
+    const schema = 'notification';
+    const tenantId = '00000000-0000-0000-0000-000000000000';
+    beforeAll(async () => {
+        ({ injector, database } = await setupIntegrationTest({
+            orm: { schema },
+            modules: {
+                taskQueue: true,
+                rateLimiter: true,
+                authentication: true,
+                messageBus: true,
+                signals: true,
+                notification: true,
+            },
+        }));
+        // Mock MailService
+        mailServiceMock = { send: vi.fn() };
+        injector.register(MailService, { useValue: mailServiceMock });
+        // Resolve Services
+        notificationService = injector.resolve(NotificationService);
+        worker = injector.resolve(NotificationDeliveryWorker);
+        categoryService = injector.resolve(NotificationCategoryService);
+        subjectService = injector.resolve(SubjectService);
+        // Register providers
+        worker.registerProvider(NotificationChannel.Email, injector.resolve(EmailChannelProvider));
+        const InAppChannelProvider = (await import('../server/providers/in-app-channel-provider.js')).InAppChannelProvider;
+        worker.registerProvider(NotificationChannel.InApp, injector.resolve(InAppChannelProvider));
+        await truncateTables(database, 'authentication', ['user', 'subject']);
+        await truncateTables(database, 'notification', ['log', 'in_app', 'category', 'preference', 'web_push_subscription']);
+    });
+    test('should execute full notification flow with escalation', async () => {
+        await runInInjectionContext(injector, async () => {
+            // Resolve Dependencies synchronously at start
+            const logRepo = injectRepository(NotificationLog);
+            const inAppRepo = injectRepository(InAppNotification);
+            // 1. Setup Data
+            const user = await subjectService.createUser({
+                tenantId,
+                email: 'test@example.com',
+                firstName: 'Test',
+                lastName: 'User',
+            });
+            // Initialize Category with Escalation
+            const categories = await categoryService.initializeCategories(tenantId, {
+                TEST_CAT: {
+                    label: 'Test Category',
+                    escalations: [{ delayMs: 1000, channel: NotificationChannel.Email }],
+                },
+            });
+            const category = categories.TEST_CAT;
+            // 2. Send Notification
+            const notification = Object.assign(new NotificationLog(), {
+                tenantId,
+                userId: user.id,
+                categoryId: category.id,
+                type: 'test',
+                priority: 'high',
+                payload: { message: 'Hello', testField: 'Test Value' },
+            });
+            await notificationService.send(notification);
+            // Verify Log Created
+            const logs = await logRepo.loadManyByQuery({ tenantId });
+            expect(logs).toHaveLength(1);
+            const log = logs[0];
+            expect(log.status).toBe(NotificationStatus.Pending);
+            expect(log.currentStep).toBe(0);
+            expect(log.payload.testField).toBe('Test Value');
+            // 3. Worker Execution - Step 0 (In-App)
+            const result0 = await worker.deliver(log.id);
+            // Verify Result
+            expect(result0.payload.action).toBe('reschedule');
+            // Verify In-App Created
+            const inApps = await inAppRepo.loadManyByQuery({ tenantId });
+            expect(inApps).toHaveLength(1);
+            expect(inApps[0].logId).toBe(log.id);
+            // Verify Log Updated
+            const logAfterStep0 = await logRepo.load(log.id);
+            expect(logAfterStep0.status).toBe(NotificationStatus.Sent);
+            expect(logAfterStep0.currentStep).toBe(1);
+            // 4. Worker Execution - Step 1 (Email Escalation)
+            const result1 = await worker.deliver(log.id);
+            // Verify Result
+            expect(result1.payload.action).toBe('complete');
+            // Verify Email Sent
+            expect(mailServiceMock.send).toHaveBeenCalled();
+            const mailArgs = mailServiceMock.send.mock.calls[0][0];
+            expect(mailArgs.to).toBe('test@example.com');
+            // Verify Log Updated
+            const logAfterStep1 = await logRepo.load(log.id);
+            expect(logAfterStep1.currentStep).toBe(2);
+        });
+    });
+});

package/notification/tests/notification-sse.service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/notification/tests/notification-sse.service.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, test } from 'vitest';
+import { runInInjectionContext } from '../../injector/index.js';
+import { setupIntegrationTest } from '../../unit-test/index.js';
+import { NotificationSseService } from '../server/services/notification-sse.service.js';
+describe('NotificationSseService', () => {
+    test('should register and publish to bus', async () => {
+        const { injector } = await setupIntegrationTest({ modules: { messageBus: true, signals: true } });
+        const service = injector.resolve(NotificationSseService);
+        const tenantId = 't1';
+        const userId = 'u1';
+        await runInInjectionContext(injector, async () => {
+            const source = service.register(tenantId, userId);
+            expect(source).toBeDefined();
+            // We can't easily spy on the LocalMessageBus internals without more complex setup,
+            // but we can verify that sending doesn't throw.
+            const msg = { tenantId, userId, logId: 'l1' };
+            await expect(service.send(msg)).resolves.not.toThrow();
+        });
+    });
+});

package/notification/tests/test-notification.model.d.ts

@@ -0,0 +1,4 @@
+import { NotificationLog } from '../models/notification-log.model.js';
+export declare class TestNotification extends NotificationLog {
+    testField: string;
+}

package/notification/tests/test-notification.model.js

@@ -0,0 +1,25 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { ChildEntity } from '../../orm/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { NotificationLog } from '../models/notification-log.model.js';
+import { NotificationTable } from '../models/notification-table.js';
+let TestNotification = class TestNotification extends NotificationLog {
+    testField;
+};
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], TestNotification.prototype, "testField", void 0);
+TestNotification = __decorate([
+    NotificationTable({ name: 'test_notification' }),
+    ChildEntity('test')
+], TestNotification);
+export { TestNotification };

package/object-storage/google/google.object-storage-provider.d.ts

@@ -29,7 +29,6 @@ export declare class GoogleObjectStorageProviderConfig {
      */
     bucketPerModule?: boolean;
 }
-export declare const bucketPerModule: unique symbol;
 export declare class GoogleObjectStorageProvider extends ObjectStorageProvider<GoogleObjectStorage> {
     private readonly client;
     private readonly bucket;

package/object-storage/google/google.object-storage-provider.js

@@ -39,7 +39,6 @@ export class GoogleObjectStorageProviderConfig {
      */
     bucketPerModule;
 }
-export const bucketPerModule = Symbol('bucket per module');
 let GoogleObjectStorageProvider = class GoogleObjectStorageProvider extends ObjectStorageProvider {
     client;
     bucket;

package/object-storage/index.d.ts

@@ -6,4 +6,3 @@
 export * from './object-storage-provider.js';
 export * from './object-storage.js';
 export * from './object.js';
-export * from './s3/index.js';

package/object-storage/index.js

@@ -6,4 +6,3 @@
 export * from './object-storage-provider.js';
 export * from './object-storage.js';
 export * from './object.js';
-export * from './s3/index.js';

package/object-storage/s3/s3.object-storage-provider.d.ts

@@ -26,7 +26,6 @@ export declare class S3ObjectStorageProviderConfig {
      */
     secretKey: string;
 }
-export declare const bucketPerModule: unique symbol;
 export declare class S3ObjectStorageProvider extends ObjectStorageProvider<S3ObjectStorage> {
     private readonly client;
     private readonly bucket;

package/object-storage/s3/s3.object-storage-provider.js

@@ -39,7 +39,6 @@ export class S3ObjectStorageProviderConfig {
      */
     secretKey;
 }
-export const bucketPerModule = Symbol('bucket per module');
 let S3ObjectStorageProvider = class S3ObjectStorageProvider extends ObjectStorageProvider {
     client;
     bucket;

package/orm/server/transactional.d.ts

@@ -19,10 +19,11 @@ declare const getCurrentTransactionalContext: {
     (required: true, debugFn: import("../../types/index.js").Function): TransactionalContext<unknown>;
     (required?: false, debugFn?: import("../../types/index.js").Function): TransactionalContext<unknown> | null;
     (required: boolean, debugFn: import("../../types/index.js").Function): TransactionalContext<unknown> | null;
-}, runInTransactionalContext: <ReturnT>(context: TransactionalContext<unknown>, fn: () => ReturnT) => ReturnT, isInTransactionalContext: () => boolean;
-export { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext };
+}, isInTransactionalContext: () => boolean, runInTransactionalContext: <ReturnT>(context: TransactionalContext<unknown>, fn: () => ReturnT) => ReturnT, tryGetCurrentTransactionalContext: () => TransactionalContext<unknown> | null;
+export { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext, tryGetCurrentTransactionalContext };
 export declare abstract class Transactional<ContextData = unknown> {
     #private;
+    protected transactionalContextData: ContextData | undefined;
     readonly session: Database | PgTransaction;
     readonly isInTransaction: boolean;
     constructor();

package/orm/server/transactional.js

@@ -6,8 +6,8 @@ import { isDefined, isNull, isUndefined } from '../../utils/type-guards.js';
 import { Database } from './database.js';
 import { DrizzleTransaction, Transaction } from './transaction.js';
 const transactionCache = new WeakMap();
-const { getCurrentTransactionalContext, runInTransactionalContext, isInTransactionalContext } = createContextProvider('Transactional');
-export { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext };
+const { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext, tryGetCurrentTransactionalContext } = createContextProvider('Transactional');
+export { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext, tryGetCurrentTransactionalContext };
 function transactionalContextDataGuardFunction() {
     throw new Error('function getTransactionalContextData must be implemented to use transactional context data.');
 }
@@ -39,6 +39,7 @@ export class Transactional {
         }
         return cache;
     }
+    transactionalContextData = this.#context.data;
     session = this.#context.session ?? inject(Database);
     isInTransaction = this.session instanceof DrizzlePgTransaction;
     constructor() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.97",
+  "version": "0.93.99",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -87,6 +87,8 @@
     "./migration": "./migration/index.js",
     "./module": "./module/index.js",
     "./object-storage": "./object-storage/index.js",
+    "./object-storage/google": "./object-storage/google/index.js",
+    "./object-storage/s3": "./object-storage/s3/index.js",
     "./openid-connect": "./openid-connect/index.js",
     "./orm": "./orm/index.js",
     "./orm/schemas": "./orm/schemas/index.js",
@@ -195,7 +197,7 @@
     "typedoc-plugin-markdown": "4.9",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.53",
+    "typescript-eslint": "8.54",
     "vite-tsconfig-paths": "6.0",
     "vitest": "4.0"
   },

package/pool/pool.d.ts

@@ -2,7 +2,7 @@ import type { Logger } from '../logger/index.js';
 export type PoolOptions = {
     /**
      * Maximum number of instances
-     * @default number of cpu cores
+     * @default half of cpu cores or 4
      */
     size?: number;
     /**

package/promise/cancelable-promise.d.ts

@@ -10,6 +10,7 @@ export type CancelablePromiseResult<T, R> = {
 };
 export declare class CancelablePromise<T, R = void> extends CustomPromise<CancelablePromiseResult<T, R>> {
     #private;
+    readonly [Symbol.toStringTag] = "CancelablePromise";
     constructor(executor: CancelablePromiseExecutor<T>);
     cancel(reason: R): void;
 }

package/promise/cancelable-promise.js

@@ -5,6 +5,7 @@ export class CancelablePromise extends CustomPromise {
     #resolve;
     #reject;
     #pending = true;
+    [Symbol.toStringTag] = 'CancelablePromise';
     constructor(executor) {
         super();
         this.#resolve = (value) => {

package/promise/index.d.ts

@@ -4,6 +4,7 @@
  * @module Promise
  */
 export * from './cancelable-promise.js';
+export * from './custom-promise.js';
 export * from './deferred-promise.js';
 export * from './lazy-promise.js';
 export * from './types.js';

package/promise/index.js

@@ -4,6 +4,7 @@
  * @module Promise
  */
 export * from './cancelable-promise.js';
+export * from './custom-promise.js';
 export * from './deferred-promise.js';
 export * from './lazy-promise.js';
 export * from './types.js';

package/random/number-generator/index.d.ts

@@ -3,3 +3,4 @@ export * from './random-number-generator-function.js';
 export * from './random-number-generator.js';
 export * from './seeded-random-number-generator.js';
 export * from './sfc32.js';
+export * from './utils.js';

package/random/number-generator/index.js

@@ -3,3 +3,4 @@ export * from './random-number-generator-function.js';
 export * from './random-number-generator.js';
 export * from './seeded-random-number-generator.js';
 export * from './sfc32.js';
+export * from './utils.js';

package/sse/data-stream.js

@@ -1,15 +1,28 @@
 import { patch } from 'jsondiffpatch';
+import { isErrorResponse, parseErrorResponse } from '../api/response.js';
 import { hasOwnProperty } from '../utils/object/object.js';
-import { finalize, map, merge, scan } from 'rxjs';
+import { finalize, map, merge, scan, switchMap, throwError } from 'rxjs';
 export class DataStream {
     static parse(eventSource) {
         const data$ = eventSource.message$('data').pipe(map((message) => ({ data: JSON.parse(message.data) })));
         const delta$ = eventSource.message$('delta').pipe(map((message) => ({ delta: JSON.parse(message.data) })));
-        return merge(data$, delta$).pipe(scan((data, message) => {
+        const stream$ = merge(data$, delta$).pipe(scan((data, message) => {
             if (hasOwnProperty(message, 'data')) {
                 return message.data;
             }
             return patch(structuredClone(data), message.delta);
-        }, undefined), finalize(() => eventSource.close()));
+        }, undefined));
+        const error$ = eventSource.message$('error').pipe(switchMap((message) => throwError(() => {
+            try {
+                const dataJson = JSON.parse(message.data);
+                if (isErrorResponse(dataJson)) {
+                    return parseErrorResponse(dataJson);
+                }
+                return new Error(`Data stream error`, { cause: dataJson });
+            }
+            catch { /* ignore json parse errors */ }
+            return new Error(`Data stream error`, { cause: message.data });
+        })));
+        return merge(stream$, error$).pipe(finalize(() => eventSource.close()));
     }
 }

package/task-queue/task-queue.d.ts

@@ -6,7 +6,7 @@ import type { Transaction } from '../orm/server/transaction.js';
 import { Transactional } from '../orm/server/transactional.js';
 import type { OneOrMany, Record, UndefinableJson } from '../types/types.js';
 import { TaskQueueEnqueueBatch } from './enqueue-batch.js';
-import type { ProcessBatchWorker, ProcessWorker, TaskData, TaskDefinitionMap, TaskOfType, TaskProcessResultPayload, TaskResult, TaskState, TaskTypes, TasksResults, TasksStates } from './types.js';
+import type { ProcessBatchWorker, ProcessWorker, TaskData, TaskDefinitionMap, TaskOfType, TaskProcessResultPayload, TaskResult, TasksResults, TasksStates, TaskState, TaskTypes } from './types.js';
 export declare class TaskProcessResult<Result = unknown> {
     readonly payload: TaskProcessResultPayload<Result>;
     private constructor();
@@ -175,7 +175,9 @@ export type TaskQueueArgument = string | (QueueConfig & {
     namespace: string;
 });
 export declare const defaultQueueConfig: Required<QueueConfig>;
-export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap = TaskDefinitionMap> extends Transactional implements Resolvable<TaskQueueArgument> {
+export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap = TaskDefinitionMap> extends Transactional<QueueConfig & {
+    namespace: string;
+}> implements Resolvable<TaskQueueArgument> {
     readonly [resolveArgumentType]: TaskQueueArgument;
     protected readonly config: QueueConfig & {
         namespace: string;
@@ -304,6 +306,9 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
         types?: Type[];
         forceDequeue?: boolean;
     }, handler: ProcessBatchWorker<Definitions, Type>): void;
+    protected getTransactionalContextData(): QueueConfig & {
+        namespace: string;
+    };
     private processWorker;
     private processBatchWorker;
 }

package/task-queue/task-queue.js

@@ -79,7 +79,7 @@ export const defaultQueueConfig = {
     idempotencyWindow: millisecondsPerMinute * 60,
 };
 export class TaskQueue extends Transactional {
-    config = (() => { const arg = injectArgument(this); return isString(arg) ? { namespace: arg } : arg; })();
+    config = this.transactionalContextData ?? (() => { const arg = injectArgument(this); return isString(arg) ? { namespace: arg } : arg; })();
     logger = inject(Logger, `TaskQueue:${this.config.namespace}`);
     batch() {
         return new TaskQueueEnqueueBatch(this);
@@ -94,6 +94,9 @@ export class TaskQueue extends Transactional {
             void this.processBatchWorker(batchSize, cancellationSignal, handler, { types, forceDequeue });
         }
     }
+    getTransactionalContextData() {
+        return this.config;
+    }
     async processWorker(cancellationSignal, handler, options) {
         await this.processBatchWorker(1, cancellationSignal, async (batchContext) => {
             const task = batchContext.tasks[0];

package/unit-test/integration-setup.d.ts

@@ -15,16 +15,17 @@ export type IntegrationTestOptions = {
     };
     logLevels?: Record<string, LogLevel>;
     modules?: {
-        taskQueue?: boolean;
-        messageBus?: boolean;
-        circuitBreaker?: boolean;
-        rateLimiter?: boolean;
+        api?: boolean;
+        audit?: boolean;
         authentication?: boolean;
+        circuitBreaker?: boolean;
         keyValueStore?: boolean;
-        audit?: boolean;
         lock?: boolean;
+        messageBus?: boolean;
+        notification?: boolean;
+        rateLimiter?: boolean;
         signals?: boolean;
-        api?: boolean;
+        taskQueue?: boolean;
         test?: boolean;
         webServer?: boolean;
     };

package/unit-test/integration-setup.js

@@ -15,6 +15,7 @@ import { configurePostgresLock, migratePostgresLockSchema } from '../lock/postgr
 import { ConsoleLogTransport, DEFAULT_LOG_LEVEL, LogFormatter, LogLevel, LogManager, LogTransport, PrettyPrintLogFormatter } from '../logger/index.js';
 import { configureLocalMessageBus } from '../message-bus/index.js';
 import { configureWebServerModule, WebServerModule } from '../module/modules/web-server.module.js';
+import { configureNotification, migrateNotificationSchema } from '../notification/server/index.js';
 import { configureOrm, Database } from '../orm/server/index.js';
 import { configurePostgresRateLimiter, migratePostgresRateLimiterSchema } from '../rate-limit/postgres/module.js';
 import { configureDefaultSignalsImplementation } from '../signals/implementation/configure.js';
@@ -63,7 +64,7 @@ export async function setupIntegrationTest(options = {}) {
             await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(options.orm.schema)}`);
         }
         // 7. Optional Modules
-        if (options.modules?.messageBus ?? options.modules?.taskQueue ?? options.modules?.authentication ?? options.modules?.test) {
+        if (options.modules?.messageBus ?? options.modules?.taskQueue ?? options.modules?.authentication ?? options.modules?.test ?? options.modules?.notification) {
             configureLocalMessageBus({ injector });
         }
         if (options.modules?.taskQueue) {
@@ -86,7 +87,7 @@ export async function setupIntegrationTest(options = {}) {
             configurePostgresLock({ injector });
             await runInInjectionContext(injector, migratePostgresLockSchema);
         }
-        if (options.modules?.signals ?? options.modules?.authentication ?? options.modules?.test) {
+        if (options.modules?.signals ?? options.modules?.authentication ?? options.modules?.test ?? options.modules?.notification) {
             configureDefaultSignalsImplementation();
         }
         if (options.modules?.audit ?? options.modules?.authentication) {
@@ -101,6 +102,10 @@ export async function setupIntegrationTest(options = {}) {
             });
             await runInInjectionContext(injector, migrateAuthenticationSchema);
         }
+        if (options.modules?.notification) {
+            configureNotification({ injector });
+            await runInInjectionContext(injector, migrateNotificationSchema);
+        }
         if (options.modules?.api ?? options.modules?.authentication) {
             configureNodeHttpServer({ trustedProxiesCount: 0, injector });
             configureApiServer({ controllers: [AuthenticationApiController], injector });