@tstdl/base 0.93.97 → 0.93.99

package/notification/server/module.js

@@ -0,0 +1,21 @@
+import { inject, Injector } from '../../injector/index.js';
+import { Database, migrate } from '../../orm/server/index.js';
+export class NotificationConfiguration {
+    database;
+}
+export function configureNotification({ injector, ...config }) {
+    const targetInjector = injector ?? Injector;
+    targetInjector.register(NotificationConfiguration, { useValue: config });
+}
+/**
+ * Migrates the notification schema.
+ */
+export async function migrateNotificationSchema() {
+    const connection = inject(NotificationConfiguration, undefined, { optional: true })?.database?.connection;
+    const database = inject(Database, connection);
+    await migrate(database, {
+        migrationsSchema: 'notification',
+        migrationsTable: '_migrations',
+        migrationsFolder: import.meta.resolve('./drizzle'),
+    });
+}

package/notification/server/providers/channel-provider.d.ts

@@ -0,0 +1,4 @@
+import { NotificationLog } from '../../models/notification-log.model.js';
+export interface ChannelProvider {
+    send(notification: NotificationLog): Promise<void>;
+}

package/notification/server/providers/channel-provider.js

@@ -0,0 +1 @@
+import { NotificationLog } from '../../models/notification-log.model.js';

package/notification/server/providers/email-channel-provider.d.ts

@@ -0,0 +1,6 @@
+import { NotificationLog } from '../../models/index.js';
+import type { ChannelProvider } from './channel-provider.js';
+export declare class EmailChannelProvider implements ChannelProvider {
+    #private;
+    send(notification: NotificationLog): Promise<void>;
+}

package/notification/server/providers/email-channel-provider.js

@@ -0,0 +1,34 @@
+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 { MailService } from '../../../mail/mail.service.js';
+import { User } from '../../../authentication/models/user.model.js';
+import { injectRepository } from '../../../orm/server/index.js';
+import { NotificationLog } from '../../models/index.js';
+import { NotificationSingleton } from '../services/singleton.js';
+import { NotificationTemplateService } from '../services/notification-template.service.js';
+let EmailChannelProvider = class EmailChannelProvider {
+    #mailService = inject(MailService);
+    #userRepository = injectRepository(User);
+    #templateService = inject(NotificationTemplateService);
+    async send(notification) {
+        const user = await this.#userRepository.loadByQuery({ tenantId: notification.tenantId, id: notification.userId });
+        const content = await this.#templateService.render(notification, 'en'); // TODO: get user language
+        await this.#mailService.send({
+            to: user.email,
+            subject: content.emailSubject ?? content.title,
+            content: {
+                text: content.emailText ?? content.message,
+                html: content.emailHtml,
+            },
+        });
+    }
+};
+EmailChannelProvider = __decorate([
+    NotificationSingleton()
+], EmailChannelProvider);
+export { EmailChannelProvider };

package/notification/server/providers/in-app-channel-provider.d.ts

@@ -0,0 +1,7 @@
+import { Transactional } from '../../../orm/server/index.js';
+import { NotificationLog } from '../../models/index.js';
+import type { ChannelProvider } from './channel-provider.js';
+export declare class InAppChannelProvider extends Transactional implements ChannelProvider {
+    #private;
+    send(notification: NotificationLog): Promise<void>;
+}

package/notification/server/providers/in-app-channel-provider.js

@@ -0,0 +1,31 @@
+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 { InAppNotification, NotificationLog } from '../../models/index.js';
+import { NotificationSingleton } from '../services/singleton.js';
+import { NotificationSseService } from '../services/notification-sse.service.js';
+let InAppChannelProvider = class InAppChannelProvider extends Transactional {
+    #inAppRepository = injectRepository(InAppNotification);
+    #sseService = inject(NotificationSseService);
+    async send(notification) {
+        const inApp = await this.transaction(async (tx) => {
+            return await this.#inAppRepository.withTransaction(tx).insert({
+                tenantId: notification.tenantId,
+                userId: notification.userId,
+                logId: notification.id,
+                readAt: null,
+                archivedAt: null,
+            });
+        });
+        await this.#sseService.send({ ...inApp, log: notification });
+    }
+};
+InAppChannelProvider = __decorate([
+    NotificationSingleton()
+], InAppChannelProvider);
+export { InAppChannelProvider };

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

