@tstdl/base 0.93.116 → 0.93.118

package/api/server/gateway.js

@@ -190,7 +190,7 @@ let ApiGateway = ApiGateway_1 = class ApiGateway {
         const decodedUrlParameters = mapObjectValues(context.resourcePatternResult.pathname.groups, (value) => isDefined(value) ? decodeURIComponent(value) : undefined);
         const parameters = { ...context.request.query.asObject(), ...bodyAsParameters, ...decodedUrlParameters };
         const validatedParameters = isDefined(context.endpoint.definition.parameters)
-            ? Schema.parse(context.endpoint.definition.parameters, parameters)
+            ? Schema.parse(context.endpoint.definition.parameters, parameters, { coerce: true })
             : parameters;
         const requestTokenProvider = this.#requestTokenProvider;
         const auditor = this.#auditor;
@@ -279,5 +279,5 @@ async function getBody(request, options, schema) {
             body = await request.body.readAsBuffer(options);
         }
     }
-    return Schema.parse(schema, body);
+    return Schema.parse(schema, body, { coerce: true });
 }

package/index.d.ts

@@ -5,4 +5,5 @@
  */
 export * from './core.js';
 export * from './import.js';
+export * from './internal.js';
 export * from './require.js';

package/index.js

@@ -5,4 +5,5 @@
  */
 export * from './core.js';
 export * from './import.js';
+export * from './internal.js';
 export * from './require.js';

package/internal.d.ts

@@ -0,0 +1 @@
+export declare const internal: unique symbol;

package/internal.js

@@ -0,0 +1 @@
+export const internal = Symbol('internal');

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

@@ -1,5 +1,6 @@
 import { DataStream } from '../../sse/data-stream.js';
 import { InAppNotificationView } from '../models/in-app-notification.model.js';
