@tstdl/base 0.92.123 → 0.92.125

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

@@ -0,0 +1,17 @@
+import type { FileContentPart } from '../../../ai/types.js';
+import { Transactional } from '../../../orm/server/index.js';
+import { DocumentFile } from '../../models/index.js';
+export declare class DocumentFileService extends Transactional {
+    #private;
+    load(id: string): Promise<DocumentFile>;
+    create(content: Uint8Array | ReadableStream<Uint8Array>, originalFileName: string | null): Promise<DocumentFile>;
+    getContent(fileId: string): Promise<Uint8Array>;
+    getContentStream(fileId: string): ReadableStream<Uint8Array>;
+    getContentUrl(fileId: string, title: string | null, download?: boolean): Promise<string>;
+    getPreview(fileId: string, page?: number): Promise<Uint8Array>;
+    getPreviewStream(fileId: string, page?: number): ReadableStream<Uint8Array>;
+    getPreviewUrl(fileId: string, page?: number): Promise<string>;
+    getAiFileContentPart(documentId: string): Promise<FileContentPart>;
+    private createPreviewIfNotExists;
+    private getDocumentFileContentObjectUrl;
+}

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

@@ -0,0 +1,204 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var _a;
+import sharp, {} from 'sharp';
+import { match } from 'ts-pattern';
+import { AiService } from '../../../ai/ai.service.js';
+import { NotImplementedError } from '../../../errors/not-implemented.error.js';
+import { getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
+import { TemporaryFile } from '../../../file/server/index.js';
+import { inject } from '../../../injector/inject.js';
+import { Logger } from '../../../logger/logger.js';
+import { ObjectStorage } from '../../../object-storage/index.js';
+import { Transactional } from '../../../orm/server/index.js';
+import { injectRepository } from '../../../orm/server/repository.js';
+import { pdfToImage } from '../../../pdf/index.js';
+import { digest } from '../../../utils/cryptography.js';
+import { currentTimestamp } from '../../../utils/date-time.js';
+import { readableStreamFromPromise, readBinaryStream } from '../../../utils/stream/index.js';
+import { isDefined, isUint8Array } from '../../../utils/type-guards.js';
+import { millisecondsPerMinute } from '../../../utils/units.js';
+import { Document, DocumentFile } from '../../models/index.js';
+import { DocumentManagementConfig } from '../module.js';
+export class DocumentFileService extends Transactional {
+    #documentFileRepository = injectRepository(DocumentFile);
+    #documentRepository = injectRepository(Document);
+    #aiService = inject(AiService);
+    #fileObjectStorage = inject(ObjectStorage, inject(DocumentManagementConfig).fileObjectStorageModule);
+    #filePreviewObjectStorage = inject(ObjectStorage, inject(DocumentManagementConfig).filePreviewObjectStorageModule);
+    #logger = inject(Logger, _a.name);
+    #aiFilePartCache = new Map();
+    async load(id) {
+        return this.#documentFileRepository.load(id);
+    }
+    async create(content, originalFileName) {
+        const contentAsUint8Array = isUint8Array(content) ? content : await readBinaryStream(content);
+        const hash = await digest('SHA-256', contentAsUint8Array).toHex();
+        const mimeType = await getMimeType(contentAsUint8Array);
+        return this.transaction(async (tx) => {
+            const documentFile = await this.#documentFileRepository
+                .withTransaction(tx)
+                .insert({
+                originalFileName,
+                mimeType,
+                hash,
+                size: contentAsUint8Array.length,
+            });
+            const key = getDocumentFileKey(documentFile.id);
+            await this.#fileObjectStorage.uploadObject(key, contentAsUint8Array);
+            return documentFile;
+        });
+    }
+    async getContent(fileId) {
+        const key = getDocumentFileKey(fileId);
+        return this.#fileObjectStorage.getContent(key);
+    }
+    getContentStream(fileId) {
+        const key = getDocumentFileKey(fileId);
+        return this.#fileObjectStorage.getContentStream(key);
+    }
+    async getContentUrl(fileId, title, download = false) {
+        const file = await this.#documentFileRepository.load(fileId);
+        return this.getDocumentFileContentObjectUrl(title ?? fileId, file, download);
+    }
+    async getPreview(fileId, page = 1) {
+        const key = getDocumentFileKey(fileId);
+        await this.createPreviewIfNotExists(fileId, page);
+        return this.#filePreviewObjectStorage.getContent(key);
+    }
+    getPreviewStream(fileId, page = 1) {
+        return readableStreamFromPromise(async () => {
+            const key = getDocumentFileKey(fileId);
+            await this.createPreviewIfNotExists(fileId, page);
+            return this.#filePreviewObjectStorage.getContentStream(key);
+        });
+    }
+    async getPreviewUrl(fileId, page = 1) {
+        const key = getDocumentFileKey(fileId);
+        await this.createPreviewIfNotExists(fileId, page);
+        return this.#filePreviewObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
+            'Response-Content-Type': 'image/jpeg',
+        });
+    }
+    async getAiFileContentPart(documentId) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const document = await this.#documentRepository.load(documentId);
+            const cachedAiFilePart = this.#aiFilePartCache.get(document.fileId);
+            if (isDefined(cachedAiFilePart)) {
+                if (cachedAiFilePart.timestamp > (currentTimestamp() - (5 * millisecondsPerMinute))) {
+                    return cachedAiFilePart.part;
+                }
+                this.#aiFilePartCache.delete(documentId);
+            }
+            const file = await this.load(document.fileId);
+            const fileContentStream = this.getContentStream(document.id);
+            const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
+            const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: file.mimeType });
+            this.#aiFilePartCache.set(document.fileId, { part: filePart, timestamp: currentTimestamp() });
+            return filePart;
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    async createPreviewIfNotExists(fileId, page = 1) {
+        const key = getDocumentFileKey(fileId);
+        const hasPreview = await this.#filePreviewObjectStorage.exists(key);
+        if (!hasPreview) {
+            const file = await this.#documentFileRepository.load(fileId);
+            const content = await this.#fileObjectStorage.getContent(key);
+            const image = await match(file.mimeType)
+                .with('application/pdf', async () => {
+                const imageBytes = await pdfToImage(content, page, 768, 'jpeg');
+                return imageToPreview(imageBytes);
+            })
+                .with('image/*', async () => imageToPreview(content))
+                .otherwise(() => { throw new NotImplementedError('Preview generation is not implemented for this file type.'); });
+            await this.#filePreviewObjectStorage.uploadObject(key, image, { contentLength: image.length, metadata: { 'Content-Type': 'image/jpeg' } });
+        }
+    }
+    async getDocumentFileContentObjectUrl(title, file, download) {
+        const key = getDocumentFileKey(file.id);
+        const fileExtension = getMimeTypeExtensions(file.mimeType)[0] ?? 'bin';
+        const disposition = download ? 'attachment' : 'inline';
+        const filename = `${title}.${fileExtension}`;
+        return this.#fileObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
+            'Response-Content-Type': file.mimeType,
+            'Response-Content-Disposition': `${disposition}; filename = "${encodeURIComponent(filename)}"`,
+        });
+    }
+}
+_a = DocumentFileService;
+function getDocumentFileKey(id) {
+    return `${id.slice(0, 2)}/${id.slice(0, 4)}/${id}`;
+}
+async function imageToPreview(input) {
+    return sharp(input)
+        .resize({
+        width: 768,
+        height: 768,
+        fit: 'cover',
+        position: 'top',
+        withoutEnlargement: true,
+        fastShrinkOnLoad: false,
+    })
+        .toFormat('jpeg', { quality: 75 })
+        .toBuffer();
+}

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

