@tstdl/base 0.93.99 → 0.93.101

package/authentication/client/authentication.service.d.ts

@@ -25,7 +25,7 @@ export declare class AuthenticationClientService<AdditionalTokenPayload extends
     private readonly forceRefreshToken;
     private readonly lock;
     private readonly logger;
-    private readonly disposeToken;
+    private readonly disposeSignal;
     private clockOffset;
     private refreshLoopPromise;
     /**

package/authentication/client/authentication.service.js

@@ -7,23 +7,24 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Subject, filter, firstValueFrom, race, timer } from 'rxjs';
+import { Subject, filter, firstValueFrom, map, race, timer } from 'rxjs';
 import { CancellationSignal, CancellationToken } from '../../cancellation/token.js';
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { ForbiddenError } from '../../errors/forbidden.error.js';
+import { formatError } from '../../errors/index.js';
 import { InvalidTokenError } from '../../errors/invalid-token.error.js';
 import { NotFoundError } from '../../errors/not-found.error.js';
 import { NotSupportedError } from '../../errors/not-supported.error.js';
 import { UnauthorizedError } from '../../errors/unauthorized.error.js';
+import { HttpError } from '../../http/index.js';
 import { Singleton, afterResolve, inject } from '../../injector/index.js';
 import { Lock } from '../../lock/index.js';
 import { Logger } from '../../logger/index.js';
 import { MessageBus } from '../../message-bus/index.js';
 import { computed, signal, toObservable } from '../../signals/api.js';
 import { currentTimestampSeconds } from '../../utils/date-time.js';
-import { formatError } from '../../errors/index.js';
 import { timeout } from '../../utils/timing.js';
-import { assertDefinedPass, isDefined, isNotFunction, isNullOrUndefined, isUndefined } from '../../utils/type-guards.js';
+import { assertDefinedPass, isDefined, isInstanceOf, isNotFunction, isNullOrUndefined, isUndefined } from '../../utils/type-guards.js';
 import { millisecondsPerMinute, millisecondsPerSecond } from '../../utils/units.js';
 import { AUTHENTICATION_API_CLIENT, INITIAL_AUTHENTICATION_DATA } from './tokens.js';
 const tokenStorageKey = 'AuthenticationService:token';
@@ -69,7 +70,7 @@ let AuthenticationClientService = class AuthenticationClientService {
     forceRefreshToken = new CancellationToken();
     lock = inject(Lock, refreshLockResource);
     logger = inject(Logger, 'AuthenticationService');
-    disposeToken = inject(CancellationSignal).createChild();
+    disposeSignal = inject(CancellationSignal).createChild();
     clockOffset = 0;
     refreshLoopPromise;
     /**
@@ -188,7 +189,7 @@ let AuthenticationClientService = class AuthenticationClientService {
      * Stops refresh loop and completes subjects.
      */
     async dispose() {
-        this.disposeToken.set();
+        this.disposeSignal.set();
         await this.refreshLoopPromise;
         this.errorSubject.complete();
         await this.loggedOutBus.dispose();
@@ -375,13 +376,13 @@ let AuthenticationClientService = class AuthenticationClientService {
         if (this.isLoggedIn()) {
             await this.syncClock();
         }
-        while (this.disposeToken.isUnset) {
+        while (this.disposeSignal.isUnset) {
             try {
                 const token = this.token();
                 if (isUndefined(token)) {
                     // Wait for login or dispose.
                     // We ignore forceRefreshToken here because we can't refresh without a token.
-                    await firstValueFrom(race([this.definedToken$, this.disposeToken]), { defaultValue: undefined });
+                    await firstValueFrom(race([this.definedToken$, this.disposeSignal]), { defaultValue: undefined });
                     continue;
                 }
                 const now = this.estimatedServerTimestampSeconds();
@@ -402,13 +403,20 @@ let AuthenticationClientService = class AuthenticationClientService {
                     if (!lockAcquired) {
                         // Lock held by another instance, wait 5 seconds or until state/token changes.
                         // We ignore forceRefreshToken here to avoid a busy loop if it is already set.
-                        await firstValueFrom(race([timer(5000), this.disposeToken, this.token$.pipe(filter((t) => t !== token))]), { defaultValue: undefined });
+                        const changeReason = await firstValueFrom(race([
+                            timer(5000).pipe(map(() => 'timer')),
+                            this.token$.pipe(filter((t) => t !== token), map(() => 'token')),
+                            this.disposeSignal,
+                        ]), { defaultValue: undefined });
+                        if (changeReason == 'token') {
+                            this.forceRefreshToken.unset();
+                        }
                         continue;
                     }
                 }
                 const delay = Math.min(maxRefreshDelay, ((this.token()?.exp ?? 0) - this.estimatedServerTimestampSeconds() - refreshBufferSeconds) * millisecondsPerSecond);
                 const wakeUpSignals = [
-                    this.disposeToken,
+                    this.disposeSignal,
                     this.token$.pipe(filter((t) => t != token)),
                 ];
                 if (!forceRefresh) {
@@ -423,14 +431,18 @@ let AuthenticationClientService = class AuthenticationClientService {
             }
             catch (error) {
                 this.logger.error(error);
-                await firstValueFrom(race([timer(5000), this.disposeToken, this.token$.pipe(filter((t) => t !== this.token()))]), { defaultValue: undefined });
+                const initialToken = this.token();
+                await firstValueFrom(race([timer(5000), this.disposeSignal, this.token$.pipe(filter((t) => t != initialToken))]), { defaultValue: undefined });
+                await timeout(2500);
             }
         }
     }
     async handleRefreshError(error) {
         this.logger.error(error);
         this.errorSubject.next(error);
-        if (unrecoverableErrors.some((errorType) => error instanceof errorType)) {
+        const isUnrecoverable = unrecoverableErrors.some((errorType) => isInstanceOf(error, errorType))
+            || (error instanceof HttpError && ((error.response?.statusCode == 401) || (error.response?.statusCode == 404)));
+        if (isUnrecoverable) {
             await this.logout();
         }
     }

package/file/mime-type.d.ts

@@ -1,3 +1,3 @@
-export declare function getMimeType(file: string | Uint8Array | ReadableStream<Uint8Array>): Promise<string | undefined>;
-export declare function getMimeType<F>(file: string | Uint8Array | ReadableStream<Uint8Array>, fallback: F): Promise<string | F>;
+export declare function getMimeType(file: Uint8Array | ReadableStream<Uint8Array>): Promise<string | undefined>;
+export declare function getMimeType<F>(file: Uint8Array | ReadableStream<Uint8Array>, fallback: F): Promise<string | F>;
 export declare function getMimeTypeExtensions(mimeType: string): string[];

package/file/mime-type.js

@@ -1,10 +1,9 @@
-import { fileTypeFromBuffer, fileTypeFromFile, fileTypeFromStream } from 'file-type/node';
-import { isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
+import { fileTypeFromBuffer, fileTypeFromStream } from 'file-type';
 import { match } from 'ts-pattern';
+import { isReadableStream, isUint8Array } from '../utils/type-guards.js';
 import { mimeTypesMap } from './mime-types.js';
 export async function getMimeType(file, fallback) {
     const result = await match(file)
-        .when(isString, async (f) => await fileTypeFromFile(f))
         .when(isUint8Array, async (f) => await fileTypeFromBuffer(f))
         .when((isReadableStream), async (f) => await fileTypeFromStream(f))
         .exhaustive();

package/file/server/index.d.ts

@@ -1 +1,2 @@
+export * from './mime-type.js';
 export * from './temporary-file.js';

package/file/server/index.js

@@ -1 +1,2 @@
+export * from './mime-type.js';
 export * from './temporary-file.js';

package/file/server/mime-type.d.ts

@@ -0,0 +1,2 @@
+export declare function getMimeTypeFromFile(path: string): Promise<string | undefined>;
+export declare function getMimeTypeFromFile<F>(path: string, fallback: F): Promise<string | F>;

package/file/server/mime-type.js

@@ -0,0 +1,5 @@
+import { fileTypeFromFile } from 'file-type/node';
+export async function getMimeTypeFromFile(path, fallback) {
+    const result = await fileTypeFromFile(path);
+    return result?.mime ?? fallback;
+}

package/notification/api/index.d.ts

@@ -0,0 +1 @@
+export * from './notification.api.js';

package/notification/api/index.js

@@ -0,0 +1 @@
+export * from './notification.api.js';

package/notification/api/notification.api.d.ts

@@ -1,4 +1,5 @@
 import { ServerSentEvents } from '../../sse/server-sent-events.js';
+import { InAppNotificationView } from '../models/in-app-notification.model.js';
 export declare const notificationApiDefinition: {
     resource: string;
     endpoints: {
@@ -15,16 +16,7 @@ export declare const notificationApiDefinition: {
                 limit?: number | undefined;
                 includeArchived?: boolean | undefined;
             }>;
-            result: import("../../schema/index.js").ArraySchema<{
-                type: string;
-                id: string;
-                createdAt: number;
-                priority: string;
-                logId: string;
-                payload?: {} | undefined;
-                readAt?: number | undefined;
-                archivedAt?: number | undefined;
-            }>;
+            result: import("../../schema/index.js").ArraySchema<InAppNotificationView>;
         };
         markRead: {
             resource: string;
@@ -46,17 +38,17 @@ export declare const notificationApiDefinition: {
             resource: string;
             method: "GET";
             result: import("../../schema/index.js").ArraySchema<{
+                type: string;
                 enabled: boolean;
-                channel: string;
-                categoryId: string;
+                channel: "email" | "in-app" | "web-push";
             }>;
         };
         updatePreference: {
             resource: string;
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly categoryId: string;
-                readonly channel: string;
+                readonly type: string;
+                readonly channel: "email" | "in-app" | "web-push";
                 readonly enabled: boolean;
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
@@ -67,8 +59,8 @@ export declare const notificationApiDefinition: {
             parameters: import("../../schema/index.js").ObjectSchema<{
                 readonly endpoint: string;
                 readonly keys: {
-                    auth: string;
-                    p256dh: string;
+                    p256dhBase64: string;
+                    authBase64: string;
                 };
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;

package/notification/api/notification.api.js

@@ -1,9 +1,10 @@
 import { defineApi } from '../../api/types.js';
-import { boolean, explicitObject, literal, number, object, optional, string, array, unknown } from '../../schema/index.js';
-import { NotificationChannel } from '../enums.js';
+import { array, boolean, enumeration, explicitObject, literal, number, object, optional, string } from '../../schema/index.js';
 import { ServerSentEvents } from '../../sse/server-sent-events.js';
+import { InAppNotificationView } from '../models/in-app-notification.model.js';
+import { NotificationChannel } from '../models/index.js';
 export const notificationApiDefinition = defineApi({
-    resource: 'notification',
+    resource: 'notifications',
     endpoints: {
         stream: {
             resource: 'stream',
@@ -18,40 +19,26 @@ export const notificationApiDefinition = defineApi({
                 offset: optional(number()),
                 includeArchived: optional(boolean()),
             }),
-            result: array(object({
-                id: string(),
-                logId: string(),
-                readAt: optional(number()),
-                archivedAt: optional(number()),
-                // Add more joined fields from Log if needed, or return polymorphic payload
-                type: string(),
-                priority: string(),
-                createdAt: number(),
-                payload: optional(object({})),
-            })),
+            result: array(InAppNotificationView),
         },
         markRead: {
             resource: 'in-app/:id/read',
             method: 'POST',
-            parameters: object({
-                id: string(),
-            }),
+            parameters: object({ id: string() }),
             result: literal('ok'),
         },
         archive: {
             resource: 'in-app/:id/archive',
             method: 'POST',
-            parameters: object({
-                id: string(),
-            }),
+            parameters: object({ id: string() }),
             result: literal('ok'),
         },
         getPreferences: {
             resource: 'preferences',
             method: 'GET',
             result: array(object({
-                categoryId: string(),
-                channel: string(),
+                type: string(),
+                channel: enumeration(NotificationChannel),
                 enabled: boolean(),
             })),
         },
@@ -59,8 +46,8 @@ export const notificationApiDefinition = defineApi({
             resource: 'preferences',
             method: 'POST',
             parameters: explicitObject({
-                categoryId: string(),
-                channel: string(),
+                type: string(),
+                channel: enumeration(NotificationChannel),
                 enabled: boolean(),
             }),
             result: literal('ok'),
@@ -71,8 +58,8 @@ export const notificationApiDefinition = defineApi({
             parameters: explicitObject({
                 endpoint: string(),
                 keys: object({
-                    p256dh: string(),
-                    auth: string(),
+                    p256dhBase64: string(),
+                    authBase64: string(),
                 }),
             }),
             result: literal('ok'),

package/notification/index.d.ts

@@ -1,2 +1,2 @@
-export * from './enums.js';
+export * from './api/index.js';
 export * from './models/index.js';

package/notification/index.js

@@ -1,2 +1,2 @@
-export * from './enums.js';
+export * from './api/index.js';
 export * from './models/index.js';

package/notification/models/in-app-notification.model.d.ts

@@ -1,9 +1,14 @@
-import { TenantEntity, type Uuid } from '../../orm/index.js';
+import { TenantBaseEntity, type Uuid } from '../../orm/index.js';
 import type { Timestamp } from '../../orm/types.js';
-export declare class InAppNotification extends TenantEntity {
+import { type NotificationLog } from './notification-log.model.js';
+export declare class InAppNotification extends TenantBaseEntity {
     static readonly entityName = "InAppNotification";
     userId: Uuid;
     logId: Uuid;
-    readAt: Timestamp | null;
-    archivedAt: Timestamp | null;
+    readTimestamp: Timestamp | null;
+    archiveTimestamp: Timestamp | null;
 }
+export declare class InAppNotificationView extends InAppNotification {
+    notification: NotificationLog;
+}
+export declare function toInAppNotificationView(inAppNotification: InAppNotification, notification: NotificationLog): InAppNotificationView;

package/notification/models/in-app-notification.model.js

@@ -7,16 +7,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { User } from '../../authentication/models/user.model.js';
-import { TenantEntity, TenantReference, TimestampProperty, UuidProperty } from '../../orm/index.js';
-import { NotificationLog } from './notification-log.model.js';
+import { User } from '../../authentication/index.js';
+import { ForeignKey, Index, TenantBaseEntity, TenantReference, TimestampProperty, UuidProperty } from '../../orm/index.js';
+import { Property } from '../../schema/index.js';
+import { NotificationLogEntity } from './notification-log.model.js';
 import { NotificationTable } from './notification-table.js';
-let InAppNotification = class InAppNotification extends TenantEntity {
+let InAppNotification = class InAppNotification extends TenantBaseEntity {
     static entityName = 'InAppNotification';
     userId;
     logId;
-    readAt;
-    archivedAt;
+    readTimestamp;
+    archiveTimestamp;
 };
 __decorate([
     UuidProperty(),
@@ -25,18 +26,32 @@ __decorate([
 ], InAppNotification.prototype, "userId", void 0);
 __decorate([
     UuidProperty(),
-    TenantReference(() => NotificationLog),
     __metadata("design:type", String)
 ], InAppNotification.prototype, "logId", void 0);
 __decorate([
     TimestampProperty({ nullable: true }),
     __metadata("design:type", Object)
-], InAppNotification.prototype, "readAt", void 0);
+], InAppNotification.prototype, "readTimestamp", void 0);
 __decorate([
     TimestampProperty({ nullable: true }),
     __metadata("design:type", Object)
-], InAppNotification.prototype, "archivedAt", void 0);
+], InAppNotification.prototype, "archiveTimestamp", void 0);
 InAppNotification = __decorate([
-    NotificationTable({ name: 'in_app' })
+    NotificationTable({ name: 'in_app' }),
+    ForeignKey(() => NotificationLogEntity, ['tenantId', 'logId', 'userId'], ['tenantId', 'id', 'userId']),
+    Index(['tenantId', 'userId', 'readTimestamp', 'archiveTimestamp'])
 ], InAppNotification);
 export { InAppNotification };
+export class InAppNotificationView extends InAppNotification {
+    notification;
+}
+__decorate([
+    Property(NotificationLogEntity),
+    __metadata("design:type", Object)
+], InAppNotificationView.prototype, "notification", void 0);
+export function toInAppNotificationView(inAppNotification, notification) {
+    return {
+        ...inAppNotification,
+        notification,
+    };
+}

package/notification/models/index.d.ts

@@ -1,6 +1,6 @@
 export * from './in-app-notification.model.js';
-export * from './notification-category.model.js';
 export * from './notification-log.model.js';
 export * from './notification-preference.model.js';
 export * from './notification-table.js';
+export * from './notification-type.model.js';
 export * from './web-push-subscription.model.js';

package/notification/models/index.js

@@ -1,6 +1,6 @@
 export * from './in-app-notification.model.js';
-export * from './notification-category.model.js';
 export * from './notification-log.model.js';
 export * from './notification-preference.model.js';
 export * from './notification-table.js';
+export * from './notification-type.model.js';
 export * from './web-push-subscription.model.js';

package/notification/models/notification-log.model.d.ts

@@ -1,13 +1,50 @@
+import { type EnumType } from '../../enumeration/index.js';
 import { type Json, TenantEntity, type Uuid } from '../../orm/index.js';
 import type { ObjectLiteral } from '../../types/types.js';
-import { NotificationPriority, NotificationStatus } from '../enums.js';
-export declare class NotificationLog extends TenantEntity {
+export declare const NotificationChannel: {
+    readonly InApp: "in-app";
+    readonly Email: "email";
+    readonly WebPush: "web-push";
+};
+export type NotificationChannel = EnumType<typeof NotificationChannel>;
+export declare const NotificationPriority: {
+    readonly Low: "low";
+    readonly Medium: "medium";
+    readonly High: "high";
+    readonly Urgent: "urgent";
+};
+export type NotificationPriority = EnumType<typeof NotificationPriority>;
+export declare const NotificationStatus: {
+    readonly Pending: "pending";
+    readonly Sent: "sent";
+    readonly Delivered: "delivered";
+    readonly Read: "read";
+    readonly Failed: "failed";
+};
+export type NotificationStatus = EnumType<typeof NotificationStatus>;
+export type NotificationDefinition<Payload extends ObjectLiteral = ObjectLiteral> = {
+    payload: Payload;
+};
+export type NotificationDefinitionMap<Definition extends Record<string, NotificationDefinition> = Record<string, NotificationDefinition>> = Definition;
+export type NotificationTypes<Definitions extends NotificationDefinitionMap> = Extract<keyof Definitions, string>;
+export type NotificationPayload<Definitions extends NotificationDefinitionMap, Type extends NotificationTypes<Definitions>> = Definitions[Type]['payload'];
+export type NotificationOfType<Definitions extends NotificationDefinitionMap, Type extends NotificationTypes<Definitions>> = string extends NotificationTypes<Definitions> ? NotificationLog<Definitions> & {
+    type: Type;
+} : Extract<NotificationLog<Definitions>, {
+    type: Type;
+}>;
+export type NotificationLog<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> = {
+    [Type in NotificationTypes<Definitions>]: Omit<NotificationLogEntity<Definitions, Type>, 'type' | 'payload'> & {
+        type: Type;
+        payload: Json<NotificationPayload<Definitions, Type>> | null;
+    };
+}[NotificationTypes<Definitions>];
+export declare class NotificationLogEntity<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap, Type extends NotificationTypes<Definitions> = NotificationTypes<Definitions>> extends TenantEntity {
     static readonly entityName = "NotificationLog";
     userId: Uuid;
-    categoryId: Uuid;
-    type: string;
+    type: Type;
     priority: NotificationPriority;
     status: NotificationStatus;
     currentStep: number;
-    payload: Json<ObjectLiteral> | null;
+    payload: Json<NotificationPayload<Definitions, Type>> | null;
 }

package/notification/models/notification-log.model.js

@@ -8,15 +8,32 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { User } from '../../authentication/models/user.model.js';
-import { JsonProperty, TenantEntity, TenantReference, UuidProperty } from '../../orm/index.js';
+import { defineEnum } from '../../enumeration/index.js';
+import { JsonProperty, Reference, TenantEntity, TenantReference, Unique, UuidProperty } from '../../orm/index.js';
 import { Enumeration, Integer, StringProperty } from '../../schema/index.js';
-import { NotificationPriority, NotificationStatus } from '../enums.js';
-import { NotificationCategory } from './notification-category.model.js';
 import { NotificationTable } from './notification-table.js';
-let NotificationLog = class NotificationLog extends TenantEntity {
+import { NotificationType } from './notification-type.model.js';
+export const NotificationChannel = defineEnum('NotificationChannel', {
+    InApp: 'in-app',
+    Email: 'email',
+    WebPush: 'web-push',
+});
+export const NotificationPriority = defineEnum('NotificationPriority', {
+    Low: 'low',
+    Medium: 'medium',
+    High: 'high',
+    Urgent: 'urgent',
+});
+export const NotificationStatus = defineEnum('NotificationStatus', {
+    Pending: 'pending',
+    Sent: 'sent',
+    Delivered: 'delivered',
+    Read: 'read',
+    Failed: 'failed',
+});
+let NotificationLogEntity = class NotificationLogEntity extends TenantEntity {
     static entityName = 'NotificationLog';
     userId;
-    categoryId;
     type;
     priority;
     status;
@@ -27,33 +44,30 @@ __decorate([
     UuidProperty(),
     TenantReference(() => User),
     __metadata("design:type", String)
-], NotificationLog.prototype, "userId", void 0);
-__decorate([
-    UuidProperty(),
-    TenantReference(() => NotificationCategory),
-    __metadata("design:type", String)
-], NotificationLog.prototype, "categoryId", void 0);
+], NotificationLogEntity.prototype, "userId", void 0);
 __decorate([
+    Reference(() => NotificationType, 'key'),
     StringProperty(),
     __metadata("design:type", String)
-], NotificationLog.prototype, "type", void 0);
+], NotificationLogEntity.prototype, "type", void 0);
 __decorate([
     Enumeration(NotificationPriority),
     __metadata("design:type", String)
-], NotificationLog.prototype, "priority", void 0);
+], NotificationLogEntity.prototype, "priority", void 0);
 __decorate([
     Enumeration(NotificationStatus),
     __metadata("design:type", String)
-], NotificationLog.prototype, "status", void 0);
+], NotificationLogEntity.prototype, "status", void 0);
 __decorate([
     Integer(),
     __metadata("design:type", Number)
-], NotificationLog.prototype, "currentStep", void 0);
+], NotificationLogEntity.prototype, "currentStep", void 0);
 __decorate([
     JsonProperty({ nullable: true }),
     __metadata("design:type", Object)
-], NotificationLog.prototype, "payload", void 0);
-NotificationLog = __decorate([
-    NotificationTable({ name: 'log' })
-], NotificationLog);
-export { NotificationLog };
+], NotificationLogEntity.prototype, "payload", void 0);
+NotificationLogEntity = __decorate([
+    NotificationTable({ name: 'log' }),
+    Unique(['tenantId', 'id', 'userId'])
+], NotificationLogEntity);
+export { NotificationLogEntity };

package/notification/models/notification-preference.model.d.ts

@@ -1,9 +1,9 @@
 import { TenantEntity, type Uuid } from '../../orm/index.js';
-import { NotificationChannel } from '../enums.js';
+import { NotificationChannel } from './notification-log.model.js';
 export declare class NotificationPreference extends TenantEntity {
     static readonly entityName = "NotificationPreference";
     userId: Uuid;
-    categoryId: Uuid;
+    type: string;
     channel: NotificationChannel;
     enabled: boolean;
 }

package/notification/models/notification-preference.model.js

@@ -8,15 +8,15 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { User } from '../../authentication/models/user.model.js';
-import { TenantEntity, TenantReference, Unique, UuidProperty } from '../../orm/index.js';
-import { BooleanProperty, Enumeration } from '../../schema/index.js';
-import { NotificationChannel } from '../enums.js';
-import { NotificationCategory } from './notification-category.model.js';
+import { Reference, TenantEntity, TenantReference, Unique, UuidProperty } from '../../orm/index.js';
+import { BooleanProperty, Enumeration, StringProperty } from '../../schema/index.js';
+import { NotificationChannel } from './notification-log.model.js';
 import { NotificationTable } from './notification-table.js';
+import { NotificationType } from './notification-type.model.js';
 let NotificationPreference = class NotificationPreference extends TenantEntity {
     static entityName = 'NotificationPreference';
     userId;
-    categoryId;
+    type;
     channel;
     enabled;
 };
@@ -26,10 +26,10 @@ __decorate([
     __metadata("design:type", String)
 ], NotificationPreference.prototype, "userId", void 0);
 __decorate([
-    UuidProperty(),
-    TenantReference(() => NotificationCategory),
+    Reference(() => NotificationType, 'key'),
+    StringProperty(),
     __metadata("design:type", String)
-], NotificationPreference.prototype, "categoryId", void 0);
+], NotificationPreference.prototype, "type", void 0);
 __decorate([
     Enumeration(NotificationChannel),
     __metadata("design:type", String)
@@ -40,6 +40,6 @@ __decorate([
 ], NotificationPreference.prototype, "enabled", void 0);
 NotificationPreference = __decorate([
     NotificationTable({ name: 'preference' }),
-    Unique(['tenantId', 'userId', 'categoryId', 'channel'])
+    Unique(['tenantId', 'userId', 'type', 'channel'])
 ], NotificationPreference);
 export { NotificationPreference };

package/notification/models/notification-type.model.d.ts

@@ -0,0 +1,17 @@
+import { Entity } from '../../orm/index.js';
+import type { NotificationChannel } from './notification-log.model.js';
+export type ThrottlingConfig = {
+    limit: number;
+    interval: number;
+};
+export type EscalationRule = {
+    delay: number;
+    channel: NotificationChannel;
+};
+export declare class NotificationType extends Entity {
+    static readonly entityName = "NotificationType";
+    label: string;
+    key: string;
+    throttling: ThrottlingConfig | null;
+    escalations: EscalationRule[] | null;
+}