+import type { NotificationStreamItem } from '../types.js';
 export type NotificationApiDefinition = typeof notificationApiDefinition;
 export declare const notificationApiDefinition: {
     resource: string;
@@ -8,17 +9,24 @@ export declare const notificationApiDefinition: {
             resource: string;
             method: "GET";
             result: {
-                new (): DataStream<InAppNotificationView<Record<string, import("../models/notification-log.model.js").NotificationDefinition<import("../../types/types.js").ObjectLiteral, import("../../types/types.js").ObjectLiteral>>>>;
+                new (): DataStream<NotificationStreamItem>;
                 parse<T>(eventSource: import("../../sse/server-sent-events.js").ServerSentEvents): import("rxjs").Observable<T>;
             };
             credentials: true;
         };
+        types: {
+            resource: string;
+            method: "GET";
+            result: import("../../schema/index.js").ObjectSchema<Partial<import("../../schema/index.js").Record<string, string>>>;
+            credentials: true;
+        };
         listInApp: {
             resource: string;
             method: "GET";
             parameters: import("../../schema/index.js").ObjectSchema<{
                 offset?: number | undefined;
                 limit?: number | undefined;
+                after?: string | undefined;
                 unreadOnly?: boolean | undefined;
                 includeArchived?: boolean | undefined;
             }>;
@@ -75,9 +83,9 @@ export declare const notificationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly type: string;
-                readonly channel: "email" | "in-app" | "web-push";
-                readonly enabled: boolean;
+                type: string;
+                enabled: boolean;
+                channel: "email" | "in-app" | "web-push";
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
             credentials: true;
@@ -86,11 +94,11 @@ export declare const notificationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly endpoint: string;
-                readonly keys: {
+                keys: {
                     p256dhBase64: string;
                     authBase64: string;
                 };
+                endpoint: string;
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
             credentials: true;
@@ -104,17 +112,24 @@ declare const _NotificationApiClient: import("../../api/client/index.js").ApiCli
             resource: string;
             method: "GET";
             result: {
-                new (): DataStream<InAppNotificationView<Record<string, import("../models/notification-log.model.js").NotificationDefinition<import("../../types/types.js").ObjectLiteral, import("../../types/types.js").ObjectLiteral>>>>;
+                new (): DataStream<NotificationStreamItem>;
                 parse<T>(eventSource: import("../../sse/server-sent-events.js").ServerSentEvents): import("rxjs").Observable<T>;
             };
             credentials: true;
         };
+        types: {
+            resource: string;
+            method: "GET";
+            result: import("../../schema/index.js").ObjectSchema<Partial<import("../../schema/index.js").Record<string, string>>>;
+            credentials: true;
+        };
         listInApp: {
             resource: string;
             method: "GET";
             parameters: import("../../schema/index.js").ObjectSchema<{
                 offset?: number | undefined;
                 limit?: number | undefined;
+                after?: string | undefined;
                 unreadOnly?: boolean | undefined;
                 includeArchived?: boolean | undefined;
             }>;
@@ -171,9 +186,9 @@ declare const _NotificationApiClient: import("../../api/client/index.js").ApiCli
             resource: string;
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly type: string;
-                readonly channel: "email" | "in-app" | "web-push";
-                readonly enabled: boolean;
+                type: string;
+                enabled: boolean;
+                channel: "email" | "in-app" | "web-push";
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
             credentials: true;
@@ -182,11 +197,11 @@ declare const _NotificationApiClient: import("../../api/client/index.js").ApiCli
             resource: string;
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly endpoint: string;
-                readonly keys: {
+                keys: {
                     p256dhBase64: string;
                     authBase64: string;
                 };
+                endpoint: string;
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
             credentials: true;

package/notification/api/notification.api.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { compileClient } from '../../api/client/index.js';
 import { defineApi } from '../../api/types.js';
 import { ReplaceClass } from '../../injector/decorators.js';
-import { array, boolean, enumeration, explicitObject, literal, number, object, optional, string } from '../../schema/index.js';
+import { array, boolean, enumeration, literal, number, object, optional, record, string } from '../../schema/index.js';
 import { DataStream } from '../../sse/data-stream.js';
 import { InAppNotificationView } from '../models/in-app-notification.model.js';
 import { NotificationChannel } from '../models/index.js';
@@ -20,12 +20,19 @@ export const notificationApiDefinition = defineApi({
             result: (DataStream),
             credentials: true,
         },
+        types: {
+            resource: 'types',
+            method: 'GET',
+            result: record(string(), string()),
+            credentials: true,
+        },
         listInApp: {
             resource: 'in-app',
             method: 'GET',
             parameters: object({
                 limit: optional(number()),
                 offset: optional(number()),
+                after: optional(string()),
                 unreadOnly: optional(boolean()),
                 includeArchived: optional(boolean()),
             }),
@@ -77,7 +84,7 @@ export const notificationApiDefinition = defineApi({
         updatePreference: {
             resource: 'preferences',
             method: 'POST',
-            parameters: explicitObject({
+            parameters: object({
                 type: string(),
                 channel: enumeration(NotificationChannel),
                 enabled: boolean(),
@@ -88,7 +95,7 @@ export const notificationApiDefinition = defineApi({
         registerWebPush: {
             resource: 'web-push/register',
             method: 'POST',
-            parameters: explicitObject({
+            parameters: object({
                 endpoint: string(),
                 keys: object({
                     p256dhBase64: string(),

package/notification/client/index.d.ts

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

package/notification/client/index.js

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

package/notification/client/notification-client.d.ts

@@ -0,0 +1,20 @@
+import { NotificationApiClient } from '../../notification/api/index.js';
+import type { InAppNotificationView, NotificationDefinitionMap } from '../../notification/models/index.js';
+type NotificationState<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> = {
+    notifications: InAppNotificationView<Definitions>[];
+    unreadCount: number;
+};
+export declare class NotificationClient<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> {
+    #private;
+    readonly api: NotificationApiClient;
+    readonly state$: import("rxjs").Observable<NotificationState<Definitions>>;
+    readonly notifications$: import("rxjs").Observable<InAppNotificationView<Definitions>[]>;
+    readonly unreadCount$: import("rxjs").Observable<number>;
+    readonly types$: import("rxjs").Observable<Record<keyof Definitions, string>>;
+    readonly state: import("../../signals/api.js").Signal<NotificationState<Definitions>>;
+    readonly notifications: import("../../signals/api.js").Signal<InAppNotificationView<Definitions>[]>;
+    readonly unreadCount: import("../../signals/api.js").Signal<number>;
+    readonly types: import("../../signals/api.js").Signal<Record<keyof Definitions, string>>;
+    loadNext(count?: number): void;
+}
+export {};

package/notification/client/notification-client.js

@@ -0,0 +1,69 @@
+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 { concatMap, defer, from, map, merge, of, scan, shareReplay, Subject, switchAll, switchMap } from 'rxjs';
+import { AuthenticationClientService } from '../../authentication/client/authentication.service.js';
+import { Singleton } from '../../injector/decorators.js';
+import { inject } from '../../injector/inject.js';
+import { NotificationApiClient } from '../../notification/api/index.js';
+import { forceCast } from '../../rxjs-utils/cast.js';
+import { computed, toSignal } from '../../signals/api.js';
+import { isDefined, isUndefined } from '../../utils/type-guards.js';
+let NotificationClient = class NotificationClient {
+    #pagination$ = new Subject();
+    #authenticationService = inject(AuthenticationClientService);
+    api = inject(NotificationApiClient);
+    state$ = this.#authenticationService.sessionId$.pipe(switchMap((sessionId) => {
+        if (isUndefined(sessionId)) {
+            return of({ notifications: [], unreadCount: 0 });
+        }
+        return merge(defer(() => from(this.api.listInApp({ limit: 20 }))).pipe(map((notifications) => ({ type: 'set-notifications', notifications: notifications }))), defer(() => from(this.api.unreadCount())).pipe(map((unreadCount) => ({ type: 'set-unread-count', unreadCount }))), defer(() => from(this.api.stream())).pipe(switchAll(), forceCast(), switchMap((item) => {
+            const actions = [{ type: 'set-unread-count', unreadCount: item.unreadCount }];
+            if (isDefined(item.notification)) {
+                actions.push({ type: 'prepend-notification', notification: item.notification });
+            }
+            return from(actions);
+        })), this.#pagination$.pipe(concatMap(({ count, after }) => from(this.api.listInApp({ limit: count, after }))), map((notifications) => ({ type: 'append-notifications', notifications: notifications })))).pipe(scan((acc, action) => {
+            switch (action.type) {
+                case 'set-notifications':
+                    return { ...acc, notifications: action.notifications };
+                case 'prepend-notification':
+                    if (acc.notifications.some((n) => n.id == action.notification.id)) {
+                        return acc;
+                    }
+                    return { ...acc, notifications: [action.notification, ...acc.notifications] };
+                case 'append-notifications':
+                    const filtered = action.notifications.filter((n) => !acc.notifications.some((c) => c.id == n.id));
+                    return { ...acc, notifications: [...acc.notifications, ...filtered] };
+                case 'set-unread-count':
+                    return { ...acc, unreadCount: action.unreadCount };
+                default:
+                    return acc;
+            }
+        }, { notifications: [], unreadCount: 0 }));
+    }), shareReplay({ bufferSize: 1, refCount: true }));
+    notifications$ = this.state$.pipe(map((state) => state.notifications));
+    unreadCount$ = this.state$.pipe(map((state) => state.unreadCount));
+    types$ = this.#authenticationService.sessionId$.pipe(switchMap((sessionId) => {
+        if (isUndefined(sessionId)) {
+            return of({});
+        }
+        return this.api.types();
+    }), shareReplay({ bufferSize: 1, refCount: true }));
+    state = toSignal(this.state$, { initialValue: { notifications: [], unreadCount: 0 } });
+    notifications = computed(() => this.state().notifications);
+    unreadCount = computed(() => this.state().unreadCount);
+    types = toSignal(this.types$, { initialValue: {} });
+    loadNext(count = 20) {
+        const current = this.notifications();
+        const after = current[current.length - 1]?.id;
+        this.#pagination$.next({ count, after });
+    }
+};
+NotificationClient = __decorate([
+    Singleton()
+], NotificationClient);
+export { NotificationClient };

package/notification/index.d.ts

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

package/notification/index.js

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

package/notification/server/api/notification.api-controller.d.ts

@@ -1,11 +1,14 @@
 import type { ApiController, ApiRequestContext, ApiServerResult } from '../../../api/types.js';
 import type { NotificationApiDefinition } from '../../api/notification.api.js';
 import { NotificationSseService } from '../services/notification-sse.service.js';
+import { NotificationTypeService } from '../services/notification-type.service.js';
 import { NotificationService } from '../services/notification.service.js';
 export declare class NotificationApiController implements ApiController<NotificationApiDefinition> {
     protected readonly notificationService: NotificationService<Record<string, import("../../index.js").NotificationDefinition<import("../../../types/types.js").ObjectLiteral, import("../../../types/types.js").ObjectLiteral>>>;
+    protected readonly notificationTypeService: NotificationTypeService;
     protected readonly sseService: NotificationSseService;
     stream({ abortSignal, getToken }: ApiRequestContext<NotificationApiDefinition, 'stream'>): ApiServerResult<NotificationApiDefinition, 'stream'>;
+    types(): Promise<Record<string, string>>;
     listInApp({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'listInApp'>): Promise<any>;
     markRead({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'markRead'>): Promise<'ok'>;
     markAllRead({ getToken }: ApiRequestContext<NotificationApiDefinition, 'markAllRead'>): Promise<'ok'>;

package/notification/server/api/notification.api-controller.js

@@ -10,9 +10,11 @@ import { toAsyncIterable } from '../../../rxjs-utils/index.js';
 import { decodeBase64 } from '../../../utils/base64.js';
 import { notificationApiDefinition } from '../../api/notification.api.js';
 import { NotificationSseService } from '../services/notification-sse.service.js';
+import { NotificationTypeService } from '../services/notification-type.service.js';
 import { NotificationService } from '../services/notification.service.js';
 let NotificationApiController = class NotificationApiController {
     notificationService = inject(NotificationService);
+    notificationTypeService = inject(NotificationTypeService);
     sseService = inject(NotificationSseService);
     async *stream({ abortSignal, getToken }) {
         const token = await getToken();
@@ -26,6 +28,9 @@ let NotificationApiController = class NotificationApiController {
             this.sseService.unregister(token.payload.tenant, token.payload.subject, source);
         }
     }
+    async types() {
+        return await this.notificationTypeService.getTypes();
+    }
     async listInApp({ parameters, getToken }) {
         const token = await getToken();
         return await this.notificationService.listInApp(token.payload.tenant, token.payload.subject, parameters);

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

@@ -8,9 +8,11 @@ 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';
+import { NotificationService } from '../services/notification.service.js';
 import { ChannelProvider } from './channel-provider.js';
 let InAppChannelProvider = class InAppChannelProvider extends ChannelProvider {
     #inAppRepository = injectRepository(InAppNotification);
+    #notificationService = inject(NotificationService);
     #sseService = inject(NotificationSseService);
     async send(notification, tx) {
         const inApp = await this.#inAppRepository.withOptionalTransaction(tx).insert({
@@ -21,7 +23,8 @@ let InAppChannelProvider = class InAppChannelProvider extends ChannelProvider {
             archiveTimestamp: null,
         });
         const inAppNotificationView = toInAppNotificationView(inApp, notification);
-        await this.#sseService.send(inAppNotificationView);
+        const unreadCount = await this.#notificationService.withOptionalTransaction(tx).unreadCount(notification.tenantId, notification.userId);
+        await this.#sseService.send(inAppNotificationView, unreadCount);
     }
 };
 InAppChannelProvider = __decorate([

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

@@ -1,11 +1,13 @@
 import { Subject } from 'rxjs';
 import { afterResolve } from '../../../injector/index.js';
 import type { InAppNotificationView } from '../../models/index.js';
+import type { NotificationStreamItem } from '../../types.js';
 export declare class NotificationSseService {
     #private;
     [afterResolve](): void;
-    register(tenantId: string, userId: string): Subject<InAppNotificationView>;
-    unregister(tenantId: string, userId: string, source: Subject<InAppNotificationView>): void;
-    send(notification: InAppNotificationView): Promise<void>;
+    register(tenantId: string, userId: string): Subject<NotificationStreamItem>;
+    unregister(tenantId: string, userId: string, source: Subject<NotificationStreamItem>): void;
+    send(notification: InAppNotificationView, unreadCount: number): Promise<void>;
+    dispatchUnreadCountUpdate(tenantId: string, userId: string, unreadCount: number): Promise<void>;
     private dispatchToLocal;
 }

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

@@ -10,7 +10,7 @@ import { MessageBusProvider } from '../../../message-bus/index.js';
 let NotificationSseService = class NotificationSseService {
     #messageBusProvider = inject(MessageBusProvider);
     #messageBus = this.#messageBusProvider.get('notification');
-    #sources = new Map(); // tenantId -> userId -> Sources
+    #sources = new Map(); // tenantId -> userId -> sources
     [afterResolve]() {
         this.#messageBus.allMessages$.subscribe((message) => this.dispatchToLocal(message));
     }
@@ -43,15 +43,27 @@ let NotificationSseService = class NotificationSseService {
         }
         source.complete();
     }
-    async send(notification) {
-        await this.#messageBus.publish(notification);
+    async send(notification, unreadCount) {
+        await this.#messageBus.publish({
+            tenantId: notification.tenantId,
+            userId: notification.userId,
+            notification,
+            unreadCount,
+        });
     }
-    dispatchToLocal(notification) {
-        const tenantMap = this.#sources.get(notification.tenantId);
-        const userSources = tenantMap?.get(notification.userId);
+    async dispatchUnreadCountUpdate(tenantId, userId, unreadCount) {
+        await this.#messageBus.publish({
+            tenantId,
+            userId,
+            unreadCount,
+        });
+    }
+    dispatchToLocal(message) {
+        const tenantMap = this.#sources.get(message.tenantId);
+        const userSources = tenantMap?.get(message.userId);
         if (userSources != null) {
             for (const source of userSources) {
-                source.next(notification);
+                source.next({ notification: message.notification, unreadCount: message.unreadCount });
             }
         }
     }

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

@@ -8,4 +8,5 @@ export type TypeInitializationData = {
 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>>;
+    getTypes(): Promise<Record<string, string>>;
 }

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

@@ -34,6 +34,11 @@ let NotificationTypeService = class NotificationTypeService extends Transactiona
         const mappedTypes = typeEntries.map(([key]) => [key, assertDefinedPass(typeMap.get(key), 'Could not map notification type.')]);
         return fromEntries(mappedTypes);
     }
+    async getTypes() {
+        const types = await this.repository.loadAll();
+        const entries = types.map((type) => [type.key, type.label]);
+        return fromEntries(entries);
+    }
 };
 NotificationTypeService = __decorate([
     Singleton()

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

@@ -11,6 +11,7 @@ export declare class NotificationService<Definitions extends NotificationDefinit
     listInApp(tenantId: string, userId: string, options?: {
         limit?: number;
         offset?: number;
+        after?: string;
         includeArchived?: boolean;
         unreadOnly?: boolean;
     }): Promise<InAppNotificationView[]>;
@@ -22,4 +23,5 @@ export declare class NotificationService<Definitions extends NotificationDefinit
     getPreferences(tenantId: string, userId: string): Promise<NotificationPreference[]>;
     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>;
+    private dispatchUnreadCountUpdate;
 }

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

@@ -4,22 +4,30 @@ 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 { and, desc, eq, isNull } from 'drizzle-orm';
+var _a;
+var NotificationService_1;
+import { and, desc, eq, isNull, lt, or } from 'drizzle-orm';
 import { BadRequestError } from '../../../errors/bad-request.error.js';
 import { inject, Singleton } from '../../../injector/index.js';
+import { Logger } from '../../../logger/logger.js';
 import { TRANSACTION_TIMESTAMP } from '../../../orm/index.js';
 import { injectRepository, Transactional } from '../../../orm/server/index.js';
 import { TaskQueue } from '../../../task-queue/task-queue.js';
+import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
+import { isDefined } from '../../../utils/type-guards.js';
 import { InAppNotification, NotificationLogEntity, NotificationPreference, NotificationPriority, NotificationStatus, toInAppNotificationView, WebPushSubscription } from '../../models/index.js';
 import { inAppNotification, notificationLog } from '../schemas.js';
 import { NotificationAncillaryService } from './notification-ancillary.service.js';
-let NotificationService = class NotificationService extends Transactional {
+import { NotificationSseService } from './notification-sse.service.js';
+let NotificationService = NotificationService_1 = class NotificationService extends Transactional {
     #notificationLogRepository = injectRepository(NotificationLogEntity);
     #inAppNotificationRepository = injectRepository(InAppNotification);
     #preferenceRepository = injectRepository(NotificationPreference);
     #webPushSubscriptionRepository = injectRepository(WebPushSubscription);
     #notificationAncillaryService = inject(NotificationAncillaryService);
     #taskQueue = inject((TaskQueue), 'notification');
+    #sseService = inject(NotificationSseService);
+    #logger = inject(Logger, NotificationService_1.name);
     async send(tenantId, userId, notification, options) {
         await this.useTransaction(options?.transaction, async (tx) => {
             const notificationToInsert = {
@@ -36,6 +44,11 @@ let NotificationService = class NotificationService extends Transactional {
         });
     }
     async listInApp(tenantId, userId, options = {}) {
+        let afterNotification;
+        if (options.after != null) {
+            const inApp = await this.#inAppNotificationRepository.loadByQuery({ tenantId, userId, id: options.after });
+            afterNotification = await this.#notificationLogRepository.loadByQuery({ tenantId, userId, id: inApp.logId });
+        }
         const rows = await this.#notificationLogRepository.session
             .select({
             notification: notificationLog,
@@ -43,10 +56,12 @@ let NotificationService = class NotificationService extends Transactional {
         })
             .from(notificationLog)
             .innerJoin(inAppNotification, and(eq(inAppNotification.tenantId, notificationLog.tenantId), eq(inAppNotification.userId, notificationLog.userId), eq(inAppNotification.logId, notificationLog.id)))
-            .where(and(eq(notificationLog.tenantId, tenantId), eq(notificationLog.userId, userId), options.includeArchived ? undefined : isNull(inAppNotification.archiveTimestamp), options.unreadOnly ? isNull(inAppNotification.readTimestamp) : undefined))
+            .where(and(eq(notificationLog.tenantId, tenantId), eq(notificationLog.userId, userId), options.includeArchived ? undefined : isNull(inAppNotification.archiveTimestamp), options.unreadOnly ? isNull(inAppNotification.readTimestamp) : undefined, isDefined(afterNotification)
+            ? or(lt(notificationLog.timestamp, afterNotification.timestamp), and(eq(notificationLog.timestamp, afterNotification.timestamp), lt(notificationLog.id, afterNotification.id)))
+            : undefined))
             .limit(options.limit ?? 50)
             .offset(options.offset ?? 0)
-            .orderBy(desc(notificationLog.timestamp));
+            .orderBy(desc(notificationLog.timestamp), desc(notificationLog.id));
         const inAppRows = rows.map((row) => row.inApp);
         const notificationRows = rows.map((row) => row.notification);
         const notificationEntities = await this.#notificationLogRepository.mapManyToEntity(notificationRows);
@@ -62,15 +77,19 @@ let NotificationService = class NotificationService extends Transactional {
     }
     async markRead(tenantId, userId, id) {
         await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { readTimestamp: TRANSACTION_TIMESTAMP });
+        await this.dispatchUnreadCountUpdate(tenantId, userId);
     }
     async markAllRead(tenantId, userId) {
         await this.#inAppNotificationRepository.updateByQuery({ tenantId, userId, readTimestamp: null }, { readTimestamp: TRANSACTION_TIMESTAMP });
+        await this.dispatchUnreadCountUpdate(tenantId, userId);
     }
     async archive(tenantId, userId, id) {
         await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
+        await this.dispatchUnreadCountUpdate(tenantId, userId);
     }
     async archiveAll(tenantId, userId) {
         await this.#inAppNotificationRepository.updateByQuery({ tenantId, userId, archiveTimestamp: null }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
+        await this.dispatchUnreadCountUpdate(tenantId, userId);
     }
     async unreadCount(tenantId, userId) {
         return await this.#inAppNotificationRepository.countByQuery({
@@ -113,8 +132,14 @@ let NotificationService = class NotificationService extends Transactional {
             auth,
         });
     }
+    async dispatchUnreadCountUpdate(tenantId, userId) {
+        await tryIgnoreLogAsync(this.#logger, async () => {
+            const unreadCount = await this.unreadCount(tenantId, userId);
+            this.#sseService.dispatchUnreadCountUpdate(tenantId, userId, unreadCount);
+        });
+    }
 };
-NotificationService = __decorate([
+NotificationService = NotificationService_1 = __decorate([
     Singleton()
 ], NotificationService);
 export { NotificationService };

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

@@ -5,6 +5,7 @@ import { setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
 import { NotificationChannel } from '../models/index.js';
 import { NotificationApiController } from '../server/api/notification.api-controller.js';
 import { NotificationSseService } from '../server/services/notification-sse.service.js';
+import { NotificationTypeService } from '../server/services/notification-type.service.js';
 import { NotificationService } from '../server/services/notification.service.js';
 describe('Notification API (Integration)', () => {
     let injector;
@@ -64,6 +65,13 @@ describe('Notification API (Integration)', () => {
         await nextPromise;
         expect(registerSpy).toHaveBeenCalledWith(tenantId, userId);
     });
+    test('types should call service', async () => {
+        const notificationTypeService = injector.resolve(NotificationTypeService);
+        const getTypesSpy = vi.spyOn(notificationTypeService, 'getTypes').mockResolvedValue({ test: 'Test' });
+        const result = await controller.types();
+        expect(result).toEqual({ test: 'Test' });
+        expect(getTypesSpy).toHaveBeenCalled();
+    });
     test('listInApp should call service', async () => {
         const listInAppSpy = vi.spyOn(notificationService, 'listInApp').mockResolvedValue([]);
         const params = { limit: 10, offset: 0, includeArchived: false };

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

@@ -265,4 +265,32 @@ describe('Notification Flow (Integration)', () => {
             expect(prefs[0].enabled).toBe(true);
         });
     });
+    test('should support keyset pagination with after and orderBy', async () => {
+        await runInInjectionContext(injector, async () => {
+            const logRepo = injectRepository(NotificationLogEntity);
+            const user = await subjectService.createUser({ tenantId, email: 'pagination@example.com', firstName: 'Pagination', lastName: 'User' });
+            await typeService.initializeTypes({ test: { label: 'Pagination Test' } });
+            // Create 3 notifications
+            await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: { index: 1 } });
+            await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: { index: 2 } });
+            await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: { index: 3 } });
+            const logs = await logRepo.loadManyByQuery({ tenantId });
+            for (const log of logs) {
+                await worker.deliver(log.id);
+            }
+            // Default list (desc timestamp, then desc id)
+            const list = await notificationService.listInApp(tenantId, user.id);
+            expect(list).toHaveLength(3);
+            const firstId = list[0].id;
+            const secondId = list[1].id;
+            // After first
+            const afterFirst = await notificationService.listInApp(tenantId, user.id, { after: firstId });
+            expect(afterFirst).toHaveLength(2);
+            expect(afterFirst[0].id).toBe(secondId);
+            // After second
+            const afterSecond = await notificationService.listInApp(tenantId, user.id, { after: secondId });
+            expect(afterSecond).toHaveLength(1);
+            expect(afterSecond[0].id).toBe(list[2].id);
+        });
+    });
 });

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

@@ -14,7 +14,16 @@ describe('NotificationSseService', () => {
             // We can't easily spy on the LocalMessageBus internals without more complex setup,
             // but we can verify that sending doesn't throw.
             const msg = { tenantId, userId, logId: 'l1' };
-            await expect(service.send(msg)).resolves.not.toThrow();
+            await expect(service.send(msg, 1)).resolves.not.toThrow();
+        });
+    });
+    test('should dispatch unread count update', async () => {
+        const { injector } = await setupIntegrationTest({ modules: { messageBus: true, signals: true } });
+        const service = injector.resolve(NotificationSseService);
+        const tenantId = 't1';
+        const userId = 'u1';
+        await runInInjectionContext(injector, async () => {
+            await expect(service.dispatchUnreadCountUpdate(tenantId, userId, 5)).resolves.not.toThrow();
         });
     });
 });