@tstdl/base 0.93.121 → 0.93.123

package/api/server/gateway.js

@@ -199,6 +199,11 @@ let ApiGateway = ApiGateway_1 = class ApiGateway {
             body,
             request: context.request,
             abortSignal: context.abortSignal,
+            serverSentEvents: {
+                get lastEventId() {
+                    return context.request.headers.tryGetSingle('Last-Event-ID');
+                },
+            },
             tryGetToken: async () => {
                 return await requestTokenProvider.tryGetToken(requestContext);
             },
@@ -238,7 +243,7 @@ let ApiGateway = ApiGateway_1 = class ApiGateway {
                     const { errorResponse } = logAndGetErrorResponse(this.#logger, this.#supressedErrors, error);
                     return errorResponse.error;
                 };
-                return ({ events: DataStreamSource.fromIterable(value, { errorFormatter }).eventSource });
+                return ({ events: DataStreamSource.fromIterable(value, { errorFormatter, ...context.endpoint.definition.dataStream }).eventSource });
             })
                 .when(() => (context.endpoint.definition.result == String), (text) => ({ text: text }))
                 .otherwise((json) => ({ json }));

package/api/types.d.ts

@@ -4,7 +4,7 @@ import type { Token } from '../authentication/index.js';
 import type { HttpServerRequest, HttpServerResponse } from '../http/server/index.js';
 import type { HttpMethod } from '../http/types.js';
 import type { SchemaOutput, SchemaTestable } from '../schema/index.js';
-import type { DataStream, DataStreamSource } from '../sse/index.js';
+import type { DataStream, DataStreamSource, DataStreamSourceOptions } from '../sse/index.js';
 import type { ServerSentEventsSource } from '../sse/server-sent-events-source.js';
 import type { ServerSentEvents } from '../sse/server-sent-events.js';
 import type { NonUndefinable, OneOrMany, Record, ReturnTypeOrT } from '../types/index.js';