@@ -0,0 +1,4 @@
+export * from './email-channel-provider.js';
+export * from './in-app-channel-provider.js';
+export * from './web-push-channel-provider.js';
+export * from './channel-provider.js';

package/notification/server/providers/index.js

@@ -0,0 +1,4 @@
+export * from './email-channel-provider.js';
+export * from './in-app-channel-provider.js';
+export * from './web-push-channel-provider.js';
+export * from './channel-provider.js';

package/notification/server/providers/web-push-channel-provider.d.ts

@@ -0,0 +1,6 @@
+import { NotificationLog } from '../../models/index.js';
+import type { ChannelProvider } from './channel-provider.js';
+export declare class WebPushChannelProvider implements ChannelProvider {
+    #private;
+    send(notification: NotificationLog): Promise<void>;
+}

package/notification/server/providers/web-push-channel-provider.js

@@ -0,0 +1,26 @@
+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 { injectRepository } from '../../../orm/server/index.js';
+import { NotificationLog, WebPushSubscription } from '../../models/index.js';
+import { NotificationSingleton } from '../services/singleton.js';
+let WebPushChannelProvider = class WebPushChannelProvider {
+    #subscriptionRepository = injectRepository(WebPushSubscription);
+    async send(notification) {
+        const subscriptions = await this.#subscriptionRepository.loadManyByQuery({
+            tenantId: notification.tenantId,
+            userId: notification.userId
+        });
+        for (const subscription of subscriptions) {
+            // TODO: Use a Web Push library (e.g. web-push) to send the notification
+            // Using subscription.endpoint, subscription.p256dh, subscription.auth
+        }
+    }
+};
+WebPushChannelProvider = __decorate([
+    NotificationSingleton()
+], WebPushChannelProvider);
+export { WebPushChannelProvider };

package/notification/server/schemas.d.ts

@@ -0,0 +1,25 @@
+import { InAppNotification, NotificationCategory, NotificationLog, NotificationPreference, WebPushSubscription } from '../models/index.js';
+export declare const notificationSchema: import("../../orm/server/index.js").DatabaseSchema<"notification">;
+export declare const notificationChannel: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly InApp: "in-app";
+    readonly Email: "email";
+    readonly WebPush: "web-push";
+}>;
+export declare const notificationPriority: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Low: "low";
+    readonly Medium: "medium";
+    readonly High: "high";
+    readonly Urgent: "urgent";
+}>;
+export declare const notificationStatus: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Pending: "pending";
+    readonly Sent: "sent";
+    readonly Delivered: "delivered";
+    readonly Read: "read";
+    readonly Failed: "failed";
+}>;
+export declare const inAppNotification: import("../../orm/server/types.js").PgTableFromType<typeof InAppNotification, "notification">;
+export declare const notificationCategory: import("../../orm/server/types.js").PgTableFromType<typeof NotificationCategory, "notification">;
+export declare const notificationLog: import("../../orm/server/types.js").PgTableFromType<typeof NotificationLog, "notification">;
+export declare const notificationPreference: import("../../orm/server/types.js").PgTableFromType<typeof NotificationPreference, "notification">;
+export declare const webPushSubscription: import("../../orm/server/types.js").PgTableFromType<typeof WebPushSubscription, "notification">;

package/notification/server/schemas.js

