@tstdl/base 0.93.105 → 0.93.106

package/api/server/gateway.d.ts

@@ -14,6 +14,7 @@ export type ApiGatewayMiddlewareContext = {
     readonly resourcePatternResult: URLPatternResult;
     readonly request: HttpServerRequest;
     readonly response: HttpServerResponse;
+    readonly abortSignal: AbortSignal;
 };
 export type ApiGatewayMiddlewareNext = AsyncMiddlewareNext;
 export type ApiGatewayMiddleware = AsyncMiddleware<ApiGatewayMiddlewareContext>;
@@ -59,7 +60,7 @@ export declare class ApiGateway implements Resolvable<ApiGatewayOptions> {
     addMiddleware(middleware: ApiGatewayMiddleware): void;
     supressErrors(...errorTypes: Type<Error>[]): void;
     registerApi<T extends ApiDefinition>(definition: ApiDefinition, implementation: ApiController<T>): void;
-    handleHttpServerRequestContext({ request, respond, close }: HttpServerRequestContext): Promise<void>;
+    handleHttpServerRequestContext({ request, abortSignal, respond, close }: HttpServerRequestContext): Promise<void>;
     getApiMetadata(resource: URL): ApiMetadata;
     private updateMiddleware;
     private endpointMiddleware;

package/api/server/gateway.js

@@ -121,13 +121,13 @@ let ApiGateway = ApiGateway_1 = class ApiGateway {
             }
         }
     }
