@tstdl/base 0.93.170 → 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/document-management/models/ai-configuration.d.ts

@@ -1,7 +1,9 @@
 import type { ModelReference } from 'genkit';
 import type { Instructions } from '../../ai/prompts/instructions-formatter.js';
 import type { DocumentWorkflowStep } from './document-workflow.model.js';
+import type { GeminiModelConfig } from '../../ai/index.js';
 export type InstructionStrategy = 'replace' | 'append';
+export type DocumentManagementThinkingLevel = NonNullable<GeminiModelConfig['thinkingConfig']>['thinkingLevel'];
 export type InstructionOverride = string | {
     /**
      * Simple way: Provide a specific format pattern.
@@ -20,6 +22,8 @@ export type InstructionOverride = string | {
 export type AiConfiguration = {
     /** The model to use. */
     model?: ModelReference<any>;
+    /** The thinking level to use for thinking models. */
+    thinkingLevel?: DocumentManagementThinkingLevel;
     /** The language to use for AI outputs. */
     language?: string;
     /** Prompt overrides. */

package/document-management/server/services/document-management-ai.service.d.ts

@@ -2,7 +2,7 @@ import { type TstdlGenkitGenerationOptions } from '../../../ai/genkit/index.js';
 import { type PromptBuilder } from '../../../ai/prompts/index.js';
 import { type SchemaTestable } from '../../../schema/index.js';
 import type { ObjectLiteral } from '../../../types/types.js';
-import type { ModelReference } from 'genkit';
+import { type ModelReference } from 'genkit';
 import type { AiConfiguration, DocumentPropertyDataType, InstructionOverride } from '../../models/index.js';
 import { Document, DocumentWorkflowStep } from '../../models/index.js';
 import { type AiConfigurationResolveDataMap } from './document-management-ai-provider.service.js';

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

@@ -19,8 +19,8 @@ import { distinct } from '../../../utils/array/index.js';
 import { numericDateToDateTime, tryDateObjectToNumericDate } from '../../../utils/date-time.js';
 import { fromEntries, hasOwnProperty, objectEntries, objectKeys } from '../../../utils/object/object.js';
 import { assertDefined, assertDefinedPass, assertNotNull, isDefined, isNotNull, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
+import { GenkitError } from 'genkit';
 import { Document, DocumentProperty, DocumentRequestState, DocumentType, DocumentTypeProperty, DocumentWorkflowStep } from '../../models/index.js';
-import { DocumentManagementConfiguration } from '../module.js';
 import { documentCategory, documentRequest, documentRequestCollectionAssignment, documentType } from '../schemas.js';
 import { DocumentCategoryTypeService } from './document-category-type.service.js';
 import { DocumentCollectionService } from './document-collection.service.js';
@@ -41,7 +41,6 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
     #documentCategoryTypeService = inject(DocumentCategoryTypeService);
     #documentFileService = inject(DocumentFileService);
     #documentPropertyService = inject(DocumentPropertyService);
-    #documentManagementConfiguration = inject(DocumentManagementConfiguration, undefined, { optional: true });
     #aiProvider = inject(DocumentManagementAiProviderService, undefined, { optional: true });
     #documentPropertyRepository = injectRepository(DocumentProperty);
     #documentRepository = injectRepository(Document);
@@ -83,7 +82,7 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
             promptBuilder,
             schema,
             document,
-            config: { maxOutputTokens: 128 },
+            config: { maxOutputTokens: 1024 },
             aiConfig,
         });
         const typeId = typeLabelEntries.find((entry) => entry.label == result.documentType)?.id;
@@ -149,7 +148,7 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
             data: { existingTags: tagLabels },
             schema: generationSchema,
             document,
-            config: { maxOutputTokens: 2048 },
+            config: { maxOutputTokens: 4096 },
             aiConfig,
         });
         const filteredDocumentTags = extraction.documentTags.filter((tag) => (tag != extraction.documentTitle) && (tag != extraction.documentSubtitle));
@@ -207,7 +206,7 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
             promptBuilder: createAssignCollectionPrompt(),
             data: { document: documentData, documentProperties: fromEntries(propertyEntries), collections },
             schema: assignCollectionSchema,
-            config: { maxOutputTokens: 512 },
+            config: { maxOutputTokens: 2048 },
         });
         return result.collectionIds;
     }
@@ -253,13 +252,15 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
             promptBuilder: createAssignRequestPrompt(),
             data: { document: documentData, documentProperties: fromEntries(propertyEntries), requests },
             schema: assignRequestSchema,