@@ -66,6 +66,7 @@ export type ApiEndpointDefinition = {
     maxBytes?: number;
     description?: string;
     data?: Record;
+    dataStream?: DataStreamSourceOptions<any>;
     /**
      * If true, sets browsers fetch to { credentials: 'include' } and enables 'Access-Control-Allow-Credentials' header.
      *
@@ -107,6 +108,9 @@ export type ApiRequestData<T extends ApiDefinition = ApiDefinition, K extends Ap
     body: ApiServerBody<T, K>;
     request: HttpServerRequest;
     abortSignal: AbortSignal;
+    serverSentEvents: {
+        lastEventId?: string;
+    };
 };
 export type ApiRequestContext<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = ApiRequestData<T, K> & {
     tryGetToken<T extends Token>(): Promise<T | null>;

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

@@ -13,6 +13,9 @@ export declare const notificationApiDefinition: {
                 parse<T>(eventSource: import("../../sse/server-sent-events.js").ServerSentEvents): import("rxjs").Observable<T>;
             };
             credentials: true;
+            dataStream: {
+                idProvider: (item: NotificationStreamItem) => import("../../types/tagged.js").Tagged<string, "column", import("drizzle-orm").IsPrimaryKey<import("drizzle-orm").HasDefault<import("drizzle-orm/pg-core").PgUUIDBuilderInitial<string>>>> | undefined;
+            };
         };
         types: {
             resource: string;
@@ -116,6 +119,9 @@ declare const _NotificationApiClient: import("../../api/client/index.js").ApiCli
                 parse<T>(eventSource: import("../../sse/server-sent-events.js").ServerSentEvents): import("rxjs").Observable<T>;
             };
             credentials: true;
+            dataStream: {
+                idProvider: (item: NotificationStreamItem) => import("../../types/tagged.js").Tagged<string, "column", import("drizzle-orm").IsPrimaryKey<import("drizzle-orm").HasDefault<import("drizzle-orm/pg-core").PgUUIDBuilderInitial<string>>>> | undefined;
+            };
         };
         types: {
             resource: string;

package/notification/api/notification.api.js

@@ -19,6 +19,9 @@ export const notificationApiDefinition = defineApi({
             method: 'GET',
             result: (DataStream),
             credentials: true,
+            dataStream: {
+                idProvider: (item) => item.notification?.id,
+            },
         },
         types: {
             resource: 'types',

package/notification/client/notification-client.js

@@ -21,10 +21,25 @@ let NotificationClient = class NotificationClient {
             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 }];
+            const actions = [];
+            if (isDefined(item.unreadCount)) {
+                actions.push({ type: 'set-unread-count', unreadCount: item.unreadCount });
+            }
             if (isDefined(item.notification)) {
                 actions.push({ type: 'prepend-notification', notification: item.notification });
             }
+            if (isDefined(item.readId)) {
+                actions.push({ type: 'mark-read', id: item.readId });
+            }
+            if (item.readAll == true) {
+                actions.push({ type: 'mark-all-read' });
+            }
+            if (isDefined(item.archiveId)) {
+                actions.push({ type: 'archive', id: item.archiveId });
+            }
+            if (item.archiveAll == true) {
+                actions.push({ type: 'archive-all' });
+            }
             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) {
@@ -38,6 +53,24 @@ let NotificationClient = class NotificationClient {
                 case 'append-notifications':
                     const filtered = action.notifications.filter((n) => !acc.notifications.some((c) => c.id == n.id));
                     return { ...acc, notifications: [...acc.notifications, ...filtered] };
+                case 'mark-read':
+                    return {
+                        ...acc,
+                        notifications: acc.notifications.map((notification) => (notification.id == action.id) ? { ...notification, readTimestamp: Date.now() } : notification),
+                    };
+                case 'mark-all-read':
+                    const now = Date.now();
+                    return {
+                        ...acc,
+                        notifications: acc.notifications.map((notification) => ({ ...notification, readTimestamp: notification.readTimestamp ?? now })),
+                    };
+                case 'archive':
+                    return {
+                        ...acc,
+                        notifications: acc.notifications.filter((notification) => notification.id != action.id),
+                    };
+                case 'archive-all':
+                    return { ...acc, notifications: [] };
                 case 'set-unread-count':
                     return { ...acc, unreadCount: action.unreadCount };
                 default:

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

@@ -7,7 +7,7 @@ export declare class NotificationApiController implements ApiController<Notifica
     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'>;
+    stream({ abortSignal, getToken, serverSentEvents: { lastEventId } }: 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'>;

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

@@ -8,6 +8,7 @@ import { apiController } from '../../../api/server/index.js';
 import { inject } from '../../../injector/index.js';
 import { toAsyncIterable } from '../../../rxjs-utils/index.js';
 import { decodeBase64 } from '../../../utils/base64.js';
+import { isDefined } from '../../../utils/type-guards.js';
 import { notificationApiDefinition } from '../../api/notification.api.js';
 import { NotificationSseService } from '../services/notification-sse.service.js';
 import { NotificationTypeService } from '../services/notification-type.service.js';
@@ -16,12 +17,25 @@ let NotificationApiController = class NotificationApiController {
     notificationService = inject(NotificationService);
     notificationTypeService = inject(NotificationTypeService);
     sseService = inject(NotificationSseService);
-    async *stream({ abortSignal, getToken }) {
+    async *stream({ abortSignal, getToken, serverSentEvents: { lastEventId } }) {
         const token = await getToken();
         const source = this.sseService.register(token.payload.tenant, token.payload.subject);
         const asyncIterable = toAsyncIterable(source);
         abortSignal.addEventListener('abort', () => this.sseService.unregister(token.payload.tenant, token.payload.subject, source));
         try {
+            if (isDefined(lastEventId)) {
+                const { unreadCount, missedNotifications, readIds, archiveIds } = await this.notificationService.getCatchupData(token.payload.tenant, token.payload.subject, lastEventId);
+                yield { unreadCount };
+                for (const readId of readIds) {
+                    yield { readId };
+                }
+                for (const archiveId of archiveIds) {
+                    yield { archiveId };
+                }
+                for (const notification of missedNotifications.reverse()) {
+                    yield { notification };
+                }
+            }
             yield* asyncIterable;
         }
         finally {

package/notification/server/index.d.ts

@@ -1,5 +1,6 @@
 export * from './api/index.js';
 export * from './module.js';
+export * from './modules/index.js';
 export * from './providers/index.js';
 export * from './schemas.js';
 export * from './services/index.js';

package/notification/server/index.js

@@ -1,5 +1,6 @@
 export * from './api/index.js';
 export * from './module.js';
+export * from './modules/index.js';
 export * from './providers/index.js';
 export * from './schemas.js';
 export * from './services/index.js';

package/notification/server/modules/notification-delivery-worker.module.d.ts

@@ -3,6 +3,7 @@ import { afterResolve } from '../../../injector/index.js';
 import { Module } from '../../../module/module.js';
 export declare class NotificationDeliveryWorkerModule extends Module {
     #private;
+    constructor();
     [afterResolve](): void;
     _run(cancellationSignal: CancellationSignal): Promise<void>;
 }

package/notification/server/modules/notification-delivery-worker.module.js

@@ -4,23 +4,34 @@ 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 { CancellationSignal } from '../../../cancellation/token.js';
 import { afterResolve, inject, Singleton } from '../../../injector/index.js';
 import { Module } from '../../../module/module.js';
 import { NotificationChannel } from '../../../notification/models/index.js';
-import { InAppChannelProvider } from '../providers/index.js';
+import { EmailChannelProvider, InAppChannelProvider, WebPushChannelProvider } from '../providers/index.js';
 import { NotificationDeliveryWorker } from '../services/index.js';
 let NotificationDeliveryWorkerModule = class NotificationDeliveryWorkerModule extends Module {
     #notificationDeliveryWorker = inject(NotificationDeliveryWorker);
     #inAppChannelProvider = inject(InAppChannelProvider);
+    #emailChannelProvider = inject(EmailChannelProvider);
+    #webPushChannelProvider = inject(WebPushChannelProvider);
+    constructor() {
+        super('NotificationDeliveryWorker');
+    }
     [afterResolve]() {
         this.#notificationDeliveryWorker.registerProvider(NotificationChannel.InApp, this.#inAppChannelProvider);
+        this.#notificationDeliveryWorker.registerProvider(NotificationChannel.Email, this.#emailChannelProvider);
+        this.#notificationDeliveryWorker.registerProvider(NotificationChannel.WebPush, this.#webPushChannelProvider);
     }
     async _run(cancellationSignal) {
         await this.#notificationDeliveryWorker.run(cancellationSignal);
     }
 };
 NotificationDeliveryWorkerModule = __decorate([
-    Singleton()
+    Singleton(),
+    __metadata("design:paramtypes", [])
 ], NotificationDeliveryWorkerModule);
 export { NotificationDeliveryWorkerModule };

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

@@ -24,7 +24,7 @@ let InAppChannelProvider = class InAppChannelProvider extends ChannelProvider {
         });
         const inAppNotificationView = toInAppNotificationView(inApp, notification);
         const unreadCount = await this.#notificationService.withOptionalTransaction(tx).unreadCount(notification.tenantId, notification.userId);
-        await this.#sseService.send(inAppNotificationView, unreadCount);
+        await this.#sseService.dispatch(notification.tenantId, notification.userId, { notification: inAppNotificationView, unreadCount });
     }
 };
 InAppChannelProvider = __decorate([

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

@@ -1,13 +1,25 @@
 import { Subject } from 'rxjs';
 import { afterResolve } from '../../../injector/index.js';
+import type { TypedOmit } from '../../../types/index.js';
 import type { InAppNotificationView } from '../../models/index.js';
 import type { NotificationStreamItem } from '../../types.js';
+type NotificationBusMessage = {
+    tenantId: string;
+    userId: string;
+    notification?: InAppNotificationView;
+    readId?: string;
+    readAll?: boolean;
+    archiveId?: string;
+    archiveAll?: boolean;
+    unreadCount?: number;
+};
+export type NotificationBusMessageData = TypedOmit<NotificationBusMessage, 'tenantId' | 'userId'>;
 export declare class NotificationSseService {
     #private;
     [afterResolve](): 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>;
+    dispatch(tenantId: string, userId: string, data: NotificationBusMessageData): Promise<void>;
     private dispatchToLocal;
 }
+export {};

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

@@ -43,19 +43,11 @@ let NotificationSseService = class NotificationSseService {
         }
         source.complete();
     }
-    async send(notification, unreadCount) {
-        await this.#messageBus.publish({
-            tenantId: notification.tenantId,
-            userId: notification.userId,
-            notification,
-            unreadCount,
-        });
-    }
-    async dispatchUnreadCountUpdate(tenantId, userId, unreadCount) {
+    async dispatch(tenantId, userId, data) {
         await this.#messageBus.publish({
             tenantId,
             userId,
-            unreadCount,
+            ...data,
         });
     }
     dispatchToLocal(message) {
@@ -63,7 +55,14 @@ let NotificationSseService = class NotificationSseService {
         const userSources = tenantMap?.get(message.userId);
         if (userSources != null) {
             for (const source of userSources) {
-                source.next({ notification: message.notification, unreadCount: message.unreadCount });
+                source.next({
+                    notification: message.notification,
+                    readId: message.readId,
+                    readAll: message.readAll,
+                    archiveId: message.archiveId,
+                    archiveAll: message.archiveAll,
+                    unreadCount: message.unreadCount,
+                });
             }
         }
     }

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

@@ -20,8 +20,14 @@ export declare class NotificationService<Definitions extends NotificationDefinit
     archive(tenantId: string, userId: string, id: string): Promise<void>;
     archiveAll(tenantId: string, userId: string): Promise<void>;
     unreadCount(tenantId: string, userId: string): Promise<number>;
+    getCatchupData(tenantId: string, userId: string, lastNotificationId: string): Promise<{
+        unreadCount: number;
+        missedNotifications: InAppNotificationView[];
+        readIds: string[];
+        archiveIds: string[];
+    }>;
+    getTimestamp(tenantId: string, userId: string, inAppId: string): Promise<number>;
     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

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 var _a;
 var NotificationService_1;
-import { and, desc, eq, isNull, lt, or } from 'drizzle-orm';
+import { and, desc, eq, gt, 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';
@@ -14,7 +14,7 @@ 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 { isDefined, isNotNull } from '../../../utils/type-guards.js';
 import { InAppNotification, NotificationChannel, NotificationLogEntity, NotificationPreference, NotificationPriority, NotificationStatus, toInAppNotificationView, WebPushSubscription } from '../../models/index.js';
 import { inAppNotification, notificationLog } from '../schemas.js';
 import { NotificationAncillaryService } from './notification-ancillary.service.js';
@@ -77,19 +77,31 @@ let NotificationService = NotificationService_1 = class NotificationService exte
     }
     async markRead(tenantId, userId, id) {
         await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { readTimestamp: TRANSACTION_TIMESTAMP });
-        await this.dispatchUnreadCountUpdate(tenantId, userId);
+        await tryIgnoreLogAsync(this.#logger, async () => {
+            const unreadCount = await this.unreadCount(tenantId, userId);
+            await this.#sseService.dispatch(tenantId, userId, { readId: id, unreadCount });
+        });
     }
     async markAllRead(tenantId, userId) {
-        await this.#inAppNotificationRepository.updateByQuery({ tenantId, userId, readTimestamp: null }, { readTimestamp: TRANSACTION_TIMESTAMP });
-        await this.dispatchUnreadCountUpdate(tenantId, userId);
+        await this.#inAppNotificationRepository.updateManyByQuery({ tenantId, userId, readTimestamp: null }, { readTimestamp: TRANSACTION_TIMESTAMP });
+        await tryIgnoreLogAsync(this.#logger, async () => {
+            const unreadCount = await this.unreadCount(tenantId, userId);
+            await this.#sseService.dispatch(tenantId, userId, { readAll: true, unreadCount });
+        });
     }
     async archive(tenantId, userId, id) {
         await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
-        await this.dispatchUnreadCountUpdate(tenantId, userId);
+        await tryIgnoreLogAsync(this.#logger, async () => {
+            const unreadCount = await this.unreadCount(tenantId, userId);
+            await this.#sseService.dispatch(tenantId, userId, { archiveId: id, unreadCount });
+        });
     }
     async archiveAll(tenantId, userId) {
-        await this.#inAppNotificationRepository.updateByQuery({ tenantId, userId, archiveTimestamp: null }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
-        await this.dispatchUnreadCountUpdate(tenantId, userId);
+        await this.#inAppNotificationRepository.updateManyByQuery({ tenantId, userId, archiveTimestamp: null }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
+        await tryIgnoreLogAsync(this.#logger, async () => {
+            const unreadCount = await this.unreadCount(tenantId, userId);
+            await this.#sseService.dispatch(tenantId, userId, { archiveAll: true, unreadCount });
+        });
     }
     async unreadCount(tenantId, userId) {
         return await this.#inAppNotificationRepository.countByQuery({
@@ -99,6 +111,30 @@ let NotificationService = NotificationService_1 = class NotificationService exte
             archiveTimestamp: null,
         });
     }
+    async getCatchupData(tenantId, userId, lastNotificationId) {
+        const lastTimestamp = await this.getTimestamp(tenantId, userId, lastNotificationId);
+        const [unreadCount, missedNotifications, readAndArchived] = await Promise.all([
+            this.unreadCount(tenantId, userId),
+            this.listInApp(tenantId, userId, { after: lastNotificationId, limit: 50 }),
+            this.#inAppNotificationRepository.session
+                .select({
+                id: inAppNotification.id,
+                readTimestamp: inAppNotification.readTimestamp,
+                archiveTimestamp: inAppNotification.archiveTimestamp,
+            })
+                .from(inAppNotification)
+                .where(and(eq(inAppNotification.tenantId, tenantId), eq(inAppNotification.userId, userId), or(gt(inAppNotification.readTimestamp, lastTimestamp), gt(inAppNotification.archiveTimestamp, lastTimestamp))))
+                .limit(50),
+        ]);
+        const readIds = readAndArchived.filter((row) => isNotNull(row.readTimestamp) && (row.readTimestamp > lastTimestamp)).map((row) => row.id);
+        const archiveIds = readAndArchived.filter((row) => isNotNull(row.archiveTimestamp) && (row.archiveTimestamp > lastTimestamp)).map((row) => row.id);
+        return { unreadCount, missedNotifications, readIds, archiveIds };
+    }
+    async getTimestamp(tenantId, userId, inAppId) {
+        const inApp = await this.#inAppNotificationRepository.loadByQuery({ tenantId, userId, id: inAppId });
+        const log = await this.#notificationLogRepository.loadByQuery({ tenantId, userId, id: inApp.logId });
+        return log.timestamp;
+    }
     async getPreferences(tenantId, userId) {
         return await this.#preferenceRepository.loadManyByQuery({ tenantId, userId });
     }
@@ -132,12 +168,6 @@ let NotificationService = NotificationService_1 = class NotificationService exte
             auth,
         });
     }
-    async dispatchUnreadCountUpdate(tenantId, userId) {
-        await tryIgnoreLogAsync(this.#logger, async () => {
-            const unreadCount = await this.unreadCount(tenantId, userId);
-            await this.#sseService.dispatchUnreadCountUpdate(tenantId, userId, unreadCount);
-        });
-    }
 };
 NotificationService = NotificationService_1 = __decorate([
     Singleton()

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

@@ -13,8 +13,8 @@ describe('NotificationSseService', () => {
             expect(source).toBeDefined();
             // 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, 1)).resolves.not.toThrow();
+            const msg = { id: 'l1', tenantId, userId, logId: 'l1' };
+            await expect(service.dispatch(tenantId, userId, { notification: msg, unreadCount: 1 })).resolves.not.toThrow();
         });
     });
     test('should dispatch unread count update', async () => {
@@ -23,7 +23,28 @@ describe('NotificationSseService', () => {
         const tenantId = 't1';
         const userId = 'u1';
         await runInInjectionContext(injector, async () => {
-            await expect(service.dispatchUnreadCountUpdate(tenantId, userId, 5)).resolves.not.toThrow();
+            const source = service.register(tenantId, userId);
+            const messages = [];
+            source.subscribe((msg) => messages.push(msg));
+            await service.dispatch(tenantId, userId, { unreadCount: 5 });
+            expect(messages).toHaveLength(1);
+            expect(messages[0]).toEqual({ unreadCount: 5 });
+        });
+    });
+    test('should dispatch mark read and mark all read', 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 () => {
+            const source = service.register(tenantId, userId);
+            const messages = [];
+            source.subscribe((msg) => messages.push(msg));
+            await service.dispatch(tenantId, userId, { readId: 'n1', unreadCount: 2 });
+            await service.dispatch(tenantId, userId, { readAll: true, unreadCount: 0 });
+            expect(messages).toHaveLength(2);
+            expect(messages[0]).toEqual({ readId: 'n1', unreadCount: 2 });
+            expect(messages[1]).toEqual({ readAll: true, unreadCount: 0 });
         });
     });
 });

package/notification/types.d.ts

@@ -1,9 +1,17 @@
 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;
+    readId?: string | undefined;
+    readAll?: boolean | undefined;
+    archiveId?: string | undefined;
+    archiveAll?: boolean | undefined;
+    unreadCount?: number | undefined;
 }>;
 export type NotificationStreamItem<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> = {
     notification?: InAppNotificationView<Definitions>;
-    unreadCount: number;
+    readId?: string;
+    readAll?: boolean;
+    archiveId?: string;
+    archiveAll?: boolean;
+    unreadCount?: number;
 };

package/notification/types.js

@@ -1,6 +1,10 @@
-import { number, object, optional } from '../schema/index.js';
+import { boolean, number, object, optional, string } from '../schema/index.js';
 import { InAppNotificationView } from './models/index.js';
 export const notificationStreamItemSchema = object({
     notification: optional(InAppNotificationView),
-    unreadCount: number(),
+    readId: optional(string()),
+    readAll: optional(boolean()),
+    archiveId: optional(string()),
+    archiveAll: optional(boolean()),
+    unreadCount: optional(number()),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.121",
+  "version": "0.93.123",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/sse/data-stream-source.d.ts

@@ -2,20 +2,23 @@ import type { UndefinableJson } from '../types/types.js';
 import type { AnyIterable } from '../utils/any-iterable-iterator.js';
 import { ServerSentEventsSource } from './server-sent-events-source.js';
 export type DataStreamErrorFormatter = (error: unknown) => UndefinableJson;
-export type DataStreamSourceOptions = {
+export type DataStreamSourceOptions<T> = {
     /**
      * Whether to send deltas (the changes) between the last and current data or always the full data.
+     * Useful when the target data is a full "state object".
+     * For notification-like streams, where only new items are sent, delta should usually be disabled.
      */
     delta?: boolean;
     errorFormatter?: DataStreamErrorFormatter;
+    idProvider?: (data: T) => string | undefined;
 };
 export declare class DataStreamSource<T> {
     #private;
     readonly eventSource: ServerSentEventsSource;
     readonly closed: import("../signals/api.js").Signal<boolean>;
-    constructor({ delta, errorFormatter }?: DataStreamSourceOptions);
-    static fromIterable<T>(iterable: AnyIterable<T>, options?: DataStreamSourceOptions): DataStreamSource<T>;
-    send(data: T): Promise<void>;
+    constructor({ delta, errorFormatter, idProvider }?: DataStreamSourceOptions<T>);
+    static fromIterable<T>(iterable: AnyIterable<T>, options?: DataStreamSourceOptions<T>): DataStreamSource<T>;
+    send(data: T, id?: string): Promise<void>;
     close(): Promise<void>;
     error(error: unknown): Promise<void>;
 }