@@ -0,0 +1,12 @@
+import { databaseSchema } from '../../orm/server/index.js';
+import { NotificationChannel, NotificationPriority, NotificationStatus } from '../enums.js';
+import { InAppNotification, NotificationCategory, NotificationLog, NotificationPreference, WebPushSubscription } from '../models/index.js';
+export const notificationSchema = databaseSchema('notification');
+export const notificationChannel = notificationSchema.getEnum(NotificationChannel);
+export const notificationPriority = notificationSchema.getEnum(NotificationPriority);
+export const notificationStatus = notificationSchema.getEnum(NotificationStatus);
+export const inAppNotification = notificationSchema.getTable(InAppNotification);
+export const notificationCategory = notificationSchema.getTable(NotificationCategory);
+export const notificationLog = notificationSchema.getTable(NotificationLog);
+export const notificationPreference = notificationSchema.getTable(NotificationPreference);
+export const webPushSubscription = notificationSchema.getTable(WebPushSubscription);

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

@@ -0,0 +1,8 @@
+export * from './notification-category.service.js';
+export * from './notification-delivery.task.js';
+export * from './notification-delivery.worker.js';
+export * from './notification-sse.service.js';
+export * from './notification-template.service.js';
+export * from './notification-template.js';
+export * from './notification.service.js';
+export * from './singleton.js';

package/notification/server/services/index.js

@@ -0,0 +1,8 @@
+export * from './notification-category.service.js';
+export * from './notification-delivery.task.js';
+export * from './notification-delivery.worker.js';
+export * from './notification-sse.service.js';
+export * from './notification-template.service.js';
+export * from './notification-template.js';
+export * from './notification.service.js';
+export * from './singleton.js';

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

@@ -0,0 +1,11 @@
+import { Transactional } from '../../../orm/server/index.js';
+import { NotificationCategory, type EscalationRule, type ThrottlingConfig } from '../../models/index.js';
+export type CategoryInitializationData = {
+    label: string;
+    throttling?: ThrottlingConfig;
+    escalations?: EscalationRule[];
+};
+export declare class NotificationCategoryService extends Transactional {
+    readonly repository: import("../../../orm/server/index.js").EntityRepository<NotificationCategory>;
+    initializeCategories<T extends string>(tenantId: string, categoryData: Record<T, CategoryInitializationData>): Promise<Record<T, NotificationCategory>>;
+}

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

@@ -0,0 +1,41 @@
+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 { injectRepository, Transactional } from '../../../orm/server/index.js';
+import { fromEntries, objectEntries } from '../../../utils/object/index.js';
+import { assertDefinedPass, isUndefined } from '../../../utils/type-guards.js';
+import { NotificationCategory } from '../../models/index.js';
+import { NotificationSingleton } from './singleton.js';
+let NotificationCategoryService = class NotificationCategoryService extends Transactional {
+    repository = injectRepository(NotificationCategory);
+    async initializeCategories(tenantId, categoryData) {
+        const categoryEntries = objectEntries(categoryData);
+        const categoryMap = await this.transaction(async (tx) => {
+            const dbCategories = await this.repository.withTransaction(tx).loadManyByQuery({ tenantId });
+            const enumKeyCategoryMap = new Map(dbCategories.map((category) => [category.key, category]));
+            for (const [key, data] of categoryEntries) {
+                const category = enumKeyCategoryMap.get(key);
+                const throttling = data.throttling ?? null;
+                const escalations = data.escalations ?? null;
+                if (isUndefined(category)) {
+                    const newCategory = await this.repository.withTransaction(tx).insert({ tenantId, key, label: data.label, throttling, escalations });
+                    enumKeyCategoryMap.set(key, newCategory);
+                }
+                else if ((category.label != data.label) || (JSON.stringify(category.throttling) != JSON.stringify(throttling)) || (JSON.stringify(category.escalations) != JSON.stringify(escalations))) {
+                    const updatedCategory = await this.repository.withTransaction(tx).updateByQuery({ tenantId, id: category.id }, { label: data.label, throttling, escalations });
+                    enumKeyCategoryMap.set(key, updatedCategory);
+                }
+            }
+            return enumKeyCategoryMap;
+        });
+        const mappedCategories = categoryEntries.map(([key]) => [key, assertDefinedPass(categoryMap.get(key), 'Could not map notification category.')]);
+        return fromEntries(mappedCategories);
+    }
+};
+NotificationCategoryService = __decorate([
+    NotificationSingleton()
+], NotificationCategoryService);
+export { NotificationCategoryService };

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