-            config: { maxOutputTokens: 128 },
+            config: { maxOutputTokens: 1024 },
         });
         return result.requestId;
     }
     async runAi(tenantId, step, stepData, options) {
         const config = options.aiConfig ?? await this.resolveAiConfiguration(tenantId, step, stepData);
         const model = config.model ?? options.defaultModel;
+        const thinkingLevel = config.thinkingLevel ?? 'LOW';
+        const configuredModel = isString(model) ? model : model.withConfig({ thinkingConfig: { thinkingLevel } });
         const builder = options.promptBuilder;
         if (isDefined(config.language)) {
             builder.addInstructions({ 'Output Language': languagePrompt(config.language) });
@@ -282,17 +283,26 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
         if (isDefined(options.document)) {
             builder.addMedia(await this.#documentFileService.getContent(options.document), options.document.mimeType);
         }
-        const result = await this.#genkit.generate(genkitGenerationOptions({
-            model,
-            config: options.config,
-            output: { schema: options.schema },
-            system: builder.buildSystemPrompt(),
-            prompt: builder.buildUserPrompt(),
-        }));
-        if (isNull(result.output)) {
-            throw new Error(`AI returned null output for ${step} ${options.targetId ?? ''}`);
+        try {
+            const result = await this.#genkit.generate(genkitGenerationOptions({
+                model: configuredModel,
+                config: options.config,
+                output: { schema: options.schema },
+                system: builder.buildSystemPrompt(),
+                prompt: builder.buildUserPrompt(),
+            }));
+            this.#logger.trace(`AI result for ${step} ${options.targetId ?? ''}: usage=${JSON.stringify(result.usage)}, finishReason=${result.finishReason}`);
+            if (isNull(result.output)) {
+                throw new Error(`AI returned null output for ${step} ${options.targetId ?? ''}. Finish reason: ${result.finishReason}`);
+            }
+            return result.output;
+        }
+        catch (error) {
+            if (error instanceof GenkitError) {
+                this.#logger.error(`AI ${step} ${options.targetId ?? ''} failed: status=${error.status}, message=${error.originalMessage}, details=${JSON.stringify(error.detail)}`);
+            }
+            throw error;
         }
-        return result.output;
     }
     async resolveAiConfiguration(tenantId, step, data) {
         const globalConfig = await this.#aiProvider?.getGlobalConfiguration(tenantId);
@@ -312,6 +322,7 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
             stepConfig,
         ].filter(isDefined);
         const model = mergeMostSpecific(configs, 'model');
+        const thinkingLevel = mergeMostSpecific(configs, 'thinkingLevel');
         const language = mergeMostSpecific(configs, 'language');
         const systemAddition = resolveAdditions(configs.map((c) => c.prompt?.systemAddition));
         const userAddition = resolveAdditions(configs.map((c) => c.prompt?.userAddition));
@@ -321,6 +332,7 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
         const classification = mergeMostSpecific(configs, 'classification');
         return {
             model,
+            thinkingLevel,
             language,
             prompt: {
                 systemAddition,

package/examples/document-management/ai-provider.d.ts

@@ -1,6 +1,7 @@
 import type { AiConfiguration, DocumentManagementAiConfiguration, DocumentWorkflowStep } from '../../document-management/index.js';
 import { DocumentManagementAiProviderService, type AiConfigurationResolveDataMap } from '../../document-management/server/index.js';
 export declare class ExampleAiProviderService extends DocumentManagementAiProviderService {
+    #private;
     /**
      * Providing global defaults for the entire Document Management module.
      */

package/examples/document-management/ai-provider.js

@@ -9,6 +9,7 @@ import { fewShotPrompt, stylePrompt } from '../../ai/prompts/index.js';
 import { DocumentManagementAiProviderService } from '../../document-management/server/index.js';
 import { Singleton } from '../../injector/index.js';
 let ExampleAiProviderService = class ExampleAiProviderService extends DocumentManagementAiProviderService {
+    #model = injectModel('gemini-3.1-flash-lite-preview').withConfig({ thinkingConfig: { thinkingLevel: 'LOW' } });
     /**
      * Providing global defaults for the entire Document Management module.
      */
@@ -16,9 +17,9 @@ let ExampleAiProviderService = class ExampleAiProviderService extends DocumentMa
         return {
             defaults: {
                 language: 'German', // Steer all AI outputs to German
-                model: injectModel('gemini-3.1-flash-lite-preview').withConfig({ thinkingConfig: { thinkingLevel: 'LOW' } }),
+                model: this.#model,
                 prompt: {
-                    systemAddition: 'Additional global instructions for all AI steps.',
+                // systemAddition: 'Additional global instructions for all AI steps.',
                 },
             },
         };
@@ -32,9 +33,9 @@ let ExampleAiProviderService = class ExampleAiProviderService extends DocumentMa
     getClassificationConfiguration() {
         return {
             // Use a faster/cheaper model for classification
-            model: injectModel('gemini-3.1-flash-lite-preview').withConfig({ thinkingConfig: { thinkingLevel: 'LOW' } }),
+            model: this.#model,
             prompt: {
-                systemAddition: 'For classification, focus strictly on the layout.',
+                systemAddition: 'For classification, focus strictly on document content.',
             },
         };
     }

package/examples/document-management/main.js

@@ -49,7 +49,7 @@ const config = {
         },
     },
     s3: {
-        endpoint: string('S3_ENDPOINT', 'http://localhost:9000'),
+        endpoint: string('S3_ENDPOINT', 'http://localhost:19552'),
         accessKey: string('S3_ACCESS_KEY', 'tstdl-dev'),
         secretKey: string('S3_SECRET_KEY', 'tstdl-dev'),
         bucket: string('S3_BUCKET', undefined),

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.170",
+  "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();