-    async handleHttpServerRequestContext({ request, respond, close }) {
+    async handleHttpServerRequestContext({ request, abortSignal, respond, close }) {
         let responded = false;
         const response = new HttpServerResponse();
         try {
             const { api, patternResult } = this.getApiMetadata(request.url);
             const endpoint = api.endpoints.get(request.method);
-            const context = { api, resourcePatternResult: patternResult, endpoint, request, response };
+            const context = { api, resourcePatternResult: patternResult, endpoint, request, response, abortSignal };
             await this.#composedMiddleware(context);
             responded = true;
             await respond(context.response);
@@ -198,6 +198,7 @@ let ApiGateway = ApiGateway_1 = class ApiGateway {
             parameters: validatedParameters,
             body,
             request: context.request,
+            abortSignal: context.abortSignal,
             tryGetToken: async () => {
                 return await requestTokenProvider.tryGetToken(requestContext);
             },

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 } from '../sse/index.js';
+import type { DataStream, DataStreamSource } 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';
@@ -95,7 +95,7 @@ export type ApiEndpointParametersSchema<T extends ApiDefinition, K extends ApiEn
 export type ApiEndpointBodySchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['body']>;
 export type ApiEndpointResultSchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['result']>;
 export type ApiBinaryType = typeof Uint8Array | typeof Blob | typeof ReadableStream;
-export type ApiInputType<T extends SchemaTestable> = T extends ApiBinaryType ? InstanceType<Exclude<ApiBinaryType, typeof ReadableStream> | typeof ReadableStream<Uint8Array<ArrayBuffer>>> : T extends typeof ServerSentEvents ? ServerSentEventsSource : T extends typeof DataStream<infer U> ? AsyncIterable<U> : T extends SchemaTestable ? SchemaOutput<T> : never;
+export type ApiInputType<T extends SchemaTestable> = T extends ApiBinaryType ? InstanceType<Exclude<ApiBinaryType, typeof ReadableStream> | typeof ReadableStream<Uint8Array<ArrayBuffer>>> : T extends typeof ServerSentEvents ? ServerSentEventsSource : T extends typeof DataStream<infer U> ? AsyncIterable<U> | DataStreamSource<U> : T extends SchemaTestable ? SchemaOutput<T> : never;
 export type ApiOutputType<T extends SchemaTestable> = T extends typeof ReadableStream ? ReadableStream<Uint8Array<ArrayBuffer>> : T extends typeof DataStream<infer U> ? Observable<U> : T extends SchemaTestable ? SchemaOutput<T> : never;
 export type ApiParameters<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointParametersSchema<T, K>>;
 export type ApiClientBody<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointBodySchema<T, K>>;
@@ -106,6 +106,7 @@ export type ApiRequestData<T extends ApiDefinition = ApiDefinition, K extends Ap
     parameters: ApiParameters<T, K>;
     body: ApiServerBody<T, K>;
     request: HttpServerRequest;
+    abortSignal: AbortSignal;
 };
 export type ApiRequestContext<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = ApiRequestData<T, K> & {
     tryGetToken<T extends Token>(): Promise<T | null>;

package/document-management/server/services/document-file.service.js

@@ -73,7 +73,7 @@ import { currentTimestamp } from '../../../utils/date-time.js';
 import { getRandomString } from '../../../utils/random.js';
 import { readableStreamFromPromise, readBinaryStream } from '../../../utils/stream/index.js';
 import { isDefined, isNotReadableStream, isNotUint8Array, isUint8Array } from '../../../utils/type-guards.js';
-import { millisecondsPerMinute, secondsPerMinute } from '../../../utils/units.js';
+import { millisecondsPerMinute } from '../../../utils/units.js';
 import { Document } from '../../models/index.js';
 import { DocumentManagementConfiguration } from '../module.js';
 import { DocumentManagementSingleton } from './singleton.js';

package/http/server/http-server.d.ts

@@ -1,6 +1,7 @@
 import type { HttpServerRequest, HttpServerResponse } from '../../http/server/index.js';
 export type HttpServerRequestContext<Context = unknown> = {
     request: HttpServerRequest;
+    abortSignal: AbortSignal;
     context: Context;
     respond(response: HttpServerResponse): Promise<void>;
     close(): Promise<void>;

package/http/server/node/node-http-server.js

@@ -116,8 +116,11 @@ let NodeHttpServer = NodeHttpServer_1 = class NodeHttpServer extends HttpServer
             ip: clientIp,
             body: request,
         });
+        const abortController = new AbortController();
+        response.on('close', () => abortController.abort());
         const item = {
             request: httpRequest,
+            abortSignal: abortController.signal,
             respond: getResponder(response),
             context,
             async close() {

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

@@ -1,4 +1,4 @@
-import { ServerSentEvents } from '../../sse/server-sent-events.js';
+import { DataStream } from '../../sse/data-stream.js';
 import { InAppNotificationView } from '../models/in-app-notification.model.js';
 export declare const notificationApiDefinition: {
     resource: string;
@@ -6,7 +6,11 @@ export declare const notificationApiDefinition: {
         stream: {
             resource: string;
             method: "GET";
-            result: typeof ServerSentEvents;
+            result: {
+                new (): DataStream<InAppNotificationView<Record<string, import("../models/notification-log.model.js").NotificationDefinition<import("../../types/types.js").ObjectLiteral, import("../../types/types.js").ObjectLiteral>>>>;
+                parse<T>(eventSource: import("../../sse/server-sent-events.js").ServerSentEvents): import("rxjs").Observable<T>;
+            };
+            credentials: true;
         };
         listInApp: {
             resource: string;
@@ -16,7 +20,8 @@ export declare const notificationApiDefinition: {
                 limit?: number | undefined;
                 includeArchived?: boolean | undefined;
             }>;
-            result: import("../../schema/index.js").ArraySchema<InAppNotificationView>;
+            result: import("../../schema/index.js").ArraySchema<InAppNotificationView<Record<string, import("../models/notification-log.model.js").NotificationDefinition<import("../../types/types.js").ObjectLiteral, import("../../types/types.js").ObjectLiteral>>>>;
+            credentials: true;
         };
         markRead: {
             resource: string;
@@ -25,6 +30,7 @@ export declare const notificationApiDefinition: {
                 id: string;
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
+            credentials: true;
         };
         archive: {
             resource: string;
@@ -33,6 +39,7 @@ export declare const notificationApiDefinition: {
                 id: string;
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
+            credentials: true;
         };
         getPreferences: {
             resource: string;
@@ -42,6 +49,7 @@ export declare const notificationApiDefinition: {
                 enabled: boolean;
                 channel: "email" | "in-app" | "web-push";
             }>;
+            credentials: true;
         };
         updatePreference: {
             resource: string;
@@ -52,6 +60,7 @@ export declare const notificationApiDefinition: {
                 readonly enabled: boolean;
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
+            credentials: true;
         };
         registerWebPush: {
             resource: string;
@@ -64,6 +73,7 @@ export declare const notificationApiDefinition: {
                 };
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
+            credentials: true;
         };
     };
 };

package/notification/api/notification.api.js

@@ -1,6 +1,6 @@
 import { defineApi } from '../../api/types.js';
 import { array, boolean, enumeration, explicitObject, literal, number, object, optional, string } from '../../schema/index.js';
-import { ServerSentEvents } from '../../sse/server-sent-events.js';
+import { DataStream } from '../../sse/data-stream.js';
 import { InAppNotificationView } from '../models/in-app-notification.model.js';
 import { NotificationChannel } from '../models/index.js';
 export const notificationApiDefinition = defineApi({
@@ -9,7 +9,8 @@ export const notificationApiDefinition = defineApi({
         stream: {
             resource: 'stream',
             method: 'GET',
-            result: ServerSentEvents,
+            result: (DataStream),
+            credentials: true,
         },
         listInApp: {
             resource: 'in-app',
@@ -20,18 +21,21 @@ export const notificationApiDefinition = defineApi({
                 includeArchived: optional(boolean()),
             }),
             result: array(InAppNotificationView),
+            credentials: true,
         },
         markRead: {
             resource: 'in-app/:id/read',
             method: 'POST',
             parameters: object({ id: string() }),
             result: literal('ok'),
+            credentials: true,
         },
         archive: {
             resource: 'in-app/:id/archive',
             method: 'POST',
             parameters: object({ id: string() }),
             result: literal('ok'),
+            credentials: true,
         },
         getPreferences: {
             resource: 'preferences',
@@ -41,6 +45,7 @@ export const notificationApiDefinition = defineApi({
                 channel: enumeration(NotificationChannel),
                 enabled: boolean(),
             })),
+            credentials: true,
         },
         updatePreference: {
             resource: 'preferences',
@@ -51,6 +56,7 @@ export const notificationApiDefinition = defineApi({
                 enabled: boolean(),
             }),
             result: literal('ok'),
+            credentials: true,
         },
         registerWebPush: {
             resource: 'web-push/register',
@@ -63,6 +69,7 @@ export const notificationApiDefinition = defineApi({
                 }),
             }),
             result: literal('ok'),
+            credentials: true,
         },
     },
 });

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

@@ -1,6 +1,6 @@
 import { TenantBaseEntity, type Uuid } from '../../orm/index.js';
 import type { Timestamp } from '../../orm/types.js';
-import { type NotificationLog } from './notification-log.model.js';
+import { type NotificationDefinitionMap, type NotificationLogView } from './notification-log.model.js';
 export declare class InAppNotification extends TenantBaseEntity {
     static readonly entityName = "InAppNotification";
     userId: Uuid;
@@ -8,7 +8,7 @@ export declare class InAppNotification extends TenantBaseEntity {
     readTimestamp: Timestamp | null;
     archiveTimestamp: Timestamp | null;
 }
-export declare class InAppNotificationView extends InAppNotification {
-    notification: NotificationLog;
+export declare class InAppNotificationView<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> extends InAppNotification {
+    notification: NotificationLogView<Definitions>;
 }
-export declare function toInAppNotificationView(inAppNotification: InAppNotification, notification: NotificationLog): InAppNotificationView;
+export declare function toInAppNotificationView<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap>(inAppNotification: InAppNotification, notification: NotificationLogView<Definitions>): InAppNotificationView<Definitions>;

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

@@ -22,12 +22,14 @@ export declare const NotificationStatus: {
     readonly Failed: "failed";
 };
 export type NotificationStatus = EnumType<typeof NotificationStatus>;
-export type NotificationDefinition<Payload extends ObjectLiteral = ObjectLiteral> = {
-    payload: Payload;
+export type NotificationDefinition<Payload extends ObjectLiteral = ObjectLiteral, View extends ObjectLiteral = ObjectLiteral> = {
+    payload?: Payload;
+    view?: View;
 };
 export type NotificationDefinitionMap<Definition extends Record<string, NotificationDefinition> = Record<string, NotificationDefinition>> = Definition;
 export type NotificationTypes<Definitions extends NotificationDefinitionMap> = Extract<keyof Definitions, string>;
-export type NotificationPayload<Definitions extends NotificationDefinitionMap, Type extends NotificationTypes<Definitions>> = Definitions[Type]['payload'];
+export type NotificationPayload<Definitions extends NotificationDefinitionMap, Type extends NotificationTypes<Definitions> = NotificationTypes<Definitions>> = Definitions[Type]['payload'];
+export type NotificationView<Definitions extends NotificationDefinitionMap, Type extends NotificationTypes<Definitions> = NotificationTypes<Definitions>> = Definitions[Type]['view'];
 export type NotificationOfType<Definitions extends NotificationDefinitionMap, Type extends NotificationTypes<Definitions>> = string extends NotificationTypes<Definitions> ? NotificationLog<Definitions> & {
     type: Type;
 } : Extract<NotificationLog<Definitions>, {
@@ -39,6 +41,13 @@ export type NotificationLog<Definitions extends NotificationDefinitionMap = Noti
         payload: Json<NotificationPayload<Definitions, Type>> | null;
     };
 }[NotificationTypes<Definitions>];
+export type NotificationLogView<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> = {
+    [Type in NotificationTypes<Definitions>]: Omit<NotificationLogEntity<Definitions, Type>, 'type' | 'payload'> & {
+        type: Type;
+        payload: NotificationPayload<Definitions, Type>;
+        view: NotificationView<Definitions, Type>;
+    };
+}[NotificationTypes<Definitions>];
 export declare class NotificationLogEntity<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap, Type extends NotificationTypes<Definitions> = NotificationTypes<Definitions>> extends TenantEntity {
     static readonly entityName = "NotificationLog";
     userId: Uuid;
@@ -48,3 +57,6 @@ export declare class NotificationLogEntity<Definitions extends NotificationDefin
     currentStep: number;
     payload: Json<NotificationPayload<Definitions, Type>> | null;
 }
+export declare class NotificationLogViewEntity<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap, Type extends NotificationTypes<Definitions> = NotificationTypes<Definitions>> extends NotificationLogEntity<Definitions, Type> {
+    view?: unknown;
+}

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

@@ -10,7 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { User } from '../../authentication/models/user.model.js';
 import { defineEnum } from '../../enumeration/index.js';
 import { JsonProperty, Reference, TenantEntity, TenantReference, Unique, UuidProperty } from '../../orm/index.js';
-import { Enumeration, Integer, StringProperty } from '../../schema/index.js';
+import { Enumeration, Integer, StringProperty, Unknown } from '../../schema/index.js';
 import { NotificationTable } from './notification-table.js';
 import { NotificationType } from './notification-type.model.js';
 export const NotificationChannel = defineEnum('NotificationChannel', {
@@ -71,3 +71,10 @@ NotificationLogEntity = __decorate([
     Unique(['tenantId', 'id', 'userId'])
 ], NotificationLogEntity);
 export { NotificationLogEntity };
+export class NotificationLogViewEntity extends NotificationLogEntity {
+    view;
+}
+__decorate([
+    Unknown(),
+    __metadata("design:type", Object)
+], NotificationLogViewEntity.prototype, "view", void 0);

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

@@ -1,12 +1,11 @@
-import type { ApiController, ApiRequestContext } from '../../../api/types.js';
-import type { ServerSentEventsSource } from '../../../sse/server-sent-events-source.js';
+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 { NotificationService } from '../services/notification.service.js';
 export declare class NotificationApiController implements ApiController<NotificationApiDefinition> {
-    protected readonly notificationService: NotificationService;
+    protected readonly notificationService: NotificationService<Record<string, import("../../index.js").NotificationDefinition<import("../../../types/types.js").ObjectLiteral, import("../../../types/types.js").ObjectLiteral>>>;
     protected readonly sseService: NotificationSseService;
-    stream({ getToken }: ApiRequestContext<NotificationApiDefinition, 'stream'>): Promise<ServerSentEventsSource>;
+    stream({ abortSignal, getToken }: ApiRequestContext<NotificationApiDefinition, 'stream'>): ApiServerResult<NotificationApiDefinition, 'stream'>;
     listInApp({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'listInApp'>): Promise<any>;
     markRead({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'markRead'>): Promise<'ok'>;
     archive({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'archive'>): Promise<'ok'>;

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

@@ -6,6 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 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 { notificationApiDefinition } from '../../api/notification.api.js';
 import { NotificationSseService } from '../services/notification-sse.service.js';
@@ -13,9 +14,17 @@ import { NotificationService } from '../services/notification.service.js';
 let NotificationApiController = class NotificationApiController {
     notificationService = inject(NotificationService);
     sseService = inject(NotificationSseService);
-    async stream({ getToken }) {
+    async *stream({ abortSignal, getToken }) {
         const token = await getToken();
-        return this.sseService.register(token.payload.tenant, token.payload.subject);
+        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 {
+            yield* asyncIterable;
+        }
+        finally {
+            this.sseService.unregister(token.payload.tenant, token.payload.subject, source);
+        }
     }
     async listInApp({ parameters, getToken }) {
         const token = await getToken();

package/notification/server/drizzle/{0000_shiny_the_anarchist.sql → 0000_ancient_hellion.sql}

@@ -64,8 +64,8 @@ CREATE TABLE "notification"."web_push_subscription" (
 	"tenant_id" uuid NOT NULL,
 	"user_id" uuid NOT NULL,
 	"endpoint" text NOT NULL,
-	"p256dh" text NOT NULL,
-	"auth" text NOT NULL,
+	"p256dh" "bytea" NOT NULL,
+	"auth" "bytea" NOT NULL,
 	"revision" integer NOT NULL,
 	"revision_timestamp" timestamp with time zone NOT NULL,
 	"create_timestamp" timestamp with time zone NOT NULL,

package/notification/server/drizzle/meta/0000_snapshot.json

@@ -1,5 +1,5 @@
 {
-  "id": "8f352123-edd8-491f-a4ad-008d09531722",
+  "id": "7751e29f-1334-4511-8bf5-0d0f2550b5ae",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
@@ -521,13 +521,13 @@
         },
         "p256dh": {
           "name": "p256dh",
-          "type": "text",
+          "type": "bytea",
           "primaryKey": false,
           "notNull": true
         },
         "auth": {
           "name": "auth",
-          "type": "text",
+          "type": "bytea",
           "primaryKey": false,
           "notNull": true
         },

package/notification/server/drizzle/meta/_journal.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1769546272361,
-      "tag": "0000_shiny_the_anarchist",
+      "when": 1770118617281,
+      "tag": "0000_ancient_hellion",
       "breakpoints": true
     }
   ]

package/notification/server/module.d.ts

@@ -1,9 +1,11 @@
-import { Injector } from '../../injector/index.js';
+import { Injector, type InjectionToken } from '../../injector/index.js';
 import { type DatabaseConfig } from '../../orm/server/index.js';
 import type { NotificationChannel } from '../models/index.js';
+import { NotificationAncillaryService } from './services/notification-ancillary.service.js';
 export declare class NotificationConfiguration {
     database?: DatabaseConfig;
     defaultChannels?: NotificationChannel[];
+    ancillaryService?: InjectionToken<NotificationAncillaryService>;
 }
 export declare function configureNotification({ injector, ...config }: NotificationConfiguration & {
     injector?: Injector;

package/notification/server/module.js

@@ -1,12 +1,18 @@
 import { inject, Injector } from '../../injector/index.js';
 import { Database, migrate } from '../../orm/server/index.js';
+import { isDefined } from '../../utils/type-guards.js';
+import { NotificationAncillaryService } from './services/notification-ancillary.service.js';
 export class NotificationConfiguration {
     database;
     defaultChannels;
+    ancillaryService;
 }
 export function configureNotification({ injector, ...config }) {
     const targetInjector = injector ?? Injector;
     targetInjector.register(NotificationConfiguration, { useValue: config });
+    if (isDefined(config.ancillaryService)) {
+        targetInjector.register(NotificationAncillaryService, { useToken: config.ancillaryService });
+    }
 }
 /**
  * Migrates the notification schema.

package/notification/server/providers/channel-provider.d.ts

@@ -1,5 +1,5 @@
 import type { Transaction } from '../../../orm/server/index.js';
-import type { NotificationLog } from '../../models/notification-log.model.js';
+import type { NotificationLogView } from '../../models/notification-log.model.js';
 export declare abstract class ChannelProvider {
-    abstract send(notification: NotificationLog, tx?: Transaction): Promise<void>;
+    abstract send(notification: NotificationLogView, tx?: Transaction): Promise<void>;
 }

package/notification/server/providers/email-channel-provider.d.ts

@@ -1,6 +1,6 @@
-import type { NotificationLog } from '../../models/index.js';
+import type { NotificationLogView } from '../../models/index.js';
 import { ChannelProvider } from './channel-provider.js';
 export declare class EmailChannelProvider extends ChannelProvider {
     #private;
-    send(notification: NotificationLog): Promise<void>;
+    send(notification: NotificationLogView): Promise<void>;
 }

package/notification/server/providers/in-app-channel-provider.d.ts

@@ -1,7 +1,7 @@
 import { type Transaction } from '../../../orm/server/index.js';
-import { type NotificationLog } from '../../models/index.js';
+import { type NotificationLogView } from '../../models/index.js';
 import { ChannelProvider } from './channel-provider.js';
 export declare class InAppChannelProvider extends ChannelProvider {
     #private;
-    send(notification: NotificationLog, tx?: Transaction): Promise<void>;
+    send(notification: NotificationLogView, tx?: Transaction): Promise<void>;
 }

package/notification/server/providers/web-push-channel-provider.d.ts

@@ -1,7 +1,7 @@
 import { type Transaction } from '../../../orm/server/index.js';
-import { type NotificationLog } from '../../models/index.js';
+import { type NotificationLogView } from '../../models/index.js';
 import { ChannelProvider } from './channel-provider.js';
 export declare class WebPushChannelProvider extends ChannelProvider {
     #private;
-    send(notification: NotificationLog, tx?: Transaction): Promise<void>;
+    send(notification: NotificationLogView, tx?: Transaction): Promise<void>;
 }

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

@@ -1,3 +1,4 @@
+export * from './notification-ancillary.service.js';
 export * from './notification-delivery.worker.js';
 export * from './notification-sse.service.js';
 export * from './notification-template.js';

package/notification/server/services/index.js

@@ -1,3 +1,4 @@
+export * from './notification-ancillary.service.js';
 export * from './notification-delivery.worker.js';
 export * from './notification-sse.service.js';
 export * from './notification-template.js';

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

@@ -0,0 +1,5 @@
+import { Transactional } from '../../../orm/server/index.js';
+import type { NotificationDefinitionMap, NotificationLog, NotificationView } from '../../models/index.js';
+export declare abstract class NotificationAncillaryService<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> extends Transactional {
+    abstract getViewData(notifications: NotificationLog<Definitions>[]): Promise<NotificationView<Definitions>[]>;
+}

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

@@ -0,0 +1,14 @@
+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 { Singleton } from '../../../injector/index.js';
+import { Transactional } from '../../../orm/server/index.js';
+let NotificationAncillaryService = class NotificationAncillaryService extends Transactional {
+};
+NotificationAncillaryService = __decorate([
+    Singleton()
+], NotificationAncillaryService);
+export { NotificationAncillaryService };

package/notification/server/services/notification-delivery.worker.js

@@ -12,11 +12,13 @@ import { TaskProcessResult, TaskQueue } from '../../../task-queue/task-queue.js'
 import { isNotNull, isNotNullOrUndefined, isUndefined } from '../../../utils/type-guards.js';
 import { InAppNotification, NotificationChannel, NotificationLogEntity, NotificationPreference, NotificationStatus, NotificationType } from '../../models/index.js';
 import { NotificationConfiguration } from '../module.js';
+import { NotificationAncillaryService } from './notification-ancillary.service.js';
 let NotificationDeliveryWorker = class NotificationDeliveryWorker extends Transactional {
     #notificationLogRepository = injectRepository(NotificationLogEntity);
     #inAppRepository = injectRepository(InAppNotification);
     #preferenceRepository = injectRepository(NotificationPreference);
     #typeRepository = injectRepository(NotificationType);
+    #notificationAncillaryService = inject(NotificationAncillaryService);
     #taskQueue = inject((TaskQueue), 'notification');
     #rateLimiter = inject(RateLimiter, 'notification');
     #logger = inject(Logger, 'NotificationDeliveryWorker');
@@ -77,7 +79,8 @@ let NotificationDeliveryWorker = class NotificationDeliveryWorker extends Transa
                 }
                 for (const channel of enabledChannels) {
                     // TODO: what if an error occurs here? partial delivery? Should we use tasks to allow retrying individual channels?
-                    await this.sendToChannel(notification, channel, tx);
+                    const [viewData] = await this.#notificationAncillaryService.getViewData([notification]);
+                    await this.sendToChannel({ ...notification, view: viewData }, channel, tx);
                 }
                 await this.#notificationLogRepository.withTransaction(tx).update(notificationId, { status: NotificationStatus.Sent, currentStep: 1 });
                 if (isNotNull(type.escalations) && (type.escalations.length > 0)) {
@@ -95,7 +98,8 @@ let NotificationDeliveryWorker = class NotificationDeliveryWorker extends Transa
                     this.#logger.debug(`Notification ${notificationId} already read, skipping escalation step ${step}`);
                     return TaskProcessResult.Complete();
                 }
-                await this.sendToChannel(notification, rule.channel, tx);
+                const [viewData] = await this.#notificationAncillaryService.getViewData([notification]);
+                await this.sendToChannel({ ...notification, view: viewData }, rule.channel, tx);
                 await this.#notificationLogRepository.withTransaction(tx).update(notificationId, { currentStep: step + 1 });
                 if (step < type.escalations.length) {
                     const nextRule = type.escalations[step];

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

@@ -1,10 +1,11 @@
+import { Subject } from 'rxjs';
 import { afterResolve } from '../../../injector/index.js';
-import { ServerSentEventsSource } from '../../../sse/server-sent-events-source.js';
 import type { InAppNotificationView } from '../../models/index.js';
 export declare class NotificationSseService {
     #private;
     [afterResolve](): void;
-    register(tenantId: string, userId: string): ServerSentEventsSource;
+    register(tenantId: string, userId: string): Subject<InAppNotificationView>;
+    unregister(tenantId: string, userId: string, source: Subject<InAppNotificationView>): void;
     send(notification: InAppNotificationView): Promise<void>;
     private dispatchToLocal;
 }

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

@@ -4,10 +4,9 @@ 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 { Subject } from 'rxjs';
 import { afterResolve, inject, Singleton } from '../../../injector/index.js';
-import { MessageBusProvider } from '../../../message-bus/message-bus-provider.js';
-import { toObservable } from '../../../signals/api.js';
-import { ServerSentEventsSource } from '../../../sse/server-sent-events-source.js';
+import { MessageBusProvider } from '../../../message-bus/index.js';
 let NotificationSseService = class NotificationSseService {
     #messageBusProvider = inject(MessageBusProvider);
     #messageBus = this.#messageBusProvider.get('notification');
@@ -16,7 +15,7 @@ let NotificationSseService = class NotificationSseService {
         this.#messageBus.allMessages$.subscribe((message) => this.dispatchToLocal(message));
     }
     register(tenantId, userId) {
-        const source = new ServerSentEventsSource();
+        const source = new Subject();
         let tenantMap = this.#sources.get(tenantId);
         if (tenantMap == null) {
             tenantMap = new Map();
@@ -28,23 +27,22 @@ let NotificationSseService = class NotificationSseService {
             tenantMap.set(userId, userSources);
         }
         userSources.add(source);
-        toObservable(source.closed).subscribe((closed) => {
-            if (closed) {
-                const currentTenantMap = this.#sources.get(tenantId);
-                const currentUserSources = currentTenantMap?.get(userId);
-                if (currentUserSources) {
-                    currentUserSources.delete(source);
-                    if (currentUserSources.size == 0) {
-                        currentTenantMap?.delete(userId);
-                    }
-                }
-                if (currentTenantMap?.size == 0) {
-                    this.#sources.delete(tenantId);
-                }
-            }
-        });
         return source;
     }
+    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 (tenantMap?.size == 0) {
+            this.#sources.delete(tenantId);
+        }
+        source.complete();
+    }
     async send(notification) {
         await this.#messageBus.publish(notification);
     }
@@ -53,10 +51,7 @@ let NotificationSseService = class NotificationSseService {
         const userSources = tenantMap?.get(notification.userId);
         if (userSources != null) {
             for (const source of userSources) {
-                void source.sendJson({
-                    name: 'notification',
-                    data: notification,
-                });
+                source.next(notification);
             }
         }
     }

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

@@ -1,7 +1,7 @@
-import { type NotificationLog } from '../../models/index.js';
+import { type NotificationLogView } from '../../models/index.js';
 import type { NotificationContent, NotificationTemplate } from './notification-template.js';
 export declare class NotificationTemplateService {
     #private;
     register(template: NotificationTemplate<any>): void;
-    render(notification: NotificationLog, language?: string): Promise<NotificationContent>;
+    render(notification: NotificationLogView, language?: string): Promise<NotificationContent>;
 }

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

@@ -1,8 +1,10 @@
+import { type NewEntity } from '../../../orm/index.js';
 import { Transactional } from '../../../orm/server/index.js';
-import { NotificationPreference, type InAppNotificationView, type NotificationChannel, type NotificationLog } from '../../models/index.js';
-export declare class NotificationService extends Transactional {
+import type { TypedOmit } from '../../../types/types.js';
+import { NotificationPreference, type InAppNotificationView, type NotificationChannel, type NotificationDefinitionMap, type NotificationLog } from '../../models/index.js';
+export declare class NotificationService<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> extends Transactional {
     #private;
-    send(notification: NotificationLog): Promise<void>;
+    send(tenantId: string, userId: string, notification: TypedOmit<NewEntity<NotificationLog<Definitions>>, 'tenantId' | 'id' | 'userId' | 'status' | 'currentStep' | 'priority' | 'metadata'> & Partial<Pick<NotificationLog<Definitions>, 'priority'>>): Promise<void>;
     listInApp(tenantId: string, userId: string, options?: {
         limit?: number;
         offset?: number;

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

@@ -10,17 +10,22 @@ import { inject, Singleton } from '../../../injector/index.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 { InAppNotification, NotificationLogEntity, NotificationPreference, NotificationStatus, toInAppNotificationView, WebPushSubscription } from '../../models/index.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 {
     #notificationLogRepository = injectRepository(NotificationLogEntity);
     #inAppNotificationRepository = injectRepository(InAppNotification);
     #preferenceRepository = injectRepository(NotificationPreference);
     #webPushSubscriptionRepository = injectRepository(WebPushSubscription);
+    #notificationAncillaryService = inject(NotificationAncillaryService);
     #taskQueue = inject((TaskQueue), 'notification');
-    async send(notification) {
+    async send(tenantId, userId, notification) {
         await this.transaction(async (tx) => {
             const notificationToInsert = {
+                tenantId,
+                userId,
+                priority: NotificationPriority.Medium,
                 ...notification,
                 status: NotificationStatus.Pending,
                 currentStep: 0,
@@ -45,9 +50,11 @@ let NotificationService = class NotificationService extends Transactional {
         const notificationRows = rows.map((row) => row.notification);
         const notificationEntities = await this.#notificationLogRepository.mapManyToEntity(notificationRows);
         const inAppEntities = await this.#inAppNotificationRepository.mapManyToEntity(inAppRows);
+        const notificationViewDatas = await this.#notificationAncillaryService.getViewData(notificationEntities);
         const views = notificationEntities.map((notification, index) => {
             const inApp = inAppEntities[index];
-            return toInAppNotificationView(inApp, notification);
+            const viewData = notificationViewDatas[index];
+            return toInAppNotificationView(inApp, { ...notification, view: viewData });
         });
         return views;
     }

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

@@ -1,13 +1,14 @@
+import { Subject } from 'rxjs';
 import { beforeAll, describe, expect, test, vi } from 'vitest';
 import { SubjectService } from '../../authentication/server/subject.service.js';
-import {} from '../../injector/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+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 { NotificationService } from '../server/services/notification.service.js';
 describe('Notification API (Integration)', () => {
     let injector;
+    let database;
     let controller;
     let notificationService;
     let sseService;
@@ -16,7 +17,7 @@ describe('Notification API (Integration)', () => {
     const tenantId = '00000000-0000-0000-0000-000000000000';
     let userId;
     beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({
+        ({ injector, database } = await setupIntegrationTest({
             orm: { schema },
             modules: {
                 notification: true,
@@ -25,6 +26,7 @@ describe('Notification API (Integration)', () => {
                 rateLimiter: true,
             },
         }));
+        await truncateTables(database, 'authentication', ['user', 'subject']);
         controller = injector.resolve(NotificationApiController);
         notificationService = injector.resolve(NotificationService);
         sseService = injector.resolve(NotificationSseService);
@@ -40,6 +42,7 @@ describe('Notification API (Integration)', () => {
     });
     const createMockContext = (params = {}) => ({
         parameters: params,
+        abortSignal: new AbortController().signal,
         getToken: async () => ({
             payload: {
                 tenant: tenantId,
@@ -49,12 +52,16 @@ describe('Notification API (Integration)', () => {
     });
     test('stream should register sse client', async () => {
         const registerSpy = vi.spyOn(sseService, 'register');
+        const subject = new Subject();
         // Mock register to return a dummy source or similar if needed,
         // but the real one might work if it just returns an object.
         // Looking at sseService, register returns a ServerSentEventsSource.
         // We might need to mock implementation if it tries to do something complex
-        registerSpy.mockImplementation(() => ({}));
-        await controller.stream(createMockContext());
+        registerSpy.mockImplementation(() => subject);
+        const generator = controller.stream(createMockContext());
+        const nextPromise = generator.next();
+        subject.complete();
+        await nextPromise;
         expect(registerSpy).toHaveBeenCalledWith(tenantId, userId);
     });
     test('listInApp should call service', async () => {
@@ -88,8 +95,8 @@ describe('Notification API (Integration)', () => {
     });
     test('registerWebPush should call service', async () => {
         const registerWebPushSpy = vi.spyOn(notificationService, 'registerWebPush').mockResolvedValue();
-        const params = { endpoint: 'url', keys: { p256dh: 'key', auth: 'auth' } };
+        const params = { endpoint: 'url', keys: { p256dhBase64: 'key', authBase64: 'auth' } };
         await controller.registerWebPush(createMockContext(params));
-        expect(registerWebPushSpy).toHaveBeenCalledWith(tenantId, userId, 'url', 'key', 'auth');
+        expect(registerWebPushSpy).toHaveBeenCalledWith(tenantId, userId, 'url', expect.any(Uint8Array), expect.any(Uint8Array));
     });
 });

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

@@ -1,14 +1,30 @@
+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 { beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import { SubjectService } from '../../authentication/server/subject.service.js';
-import { runInInjectionContext } from '../../injector/index.js';
+import { runInInjectionContext, Singleton } from '../../injector/index.js';
 import { MailService } from '../../mail/mail.service.js';
 import { injectRepository } from '../../orm/server/index.js';
 import { setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
 import { InAppNotification, NotificationChannel, NotificationLogEntity, NotificationStatus, WebPushSubscription } from '../models/index.js';
+import { configureNotification } from '../server/module.js';
 import { EmailChannelProvider } from '../server/providers/email-channel-provider.js';
+import { NotificationAncillaryService } from '../server/services/notification-ancillary.service.js';
 import { NotificationDeliveryWorker } from '../server/services/notification-delivery.worker.js';
 import { NotificationTypeService } from '../server/services/notification-type.service.js';
 import { NotificationService } from '../server/services/notification.service.js';
+let MockNotificationAncillaryService = class MockNotificationAncillaryService extends NotificationAncillaryService {
+    async getViewData(notifications) {
+        return notifications.map(() => ({}));
+    }
+};
+MockNotificationAncillaryService = __decorate([
+    Singleton()
+], MockNotificationAncillaryService);
 describe('Notification Flow (Integration)', () => {
     let injector;
     let database;
@@ -34,6 +50,8 @@ describe('Notification Flow (Integration)', () => {
         // Mock MailService
         mailServiceMock = { send: vi.fn() };
         injector.register(MailService, { useValue: mailServiceMock });
+        // Mock NotificationAncillaryService
+        configureNotification({ injector, ancillaryService: MockNotificationAncillaryService });
         // Resolve Services
         notificationService = injector.resolve(NotificationService);
         worker = injector.resolve(NotificationDeliveryWorker);
@@ -65,14 +83,11 @@ describe('Notification Flow (Integration)', () => {
                     escalations: [{ delay: 1000, channel: NotificationChannel.Email }],
                 },
             });
-            const notification = Object.assign(new NotificationLogEntity(), {
-                tenantId,
-                userId: user.id,
+            await notificationService.send(tenantId, user.id, {
                 type: 'test',
                 priority: 'high',
                 payload: { message: 'Hello', testField: 'Test Value' },
             });
-            await notificationService.send(notification);
             const logs = await logRepo.loadManyByQuery({ tenantId });
             expect(logs).toHaveLength(1);
             const log = logs[0];
@@ -107,14 +122,12 @@ describe('Notification Flow (Integration)', () => {
                     throttling: { limit: 1, interval: 60000 },
                 },
             });
-            const notification1 = Object.assign(new NotificationLogEntity(), {
-                tenantId, userId: user.id, type: 'throttled', priority: 'medium', payload: {},
+            await notificationService.send(tenantId, user.id, {
+                type: 'throttled', priority: 'medium', payload: {},
             });
-            const notification2 = Object.assign(new NotificationLogEntity(), {
-                tenantId, userId: user.id, type: 'throttled', priority: 'medium', payload: {},
+            await notificationService.send(tenantId, user.id, {
+                type: 'throttled', priority: 'medium', payload: {},
             });
-            await notificationService.send(notification1);
-            await notificationService.send(notification2);
             const logs = await logRepo.loadManyByQuery({ tenantId });
             logs.sort((a, b) => Number(a.metadata.createTimestamp) - Number(b.metadata.createTimestamp));
             // First one should pass
@@ -135,10 +148,9 @@ describe('Notification Flow (Integration)', () => {
                     escalations: [{ delay: 1000, channel: NotificationChannel.Email }],
                 },
             });
-            const notification = Object.assign(new NotificationLogEntity(), {
-                tenantId, userId: user.id, type: 'readTest', priority: 'medium', payload: {},
+            await notificationService.send(tenantId, user.id, {
+                type: 'readTest', priority: 'medium', payload: {},
             });
-            await notificationService.send(notification);
             const logs = await logRepo.loadManyByQuery({ tenantId });
             const log = logs[0];
             // Step 0: Deliver In-App
@@ -163,10 +175,9 @@ describe('Notification Flow (Integration)', () => {
             // Disable InApp, Enable Email (even though not default)
             await notificationService.updatePreference(tenantId, user.id, 'prefTest', NotificationChannel.InApp, false);
             await notificationService.updatePreference(tenantId, user.id, 'prefTest', NotificationChannel.Email, true);
-            const notification = Object.assign(new NotificationLogEntity(), {
-                tenantId, userId: user.id, type: 'prefTest', priority: 'medium', payload: {},
+            await notificationService.send(tenantId, user.id, {
+                type: 'prefTest', priority: 'medium', payload: {},
             });
-            await notificationService.send(notification);
             const logs = await logRepo.loadManyByQuery({ tenantId });
             const log = logs[0];
             // Deliver
@@ -189,10 +200,9 @@ describe('Notification Flow (Integration)', () => {
             await notificationService.updatePreference(tenantId, user.id, 'unknownTest', NotificationChannel.WebPush, true);
             // Disable InApp so only WebPush is attempted
             await notificationService.updatePreference(tenantId, user.id, 'unknownTest', NotificationChannel.InApp, false);
-            const notification = Object.assign(new NotificationLogEntity(), {
-                tenantId, userId: user.id, type: 'unknownTest', priority: 'medium', payload: {},
+            await notificationService.send(tenantId, user.id, {
+                type: 'unknownTest', priority: 'medium', payload: {},
             });
-            await notificationService.send(notification);
             const logs = await logRepo.loadManyByQuery({ tenantId });
             const log = logs[0];
             // Deliver
@@ -207,10 +217,9 @@ describe('Notification Flow (Integration)', () => {
             const inAppRepo = injectRepository(InAppNotification);
             const user = await subjectService.createUser({ tenantId, email: 'manage@example.com', firstName: 'Manage', lastName: 'User' });
             await typeService.initializeTypes({ manageTest: { label: 'Manage Test' } });
-            const notification = Object.assign(new NotificationLogEntity(), {
-                tenantId, userId: user.id, type: 'manageTest', priority: 'medium', payload: {},
+            await notificationService.send(tenantId, user.id, {
+                type: 'manageTest', priority: 'medium', payload: {},
             });
-            await notificationService.send(notification);
             const logs = await logRepo.loadManyByQuery({ tenantId });
             await worker.deliver(logs[0].id);
             // List

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.105",
+  "version": "0.93.106",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -150,7 +150,7 @@
   "peerDependencies": {
     "@genkit-ai/google-genai": "^1.28",
     "@google-cloud/storage": "^7.18",
-    "@google/genai": "^1.38",
+    "@google/genai": "^1.39",
     "@toon-format/toon": "^2.1.0",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
@@ -164,12 +164,12 @@
     "minio": "^8.0",
     "mjml": "^4.18",
     "nodemailer": "^7.0",
-    "pg": "^8.17",
+    "pg": "^8.18",
     "playwright": "^1.58",
     "preact": "^10.28",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
-    "undici": "^7.19",
+    "undici": "^7.20",
     "urlpattern-polyfill": "^10.1",
     "zod": "^3.25"
   },
@@ -191,7 +191,7 @@
     "concurrently": "9.2",
     "drizzle-kit": "0.31",
     "eslint": "9.39",
-    "globals": "17.2",
+    "globals": "17.3",
     "tsc-alias": "1.8",
     "typedoc-github-wiki-theme": "2.1",
     "typedoc-plugin-markdown": "4.9",

package/rxjs-utils/async-iterable.d.ts

@@ -0,0 +1,2 @@
+import type { Observable } from 'rxjs';
+export declare function toAsyncIterable<T>(observable: Observable<T>): AsyncIterable<T>;

package/rxjs-utils/async-iterable.js

@@ -0,0 +1,15 @@
+import { FeedableAsyncIterable } from '../utils/feedable-async-iterable.js';
+export async function* toAsyncIterable(observable) {
+    const feed = new FeedableAsyncIterable();
+    const subscription = observable.subscribe({
+        next: (value) => feed.feed(value),
+        error: (err) => feed.throw(err),
+        complete: () => feed.end(),
+    });
+    try {
+        yield* feed;
+    }
+    finally {
+        subscription.unsubscribe();
+    }
+}

package/rxjs-utils/index.d.ts

@@ -1,3 +1,4 @@
+export * from './async-iterable.js';
 export * from './cast.js';
 export * from './noop.js';
 export * from './reject-error.js';

package/rxjs-utils/index.js

@@ -1,3 +1,4 @@
+export * from './async-iterable.js';
 export * from './cast.js';
 export * from './noop.js';
 export * from './reject-error.js';

package/test5.d.ts

@@ -1 +1,13 @@
 import './polyfills.js';
+import type { NotificationDefinitionMap } from './notification/index.js';
+export type Notifications = NotificationDefinitionMap<{
+    'analysis-started': {
+        payload: {
+            analysisId: string;
+        };
+        view: {
+            name: string;
+        };
+    };
+    'analysis-completed': Record<never, never>;
+}>;

package/test5.js

@@ -3,18 +3,18 @@ import { Application } from './application/application.js';
 import { provideModule, provideSignalHandler } from './application/index.js';
 import { inject } from './injector/inject.js';
 import { JsonLogFormatter, PrettyPrintLogFormatter } from './logger/index.js';
-import { Logger } from './logger/logger.js';
 import { provideConsoleLogTransport } from './logger/transports/console.js';
+import { NotificationService } from './notification/server/index.js';
 async function main(_cancellationSignal) {
-    const logger = inject(Logger, 'Test');
-    logger.error('Hello World!', { sessionId: 'abc' });
-    logger.error('Hello World!', new Error('FOO!!'), { sessionId: 'def' });
-    logger.error(new Error('BAR!!'), { sessionId: 'ghi' });
-    // logger.warn('Hello World!');
-    // logger.info('Hello World!');
-    // logger.verbose('Hello World!');
-    // logger.debug('Hello World!');
-    // logger.trace('Hello World!');
+    const notificationService = inject((NotificationService));
+    const notificationApi = new null();
+    const notification$ = (await notificationApi.stream());
+    const tenantId = 'test-tenant';
+    const userId = 'user-123';
+    await notificationService.send(tenantId, userId, {
+        type: 'analysis-started',
+        payload: { analysisId: 'analysis-456' },
+    });
 }
 Application.run('Test', [
     provideConsoleLogTransport(PrettyPrintLogFormatter),