@@ -0,0 +1,9 @@
+export type NotificationTaskDefinitions = {
+    'notification/deliver': {
+        data: {
+            notificationId: string;
+        };
+        state: void;
+        result: void;
+    };
+};

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

@@ -0,0 +1 @@
+import { NotificationLog } from '../../models/index.js';

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

@@ -0,0 +1,12 @@
+import type { CancellationSignal } from '../../../cancellation/token.js';
+import { Transactional } from '../../../orm/server/index.js';
+import { TaskProcessResult } from '../../../task-queue/task-queue.js';
+import { NotificationChannel } from '../../enums.js';
+import type { ChannelProvider } from '../providers/channel-provider.js';
+export declare class NotificationDeliveryWorker extends Transactional {
+    #private;
+    registerProvider(channel: NotificationChannel, provider: ChannelProvider): void;
+    run(cancellationSignal: CancellationSignal): void;
+    deliver(notificationId: string): Promise<TaskProcessResult<void>>;
+    private sendToChannel;
+}

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

@@ -0,0 +1,108 @@
+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 { Logger } from '../../../logger/logger.js';
+import { injectRepository, Transactional } from '../../../orm/server/index.js';
+import { RateLimiter } from '../../../rate-limit/rate-limiter.js';
+import { TaskProcessResult, TaskQueue } from '../../../task-queue/task-queue.js';
+import { isDefined, isNotNull, isUndefined } from '../../../utils/type-guards.js';
+import { NotificationChannel, NotificationStatus } from '../../enums.js';
+import { InAppNotification, NotificationCategory, NotificationLog, NotificationPreference } from '../../models/index.js';
+import { NotificationSingleton } from './singleton.js';
+let NotificationDeliveryWorker = class NotificationDeliveryWorker extends Transactional {
+    #notificationLogRepository = injectRepository(NotificationLog);
+    #inAppRepository = injectRepository(InAppNotification);
+    #preferenceRepository = injectRepository(NotificationPreference);
+    #categoryRepository = injectRepository(NotificationCategory);
+    #taskQueue = inject((TaskQueue), 'notification');
+    #rateLimiter = inject(RateLimiter, 'notification');
+    #logger = inject(Logger, 'NotificationDeliveryWorker');
+    #providers = new Map();
+    registerProvider(channel, provider) {
+        this.#providers.set(channel, provider);
+    }
+    run(cancellationSignal) {
+        this.#taskQueue.process({ cancellationSignal }, async (context) => {
+            const { notificationId } = context.data;
+            try {
+                const result = await this.deliver(notificationId);
+                return result;
+            }
+            catch (error) {
+                this.#logger.error(`Failed to deliver notification ${notificationId}`, error);
+                return TaskProcessResult.Fail(error);
+            }
+        });
+    }
+    async deliver(notificationId) {
+        return await this.transaction(async (tx) => {
+            const notification = await this.#notificationLogRepository.withTransaction(tx).loadByQuery({ id: notificationId });
+            const category = await this.#categoryRepository.withTransaction(tx).loadByQuery({ id: notification.categoryId });
+            const step = notification.currentStep;
+            // 1. Throttling
+            if (step == 0 && isNotNull(category.throttling)) {
+                const resource = `${notification.tenantId}:${notification.userId}:${category.key}`;
+                const acquired = await this.#rateLimiter.withTransaction(tx).tryAcquire(resource);
+                if (!acquired) {
+                    this.#logger.info(`Throttled notification ${notificationId} for user ${notification.userId} in category ${category.key}`);
+                    return TaskProcessResult.RescheduleBy(category.throttling.intervalMs / category.throttling.limit);
+                }
+            }
+            // 2. Initial Delivery
+            if (step == 0) {
+                const preferences = await this.#preferenceRepository.withTransaction(tx).loadManyByQuery({
+                    tenantId: notification.tenantId,
+                    userId: notification.userId,
+                    categoryId: notification.categoryId,
+                });
+                const enabledChannels = preferences.length > 0
+                    ? preferences.filter((p) => p.enabled).map((p) => p.channel)
+                    : [NotificationChannel.InApp];
+                for (const channel of enabledChannels) {
+                    await this.sendToChannel(notification, channel);
+                }
+                await this.#notificationLogRepository.withTransaction(tx).updateByQuery({ id: notificationId }, { status: NotificationStatus.Sent, currentStep: 1 });
+                // Check for escalation
+                if (isNotNull(category.escalations) && category.escalations.length > 0) {
+                    const firstEscalation = category.escalations[0];
+                    return TaskProcessResult.RescheduleBy(firstEscalation.delayMs);
+                }
+                return TaskProcessResult.Complete();
+            }
+            // 3. Escalation Steps
+            if (isNotNull(category.escalations) && step > 0 && step <= category.escalations.length) {
+                const rule = category.escalations[step - 1];
+                // Check if already read (for In-App escalation)
+                const inApp = await this.#inAppRepository.withTransaction(tx).tryLoadByQuery({ logId: notificationId });
+                if (isDefined(inApp?.readAt)) {
+                    this.#logger.debug(`Notification ${notificationId} already read, skipping escalation step ${step}`);
+                    return TaskProcessResult.Complete();
+                }
+                await this.sendToChannel(notification, rule.channel);
+                const nextStep = step + 1;
+                await this.#notificationLogRepository.withTransaction(tx).updateByQuery({ id: notificationId }, { currentStep: nextStep });
+                if (step < category.escalations.length) {
+                    const nextRule = category.escalations[step];
+                    return TaskProcessResult.RescheduleBy(nextRule.delayMs);
+                }
+            }
+            return TaskProcessResult.Complete();
+        });
+    }
+    async sendToChannel(notification, channel) {
+        const provider = this.#providers.get(channel);
+        if (isUndefined(provider)) {
+            this.#logger.warn(`No provider registered for channel ${channel}`);
+            return;
+        }
+        await provider.send(notification);
+    }
+};
+NotificationDeliveryWorker = __decorate([
+    NotificationSingleton()
+], NotificationDeliveryWorker);
+export { NotificationDeliveryWorker };

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