package/sse/data-stream-source.js

@@ -16,12 +16,14 @@ const jsonDiffPatch = createDiffPatch({
 export class DataStreamSource {
     #useDelta;
     #errorFormatter;
+    #idProvider;
     eventSource = new ServerSentEventsSource();
     closed = this.eventSource.closed;
     #lastData;
-    constructor({ delta = true, errorFormatter } = {}) {
+    constructor({ delta = true, errorFormatter, idProvider } = {}) {
         this.#useDelta = delta;
         this.#errorFormatter = errorFormatter ?? defaultErrorFormatter;
+        this.#idProvider = idProvider;
     }
     static fromIterable(iterable, options) {
         const source = new DataStreamSource(options);
@@ -43,16 +45,17 @@ export class DataStreamSource {
         })();
         return source;
     }
-    async send(data) {
+    async send(data, id) {
         if (this.eventSource.closed()) {
             throw new Error('Cannot send data to a closed DataStreamSource connection.');
         }
+        const eventId = id ?? this.#idProvider?.(data);
         if (this.#useDelta && isDefined(this.#lastData)) {
             const delta = jsonDiffPatch.diff(this.#lastData, data);
-            await this.eventSource.sendJson({ name: 'delta', data: delta });
+            await this.eventSource.sendJson({ name: 'delta', data: delta, id: eventId });
         }
         else {
-            await this.eventSource.sendJson({ name: 'data', data });
+            await this.eventSource.sendJson({ name: 'data', data, id: eventId });
         }
         if (this.#useDelta) {
             this.#lastData = data;