@tstdl/base 0.93.171 → 0.93.172

package/api/server/gateway.js

@@ -202,7 +202,7 @@ let ApiGateway = ApiGateway_1 = class ApiGateway {
             abortSignal: context.abortSignal,
             serverSentEvents: {
                 get lastEventId() {
-                    return context.request.headers.tryGetSingle('Last-Event-ID');
+                    return (context.request.headers.tryGetSingle('Last-Event-ID') ?? context.request.query.tryGetSingle('lastEventId'));
                 },
             },
             tryGetToken: async () => {

package/api/server/middlewares/server-sent-events.middleware.js

@@ -1,4 +1,6 @@
+import { DataStream, ServerSentEvents } from '../../../sse/index.js';
 import { toArray } from '../../../utils/array/array.js';
+import { isDefined } from '../../../utils/type-guards.js';
 /**
  * Middleware that adds required CORS headers for SSE and cache busting.
  * @param context Gateway context.
@@ -6,13 +8,24 @@ import { toArray } from '../../../utils/array/array.js';
  */
 export async function serverSentEventsMiddleware(context, next) {
     await next();
-    if ((context.response.bodyType != 'events') || (context.request.method != 'OPTIONS')) {
-        return;
+    const isEvents = (context.response.bodyType == 'events');
+    const isOptions = (context.request.method == 'OPTIONS');
+    if (isEvents) {
+        context.response.headers.setIfMissing('Cache-Control', 'no-cache');
+        context.response.headers.setIfMissing('Connection', 'keep-alive');
+        context.response.headers.setIfMissing('X-Accel-Buffering', 'no');
+    }
+    if (isOptions) {
+        const requestMethod = context.request.headers.tryGetSingle('Access-Control-Request-Method') ?? context.request.method;
+        const endpointDefinition = context.api.endpoints.get(requestMethod)?.definition;
+        const isSse = isDefined(endpointDefinition) && ((endpointDefinition.result == DataStream) || (endpointDefinition.result == ServerSentEvents));
+        if (isSse || (endpointDefinition?.bustCache == true)) {
+            const existing = context.response.headers.tryGet('Access-Control-Allow-Headers');
+            const items = toArray(existing).flatMap((header) => header?.split(',') ?? []).map((header) => header.trim()).filter((header) => header.length > 0);
+            const headers = new Set(items);
+            headers.add('Cache-Control');
+            headers.add('Last-Event-ID');
+            context.response.headers.set('Access-Control-Allow-Headers', [...headers].join(', '));
+        }
     }
-    const existing = context.response.headers.tryGet('Access-Control-Allow-Headers');
-    const items = toArray(existing).flatMap((header) => header?.split(',') ?? []).map((header) => header.trim()).filter((header) => header.length > 0);
-    const headers = new Set(items);
-    headers.add('Cache-Control');
-    headers.add('Last-Event-ID');
-    context.response.headers.set('Access-Control-Allow-Headers', [...headers].join(', '));
 }

package/api/utils.d.ts

@@ -5,6 +5,5 @@ type GetApiEndpointUrlData = {
     defaultPrefix: string | undefined | null;
     explicitVersion?: number | null;
 };
-export declare const defaultAccessControlAllowHeaders = "Content-Type, Authorization";
 export declare function getFullApiEndpointResource({ api, endpoint, defaultPrefix, explicitVersion }: GetApiEndpointUrlData): string;
 export {};

package/api/utils.js

@@ -2,7 +2,6 @@ import { toArray } from '../utils/array/array.js';
 import { compareByValueDescending } from '../utils/comparison.js';
 import { sort } from '../utils/iterable-helpers/sort.js';
 import { isDefined, isNull } from '../utils/type-guards.js';
-export const defaultAccessControlAllowHeaders = 'Content-Type, Authorization';
 export function getFullApiEndpointResource({ api, endpoint, defaultPrefix, explicitVersion }) {
     const versionArray = toArray(isDefined(explicitVersion) ? explicitVersion : endpoint.version);
     const version = sort(versionArray, compareByValueDescending)[0];

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

@@ -15,6 +15,7 @@ export declare const notificationApiDefinition: {
             credentials: true;
             dataStream: {
                 idProvider: () => string;
+                heartbeatInterval: number;
             };
         };
         types: {
@@ -131,6 +132,7 @@ declare const _NotificationApiClient: import("../../api/client/index.js").ApiCli
             credentials: true;
             dataStream: {
                 idProvider: () => string;
+                heartbeatInterval: number;
             };
         };
         types: {

package/notification/api/notification.api.js

@@ -22,6 +22,7 @@ export const notificationApiDefinition = defineApi({
             credentials: true,
             dataStream: {
                 idProvider: () => currentTimestamp().toString(),
+                heartbeatInterval: 15000,
             },
         },
         types: {

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

@@ -21,7 +21,8 @@ let NotificationApiController = class NotificationApiController {
         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));
+        const abortHandler = () => this.sseService.unregister(token.payload.tenant, token.payload.subject, source);
+        abortSignal.addEventListener('abort', abortHandler, { once: true });
         try {
             if (isDefined(lastEventId)) {
                 const lastEventIdNumber = Number(lastEventId);
@@ -41,6 +42,7 @@ let NotificationApiController = class NotificationApiController {
             yield* asyncIterable;
         }
         finally {
+            abortSignal.removeEventListener('abort', abortHandler);
             this.sseService.unregister(token.payload.tenant, token.payload.subject, source);
         }
     }

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

@@ -14,9 +14,10 @@ type NotificationBusMessage = {
     unreadCount?: number;
 };
 export type NotificationBusMessageData = TypedOmit<NotificationBusMessage, 'tenantId' | 'userId'>;
-export declare class NotificationSseService {
+export declare class NotificationSseService implements Disposable {
     #private;
     [afterResolve](): void;
+    [Symbol.dispose](): void;
     register(tenantId: string, userId: string): Subject<NotificationStreamItem>;
     unregister(tenantId: string, userId: string, source: Subject<NotificationStreamItem>): void;
     dispatch(tenantId: string, userId: string, data: NotificationBusMessageData): Promise<void>;

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

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Subject } from 'rxjs';
 import { afterResolve, inject, Singleton } from '../../../injector/index.js';
 import { MessageBusProvider } from '../../../message-bus/index.js';
+import { isDefined, isUndefined } from '../../../utils/type-guards.js';
 let NotificationSseService = class NotificationSseService {
     #messageBusProvider = inject(MessageBusProvider);
     #messageBus = this.#messageBusProvider.get('notification');
@@ -14,6 +15,16 @@ let NotificationSseService = class NotificationSseService {
     [afterResolve]() {
         this.#messageBus.allMessages$.subscribe((message) => this.dispatchToLocal(message));
     }
+    [Symbol.dispose]() {
+        for (const tenantMap of this.#sources.values()) {
+            for (const userSources of tenantMap.values()) {
+                for (const source of userSources) {
+                    source.complete();
+                }
+            }
+        }
+        this.#sources.clear();
+    }
     register(tenantId, userId) {
         const source = new Subject();
         let tenantMap = this.#sources.get(tenantId);
@@ -31,15 +42,17 @@ let NotificationSseService = class NotificationSseService {
     }
     unregister(tenantId, userId, source) {
         const tenantMap = this.#sources.get(tenantId);
-        const userSources = tenantMap?.get(userId);
-        if (userSources) {
-            userSources.delete(source);
-            if (userSources.size == 0) {
-                tenantMap?.delete(userId);
+        if (isDefined(tenantMap)) {
+            const userSources = tenantMap.get(userId);
+            if (isDefined(userSources)) {
+                userSources.delete(source);
+                if (userSources.size == 0) {
+                    tenantMap.delete(userId);
+                }
+            }
+            if (tenantMap.size == 0) {
+                this.#sources.delete(tenantId);
             }
-        }
-        if (tenantMap?.size == 0) {
-            this.#sources.delete(tenantId);
         }
         source.complete();
     }
@@ -53,17 +66,19 @@ let NotificationSseService = class NotificationSseService {
     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: message.notification,
-                    readId: message.readId,
-                    readAll: message.readAll,
-                    archiveId: message.archiveId,
-                    archiveAll: message.archiveAll,
-                    unreadCount: message.unreadCount,
-                });
-            }
+        if (isUndefined(userSources)) {
+            return;
+        }
+        const item = {
+            notification: message.notification,
+            readId: message.readId,
+            readAll: message.readAll,
+            archiveId: message.archiveId,
+            archiveAll: message.archiveAll,
+            unreadCount: message.unreadCount,
+        };
+        for (const source of userSources) {
+            source.next(item);
         }
     }
 };

package/package.json

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

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

@@ -1,3 +1,4 @@
+import type { Signal } from '../signals/index.js';
 import type { UndefinableJson } from '../types/types.js';
 import type { AnyIterable } from '../utils/any-iterable-iterator.js';
 import { ServerSentEventsSource } from './server-sent-events-source.js';
@@ -9,14 +10,18 @@ export type DataStreamSourceOptions<T> = {
      * For notification-like streams, where only new items are sent, delta should usually be disabled.
      */
     delta?: boolean;
+    /** Interval in milliseconds to send a heartbeat (SSE comment). */
+    heartbeatInterval?: number;
+    /** Initial retry recommendation for consumers in milliseconds. */
+    retry?: number;
     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, idProvider }?: DataStreamSourceOptions<T>);
+    readonly closed: Signal<boolean>;
+    constructor(options?: DataStreamSourceOptions<T>);
     static fromIterable<T>(iterable: AnyIterable<T>, options?: DataStreamSourceOptions<T>): DataStreamSource<T>;
     send(data: T, id?: string): Promise<void>;
     close(): Promise<void>;

package/sse/data-stream-source.js

@@ -17,13 +17,16 @@ export class DataStreamSource {
     #useDelta;
     #errorFormatter;
     #idProvider;
-    eventSource = new ServerSentEventsSource();
-    closed = this.eventSource.closed;
+    eventSource;
+    closed;
     #lastData;
-    constructor({ delta = true, errorFormatter, idProvider } = {}) {
+    constructor(options = {}) {
+        const { delta = true, errorFormatter, idProvider, heartbeatInterval, retry } = options;
         this.#useDelta = delta;
         this.#errorFormatter = errorFormatter ?? defaultErrorFormatter;
         this.#idProvider = idProvider;
+        this.eventSource = new ServerSentEventsSource({ heartbeatInterval, retry });
+        this.closed = this.eventSource.closed;
     }
     static fromIterable(iterable, options) {
         const source = new DataStreamSource(options);

package/sse/server-sent-events-source.d.ts

@@ -1,10 +1,16 @@
 import type { ServerSentJsonEvent, ServerSentTextEvent } from './model.js';
+export type ServerSentEventsSourceOptions = {
+    /** Interval in milliseconds to send a heartbeat (SSE comment). */
+    heartbeatInterval?: number;
+    /** Initial retry recommendation for consumers in milliseconds. */
+    retry?: number;
+};
 export declare class ServerSentEventsSource {
     #private;
     readonly readable: ReadableStream<string>;
     readonly closed: import("../signals/api.js").Signal<boolean>;
     readonly error: import("../signals/api.js").Signal<Error | undefined>;
-    constructor();
+    constructor(options?: ServerSentEventsSourceOptions);
     close(): Promise<void>;
     sendComment(comment: string): Promise<void>;
     sendText({ name, data, id, retry }: ServerSentTextEvent): Promise<void>;

package/sse/server-sent-events-source.js

@@ -8,17 +8,35 @@ export class ServerSentEventsSource {
     readable;
     closed = this.#closed.asReadonly();
     error = this.#error.asReadonly();
-    constructor() {
+    constructor(options) {
         const { writable, readable } = new TransformStream();
         this.#writable = writable;
         this.readable = readable;
         this.#writer = this.#writable.getWriter();
+        let interval;
         this.#writer.closed
-            .then(() => (this.#closed.set(true)))
+            .then(() => {
+            this.#closed.set(true);
+            clearInterval(interval);
+        })
             .catch((error) => {
             this.#error.set(error);
             this.#closed.set(true);
+            clearInterval(interval);
         });
+        if (isDefined(options?.retry)) {
+            void this.sendText({ retry: options.retry });
+        }
+        if (isDefined(options?.heartbeatInterval)) {
+            interval = setInterval(() => {
+                if (this.#closed()) {
+                    clearInterval(interval);
+                    return;
+                }
+                void this.sendComment('').catch(() => { });
+            }, options.heartbeatInterval);
+            interval.unref?.();
+        }
     }
     async close() {
         await this.#writer.close();