@@ -0,0 +1,13 @@
+import { ServerSentEventsSource } from '../../../sse/server-sent-events-source.js';
+import type { InAppNotification } from '../../models/index.js';
+type NotificationMessage = InAppNotification & {
+    log?: any;
+};
+export declare class NotificationSseService {
+    #private;
+    constructor();
+    register(tenantId: string, userId: string): ServerSentEventsSource;
+    send(notification: NotificationMessage): Promise<void>;
+    private dispatchToLocal;
+}
+export {};

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

@@ -0,0 +1,74 @@
+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 { inject } from '../../../injector/index.js';
+import { MessageBusProvider } from '../../../message-bus/message-bus-provider.js';
+import { toObservable } from '../../../signals/api.js';
+import { ServerSentEventsSource } from '../../../sse/server-sent-events-source.js';
+import { NotificationSingleton } from './singleton.js';
+let NotificationSseService = class NotificationSseService {
+    #messageBusProvider = inject(MessageBusProvider);
+    #messageBus = this.#messageBusProvider.get('notification');
+    #sources = new Map(); // tenantId -> userId -> Sources
+    constructor() {
+        this.#messageBus.allMessages$.subscribe((message) => {
+            this.dispatchToLocal(message);
+        });
+    }
+    register(tenantId, userId) {
+        const source = new ServerSentEventsSource();
+        let tenantMap = this.#sources.get(tenantId);
+        if (tenantMap == null) {
+            tenantMap = new Map();
+            this.#sources.set(tenantId, tenantMap);
+        }
+        let userSources = tenantMap.get(userId);
+        if (userSources == null) {
+            userSources = new Set();
+            tenantMap.set(userId, userSources);
+        }
+        userSources.add(source);
+        toObservable(source.closed).subscribe((closed) => {
+            if (closed) {
+                const currentTenantMap = this.#sources.get(tenantId);
+                const currentUserSources = currentTenantMap?.get(userId);
+                if (currentUserSources) {
+                    currentUserSources.delete(source);
+                    if (currentUserSources.size == 0) {
+                        currentTenantMap?.delete(userId);
+                    }
+                }
+                if (currentTenantMap?.size == 0) {
+                    this.#sources.delete(tenantId);
+                }
+            }
+        });
+        return source;
+    }
+    async send(notification) {
+        await this.#messageBus.publish(notification);
+    }
+    dispatchToLocal(notification) {
+        const tenantMap = this.#sources.get(notification.tenantId);
+        const userSources = tenantMap?.get(notification.userId);
+        if (userSources != null) {
+            for (const source of userSources) {
+                void source.sendJson({
+                    name: 'notification',
+                    data: notification,
+                });
+            }
+        }
+    }
+};
+NotificationSseService = __decorate([
+    NotificationSingleton(),
+    __metadata("design:paramtypes", [])
+], NotificationSseService);
+export { NotificationSseService };

