@tstdl/base 0.93.120 → 0.93.122

package/notification/server/index.d.ts

@@ -1,5 +1,6 @@
 export * from './api/index.js';
 export * from './module.js';
+export * from './modules/index.js';
 export * from './providers/index.js';
 export * from './schemas.js';
 export * from './services/index.js';

package/notification/server/index.js

@@ -1,5 +1,6 @@
 export * from './api/index.js';
 export * from './module.js';
+export * from './modules/index.js';
 export * from './providers/index.js';
 export * from './schemas.js';
 export * from './services/index.js';

package/notification/server/modules/index.d.ts

@@ -0,0 +1 @@
+export * from './notification-delivery-worker.module.js';

package/notification/server/modules/index.js

@@ -0,0 +1 @@
+export * from './notification-delivery-worker.module.js';

package/notification/server/modules/notification-delivery-worker.module.d.ts

@@ -0,0 +1,9 @@
+import { CancellationSignal } from '../../../cancellation/token.js';
+import { afterResolve } from '../../../injector/index.js';
+import { Module } from '../../../module/module.js';
+export declare class NotificationDeliveryWorkerModule extends Module {
+    #private;
+    constructor();
+    [afterResolve](): void;
+    _run(cancellationSignal: CancellationSignal): Promise<void>;
+}

package/notification/server/modules/notification-delivery-worker.module.js

@@ -0,0 +1,37 @@
+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 { CancellationSignal } from '../../../cancellation/token.js';
+import { afterResolve, inject, Singleton } from '../../../injector/index.js';
+import { Module } from '../../../module/module.js';
+import { NotificationChannel } from '../../../notification/models/index.js';
+import { EmailChannelProvider, InAppChannelProvider, WebPushChannelProvider } from '../providers/index.js';
+import { NotificationDeliveryWorker } from '../services/index.js';
+let NotificationDeliveryWorkerModule = class NotificationDeliveryWorkerModule extends Module {
+    #notificationDeliveryWorker = inject(NotificationDeliveryWorker);
+    #inAppChannelProvider = inject(InAppChannelProvider);
+    #emailChannelProvider = inject(EmailChannelProvider);
+    #webPushChannelProvider = inject(WebPushChannelProvider);
+    constructor() {
+        super('NotificationDeliveryWorker');
+    }
+    [afterResolve]() {
+        this.#notificationDeliveryWorker.registerProvider(NotificationChannel.InApp, this.#inAppChannelProvider);
+        this.#notificationDeliveryWorker.registerProvider(NotificationChannel.Email, this.#emailChannelProvider);
+        this.#notificationDeliveryWorker.registerProvider(NotificationChannel.WebPush, this.#webPushChannelProvider);
+    }
+    async _run(cancellationSignal) {
+        await this.#notificationDeliveryWorker.run(cancellationSignal);
+    }
+};
+NotificationDeliveryWorkerModule = __decorate([
+    Singleton(),
+    __metadata("design:paramtypes", [])
+], NotificationDeliveryWorkerModule);
+export { NotificationDeliveryWorkerModule };

package/notification/server/services/notification-delivery.worker.d.ts

