@tstdl/base 0.92.139 → 0.92.141

package/ai/ai.service.js

@@ -155,7 +155,7 @@ let AiService = AiService_1 = class AiService {
                     break;
                 }
                 catch (error) {
-                    if ((i < 20) && isError(error) && ((error['status'] == 429) || (error['status'] == 503))) {
+                    if ((i < 20) && isError(error) && (error.message.includes('429 Too Many Requests') || (error.message.includes('503 Service Unavailable')))) {
                         this.#logger.verbose('429 Too Many Requests - trying again in 15 seconds');
                         const canceled = await cancelableTimeout(15 * millisecondsPerSecond, getShutdownSignal());
                         if (!canceled) {

package/css/css-variables.d.ts

@@ -0,0 +1,14 @@
+export declare class CssVariables implements Disposable {
+    #private;
+    readonly selector: string;
+    readonly prefix: string;
+    constructor(selector: string | null, prefix?: string);
+    [Symbol.dispose](): void;
+    set(name: string, value: string): void;
+    setMany(variables: Record<string, string> | readonly (readonly [string, string])[]): void;
+    get(name: string): string | null;
+    delete(name: string): void;
+    clear(): void;
+    private _prefix;
+}
+export declare function cssVariables(selector?: string | null, prefix?: string): CssVariables;

package/css/css-variables.js

@@ -0,0 +1,56 @@
+import { objectEntries } from '../utils/object/object.js';
+import { isArray } from '../utils/type-guards.js';
+export class CssVariables {
+    #styleSheet = new CSSStyleSheet();
+    #cssRule;
+    selector;
+    prefix;
+    constructor(selector, prefix = '') {
+        this.selector = selector ?? ':root';
+        this.prefix = prefix;
+        document.adoptedStyleSheets.push(this.#styleSheet);
+        this.#cssRule = createCssRule(this.#styleSheet, `${this.selector} {}`);
+    }
+    [Symbol.dispose]() {
+        const index = document.adoptedStyleSheets.indexOf(this.#styleSheet);
+        if (index != -1) {
+            document.adoptedStyleSheets.splice(index, 1);
+        }
+    }
+    set(name, value) {
+        const prefixed = this._prefix(name);
+        this.#cssRule.style.setProperty(prefixed, value);
+    }
+    setMany(variables) {
+        const entries = isArray(variables) ? variables : objectEntries(variables);
+        for (const [name, value] of entries) {
+            this.set(name, value);
+        }
+    }
+    get(name) {
+        const prefixed = this._prefix(name);
+        const rawValue = this.#cssRule.style.getPropertyValue(prefixed);
+        if (rawValue.length == 0) {
+            return null;
+        }
+        return rawValue;
+    }
+    delete(name) {
+        const prefixed = this._prefix(name);
+        this.#cssRule.style.removeProperty(prefixed);
+    }
+    clear() {
+        this.#cssRule.style.cssText = '';
+    }
+    _prefix(name) {
+        const prefixed = `${this.prefix}${name}`;
+        return name.startsWith('--') ? prefixed : `--${prefixed}`;
+    }
+}
+export function cssVariables(selector = null, prefix = '') {
+    return new CssVariables(selector, prefix);
+}
+function createCssRule(styleSheet, rule) {
+    const index = styleSheet.insertRule(rule);
+    return styleSheet.cssRules[index];
+}

package/css/index.d.ts

@@ -0,0 +1 @@
+export * from './css-variables.js';

package/css/index.js

@@ -0,0 +1 @@
+export * from './css-variables.js';

package/document-management/api/document-management.api.d.ts

@@ -1,3 +1,4 @@
+import { ServerSentEvents } from '../../sse/server-sent-events.js';
 import { Document, DocumentCategory, DocumentRequest, DocumentRequestsTemplate, DocumentRequestTemplate, DocumentType } from '../models/index.js';
 import { DocumentCategoryView, DocumentManagementData, DocumentRequestsTemplateData } from '../service-models/index.js';
 export type DocumentManagementApiDefinition = typeof documentManagementApiDefinition;
@@ -13,6 +14,15 @@ export declare const documentManagementApiDefinition: {
             result: typeof DocumentManagementData;
             credentials: true;
         };
+        loadDataStream: {
+            resource: string;
+            method: "GET";
+            parameters: import("../../schema/index.js").ObjectSchema<{
+                collectionIds: string | string[];
+            }>;
+            result: typeof ServerSentEvents;
+            credentials: true;
+        };
         loadDocumentRequestsTemplateData: {
             resource: string;
             method: "GET";
@@ -346,6 +356,15 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
             result: typeof DocumentManagementData;
             credentials: true;
         };
+        loadDataStream: {
+            resource: string;
+            method: "GET";
+            parameters: import("../../schema/index.js").ObjectSchema<{
+                collectionIds: string | string[];
+            }>;
+            result: typeof ServerSentEvents;
+            credentials: true;
+        };
         loadDocumentRequestsTemplateData: {
             resource: string;
             method: "GET";

package/document-management/api/document-management.api.js

@@ -8,6 +8,7 @@ import { compileClient } from '../../api/client/index.js';
 import { defineApi } from '../../api/index.js';
 import { ReplaceClass } from '../../injector/decorators.js';
 import { array, boolean, literal, number, object, optional, string } from '../../schema/index.js';
+import { ServerSentEvents } from '../../sse/server-sent-events.js';
 import { Document, DocumentCategory, DocumentRequest, DocumentRequestsTemplate, DocumentRequestTemplate, DocumentType } from '../models/index.js';
 import { addOrArchiveDocumentToOrFromCollectionParametersSchema, applyDocumentRequestsTemplateParametersSchema, createDocumentCategoryParametersSchema, createDocumentParametersSchema, createDocumentRequestParametersSchema, createDocumentRequestsTemplateParametersSchema, createDocumentRequestTemplateParametersSchema, createDocumentTypeParametersSchema, deleteDocumentRequestParametersSchema, deleteDocumentRequestsTemplateParametersSchema, deleteDocumentRequestTemplateParametersSchema, DocumentCategoryView, DocumentManagementData, DocumentRequestsTemplateData, loadDataParametersSchema, updateDocumentParametersSchema, updateDocumentRequestParametersSchema, updateDocumentRequestsTemplateParametersSchema, updateDocumentRequestTemplateParametersSchema } from '../service-models/index.js';
 export const documentManagementApiDefinition = defineApi({
@@ -20,6 +21,13 @@ export const documentManagementApiDefinition = defineApi({
             result: DocumentManagementData,
             credentials: true,
         },
+        loadDataStream: {
+            resource: 'data/stream',
+            method: 'GET',
+            parameters: loadDataParametersSchema,
+            result: ServerSentEvents,
+            credentials: true,
+        },
         loadDocumentRequestsTemplateData: {
             resource: 'views/document-requests-template-data',
             method: 'GET',

package/document-management/server/api/document-management.api.d.ts

@@ -1,8 +1,9 @@
-import type { ApiController, ApiRequestContext, ApiServerResult } from '../../../api/index.js';
+import { type ApiController, type ApiRequestContext, type ApiServerResult } from '../../../api/index.js';
 import { type DocumentManagementApiDefinition } from '../../../document-management/api/index.js';
 export declare class DocumentManagementApiController implements ApiController<DocumentManagementApiDefinition> {
     #private;
     loadData(context: ApiRequestContext<DocumentManagementApiDefinition, 'loadData'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'loadData'>>;
+    loadDataStream(context: ApiRequestContext<DocumentManagementApiDefinition, 'loadDataStream'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'loadDataStream'>>;
     loadDocumentRequestsTemplateData(context: ApiRequestContext<DocumentManagementApiDefinition, 'loadDocumentRequestsTemplateData'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'loadDocumentRequestsTemplateData'>>;
     loadAvailableCategories(context: ApiRequestContext<DocumentManagementApiDefinition, 'loadAvailableCategories'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'loadAvailableCategories'>>;
     loadContent(context: ApiRequestContext<DocumentManagementApiDefinition, 'loadContent'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'loadContent'>>;

package/document-management/server/api/document-management.api.js

@@ -4,17 +4,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var _a;
+var DocumentManagementApiController_1;
+import { match, P } from 'ts-pattern';
+import { createErrorResponse } from '../../../api/index.js';
 import { apiController } from '../../../api/server/index.js';
 import { documentManagementApiDefinition } from '../../../document-management/api/index.js';
 import { DocumentRequestCollectionAssignment } from '../../../document-management/models/document-request-collection-assignment.model.js';
 import { ForbiddenError, NotImplementedError } from '../../../errors/index.js';
 import { HttpServerResponse } from '../../../http/index.js';
 import { inject } from '../../../injector/index.js';
+import { Logger } from '../../../logger/logger.js';
 import { injectRepository } from '../../../orm/server/repository.js';
+import { ServerSentEventsSource } from '../../../sse/server-sent-events-source.js';
 import { toArray } from '../../../utils/array/index.js';
-import { match, P } from 'ts-pattern';
+import { tryIgnoreAsync } from '../../../utils/try-ignore.js';
 import { DocumentCategoryTypeService, DocumentFileService, DocumentManagementAuthorizationService, DocumentManagementService, DocumentRequestService, DocumentService } from '../services/index.js';
-let DocumentManagementApiController = class DocumentManagementApiController {
+let DocumentManagementApiController = DocumentManagementApiController_1 = class DocumentManagementApiController {
     #authorizationService = inject(DocumentManagementAuthorizationService);
     #documentCategoryTypeService = inject(DocumentCategoryTypeService);
     #documentFileService = inject(DocumentFileService);
@@ -22,6 +28,7 @@ let DocumentManagementApiController = class DocumentManagementApiController {
     #documentRequestService = inject(DocumentRequestService);
     #documentRequestCollectionAssignmentRepository = injectRepository(DocumentRequestCollectionAssignment);
     #documentService = inject(DocumentService);
+    #logger = inject(Logger, DocumentManagementApiController_1.name);
     async loadData(context) {
         const token = await context.getToken();
         for (const collectionId of context.parameters.collectionIds) {
@@ -32,6 +39,30 @@ let DocumentManagementApiController = class DocumentManagementApiController {
         }
         return await this.#documentManagementService.loadData(toArray(context.parameters.collectionIds));
     }
+    async loadDataStream(context) {
+        const token = await context.getToken();
+        for (const collectionId of context.parameters.collectionIds) {
+            const allowed = await this.#authorizationService.canReadCollection(collectionId, token);
+            if (!allowed) {
+                throw new ForbiddenError(`You are not allowed to read collection ${collectionId}`);
+            }
+        }
+        const stream = this.#documentManagementService.loadDataStream(toArray(context.parameters.collectionIds));
+        const eventSource = new ServerSentEventsSource();
+        void (async () => {
+            try {
+                for await (const chunk of stream) {
+                    await eventSource.sendJson({ name: 'data', data: chunk });
+                }
+            }
+            catch (error) {
+                this.#logger.error(error);
+                await tryIgnoreAsync(async () => await eventSource.sendJson({ name: 'error', data: createErrorResponse(error).error }));
+                await tryIgnoreAsync(async () => await eventSource.close());
+            }
+        })();
+        return eventSource;
+    }
     async loadDocumentRequestsTemplateData(context) {
         const token = await context.getToken();
         const allowed = await this.#authorizationService.canReadDocumentRequestsTemplates(token);
@@ -172,7 +203,7 @@ let DocumentManagementApiController = class DocumentManagementApiController {
         throw new NotImplementedError();
     }
 };
-DocumentManagementApiController = __decorate([
+DocumentManagementApiController = DocumentManagementApiController_1 = __decorate([
     apiController(documentManagementApiDefinition)
 ], DocumentManagementApiController);
 export { DocumentManagementApiController };

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

@@ -10,6 +10,7 @@ export declare class DocumentManagementService extends Transactional {
      * @param documentId The ID of the document to retrieve collection IDs for.
      */
     getRelevantDocumentCollectionIds(documentId: string): Promise<string[]>;
+    loadDataStream(collectionIds: string[]): ReadableStream<DocumentManagementData>;
     loadData(collectionIds: string[]): Promise<DocumentManagementData>;
     loadDocumentRequestsTemplateData(): Promise<DocumentRequestsTemplateData>;
     initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string, DocumentPropertyKey extends string>(categoryLabels: Record<CategoryKey, string>, categoryParents: Record<CategoryKey, CategoryKey | null>, typeLabels: Record<TypeKey, string>, typeCategories: Record<TypeKey, CategoryKey>, propertyKeys: Record<DocumentPropertyKey, [DocumentPropertyDataType, string]>, typeProperties: Record<TypeKey, DocumentPropertyKey[]>): Promise<{

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

@@ -13,6 +13,7 @@ import { distinct } from '../../../utils/array/index.js';
 import { compareByValueSelectionToOrder } from '../../../utils/comparison.js';
 import { groupToMap, groupToSingleMap } from '../../../utils/iterable-helpers/index.js';
 import { fromEntries, objectEntries } from '../../../utils/object/index.js';
+import { timeout } from '../../../utils/timing.js';
 import { assertDefinedPass, isDefined, isNotNull, isNotNullOrUndefined, isNull, isUndefined } from '../../../utils/type-guards.js';
 import { DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentTypeProperty, DocumentValidationExecution, DocumentWorkflowStep } from '../../models/index.js';
 import { documentAssignmentScope, documentAssignmentTask, documentCollectionAssignment, documentRequest, documentRequestCollectionAssignment } from '../schemas.js';
@@ -64,6 +65,15 @@ let DocumentManagementService = class DocumentManagementService extends Transact
         const result = await union(this.#documentService.session.with(directAssignments).selectDistinct().from(directAssignments), this.#documentService.session.with(requestAssignments).selectDistinct().from(requestAssignments), this.#documentService.session.with(assignmentScopes).selectDistinct().from(assignmentScopes));
         return result.map((row) => row.collectionId);
     }
+    loadDataStream(collectionIds) {
+        return new ReadableStream({
+            pull: async (controller) => {
+                const data = await this.loadData(collectionIds);
+                controller.enqueue(data);
+                await timeout(1000);
+            },
+        });
+    }
     async loadData(collectionIds) {
         return await this.transaction(async (tx) => {
             const [collections, collectionsMetadataMap, documentCollectionAssignments, requestAssignments, assignmentScopes, categories, types] = await Promise.all([

package/examples/api/streaming.js

@@ -34,7 +34,7 @@ const streamingApiDefinition = defineApi({
             method: 'POST',
             resource: 'echo',
             body: ReadableStream,
-            result: ReadableStream
+            result: ReadableStream,
         },
         events: {
             method: 'GET',
@@ -42,21 +42,21 @@ const streamingApiDefinition = defineApi({
             result: ServerSentEvents,
             cors: {
                 accessControlAllowOrigin: '*',
-                accessControlAllowMethods: 'GET'
-            }
-        }
-    }
+                accessControlAllowMethods: 'GET',
+            },
+        },
+    },
 });
 let StreamingApi = class StreamingApi {
     echo({ request, body }) {
         return HttpServerResponse.fromObject({
             headers: {
                 'Content-Type': request.headers.contentType,
-                'Content-Length': request.headers.contentLength
+                'Content-Length': request.headers.contentLength,
             },
             body: {
-                stream: body
-            }
+                stream: body,
+            },
         });
     }
     events(_data) {

package/examples/document-management/categories-and-types.d.ts

@@ -314,10 +314,10 @@ export declare const TstdlDocumentPropertyConfiguration: {
     readonly amount: ["decimal", "Betrag"];
     readonly currency: ["text", "Währung"];
     readonly "due-date": ["date", "Fälligkeitsdatum"];
-    readonly "start-date": ["date", "Startdatum (Periode)"];
-    readonly "end-date": ["date", "Enddatum (Periode)"];
+    readonly "start-date": ["date", "Startdatum"];
+    readonly "end-date": ["date", "Enddatum"];
     readonly status: ["text", "Status"];
-    readonly "case-number": ["text", "Fall-/Aktenzeichen (Recht)"];
+    readonly "case-number": ["text", "Fall-/Aktenzeichen"];
     readonly "meeting-date": ["date", "Sitzungsdatum"];
 };
 export declare const TstdlDocumentTypeProperties: {

package/examples/document-management/categories-and-types.js

@@ -360,10 +360,10 @@ export const TstdlDocumentPropertyConfiguration = {
     [TstdlDocumentProperty.Amount]: [DocumentPropertyDataType.Decimal, 'Betrag'],
     [TstdlDocumentProperty.Currency]: [DocumentPropertyDataType.Text, 'Währung'],
     [TstdlDocumentProperty.DueDate]: [DocumentPropertyDataType.Date, 'Fälligkeitsdatum'],
-    [TstdlDocumentProperty.StartDate]: [DocumentPropertyDataType.Date, 'Startdatum (Periode)'],
-    [TstdlDocumentProperty.EndDate]: [DocumentPropertyDataType.Date, 'Enddatum (Periode)'],
+    [TstdlDocumentProperty.StartDate]: [DocumentPropertyDataType.Date, 'Startdatum'],
+    [TstdlDocumentProperty.EndDate]: [DocumentPropertyDataType.Date, 'Enddatum'],
     [TstdlDocumentProperty.Status]: [DocumentPropertyDataType.Text, 'Status'],
-    [TstdlDocumentProperty.CaseNumber]: [DocumentPropertyDataType.Text, 'Fall-/Aktenzeichen (Recht)'],
+    [TstdlDocumentProperty.CaseNumber]: [DocumentPropertyDataType.Text, 'Fall-/Aktenzeichen'],
     [TstdlDocumentProperty.MeetingDate]: [DocumentPropertyDataType.Date, 'Sitzungsdatum'],
 };
 export const TstdlDocumentTypeProperties = {

package/examples/document-management/main.js

@@ -22,6 +22,7 @@ import { WebServerModule } from '../../module/index.js';
 import { configureS3ObjectStorage } from '../../object-storage/index.js';
 import { configureOrm } from '../../orm/server/index.js';
 import { configurePostgresQueue, migratePostgresQueueSchema } from '../../queue/postgres/index.js';
+import { configureDefaultSignalsImplementation } from '../../signals/implementation/configure.js';
 import { boolean, positiveInteger, string } from '../../utils/config-parser.js';
 import { TstdlCategoryParents, TstdlDocumentCategoryLabels, TstdlDocumentPropertyConfiguration, TstdlDocumentTypeCategories, TstdlDocumentTypeLabels, TstdlDocumentTypeProperties } from './categories-and-types.js';
 const config = {
@@ -84,6 +85,7 @@ async function bootstrap() {
     configureNodeHttpServer();
     configurePostgresQueue();
     configureLocalMessageBus();
+    configureDefaultSignalsImplementation();
     configureOrm({
         connection: {
             host: config.database.host,

package/file/mime-type.js

@@ -1,4 +1,4 @@
-import { fileTypeFromBuffer, fileTypeFromFile, fileTypeFromStream } from 'file-type';
+import { fileTypeFromBuffer, fileTypeFromFile, fileTypeFromStream } from 'file-type/node';
 import { isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
 import { match } from 'ts-pattern';
 import { mimeTypesMap } from './mime-types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.139",
+  "version": "0.92.141",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -51,6 +51,7 @@
     "./browser": "./browser/index.js",
     "./cancellation": "./cancellation/index.js",
     "./cookie": "./cookie/index.js",
+    "./css": "./css/index.js",
     "./data-structures": "./data-structures/index.js",
     "./database": "./database/index.js",
     "./database/mongo": "./database/mongo/index.js",
@@ -144,7 +145,7 @@
   "peerDependencies": {
     "@elastic/elasticsearch": "^9.0",
     "@google-cloud/storage": "7.16",
-    "@google/genai": "^1.0",
+    "@google/genai": "^1.1",
     "@tstdl/angular": "^0.92",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",

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

@@ -42,11 +42,11 @@ export class ServerSentEventsSource {
         await this.#writer.write(message);
     }
     async sendJson({ name, data, id, retry }) {
-        return this.sendText({
+        await this.sendText({
             name,
             data: JSON.stringify(data),
             id,
-            retry
+            retry,
         });
     }
 }

package/utils/object/object.js

@@ -49,7 +49,7 @@ export function filterObject(object, predicate) {
 }
 export async function filterObjectAsync(object, predicate) {
     const entries = objectEntries(object);
-    const mappedEntries = await toArrayAsync(filterAsync(entries, async ([key, value]) => predicate(value, key)));
+    const mappedEntries = await toArrayAsync(filterAsync(entries, async ([key, value]) => await predicate(value, key)));
     return Object.fromEntries(mappedEntries);
 }
 export function filterUndefinedFromRecord(record) {