package/notification/server/services/notification-template.d.ts

@@ -0,0 +1,12 @@
+import type { NotificationLog } from '../../models/index.js';
+export interface NotificationTemplate<T extends NotificationLog = NotificationLog> {
+    key: string;
+    render(notification: T, language: string): Promise<NotificationContent>;
+}
+export type NotificationContent = {
+    title: string;
+    message: string;
+    emailSubject?: string;
+    emailHtml?: string;
+    emailText?: string;
+};

package/notification/server/services/notification-template.js

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

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

@@ -0,0 +1,7 @@
+import type { NotificationLog } from '../../models/index.js';
+import type { NotificationContent, NotificationTemplate } from './notification-template.js';
+export declare class NotificationTemplateService {
+    #private;
+    register(template: NotificationTemplate<any>): void;
+    render(notification: NotificationLog, language?: string): Promise<NotificationContent>;
+}

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

@@ -0,0 +1,29 @@
+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 { isUndefined } from '../../../utils/type-guards.js';
+import { NotificationSingleton } from './singleton.js';
+let NotificationTemplateService = class NotificationTemplateService {
+    #templates = new Map();
+    register(template) {
+        this.#templates.set(template.key, template);
+    }
+    async render(notification, language = 'en') {
+        const template = this.#templates.get(notification.type);
+        if (isUndefined(template)) {
+            // Fallback for simple notifications without a specific template
+            return {
+                title: 'New Notification',
+                message: 'You have a new notification.',
+            };
+        }
+        return await template.render(notification, language);
+    }
+};
+NotificationTemplateService = __decorate([
+    NotificationSingleton()
+], NotificationTemplateService);
+export { NotificationTemplateService };

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

@@ -0,0 +1,17 @@
+import { Transactional } from '../../../orm/server/index.js';
+import type { NotificationChannel } from '../../enums.js';
+import { NotificationLog, NotificationPreference } from '../../models/index.js';
+export declare class NotificationService extends Transactional {
+    #private;
+    send(notification: NotificationLog): Promise<void>;
+    listInApp(tenantId: string, userId: string, options?: {
+        limit?: number;
+        offset?: number;
+        includeArchived?: boolean;
+    }): Promise<any[]>;
+    markRead(tenantId: string, userId: string, id: string): Promise<void>;
+    archive(tenantId: string, userId: string, id: string): Promise<void>;
+    getPreferences(tenantId: string, userId: string): Promise<NotificationPreference[]>;
+    updatePreference(tenantId: string, userId: string, categoryId: string, channel: NotificationChannel, enabled: boolean): Promise<void>;
+    registerWebPush(tenantId: string, userId: string, endpoint: string, p256dh: string, auth: string): Promise<void>;
+}