@@ -12,7 +12,7 @@ export type NotificationTaskDefinitions = TaskDefinitionMap<{
 export declare class NotificationDeliveryWorker extends Transactional {
     #private;
     registerProvider(channel: NotificationChannel, provider: ChannelProvider): void;
-    run(cancellationSignal: CancellationSignal): void;
+    run(cancellationSignal: CancellationSignal): Promise<void>;
     deliver(notificationId: string): Promise<TaskProcessResult<void>>;
     private sendToChannel;
 }

package/notification/server/services/notification-delivery.worker.js

@@ -27,8 +27,8 @@ let NotificationDeliveryWorker = class NotificationDeliveryWorker extends Transa
     registerProvider(channel, provider) {
         this.#providers.set(channel, provider);
     }
-    run(cancellationSignal) {
-        this.#taskQueue.process({ cancellationSignal }, async (context) => {
+    async run(cancellationSignal) {
+        await this.#taskQueue.processWorker(cancellationSignal, async (context) => {
             const { notificationId } = context.data;
             try {
                 const result = await this.deliver(notificationId);

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

@@ -1,4 +1,3 @@
-import { afterResolve } from '../../../injector/index.js';
 import { type NewEntity } from '../../../orm/index.js';
 import { Transactional, type Transaction } from '../../../orm/server/index.js';
 import type { TypedOmit } from '../../../types/types.js';
@@ -6,7 +5,6 @@ import { NotificationChannel, NotificationPreference, type InAppNotificationView
 export type NewNotificationData<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> = TypedOmit<NewEntity<NotificationLog<Definitions>>, 'tenantId' | 'id' | 'userId' | 'timestamp' | 'status' | 'currentStep' | 'priority'> & Partial<Pick<NotificationLog<Definitions>, 'priority'>>;
 export declare class NotificationService<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> extends Transactional {
     #private;
-    [afterResolve](): void;
     send(tenantId: string, userId: string, notification: NewNotificationData<Definitions>, options?: {
         transaction: Transaction;
     }): Promise<void>;

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

@@ -7,9 +7,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var _a;
 var NotificationService_1;
 import { and, desc, eq, isNull, lt, or } from 'drizzle-orm';
-import { CancellationSignal } from '../../../cancellation/token.js';
 import { BadRequestError } from '../../../errors/bad-request.error.js';
-import { afterResolve, inject, Singleton } from '../../../injector/index.js';
+import { inject, Singleton } from '../../../injector/index.js';
 import { Logger } from '../../../logger/logger.js';
 import { TRANSACTION_TIMESTAMP } from '../../../orm/index.js';
 import { injectRepository, Transactional } from '../../../orm/server/index.js';
@@ -17,10 +16,8 @@ import { TaskQueue } from '../../../task-queue/task-queue.js';
 import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
 import { isDefined } from '../../../utils/type-guards.js';
 import { InAppNotification, NotificationChannel, NotificationLogEntity, NotificationPreference, NotificationPriority, NotificationStatus, toInAppNotificationView, WebPushSubscription } from '../../models/index.js';
-import { InAppChannelProvider } from '../providers/index.js';
 import { inAppNotification, notificationLog } from '../schemas.js';
 import { NotificationAncillaryService } from './notification-ancillary.service.js';
-import { NotificationDeliveryWorker } from './notification-delivery.worker.js';
 import { NotificationSseService } from './notification-sse.service.js';
 let NotificationService = NotificationService_1 = class NotificationService extends Transactional {
     #notificationLogRepository = injectRepository(NotificationLogEntity);
@@ -28,16 +25,9 @@ let NotificationService = NotificationService_1 = class NotificationService exte
     #preferenceRepository = injectRepository(NotificationPreference);
     #webPushSubscriptionRepository = injectRepository(WebPushSubscription);
     #notificationAncillaryService = inject(NotificationAncillaryService);
-    #deliveryWorker = inject(NotificationDeliveryWorker);
-    #inAppChannelProvider = inject(InAppChannelProvider);
     #taskQueue = inject((TaskQueue), 'notification');
     #sseService = inject(NotificationSseService);
     #logger = inject(Logger, NotificationService_1.name);
-    #cancellationSignal = inject(CancellationSignal);
-    [afterResolve]() {
-        this.#deliveryWorker.registerProvider(NotificationChannel.InApp, this.#inAppChannelProvider);
-        this.#deliveryWorker.run(this.#cancellationSignal);
-    }
     async send(tenantId, userId, notification, options) {
         await this.useTransaction(options?.transaction, async (tx) => {
             const notificationToInsert = {

package/package.json

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

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

@@ -300,6 +300,9 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
         forceDequeue?: boolean;
         types?: Type[];
     }): AsyncIterableIterator<TaskOfType<Definitions, Type>[]>;
+    /**
+     * Starts processing tasks with the provided worker function in the background until the cancellation signal is triggered.
+     */
     process<Type extends TaskTypes<Definitions>>({ concurrency, cancellationSignal, types, forceDequeue }: {
         concurrency?: number;
         cancellationSignal: CancellationSignal;
@@ -309,5 +312,11 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
     protected getTransactionalContextData(): QueueConfig & {
         namespace: string;
     };
-    private processWorker;
+    /**
+     * Starts processing tasks with the provided worker function in the foreground until the cancellation signal is triggered.
+     */
+    processWorker<Type extends TaskTypes<Definitions>>(cancellationSignal: CancellationSignal, handler: ProcessWorker<Definitions, Type>, options?: {
+        types?: Type[];
+        forceDequeue?: boolean;
+    }): Promise<void>;
 }

package/task-queue/task-queue.js

@@ -83,6 +83,9 @@ export class TaskQueue extends Transactional {
     batch() {
         return new TaskQueueEnqueueBatch(this);
     }
+    /**
+     * Starts processing tasks with the provided worker function in the background until the cancellation signal is triggered.
+     */
     process({ concurrency = 1, cancellationSignal, types, forceDequeue }, handler) {
         for (let i = 0; i < concurrency; i++) {
             void this.processWorker(cancellationSignal, handler, { types, forceDequeue });
@@ -91,6 +94,9 @@ export class TaskQueue extends Transactional {
     getTransactionalContextData() {
         return this.config;
     }
+    /**
+     * Starts processing tasks with the provided worker function in the foreground until the cancellation signal is triggered.
+     */
     async processWorker(cancellationSignal, handler, options) {
         for await (const task of this.getConsumer(cancellationSignal, options)) {
             const taskToken = cancellationSignal.createChild();