@tstdl/base 0.93.100 → 0.93.102

package/notification/server/module.d.ts

@@ -1,7 +1,9 @@
 import { Injector } from '../../injector/index.js';
 import { type DatabaseConfig } from '../../orm/server/index.js';
+import type { NotificationChannel } from '../models/index.js';
 export declare class NotificationConfiguration {
     database?: DatabaseConfig;
+    defaultChannels?: NotificationChannel[];
 }
 export declare function configureNotification({ injector, ...config }: NotificationConfiguration & {
     injector?: Injector;

package/notification/server/module.js

@@ -2,6 +2,7 @@ import { inject, Injector } from '../../injector/index.js';
 import { Database, migrate } from '../../orm/server/index.js';
 export class NotificationConfiguration {
     database;
+    defaultChannels;
 }
 export function configureNotification({ injector, ...config }) {
     const targetInjector = injector ?? Injector;

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

@@ -1,4 +1,5 @@
-import { NotificationLog } from '../../models/notification-log.model.js';
-export interface ChannelProvider {
-    send(notification: NotificationLog): Promise<void>;
+import type { Transaction } from '../../../orm/server/index.js';
+import type { NotificationLog } from '../../models/notification-log.model.js';
+export declare abstract class ChannelProvider {
+    abstract send(notification: NotificationLog, tx?: Transaction): Promise<void>;
 }

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

@@ -1 +1,2 @@
-import { NotificationLog } from '../../models/notification-log.model.js';
+export class ChannelProvider {
+}

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

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

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

@@ -4,19 +4,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { SubjectService } from '../../../authentication/server/subject.service.js';
+import { inject, Singleton } 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 {
+import { ChannelProvider } from './channel-provider.js';
+let EmailChannelProvider = class EmailChannelProvider extends ChannelProvider {
     #mailService = inject(MailService);
-    #userRepository = injectRepository(User);
+    #subjectService = inject(SubjectService);
     #templateService = inject(NotificationTemplateService);
     async send(notification) {
-        const user = await this.#userRepository.loadByQuery({ tenantId: notification.tenantId, id: notification.userId });
+        const user = await this.#subjectService.getUser(notification.tenantId, notification.userId);
         const content = await this.#templateService.render(notification, 'en'); // TODO: get user language
         await this.#mailService.send({
             to: user.email,
@@ -29,6 +27,6 @@ let EmailChannelProvider = class EmailChannelProvider {
     }
 };
 EmailChannelProvider = __decorate([
-    NotificationSingleton()
+    Singleton()
 ], EmailChannelProvider);
 export { EmailChannelProvider };

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

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

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

@@ -4,28 +4,27 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { inject, Singleton } from '../../../injector/index.js';
+import { injectRepository } from '../../../orm/server/index.js';
+import { InAppNotification, toInAppNotificationView } from '../../models/index.js';
 import { NotificationSseService } from '../services/notification-sse.service.js';
-let InAppChannelProvider = class InAppChannelProvider extends Transactional {
+import { ChannelProvider } from './channel-provider.js';
+let InAppChannelProvider = class InAppChannelProvider extends ChannelProvider {
     #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,
-            });
+    async send(notification, tx) {
+        const inApp = await this.#inAppRepository.withOptionalTransaction(tx).insert({
+            tenantId: notification.tenantId,
+            userId: notification.userId,
+            logId: notification.id,
+            readTimestamp: null,
+            archiveTimestamp: null,
         });
-        await this.#sseService.send({ ...inApp, log: notification });
+        const inAppNotificationView = toInAppNotificationView(inApp, notification);
+        await this.#sseService.send(inAppNotificationView);
     }
 };
 InAppChannelProvider = __decorate([
-    NotificationSingleton()
+    Singleton()
 ], InAppChannelProvider);
 export { InAppChannelProvider };

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

@@ -1,4 +1,4 @@
+export * from './channel-provider.js';
 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

@@ -1,4 +1,4 @@
+export * from './channel-provider.js';
 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

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

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

@@ -4,15 +4,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { Singleton } from '../../../injector/index.js';
 import { injectRepository } from '../../../orm/server/index.js';
-import { NotificationLog, WebPushSubscription } from '../../models/index.js';
-import { NotificationSingleton } from '../services/singleton.js';
-let WebPushChannelProvider = class WebPushChannelProvider {
+import { WebPushSubscription } from '../../models/index.js';
+import { ChannelProvider } from './channel-provider.js';
+let WebPushChannelProvider = class WebPushChannelProvider extends ChannelProvider {
     #subscriptionRepository = injectRepository(WebPushSubscription);
-    async send(notification) {
-        const subscriptions = await this.#subscriptionRepository.loadManyByQuery({
+    async send(notification, tx) {
+        const subscriptions = await this.#subscriptionRepository.withOptionalTransaction(tx).loadManyByQuery({
             tenantId: notification.tenantId,
-            userId: notification.userId
+            userId: notification.userId,
         });
         for (const subscription of subscriptions) {
             // TODO: Use a Web Push library (e.g. web-push) to send the notification
@@ -21,6 +22,6 @@ let WebPushChannelProvider = class WebPushChannelProvider {
     }
 };
 WebPushChannelProvider = __decorate([
-    NotificationSingleton()
+    Singleton()
 ], WebPushChannelProvider);
 export { WebPushChannelProvider };

package/notification/server/schemas.d.ts

@@ -1,4 +1,4 @@
-import { InAppNotification, NotificationCategory, NotificationLog, NotificationPreference, WebPushSubscription } from '../models/index.js';
+import { InAppNotification, NotificationLogEntity, NotificationPreference, NotificationType, 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";
@@ -19,7 +19,7 @@ export declare const notificationStatus: import("../../orm/enums.js").PgEnumFrom
     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 notificationType: import("../../orm/server/types.js").PgTableFromType<typeof NotificationType, "notification">;
+export declare const notificationLog: import("../../orm/server/types.js").PgTableFromType<typeof NotificationLogEntity, "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

@@ -1,12 +1,11 @@
 import { databaseSchema } from '../../orm/server/index.js';
-import { NotificationChannel, NotificationPriority, NotificationStatus } from '../enums.js';
-import { InAppNotification, NotificationCategory, NotificationLog, NotificationPreference, WebPushSubscription } from '../models/index.js';
+import { InAppNotification, NotificationChannel, NotificationLogEntity, NotificationPreference, NotificationPriority, NotificationStatus, NotificationType, 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 notificationType = notificationSchema.getTable(NotificationType);
+export const notificationLog = notificationSchema.getTable(NotificationLogEntity);
 export const notificationPreference = notificationSchema.getTable(NotificationPreference);
 export const webPushSubscription = notificationSchema.getTable(WebPushSubscription);

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

@@ -1,8 +1,6 @@
-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-template.service.js';
+export * from './notification-type.service.js';
 export * from './notification.service.js';
-export * from './singleton.js';

package/notification/server/services/index.js

@@ -1,8 +1,6 @@
-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-template.service.js';
+export * from './notification-type.service.js';
 export * from './notification.service.js';
-export * from './singleton.js';

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

@@ -1,8 +1,14 @@
 import type { CancellationSignal } from '../../../cancellation/token.js';
 import { Transactional } from '../../../orm/server/index.js';
+import type { TaskDefinition, TaskDefinitionMap } from '../../../task-queue/index.js';
 import { TaskProcessResult } from '../../../task-queue/task-queue.js';
-import { NotificationChannel } from '../../enums.js';
+import { NotificationChannel } from '../../models/index.js';
 import type { ChannelProvider } from '../providers/channel-provider.js';
+export type NotificationTaskDefinitions = TaskDefinitionMap<{
+    'notification/deliver': TaskDefinition<{
+        notificationId: string;
+    }>;
+}>;
 export declare class NotificationDeliveryWorker extends Transactional {
     #private;
     registerProvider(channel: NotificationChannel, provider: ChannelProvider): void;

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

@@ -4,23 +4,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { inject, Singleton } 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';
+import { isNotNull, isNotNullOrUndefined, isUndefined } from '../../../utils/type-guards.js';
+import { InAppNotification, NotificationChannel, NotificationLogEntity, NotificationPreference, NotificationStatus, NotificationType } from '../../models/index.js';
+import { NotificationConfiguration } from '../module.js';
 let NotificationDeliveryWorker = class NotificationDeliveryWorker extends Transactional {
-    #notificationLogRepository = injectRepository(NotificationLog);
+    #notificationLogRepository = injectRepository(NotificationLogEntity);
     #inAppRepository = injectRepository(InAppNotification);
     #preferenceRepository = injectRepository(NotificationPreference);
-    #categoryRepository = injectRepository(NotificationCategory);
+    #typeRepository = injectRepository(NotificationType);
     #taskQueue = inject((TaskQueue), 'notification');
     #rateLimiter = inject(RateLimiter, 'notification');
     #logger = inject(Logger, 'NotificationDeliveryWorker');
+    #configuration = inject(NotificationConfiguration, undefined, { optional: true });
     #providers = new Map();
     registerProvider(channel, provider) {
         this.#providers.set(channel, provider);
@@ -40,16 +40,19 @@ let NotificationDeliveryWorker = class NotificationDeliveryWorker extends Transa
     }
     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 notification = await this.#notificationLogRepository.withTransaction(tx).load(notificationId);
+            const type = await this.#typeRepository.withTransaction(tx).loadByQuery({ key: notification.type });
             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 (step == 0 && isNotNull(type.throttling)) {
+                const resource = `${notification.tenantId}:${notification.userId}:${type.key}`;
+                const acquired = await this.#rateLimiter.withTransaction(tx).tryAcquire(resource, 1, {
+                    burstCapacity: type.throttling.limit,
+                    refillInterval: type.throttling.interval,
+                });
                 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);
+                    this.#logger.info(`Throttled notification ${notificationId} for user ${notification.userId} in category ${type.key}`);
+                    return TaskProcessResult.RescheduleBy(type.throttling.interval / type.throttling.limit);
                 }
             }
             // 2. Initial Delivery
@@ -57,52 +60,61 @@ let NotificationDeliveryWorker = class NotificationDeliveryWorker extends Transa
                 const preferences = await this.#preferenceRepository.withTransaction(tx).loadManyByQuery({
                     tenantId: notification.tenantId,
                     userId: notification.userId,
-                    categoryId: notification.categoryId,
+                    type: notification.type,
                 });
-                const enabledChannels = preferences.length > 0
-                    ? preferences.filter((p) => p.enabled).map((p) => p.channel)
-                    : [NotificationChannel.InApp];
+                const defaultChannels = this.#configuration?.defaultChannels ?? [NotificationChannel.InApp];
+                const preferenceMap = new Map(preferences.map((p) => [p.channel, p.enabled]));
+                const enabledChannels = new Set();
+                for (const channel of defaultChannels) {
+                    if (preferenceMap.get(channel) !== false) {
+                        enabledChannels.add(channel);
+                    }
+                }
+                for (const preference of preferences) {
+                    if (preference.enabled) {
+                        enabledChannels.add(preference.channel);
+                    }
+                }
                 for (const channel of enabledChannels) {
-                    await this.sendToChannel(notification, channel);
+                    // TODO: what if an error occurs here? partial delivery? Should we use tasks to allow retrying individual channels?
+                    await this.sendToChannel(notification, channel, tx);
                 }
-                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);
+                await this.#notificationLogRepository.withTransaction(tx).update(notificationId, { status: NotificationStatus.Sent, currentStep: 1 });
+                if (isNotNull(type.escalations) && (type.escalations.length > 0)) {
+                    const firstEscalation = type.escalations[0];
+                    return TaskProcessResult.RescheduleBy(firstEscalation.delay);
                 }
                 return TaskProcessResult.Complete();
             }
             // 3. Escalation Steps
-            if (isNotNull(category.escalations) && step > 0 && step <= category.escalations.length) {
-                const rule = category.escalations[step - 1];
+            if (isNotNull(type.escalations) && (step > 0) && (step <= type.escalations.length)) {
+                const rule = type.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)) {
+                const inApp = await this.#inAppRepository.withTransaction(tx).tryLoadByQuery({ tenantId: notification.tenantId, userId: notification.userId, logId: notificationId });
+                if (isNotNullOrUndefined(inApp?.readTimestamp)) {
                     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);
+                await this.sendToChannel(notification, rule.channel, tx);
+                await this.#notificationLogRepository.withTransaction(tx).update(notificationId, { currentStep: step + 1 });
+                if (step < type.escalations.length) {
+                    const nextRule = type.escalations[step];
+                    return TaskProcessResult.RescheduleBy(nextRule.delay);
                 }
             }
             return TaskProcessResult.Complete();
         });
     }
