@tstdl/base 0.93.115 → 0.93.117

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,7 +9,7 @@ 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;
@@ -19,6 +20,7 @@ export declare const notificationApiDefinition: {
             parameters: import("../../schema/index.js").ObjectSchema<{
                 offset?: number | undefined;
                 limit?: number | undefined;
+                after?: string | undefined;
                 unreadOnly?: boolean | undefined;
                 includeArchived?: boolean | undefined;
             }>;
@@ -104,7 +106,7 @@ 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;
@@ -115,6 +117,7 @@ declare const _NotificationApiClient: import("../../api/client/index.js").ApiCli
             parameters: import("../../schema/index.js").ObjectSchema<{
                 offset?: number | undefined;
                 limit?: number | undefined;
+                after?: string | undefined;
                 unreadOnly?: boolean | undefined;
                 includeArchived?: boolean | undefined;
             }>;

package/notification/api/notification.api.js

@@ -26,6 +26,7 @@ export const notificationApiDefinition = defineApi({
             parameters: object({
                 limit: optional(number()),
                 offset: optional(number()),
+                after: optional(string()),
                 unreadOnly: optional(boolean()),
                 includeArchived: optional(boolean()),
             }),

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,18 @@
+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 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>;
+    loadNext(count?: number): void;
+}
+export {};

package/notification/client/notification-client.js

@@ -0,0 +1,62 @@
+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));
+    state = toSignal(this.state$, { initialValue: { notifications: [], unreadCount: 0 } });
+    notifications = computed(() => this.state().notifications);
+    unreadCount = computed(() => this.state().unreadCount);
+    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/module.d.ts

@@ -5,7 +5,7 @@ import { NotificationAncillaryService } from './services/notification-ancillary.
 export declare class NotificationConfiguration {
     database?: DatabaseConfig;
     defaultChannels?: NotificationChannel[];
-    ancillaryService?: InjectionToken<NotificationAncillaryService>;
+    ancillaryService?: InjectionToken<NotificationAncillaryService<any>>;
 }
 export declare function configureNotification({ injector, ...config }: NotificationConfiguration & {
     injector?: Injector;

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.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-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,7 @@ 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();
         });
     });
 });

package/notification/types.d.ts

@@ -0,0 +1,9 @@
+import { InAppNotificationView, type NotificationDefinitionMap } from './models/index.js';
+export declare const notificationStreamItemSchema: import("../schema/index.js").ObjectSchema<{
+    unreadCount: number;
+    notification?: InAppNotificationView<Record<string, import("./models/notification-log.model.js").NotificationDefinition<import("../types/types.js").ObjectLiteral, import("../types/types.js").ObjectLiteral>>> | undefined;
+}>;
+export type NotificationStreamItem<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> = {
+    notification?: InAppNotificationView<Definitions>;
+    unreadCount: number;
+};

package/notification/types.js

@@ -0,0 +1,6 @@
+import { number, object, optional } from '../schema/index.js';
+import { InAppNotificationView } from './models/index.js';
+export const notificationStreamItemSchema = object({
+    notification: optional(InAppNotificationView),
+    unreadCount: number(),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.115",
+  "version": "0.93.117",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -200,7 +200,7 @@
     "typedoc-plugin-markdown": "4.10",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.54",
+    "typescript-eslint": "8.55",
     "vite-tsconfig-paths": "6.1",
     "vitest": "4.0"
   },

package/utils/try-ignore.d.ts

@@ -2,8 +2,8 @@ import type { Logger } from '../logger/logger.js';
 export declare function tryIgnore<R>(fn: () => R): R | undefined;
 export declare function tryIgnore<R, F>(fn: () => R, fallback: F): R | F;
 export declare function tryIgnoreAsync<R>(fn: () => Promise<R>): Promise<R | undefined>;
-export declare function tryIgnoreAsync<R, F>(fn: () => Promise<R>, fallback: F): Promise<F>;
+export declare function tryIgnoreAsync<R, F>(fn: () => Promise<R>, fallback: F): Promise<R | F>;
 export declare function tryIgnoreLog<R>(logger: Logger, fn: () => R): R | undefined;
 export declare function tryIgnoreLog<R, F>(logger: Logger, fn: () => R, fallback: F): R | F;
 export declare function tryIgnoreLogAsync<R>(logger: Logger, fn: () => Promise<R>): Promise<R | undefined>;
-export declare function tryIgnoreLogAsync<R, F>(logger: Logger, fn: () => Promise<R>, fallback: F): Promise<F>;
+export declare function tryIgnoreLogAsync<R, F>(logger: Logger, fn: () => Promise<R>, fallback: F): Promise<R | F>;