@@ -0,0 +1,22 @@
+import type { DocumentPropertyDataType } from '../../../document-management/models/index.js';
+type DocumentInformationExtractionPropertyResult = {
+    propertyId: string;
+    dataType: DocumentPropertyDataType;
+    value: string | number | boolean;
+};
+export type DocumentInformationExtractionResult = {
+    title: string;
+    subtitle: string | null;
+    date: number | null;
+    summary: string;
+    tags: string[];
+    properties: DocumentInformationExtractionPropertyResult[];
+};
+export declare class DocumentManagementAiService {
+    #private;
+    classifyDocumentType(documentId: string): Promise<string>;
+    extractDocumentInformation(documentId: string): Promise<DocumentInformationExtractionResult>;
+    findSuitableCollectionsForDocument(documentId: string, collectionIds: string[]): Promise<string[]>;
+    findSuitableRequestForDocument(documentId: string, collectionIds: string[]): Promise<string | null>;
+}
+export {};

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

@@ -0,0 +1,340 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var _a;
+import { and, isNull as drizzleIsNull, eq, inArray } from 'drizzle-orm';
+import { P, match } from 'ts-pattern';
+import { AiService } from '../../../ai/index.js';
+import { TemporaryFile } from '../../../file/server/index.js';
+import { inject } from '../../../injector/inject.js';
+import { Logger } from '../../../logger/logger.js';
+import { arrayAgg } from '../../../orm/index.js';
+import { injectRepository } from '../../../orm/server/index.js';
+import { array, boolean, enumeration, integer, nullable, number, object, string } from '../../../schema/index.js';
+import { distinct } from '../../../utils/array/index.js';
+import { dateObjectToNumericDate, numericDateToDateObject } from '../../../utils/date-time.js';
+import { fromEntries, objectEntries } from '../../../utils/object/object.js';
+import { assertDefined, assertDefinedPass, assertNotNull, isNotNull, isNull, isUndefined } from '../../../utils/type-guards.js';
+import { Document, DocumentProperty, DocumentRequestState, DocumentTypeProperty } from '../../models/index.js';
+import { documentCategory, documentRequest, documentRequestCollection, documentType } from '../schemas.js';
+import { DocumentCategoryTypeService } from './document-category-type.service.js';
+import { DocumentFileService } from './document-file.service.js';
+import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
+import { DocumentPropertyService } from './document-property.service.js';
+export class DocumentManagementAiService {
+    #documentManagementAncillaryService = inject(DocumentManagementAncillaryService);
+    #documentCategoryTypeService = inject(DocumentCategoryTypeService);
+    #documentFileService = inject(DocumentFileService);
+    #documentPropertyService = inject(DocumentPropertyService);
+    #aiService = inject(AiService);
+    #documentPropertyRepository = injectRepository(DocumentProperty);
+    #documentRepository = injectRepository(Document);
+    #documentTypePropertyRepository = injectRepository(DocumentTypeProperty);
+    #logger = inject(Logger, _a.name);
+    async classifyDocumentType(documentId) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const document = await this.#documentRepository.load(documentId);
+            const file = await this.#documentFileService.load(document.fileId);
+            const fileContentStream = this.#documentFileService.getContentStream(document.id);
+            const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
+            const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: file.mimeType });
+            const categories = await this.#documentCategoryTypeService.loadCategoryViews();
+            const typeLabelEntries = getDescriptiveTypeLabels(categories);
+            const typeLabels = typeLabelEntries.map(({ label }) => label);
+            this.#logger.trace(`Classifying document ${document.id}`);
+            const documentTypeGeneration = await this.#aiService.generate({
+                model: 'gemini-2.5-flash-preview-04-17',
+                generationOptions: {
+                    maxOutputTokens: 128,
+                    temperature: 0.1,
+                    topP: 0.75,
+                    topK: 4,
+                    thinkingBudget: 0,
+                },
+                generationSchema: object({
+                    documentType: enumeration(typeLabels),
+                }),
+                contents: [
+                    {
+                        role: 'user',
+                        parts: [
+                            { file: filePart.file },
+                            { text: `Klassifiziere den Inhalt des Dokuments in das angegebenen JSON Schema.` },
+                        ],
+                    },
+                ],
+            });
+            const typeId = typeLabelEntries.find((entry) => entry.label == documentTypeGeneration.json.documentType)?.id;
+            assertDefined(typeId, `Could not classify document ${document.id}`);
+            return typeId;
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    async extractDocumentInformation(documentId) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const document = await this.#documentRepository.load(documentId);
+            const file = await this.#documentFileService.load(document.fileId);
+            const fileContentStream = this.#documentFileService.getContentStream(document.fileId);
+            const tmpFile = __addDisposableResource(env_2, await TemporaryFile.from(fileContentStream), true);
+            const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: file.mimeType });
+            if (isNull(document.typeId)) {
+                throw new Error(`Document ${document.id} has no type`);
+            }
+            const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ typeId: document.typeId });
+            const propertyIds = typeProperties.map((property) => property.propertyId);
+            const properties = (propertyIds.length > 0) ? await this.#documentPropertyRepository.loadManyByQuery({ id: { $in: propertyIds } }) : undefined;
+            const propertiesSchemaEntries = properties?.map((property) => {
+                const schema = match(property.dataType)
+                    .with('text', () => nullable(string()))
+                    .with('integer', () => nullable(integer()))
+                    .with('decimal', () => nullable(number()))
+                    .with('boolean', () => nullable(boolean()))
+                    .with('date', () => nullable(object({ year: integer(), month: integer(), day: integer() })))
+                    .exhaustive();
+                return [property.label, schema];
+            });
+            const generationSchema = object({
+                documentTitle: string(),
+                documentSubtitle: nullable(string()),
+                documentSummary: string(),
+                documentTags: array(string()),
+                documentDate: nullable(object({ year: integer(), month: integer(), day: integer() })),
+                ...((isUndefined(propertiesSchemaEntries) || (propertiesSchemaEntries.length == 0))
+                    ? {}
+                    : { documentProperties: object(fromEntries(propertiesSchemaEntries)) }),
+            });
+            this.#logger.trace(`Extracting document ${document.id}`);
+            const { json: extraction } = await this.#aiService.generate({
+                model: 'gemini-2.5-flash-preview-04-17',
+                generationOptions: {
+                    maxOutputTokens: 2048,
+                    temperature: 0.2,
+                    topP: 0.5,
+                    topK: 16,
+                    thinkingBudget: 0,
+                },
+                generationSchema,
+                contents: [
+                    {
+                        role: 'user',
+                        parts: [
+                            { file: filePart.file },
+                            {
+                                text: `Extrahiere den Inhalt des Dokuments in das angegebenen JSON Schema.
+
+Gib in der summary ausführlich an, welche Informationen in dem Dokument vorkommen (ohne konkrete Werte).
+Erstelle bis zu 7 möglichst spezifische Tags.
+Antworte auf deutsch.`,
+                            },
+                        ],
+                    },
+                ],
+            });
+            const filteredDocumentTags = extraction.documentTags.filter((tag) => (tag != extraction.documentTitle) && (tag != extraction.documentSubtitle));
+            const date = isNotNull(extraction.documentDate) ? dateObjectToNumericDate(extraction.documentDate) : null;
+            const parsedProperties = isUndefined(extraction.documentProperties)
+                ? []
+                : objectEntries(extraction.documentProperties)
+                    .map(([propertyLabel, rawValue]) => {
+                    if (isNull(rawValue)) {
+                        return null;
+                    }
+                    const property = assertDefinedPass(properties?.find((property) => property.label == propertyLabel));
+                    const value = match(rawValue)
+                        .with({ year: P.number }, (val) => dateObjectToNumericDate(val))
+                        .otherwise((val) => val);
+                    return { propertyId: property.id, dataType: property.dataType, value };
+                })
+                    .filter(isNotNull);
+            return {
+                title: extraction.documentTitle,
+                subtitle: extraction.documentSubtitle,
+                date,
+                summary: extraction.documentSummary,
+                tags: filteredDocumentTags,
+                properties: parsedProperties,
+            };
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
+        }
+    }
+    async findSuitableCollectionsForDocument(documentId, collectionIds) {
+        const document = await this.#documentRepository.load(documentId);
+        assertNotNull(document.typeId, 'Document has no type');
+        const documentProperties = await this.#documentPropertyService.loadDocumentProperties(documentId);
+        const collectionNamesMap = await this.#documentManagementAncillaryService.resolveMetadata(...collectionIds);
+        const collections = collectionIds.map((collectionId, index) => ({
+            id: collectionId,
+            ...assertDefinedPass(collectionNamesMap[index]),
+        }));
+        const propertyEntries = documentProperties.map((property) => [property.label, property.value]);
+        const context = {
+            document: {
+                title: document.title ?? undefined,
+                subtitle: document.subtitle ?? undefined,
+                date: isNotNull(document.date) ? numericDateToDateObject(document.date) : undefined,
+                summary: document.summary ?? undefined,
+                tags: ((document.tags?.length ?? 0) > 0) ? document.tags : undefined,
+                properties: fromEntries(propertyEntries),
+            },
+            collections,
+        };
+        const result = await this.#aiService.generate({
+            model: 'gemini-2.5-flash-preview-04-17',
+            generationOptions: {
+                maxOutputTokens: 100,
+                temperature: 0,
+                topP: 0.2,
+                topK: 16,
+                thinkingBudget: 0,
+            },
+            generationSchema: object({ collectionIds: array(string()) }),
+            contents: [{
+                    role: 'user',
+                    parts: [
+                        {
+                            text: `<context>
+${JSON.stringify(context, null, 2)}
+</context>
+
+Ordne das Dokument unter "document" einer oder mehreren passenden Collection unter "collections" zu. Gib es als JSON im angegebenen Schema aus. Wenn keine Collection passt, gib collectionIds als leeres Array zurück.`,
+                        },
+                    ],
+                }],
+        });
+        return result.json.collectionIds;
+    }
+    async findSuitableRequestForDocument(documentId, collectionIds) {
+        const session = this.#documentPropertyRepository.session;
+        const document = await this.#documentRepository.load(documentId);
+        assertNotNull(document.typeId, 'Document has no type');
+        const documentProperties = await this.#documentPropertyService.loadDocumentProperties(documentId);
+        const openRequestsWithoutDocument = await session
+            .select({
+            id: documentRequest.id,
+            collectionIds: arrayAgg(documentRequestCollection.collectionId),
+            documentCategory: documentCategory.label,
+            documentType: documentType.label,
+            comment: documentRequest.comment,
+        })
+            .from(documentRequest)
+            .innerJoin(documentRequestCollection, eq(documentRequestCollection.requestId, documentRequest.id))
+            .innerJoin(documentType, eq(documentType.id, documentRequest.typeId))
+            .innerJoin(documentCategory, eq(documentCategory.id, documentType.categoryId))
+            .where(and(inArray(documentRequestCollection.collectionId, collectionIds), eq(documentRequest.typeId, document.typeId), eq(documentRequest.state, DocumentRequestState.Open), drizzleIsNull(documentRequest.documentId)))
+            .groupBy(documentRequest.id, documentCategory.label, documentType.label, documentRequest.comment);
+        const requestsCollectionIds = distinct(openRequestsWithoutDocument.flatMap((request) => request.collectionIds));
+        const collectionNamesMap = await this.#documentManagementAncillaryService.resolveMetadataMap(...requestsCollectionIds);
+        const requests = openRequestsWithoutDocument.map((request) => ({
+            id: request.id,
+            collections: request.collectionIds.map((collectionId) => assertDefinedPass(collectionNamesMap[collectionId]).name),
+            comment: request.comment ?? undefined,
+        }));
+        const propertyEntries = documentProperties.map((property) => [property.label, property.value]);
+        const context = {
+            document: {
+                title: document.title ?? undefined,
+                subtitle: document.subtitle ?? undefined,
+                date: isNotNull(document.date) ? numericDateToDateObject(document.date) : undefined,
+                summary: document.summary ?? undefined,
+                tags: ((document.tags?.length ?? 0) > 0) ? document.tags : undefined,
+                properties: fromEntries(propertyEntries),
+            },
+            requests,
+        };
+        const result = await this.#aiService.generate({
+            model: 'gemini-2.5-flash-preview-04-17',
+            generationOptions: {
+                maxOutputTokens: 100,
+                temperature: 0,
+                topP: 0.2,
+                topK: 16,
+                thinkingBudget: 0,
+            },
+            generationSchema: object({ requestId: nullable(string()) }),
+            contents: [{
+                    role: 'user',
+                    parts: [
+                        {
+                            text: `<context>
+${JSON.stringify(context, null, 2)}
+</context>
+
+Ordne das Dokument unter "document" der passenden Anforderungen unter "requests" zu. Gib es als JSON im angegebenen Schema aus. Wenn keine Anforderung passt, setze requestId auf null.`,
+                        },
+                    ],
+                }],
+        });
+        return result.json.requestId;
+    }
+}
+_a = DocumentManagementAiService;
+function getDescriptiveTypeLabels(categories, prefix = 'Category: ') {
+    return categories.flatMap((category) => [...category.types.map((type) => ({ id: type.id, label: `${prefix}${category.label} | Type: ${type.label}` }), ...getDescriptiveTypeLabels(category.children, `${prefix}${category.label} -> `))]);
+}