-    async sendToChannel(notification, channel) {
+    async sendToChannel(notification, channel, tx) {
         const provider = this.#providers.get(channel);
         if (isUndefined(provider)) {
             this.#logger.warn(`No provider registered for channel ${channel}`);
             return;
         }
-        await provider.send(notification);
+        await provider.send(notification, tx);
     }
 };
 NotificationDeliveryWorker = __decorate([
-    NotificationSingleton()
+    Singleton()
 ], NotificationDeliveryWorker);
 export { NotificationDeliveryWorker };

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

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

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

@@ -4,22 +4,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { afterResolve, inject, Singleton } 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);
-        });
+    [afterResolve]() {
+        this.#messageBus.allMessages$.subscribe((message) => this.dispatchToLocal(message));
     }
     register(tenantId, userId) {
         const source = new ServerSentEventsSource();
@@ -68,7 +62,6 @@ let NotificationSseService = class NotificationSseService {
     }
 };
 NotificationSseService = __decorate([
-    NotificationSingleton(),
-    __metadata("design:paramtypes", [])
+    Singleton()
 ], NotificationSseService);
 export { NotificationSseService };

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

@@ -1,7 +1,7 @@
 import type { NotificationLog } from '../../models/index.js';
-export interface NotificationTemplate<T extends NotificationLog = NotificationLog> {
+export declare abstract class NotificationTemplate<T extends NotificationLog = NotificationLog> {
     key: string;
-    render(notification: T, language: string): Promise<NotificationContent>;
+    abstract render(notification: T, language: string): Promise<NotificationContent>;
 }
 export type NotificationContent = {
     title: string;

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

@@ -1 +1,3 @@
-export {};
+export class NotificationTemplate {
+    key;
+}

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

@@ -1,4 +1,4 @@
-import type { NotificationLog } from '../../models/index.js';
+import { type NotificationLog } from '../../models/index.js';
 import type { NotificationContent, NotificationTemplate } from './notification-template.js';
 export declare class NotificationTemplateService {
     #private;

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

@@ -4,15 +4,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { Singleton } from '../../../injector/index.js';
+import { injectRepository } from '../../../orm/server/repository.js';
 import { isUndefined } from '../../../utils/type-guards.js';
-import { NotificationSingleton } from './singleton.js';
+import { NotificationType } from '../../models/index.js';
 let NotificationTemplateService = class NotificationTemplateService {
+    #typeRepository = injectRepository(NotificationType);
     #templates = new Map();
     register(template) {
         this.#templates.set(template.key, template);
     }
     async render(notification, language = 'en') {
-        const template = this.#templates.get(notification.type);
+        const type = await this.#typeRepository.loadByQuery({ key: notification.type });
+        const template = this.#templates.get(type.key);
         if (isUndefined(template)) {
             // Fallback for simple notifications without a specific template
             return {
@@ -24,6 +28,6 @@ let NotificationTemplateService = class NotificationTemplateService {
     }
 };
 NotificationTemplateService = __decorate([
-    NotificationSingleton()
+    Singleton()
 ], NotificationTemplateService);
 export { NotificationTemplateService };

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

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

package/notification/server/services/notification-type.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 { Singleton } from '../../../injector/index.js';
+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 { NotificationType } from '../../models/index.js';
+let NotificationTypeService = class NotificationTypeService extends Transactional {
+    repository = injectRepository(NotificationType);
+    async initializeTypes(typeData) {
+        const typeEntries = objectEntries(typeData);
+        const typeMap = await this.transaction(async (tx) => {
+            const dbTypes = await this.repository.withTransaction(tx).loadAll();
+            const enumKeyTypeMap = new Map(dbTypes.map((type) => [type.key, type]));
+            for (const [key, data] of typeEntries) {
+                const type = enumKeyTypeMap.get(key);
+                const throttling = data.throttling ?? null;
+                const escalations = data.escalations ?? null;
+                if (isUndefined(type)) {
+                    const newType = await this.repository.withTransaction(tx).insert({ key, label: data.label, throttling, escalations });
+                    enumKeyTypeMap.set(key, newType);
+                }
+                else if ((type.label != data.label) || (JSON.stringify(type.throttling) != JSON.stringify(throttling)) || (JSON.stringify(type.escalations) != JSON.stringify(escalations))) {
+                    const updatedType = await this.repository.withTransaction(tx).updateByQuery({ id: type.id }, { label: data.label, throttling, escalations });
+                    enumKeyTypeMap.set(key, updatedType);
+                }
+            }
+            return enumKeyTypeMap;
+        });
+        const mappedTypes = typeEntries.map(([key]) => [key, assertDefinedPass(typeMap.get(key), 'Could not map notification type.')]);
+        return fromEntries(mappedTypes);
+    }
+};
+NotificationTypeService = __decorate([
+    Singleton()
+], NotificationTypeService);
+export { NotificationTypeService };

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

@@ -1,6 +1,5 @@
 import { Transactional } from '../../../orm/server/index.js';
-import type { NotificationChannel } from '../../enums.js';
-import { NotificationLog, NotificationPreference } from '../../models/index.js';
+import { NotificationPreference, type InAppNotificationView, type NotificationChannel, type NotificationLog } from '../../models/index.js';
 export declare class NotificationService extends Transactional {
     #private;
     send(notification: NotificationLog): Promise<void>;
@@ -8,10 +7,10 @@ export declare class NotificationService extends Transactional {
         limit?: number;
         offset?: number;
         includeArchived?: boolean;
-    }): Promise<any[]>;
+    }): Promise<InAppNotificationView[]>;
     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>;
+    updatePreference(tenantId: string, userId: string, type: string, channel: NotificationChannel, enabled: boolean): Promise<void>;
+    registerWebPush(tenantId: string, userId: string, endpoint: string, p256dh: Uint8Array<ArrayBuffer>, auth: Uint8Array<ArrayBuffer>): Promise<void>;
 }