@tstdl/base 0.92.123 → 0.92.125

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

@@ -1,218 +1,88 @@
-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;
-};
-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 DocumentManagementService_1;
-import { and, eq, inArray, ne, notExists, sql } from 'drizzle-orm';
-import { P, match } from 'ts-pattern';
-import { AiService } from '../../../ai/index.js';
 import { Enumerable } from '../../../enumerable/index.js';
-import { BadRequestError } from '../../../errors/index.js';
-import { getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
-import { TemporaryFile } from '../../../file/server/index.js';
-import { Singleton, afterResolve, inject } from '../../../injector/index.js';
-import { Logger } from '../../../logger/logger.js';
-import { MessageBus } from '../../../message-bus/message-bus.js';
-import { ObjectStorage } from '../../../object-storage/index.js';
-import { TRANSACTION_TIMESTAMP, arrayAgg, coalesce, getEntityMap, jsonAgg, toJsonb } from '../../../orm/index.js';
-import { DatabaseConfig, getRepository, injectRepository } from '../../../orm/server/index.js';
-import { getPdfPageCount } from '../../../pdf/index.js';
-import { Queue } from '../../../queue/queue.js';
-import { array, boolean, enumeration, integer, nullable, number, object, string } from '../../../schema/index.js';
-import { distinct, toArray } from '../../../utils/array/index.js';
+import { inject } from '../../../injector/index.js';
+import { getEntityMap } from '../../../orm/index.js';
+import { Transactional, injectRepository } from '../../../orm/server/index.js';
+import { distinct } from '../../../utils/array/index.js';
 import { compareByValueSelectionToOrder } from '../../../utils/comparison.js';
-import { digest } from '../../../utils/cryptography.js';
-import { currentTimestamp, dateObjectToNumericDate } from '../../../utils/date-time.js';
-import { groupToMap } from '../../../utils/iterable-helpers/index.js';
-import { fromEntries, objectEntries } from '../../../utils/object/object.js';
-import { readBinaryStream } from '../../../utils/stream/index.js';
-import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
-import { assertBooleanPass, assertDefined, assertDefinedPass, assertNotNullPass, assertNumberPass, assertStringPass, isBoolean, isDefined, isNotNull, isNull, isNumber, isString, isUint8Array, isUndefined } from '../../../utils/type-guards.js';
-import { millisecondsPerMinute } from '../../../utils/units.js';
-import { union } from 'drizzle-orm/pg-core';
-import { debounceTime, filter, map } from 'rxjs';
-import { Document, DocumentCategory, DocumentCollection, DocumentCollectionDocument, DocumentFile, DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentRequest, DocumentRequestAssignmentTask, DocumentRequestAssignmentTaskCollection, DocumentRequestAssignmentTaskPropertyValue, DocumentRequestCollection, DocumentRequestFile, DocumentRequestFilePropertyValue, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentTypeProperty } from '../../models/index.js';
-import { DocumentManagementConfig } from '../module.js';
-import { documentCategory, documentCollectionDocument, documentProperty, documentRequest, documentRequestAssignmentTask, documentRequestAssignmentTaskCollection, documentRequestAssignmentTaskPropertyValue, documentRequestCollection, documentRequestFile, documentType } from '../schemas.js';
+import { groupToMap, groupToSingleMap } from '../../../utils/iterable-helpers/index.js';
+import { fromEntries, objectEntries } from '../../../utils/object/index.js';
+import { assertDefinedPass, isNotNull, isNull, isUndefined } from '../../../utils/type-guards.js';
+import { DocumentApproval, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentRequest, DocumentRequestCollection, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentValidationExecution, DocumentWorkflowStep } from '../../models/index.js';
+import { DocumentCategoryTypeService, enumTypeKey } from './document-category-type.service.js';
 import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
-const defaultGenerationOptions = {
-    model: 'gemini-2.0-flash',
-    generationOptions: {
-        maxOutputTokens: 2048,
-        temperature: 0.2,
-        topP: 0.2
-    }
-};
-let DocumentManagementService = DocumentManagementService_1 = class DocumentManagementService extends getRepository(DocumentCollection) {
-    #aiService = inject(AiService);
-    ancillaryService = inject(DocumentManagementAncillaryService);
-    documentCategoryService = injectRepository(DocumentCategory);
-    documentCollectionDocumentService = injectRepository(DocumentCollectionDocument);
-    documentFileService = injectRepository(DocumentFile);
-    documentPropertyService = injectRepository(DocumentProperty);
-    documentPropertyValueService = injectRepository(DocumentPropertyValue);
-    documentRequestAssignmentTaskCollectionService = injectRepository(DocumentRequestAssignmentTaskCollection);
-    documentRequestAssignmentTaskService = injectRepository(DocumentRequestAssignmentTask);
-    documentRequestCollectionService = injectRepository(DocumentRequestCollection);
-    documentRequestFilePropertyValueService = injectRepository(DocumentRequestFilePropertyValue);
-    documentRequestAssignmentTaskPropertyValueService = injectRepository(DocumentRequestAssignmentTaskPropertyValue);
-    documentRequestFileService = injectRepository(DocumentRequestFile);
-    documentRequestService = injectRepository(DocumentRequest);
-    documentRequestsTemplateService = injectRepository(DocumentRequestsTemplate);
-    documentRequestTemplateService = injectRepository(DocumentRequestTemplate);
-    documentService = injectRepository(Document);
-    documentTypePropertyService = injectRepository(DocumentTypeProperty);
-    documentTypeService = injectRepository(DocumentType);
-    fileObjectStorage = inject(ObjectStorage, inject(DocumentManagementConfig).fileObjectStorageModule);
-    extractionQueue = inject((Queue), { name: 'DocumentManagement:extraction', processTimeout: 15 * millisecondsPerMinute });
-    assignmentQueue = inject((Queue), { name: 'DocumentManagement:assignment', processTimeout: 15 * millisecondsPerMinute });
-    collectionChangeMessageBus = inject((MessageBus), 'DocumentManagement:collectionChange');
-    logger = inject(Logger, DocumentManagementService_1.name);
-    [afterResolve](_, { cancellationSignal }) {
-        if (this.isFork) {
-            return;
-        }
-        this.processQueues(cancellationSignal);
-    }
-    changes$(collectionIds) {
-        const collectionIdsArray = toArray(collectionIds);
-        return this.collectionChangeMessageBus.allMessages$.pipe(filter((message) => isUndefined(message) || collectionIdsArray.some((id) => message.includes(id))), debounceTime(250), map(() => undefined));
-    }
-    processQueues(cancellationSignal) {
-        this.extractionQueue.process({ concurrency: 5, cancellationSignal }, async (job) => {
-            const [entry] = objectEntries(job.data);
-            this.logger.verbose(`Processing extraction job for ${entry?.[0]} ${entry?.[1]}`);
-            await match(job.data)
-                .with({ documentId: P.string.select() }, async (documentId) => this.enrichDocument(documentId))
-                .with({ requestFileId: P.string.select() }, async (requestFileId) => this.enrichDocumentRequestFile(requestFileId))
-                .with({ requestAssignmentTaskId: P.string.select() }, async (requestAssignmentTaskId) => this.enrichDocumentRequestAssignmentTask(requestAssignmentTaskId))
-                .exhaustive();
-        }, this.logger);
-        this.assignmentQueue.process({ concurrency: 5, cancellationSignal }, async (job) => {
-            this.logger.verbose(`Processing assignment job "${job.data.requestAssignmentTaskId}"`);
-            await this.assignDocumentRequest(job.data.requestAssignmentTaskId);
-        }, this.logger);
-    }
-    async resolveNames(...collectionsOrIds) {
-        if (collectionsOrIds.length == 0) {
-            return [];
-        }
-        const loadIds = collectionsOrIds.filter((collection) => isString(collection));
-        if (loadIds.length == 0) {
-            return this.ancillaryService.resolveNames(collectionsOrIds);
-        }
-        const loadedCollections = await this.loadManyByQuery({ id: { $in: loadIds } });
-        const collections = collectionsOrIds.map((collectionOrId) => isString(collectionOrId)
-            ? assertDefinedPass(loadedCollections.find((collection) => collection.id == collectionOrId), `Could not load collection "${collectionOrId}".`)
-            : collectionOrId);
-        return this.ancillaryService.resolveNames(collections);
-    }
-    async resolveNamesMap(...collectionsOrIds) {
-        const names = await this.resolveNames(...collectionsOrIds);
-        const entries = collectionsOrIds.map((collectionOrId, index) => [isString(collectionOrId) ? collectionOrId : collectionOrId.id, names[index]]);
-        return fromEntries(entries);
-    }
-    async loadData(collectionIds, collectionsMetadata) {
-        return this.transaction(async (_, transaction) => {
-            const [collections, collectionDocuments, requestCollections, categories, types] = await Promise.all([
-                this.withTransaction(transaction).loadMany(collectionIds),
-                this.documentCollectionDocumentService.withTransaction(transaction).loadManyByQuery({ collectionId: { $in: collectionIds } }),
-                this.documentRequestCollectionService.withTransaction(transaction).loadManyByQuery({ collectionId: { $in: collectionIds } }),
-                this.documentCategoryService.withTransaction(transaction).loadManyByQuery({}, { order: 'label' }),
-                this.documentTypeService.withTransaction(transaction).loadManyByQuery({}, { order: 'label' })
+import { DocumentPropertyService } from './document-property.service.js';
+import { DocumentWorkflowService } from './document-workflow.service.js';
+import { DocumentService } from './document.service.js';
+export class DocumentManagementService extends Transactional {
+    #ancillaryService = inject(DocumentManagementAncillaryService);
+    #documentCategoryTypeService = inject(DocumentCategoryTypeService);
+    #documentCollectionRepository = injectRepository(DocumentCollection);
+    #documentCategoryRepository = injectRepository(DocumentCategory);
+    #documentCollectionAssignmentRepository = injectRepository(DocumentCollectionAssignment);
+    #documentFileRepository = injectRepository(DocumentFile);
+    #documentService = inject(DocumentService);
+    #documentPropertyService = inject(DocumentPropertyService);
+    #documentRequestCollectionRepository = injectRepository(DocumentRequestCollection);
+    #documentRequestRepository = injectRepository(DocumentRequest);
+    #documentRequestsTemplateRepository = injectRepository(DocumentRequestsTemplate);
+    #documentRequestTemplateRepository = injectRepository(DocumentRequestTemplate);
+    #documentTypeRepository = injectRepository(DocumentType);
+    #documentWorkflowService = inject(DocumentWorkflowService);
+    #documentValidationExecutionRepository = injectRepository(DocumentValidationExecution);
+    async loadData(collectionIds) {
+        return this.transaction(async (tx) => {
+            const [collections, collectionsMetadataMap, collectionAssignments, requestCollections, categories, types] = await Promise.all([
+                this.#documentCollectionRepository.withTransaction(tx).loadMany(collectionIds),
+                this.#ancillaryService.resolveMetadataMap(...collectionIds),
+                this.#documentCollectionAssignmentRepository.withTransaction(tx).loadManyByQuery({ collectionId: { $in: collectionIds } }),
+                this.#documentRequestCollectionRepository.withTransaction(tx).loadManyByQuery({ collectionId: { $in: collectionIds } }),
+                this.#documentCategoryRepository.withTransaction(tx).loadManyByQuery({}, { order: 'label' }),
+                this.#documentTypeRepository.withTransaction(tx).loadManyByQuery({}, { order: 'label' }),
             ]);
-            const documentIds = collectionDocuments.map((document) => document.documentId);
             const requestIds = requestCollections.map((requestCollection) => requestCollection.requestId);
-            const [documents, requests, requestFiles, propertyValues, extractionJobs] = await Promise.all([
-                this.documentService.withTransaction(transaction).loadManyByQuery({ id: { $in: documentIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
-                this.documentRequestService.withTransaction(transaction).loadManyByQuery({ id: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
-                this.documentRequestFileService.withTransaction(transaction).loadManyByQuery({ requestId: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
-                this.documentPropertyValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } }),
-                this.extractionQueue.getByTags(documentIds)
+            const requests = await this.#documentRequestRepository.withTransaction(tx).loadManyByQuery({ id: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } });
+            const collectionDocumentIds = collectionAssignments.map((document) => document.documentId);
+            const requestDocumentIds = requests.map((request) => request.documentId).filter(isNotNull);
+            const documentIds = distinct([...collectionDocumentIds, ...requestDocumentIds]);
+            const [documents, propertyValues] = await Promise.all([
+                this.#documentService.withTransaction(tx).repository.loadManyByQuery({ id: { $in: documentIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
+                this.#documentPropertyService.withTransaction(tx).loadDocumentProperties(documentIds),
             ]);
             const documentFileIds = documents.map((document) => document.fileId);
-            const requestFileIds = requestFiles.map((requestFile) => requestFile.fileId);
-            const files = await this.documentFileService.withTransaction(transaction).loadManyByQuery({ id: { $in: [...documentFileIds, ...requestFileIds] } }, { order: { 'metadata.createTimestamp': 'desc' } });
-            const requestsFilesMap = groupToMap(requestFiles, (requestFile) => requestFile.requestId);
+            const workflowRelevantDocumentIds = documents.map((document) => (document.approval == DocumentApproval.Pending) ? document.id : null).filter(isNotNull);
+            const [files, currentWorkflows] = await Promise.all([
+                this.#documentFileRepository.withTransaction(tx).loadManyByQuery({ id: { $in: documentFileIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
+                this.#documentWorkflowService.loadLatestWorkflows(workflowRelevantDocumentIds),
+            ]);
+            const documentIdMap = getEntityMap(documents);
+            const documentWorkflowMap = groupToSingleMap(currentWorkflows, (workflow) => workflow.documentId);
             const valuesMap = Enumerable.from(propertyValues).groupToMap((value) => value.documentId);
-            const collectionViews = collections.toSorted(compareByValueSelectionToOrder(collectionIds, (collection) => collection.id)).map((collection) => ({
-                ...collection,
-                name: collectionsMetadata?.[collection.id]?.name ?? null,
-                group: collectionsMetadata?.[collection.id]?.group ?? null
-            }));
+            const validationWorkflowIds = currentWorkflows.map((workflow) => (workflow.step == DocumentWorkflowStep.Validation) ? workflow.id : null).filter(isNotNull);
+            const validations = await this.#documentValidationExecutionRepository.loadManyByQuery({ workflowId: { $in: validationWorkflowIds } });
+            const workflowValidationMap = groupToMap(validations, (validation) => validation.workflowId);
+            const collectionViews = collections.toSorted(compareByValueSelectionToOrder(collectionIds, (collection) => collection.id)).map((collection) => {
+                const metadata = assertDefinedPass(collectionsMetadataMap[collection.id]);
+                return ({
+                    ...collection,
+                    name: metadata.name,
+                    group: metadata.group,
+                });
+            });
             const documentViews = documents.map((document) => {
-                const job = extractionJobs.find((job) => job.tag == document.id);
+                const currentWorkflow = documentWorkflowMap.get(document.id) ?? null;
+                const validations = (isNotNull(currentWorkflow) && (currentWorkflow.step == DocumentWorkflowStep.Validation)) ? workflowValidationMap.get(currentWorkflow.id) ?? [] : null;
                 return {
                     ...document,
-                    collectionAssignments: collectionDocuments.filter((collectionDocument) => collectionDocument.documentId == document.id).map(({ collectionId, archiveTimestamp }) => ({ collectionId, archiveTimestamp })),
+                    collectionAssignments: collectionAssignments.filter((collectionDocument) => collectionDocument.documentId == document.id),
                     properties: valuesMap.get(document.id) ?? [],
-                    extractionStatus: isUndefined(job)
-                        ? null
-                        : isNull(job.lastDequeueTimestamp)
-                            ? 'pending'
-                            : (job.tries >= this.extractionQueue.maxTries) && (job.lastDequeueTimestamp >= (currentTimestamp() + this.extractionQueue.processTimeout))
-                                ? 'error'
-                                : 'extracting'
+                    currentWorkflow,
+                    validations,
                 };
             });
             const requestViews = requests.map((request) => ({
                 ...request,
                 collectionIds: requestCollections.filter((requestCollection) => requestCollection.requestId == request.id).map((requestCollection) => requestCollection.collectionId),
-                requestFiles: requestsFilesMap.get(request.id) ?? []
+                document: isNull(request.documentId) ? null : documentIdMap.get(request.documentId) ?? null,
             }));
             return {
                 collections: collectionViews,
@@ -220,710 +90,58 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
                 requests: requestViews,
                 files,
                 categories,
-                types
+                types,
             };
         });
     }
     async loadDocumentRequestsTemplateData() {
         const [requestsTemplates, requestTemplates] = await Promise.all([
-            this.documentRequestsTemplateService.loadManyByQuery({}, { order: 'label' }),
-            this.documentRequestTemplateService.loadManyByQuery({})
+            this.#documentRequestsTemplateRepository.loadManyByQuery({}, { order: 'label' }),
+            this.#documentRequestTemplateRepository.loadManyByQuery({}),
         ]);
         const templates = requestsTemplates.map((requestsTemplate) => ({
             ...requestsTemplate,
-            requestTemplates: requestTemplates.filter((requestTemplate) => requestTemplate.requestsTemplateId == requestsTemplate.id)
+            requestTemplates: requestTemplates.filter((requestTemplate) => requestTemplate.requestsTemplateId == requestsTemplate.id),
         }));
         return { templates };
     }
-    async loadCategoriesAndTypes() {
-        const [categories, types] = await Promise.all([
-            this.documentCategoryService.loadManyByQuery({}, { order: 'label' }),
-            this.documentTypeService.loadManyByQuery({}, { order: 'label' })
-        ]);
-        return { categories, types };
-    }
-    async loadDocument(id) {
-        return this.documentService.load(id);
-    }
-    async loadDocumentFile(id) {
-        return this.documentFileService.load(id);
-    }
-    async loadType(id) {
-        return this.documentTypeService.load(id);
-    }
-    async getFileContent(fileId) {
-        const key = getDocumentFileKey(fileId);
-        return this.fileObjectStorage.getContent(key);
-    }
-    getFileContentStream(fileId) {
-        const key = getDocumentFileKey(fileId);
-        return this.fileObjectStorage.getContentStream(key);
-    }
-    async getFileContentUrl(fileId, title, download = false) {
-        const file = await this.documentFileService.load(fileId);
-        return this.getDocumentFileContentObjectUrl(title ?? fileId, file, download);
-    }
-    async createCategory(parameters) {
-        return this.documentCategoryService.insert(parameters);
-    }
-    async createType(parameters) {
-        return this.documentTypeService.insert(parameters);
-    }
-    async createCollection(parameters) {
-        return this.insert(parameters ?? {});
-    }
-    async collectionHasDocumentByFilter(collectionId, filter) {
-        const collectionDocuments = await this.documentCollectionDocumentService.loadManyByQuery({ collectionId });
-        const documentIds = collectionDocuments.map((cd) => cd.documentId);
-        return this.documentService.hasByQuery({ $and: [{ id: { $in: documentIds } }, filter] });
-    }
-    async getRequestFilesStats(collectionIds) {
-        const collectionRequests = await this.documentRequestCollectionService.loadManyByQuery({ collectionId: { $in: toArray(collectionIds) } });
-        const requestIds = collectionRequests.map((collectionRequest) => collectionRequest.requestId);
-        const filteredRequests = await this.documentRequestService.loadManyByQuery({ id: { $in: requestIds }, completed: false });
-        const filteredRequestIds = filteredRequests.map((request) => request.id);
-        const requiredFilesCount = filteredRequests.reduce((sum, request) => sum + request.requiredFilesCount, 0);
-        const [pendingFilesCount, approvedFilesCount] = await Promise.all([
-            this.documentRequestFileService.countByQuery({ requestId: { $in: filteredRequestIds }, approval: null }),
-            this.documentRequestFileService.countByQuery({ requestId: { $in: filteredRequestIds }, approval: true })
-        ]);
-        return { requiredFilesCount, requiredFilesLeft: Math.max(0, requiredFilesCount - approvedFilesCount), pendingFilesCount, approvedFilesCount };
-    }
-    async createDocumentRequestsTemplate(parameters) {
-        return this.documentRequestsTemplateService.insert(parameters);
-    }
-    async updateDocumentRequestsTemplate({ id, label, metadata }) {
-        return this.documentRequestsTemplateService.update(id, { label, metadata });
-    }
-    async applyDocumentRequestsTemplate({ id, collectionIds, metadata }) {
-        const requestTemplates = await this.documentRequestTemplateService.loadManyByQuery({ requestsTemplateId: id });
-        await this.documentRequestService.transaction(async (_, transaction) => {
-            for (const { typeId, requiredFilesCount, comment } of requestTemplates) {
-                await this.createDocumentRequest({ typeId, requiredFilesCount, comment, collectionIds, metadata }, transaction);
-            }
-        });
-    }
-    async deleteDocumentRequestsTemplate(parameters) {
-        return this.documentRequestsTemplateService.delete(parameters.id);
-    }
-    async createDocumentRequestTemplate(parameters) {
-        return this.documentRequestTemplateService.insert(parameters);
-    }
-    async updateDocumentRequestTemplate({ id, typeId, requiredFilesCount, comment, metadata }) {
-        return this.documentRequestTemplateService.update(id, { typeId, requiredFilesCount, comment, metadata });
-    }
-    async deleteDocumentRequestTemplate(parameters) {
-        return this.documentRequestTemplateService.delete(parameters.id);
-    }
-    async createDocument({ typeId, title, subtitle, pages, date, summary, tags, validated, originalFileName, collectionIds, properties, metadata }, content) {
-        const collectionIdsArray = toArray(collectionIds);
-        const document = await this.documentService.transaction(async (_, transaction) => {
-            const documentFile = await this.createDocumentFile(content, originalFileName, transaction);
-            const document = await this.documentService.withTransaction(transaction).insert({ fileId: documentFile.id, typeId, title, subtitle, pages, date, summary, tags, metadata, validated });
-            for (const collectionId of collectionIdsArray) {
-                await this.documentCollectionDocumentService.withTransaction(transaction).insert({ collectionId, documentId: document.id, archiveTimestamp: null });
-            }
-            if (isDefined(properties)) {
-                await this.setPropertyValues({ documentId: document.id, properties }, transaction);
-            }
-            return document;
-        });
-        void tryIgnoreLogAsync(this.logger, async () => this.extractionQueue.enqueue({ documentId: document.id }, { tag: document.id }));
-        this.publishChange({ collectionIds: collectionIdsArray });
-        return document;
-    }
-    async approveDocumentRequestFile({ id, approvalComment, documentMetadata, requestFileMetadata }) {
-        return this.documentRequestFileService.transaction(async (_, transaction) => {
-            const requestFile = await this.documentRequestFileService.withTransaction(transaction).load(id);
-            const requestCollections = await this.documentRequestCollectionService.withTransaction(transaction).loadManyByQuery({ requestId: requestFile.requestId });
-            if (requestFile.approval == true) {
-                throw new BadRequestError('Document request file already accepted.');
-            }
-            const request = await this.documentRequestService.withTransaction(transaction).load(requestFile.requestId);
-            const document = await this.documentService.withTransaction(transaction).insert({
-                fileId: requestFile.fileId,
-                typeId: request.typeId,
-                title: requestFile.title,
-                subtitle: requestFile.subtitle,
-                pages: requestFile.pages,
-                date: requestFile.date,
-                summary: requestFile.summary,
-                tags: requestFile.tags,
-                validated: true,
-                metadata: documentMetadata
-            });
-            for (const { collectionId } of requestCollections) {
-                await this.addDocumentToCollection({ collectionId, documentId: document.id }, transaction);
-            }
-            await this.documentRequestFileService.withTransaction(transaction).update(id, { approval: true, approvalComment, approvalTimestamp: TRANSACTION_TIMESTAMP, createdDocumentId: document.id, metadata: requestFileMetadata });
-            return document;
-        });
-    }
-    async rejectDocumentRequestFile({ id, approvalComment, metadata }) {
-        const requestFile = await this.documentRequestFileService.transaction(async (_, transaction) => {
-            const requestFile = await this.documentRequestFileService.withTransaction(transaction).load(id);
-            if (requestFile.approval == true) {
-                throw new BadRequestError('Document request file already accepted.');
-            }
-            return this.documentRequestFileService.withTransaction(transaction).update(id, { approval: false, approvalComment, approvalTimestamp: TRANSACTION_TIMESTAMP, metadata });
-        });
-        this.publishChange({ requestIds: [requestFile.requestId] });
-    }
-    async updateDocumentRequestFile({ id, title, approvalComment, metadata }) {
-        const result = await this.documentRequestFileService.update(id, { title, approvalComment, metadata });
-        this.publishChange({ requestIds: [result.requestId] });
-        return result;
-    }
-    async deleteDocumentRequestFile({ id, metadata }) {
-        const requestFile = await this.documentRequestFileService.load(id);
-        if (isNotNull(requestFile.approval)) {
-            throw new BadRequestError('Only pending request files can be deleted.');
-        }
-        await this.documentRequestFileService.delete(id, metadata);
-        this.publishChange({ requestIds: [requestFile.requestId] });
-    }
-    async createDocumentFile(content, originalFileName, transaction) {
-        const contentAsUint8Array = isUint8Array(content) ? content : await readBinaryStream(content);
-        const hash = await digest('SHA-256', contentAsUint8Array).toHex();
-        const mimeType = await getMimeType(contentAsUint8Array);
-        return this.documentFileService.useTransaction(transaction, async (_, transaction) => {
-            const documentFile = await this.documentFileService
-                .withTransaction(transaction)
-                .insert({
-                originalFileName,
-                mimeType,
-                hash,
-                size: contentAsUint8Array.length
-            });
-            const key = getDocumentFileKey(documentFile.id);
-            await this.fileObjectStorage.uploadObject(key, contentAsUint8Array);
-            return documentFile;
-        });
-    }
-    async createDocumentRequestFile({ requestId, title, subtitle, date, summary, tags, originalFileName, metadata }, content) {
-        const documentRequestFile = await this.documentRequestFileService.transaction(async (_, transaction) => {
-            const [request, existingRequestFiles] = await Promise.all([
-                this.documentRequestService.withTransaction(transaction).load(requestId),
-                this.documentRequestFileService.withTransaction(transaction).loadManyByQuery({ requestId })
-            ]);
-            const filesCountLeft = (request.completed ? 0 : request.requiredFilesCount) - existingRequestFiles.reduce((sum, requestFile) => sum + ((requestFile.approval != false) ? 1 : 0), 0);
-            if (filesCountLeft <= 0) {
-                throw new BadRequestError('Maximum amount of allowed files reached.');
-            }
-            const file = await this.createDocumentFile(content, originalFileName, transaction);
-            const result = await this.documentRequestFileService
-                .withTransaction(transaction)
-                .insert({
-                requestId,
-                fileId: file.id,
-                title,
-                subtitle,
-                pages: null,
-                date,
-                summary,
-                tags,
-                createdDocumentId: null,
-                approval: null,
-                approvalComment: null,
-                approvalTimestamp: null,
-                metadata
-            });
-            return result;
-        });
-        void tryIgnoreLogAsync(this.logger, async () => this.extractionQueue.enqueue({ requestFileId: documentRequestFile.id }));
-        this.publishChange({ requestIds: [documentRequestFile.requestId] });
-        return documentRequestFile;
-    }
-    async createDocumentRequest(parameters, transaction) {
-        if (parameters.collectionIds.length == 0) {
-            throw new BadRequestError('No target collectionId specified.');
-        }
-        const result = await this.documentRequestService.useTransaction(transaction, async (_, tx) => {
-            const request = await this.documentRequestService.withTransaction(tx).insert({ ...parameters, completed: false });
-            const newDocumentRequestCollections = parameters.collectionIds.map((collectionId) => ({ requestId: request.id, collectionId }));
-            await this.documentRequestCollectionService.withTransaction(tx).insertMany(newDocumentRequestCollections);
-            return request;
-        });
-        this.publishChange({ collectionIds: parameters.collectionIds });
-        return result;
-    }
-    async createDocumentRequestAssignmentTask({ originalFileName, collectionIds }, content) {
-        if (collectionIds.length == 0) {
-            throw new BadRequestError('No target collectionId specified.');
-        }
-        const file = await this.createDocumentFile(content, originalFileName);
-        return this.documentRequestAssignmentTaskService.transaction(async (_, transaction) => {
-            const task = await this.documentRequestAssignmentTaskService.withTransaction(transaction).insert({
-                fileId: file.id,
-                assignedRequestFileId: null,
-                typeId: null,
-                title: null,
-                subtitle: null,
-                pages: null,
-                date: null,
-                summary: null,
-                tags: null,
-                assignmentTries: 0
-            });
-            const newTaksCollections = collectionIds.map((collectionId) => ({ requestAssignmentTaskId: task.id, collectionId }));
-            await this.documentRequestAssignmentTaskCollectionService.withTransaction(transaction).insertMany(newTaksCollections);
-            void tryIgnoreLogAsync(this.logger, async () => this.extractionQueue.enqueue({ requestAssignmentTaskId: task.id }));
-            this.publishChange({ collectionIds });
-            return task;
-        });
-    }
-    async updateDocument(parameters, transaction) {
-        const { id: documentId, properties: propertyUpdates, ...update } = parameters;
-        await this.documentService.useTransaction(transaction, async (repository, tx) => {
-            await repository.update(documentId, update);
-            if (isDefined(propertyUpdates)) {
-                await this.setPropertyValues({ documentId, properties: propertyUpdates }, tx);
-            }
-        });
-        this.publishChange({ documentIds: [documentId] });
-    }
-    async updateDocumentRequest(parameters, transaction) {
-        const { id: documentRequestId, ...update } = parameters;
-        const requestFiles = await this.documentRequestFileService.withOptionalTransaction(transaction).loadManyByQuery({ requestId: parameters.id });
-        if (parameters.completed == true) {
-            const hasCreatedDocument = requestFiles.some((requestFile) => isNotNull(requestFile.createdDocumentId));
-            if (!hasCreatedDocument) {
-                throw new BadRequestError('Cannot complete requests which has no approved files.');
-            }
-        }
-        await this.documentRequestService.withOptionalTransaction(transaction).update(documentRequestId, update);
-        this.publishChange({ requestIds: [documentRequestId] });
-    }
-    async deleteDocumentRequest({ id, metadata }, transaction) {
-        const requestFiles = await this.documentRequestFileService.loadManyByQuery({ requestId: id });
-        const hasCreatedDocument = requestFiles.some((requestFile) => isNotNull(requestFile.createdDocumentId));
-        if (hasCreatedDocument) {
-            throw new BadRequestError('Cannot delete requests which has approved files.');
-        }
-        await this.documentRequestService.withOptionalTransaction(transaction).delete(id, metadata);
-        this.publishChange({ requestIds: [id] });
-    }
-    async setPropertyValues({ documentId, requestFileId, requestAssignmentTaskId, properties: items }, transaction) {
-        if ((items.length == 0)) {
-            return;
-        }
-        if ((Number(isDefined(documentId)) + Number(isDefined(requestFileId)) + Number(isDefined(requestAssignmentTaskId))) != 1) {
-            throw new BadRequestError('Exactly one of documentId, requestFileId or requestAssignmentTaskId must be specified.');
-        }
-        await this.documentPropertyService.useTransaction(transaction, async (_, tx) => {
-            const propertyIds = items.map((property) => property.propertyId);
-            const properties = await this.documentPropertyService.withTransaction(tx).loadManyByQuery({ id: { $in: propertyIds } });
-            const propertiesMap = getEntityMap(properties);
-            const propertyItems = items.map(({ propertyId, value, metadata }) => {
-                const property = assertDefinedPass(propertiesMap.get(propertyId));
-                validatePropertyValue(propertyId, property.dataType, value);
-                return {
-                    propertyId,
-                    text: (property.dataType == 'text') ? assertStringPass(value) : null,
-                    integer: (property.dataType == 'integer') ? assertNumberPass(value) : null,
-                    decimal: (property.dataType == 'decimal') ? assertNumberPass(value) : null,
-                    boolean: (property.dataType == 'boolean') ? assertBooleanPass(value) : null,
-                    date: (property.dataType == 'date') ? assertNumberPass(value) : null,
-                    metadata
-                };
-            });
-            if (isDefined(documentId)) {
-                await this.documentPropertyValueService.withTransaction(tx)
-                    .upsertMany(['documentId', 'propertyId'], propertyItems.map((propertyItem) => ({ ...propertyItem, documentId })));
-            }
-            else if (isDefined(requestFileId)) {
-                await this.documentRequestFilePropertyValueService.withTransaction(tx)
-                    .upsertMany(['requestFileId', 'propertyId'], propertyItems.map((propertyItem) => ({ ...propertyItem, requestFileId })));
+    async initializeCategoriesAndTypes(categoryNames, categoryParents, typeNames, typeCategories) {
+        const categoryEntries = objectEntries(categoryNames);
+        const typeEntries = objectEntries(typeNames);
+        const { categoryMap, typeMap } = await this.transaction(async (tx) => {
+            const { categories, types } = await this.#documentCategoryTypeService.loadCategoriesAndTypes();
+            const enumKeyCategoryMap = groupToSingleMap(categories, (category) => category.metadata.attributes[enumTypeKey]);
+            const enumKeyTypeMap = groupToSingleMap(types, (type) => type.metadata.attributes[enumTypeKey]);
+            for (const [key, label] of categoryEntries) {
+                const category = enumKeyCategoryMap.get(key);
+                const parentId = assertDefinedPass(categoryParents[key], `Parent category not defined for ${key}`);
+                if (isUndefined(category)) {
+                    const category = await this.#documentCategoryTypeService.withTransaction(tx).createCategory(label, parentId, key);
+                    categories.push(category);
+                }
+                else if ((category.label != label) || (category.parentId != parentId)) {
+                    await this.#documentCategoryTypeService.withTransaction(tx).updateCategory(category.id, { label, parentId });
+                }
             }
-            else if (isDefined(requestAssignmentTaskId)) {
-                await this.documentRequestAssignmentTaskPropertyValueService.withTransaction(tx)
-                    .upsertMany(['requestAssignmentTaskId', 'propertyId'], propertyItems.map((propertyItem) => ({ ...propertyItem, requestAssignmentTaskId })));
+            for (const [key, label] of typeEntries) {
+                const type = enumKeyTypeMap.get(key);
+                const enumCategory = typeCategories[key];
+                const category = assertDefinedPass(enumKeyCategoryMap.get(enumCategory));
+                if (isUndefined(type)) {
+                    const type = await this.#documentCategoryTypeService.createType(label, category.id, key);
+                    types.push(type);
+                }
+                else if ((type.categoryId != category.id) || (type.label != label)) {
+                    await this.#documentCategoryTypeService.withTransaction(tx).updateType(type.id, { categoryId: category.id, label: label });
+                }
             }
+            return { categoryMap: enumKeyCategoryMap, typeMap: enumKeyTypeMap };
         });
-        this.publishChange({
-            documentIds: isDefined(documentId) ? [documentId] : undefined,
-            requestFileIds: isDefined(requestFileId) ? [requestFileId] : undefined,
-            requestAssignmentTaskIds: isDefined(requestAssignmentTaskId) ? [requestAssignmentTaskId] : undefined
-        });
-    }
-    async addDocumentToCollection(parameters, transaction) {
-        await this.documentCollectionDocumentService.withOptionalTransaction(transaction).upsert(['collectionId', 'documentId'], { ...parameters, archiveTimestamp: null });
-        this.publishChange({ documentIds: [parameters.documentId] });
-    }
-    async archiveDocument({ collectionId, documentId, metadata }) {
-        await this.documentCollectionDocumentService.updateByQuery({ collectionId, documentId }, { archiveTimestamp: TRANSACTION_TIMESTAMP, metadata });
-        this.publishChange({ documentIds: [documentId] });
-    }
-    async createProperty(parameters) {
-        return this.documentPropertyService.insert(parameters);
-    }
-    async assignPropertyToType(parameters) {
-        await this.documentTypePropertyService.insert(parameters);
-    }
-    async enrichDocument(documentId) {
-        const document = await this.documentService.load(documentId);
-        const { properties, ...extractionResult } = await this.extractFileInformation(document.fileId, document.typeId);
-        this.logger.trace(`Applying extraction to document ${document.id}`);
-        await this.documentService.transaction(async (documentService, transaction) => {
-            await documentService.update(document.id, { ...extractionResult, validated: false });
-            await this.setPropertyValues({ documentId, properties: properties }, transaction);
-        });
-        this.publishChange({ documentIds: [documentId] });
-    }
-    async enrichDocumentRequestFile(requestFileId) {
-        const requestFile = await this.documentRequestFileService.load(requestFileId);
-        const request = await this.documentRequestService.load(requestFile.requestId);
-        const { properties, typeId: _, ...extractionResult } = await this.extractFileInformation(requestFile.fileId, request.typeId);
-        await this.documentRequestFileService.transaction(async (documentRequestFileService, transaction) => {
-            await documentRequestFileService.update(requestFile.id, extractionResult);
-            await this.setPropertyValues({ requestFileId, properties: properties }, transaction);
-        });
-        this.publishChange({ requestIds: [request.id] });
-    }
-    async enrichDocumentRequestAssignmentTask(requestAssignmentTaskId) {
-        const task = await this.documentRequestAssignmentTaskService.load(requestAssignmentTaskId);
-        const { properties, ...extractionResult } = await this.extractFileInformation(task.fileId);
-        await this.documentRequestAssignmentTaskService.transaction(async (documentRequestAssignmentTaskService, transaction) => {
-            await documentRequestAssignmentTaskService.update(task.id, extractionResult);
-            await this.setPropertyValues({ requestAssignmentTaskId, properties: properties }, transaction);
-        });
-        void tryIgnoreLogAsync(this.logger, async () => this.assignmentQueue.enqueue({ requestAssignmentTaskId }));
-        this.publishChange({ requestAssignmentTaskIds: [requestAssignmentTaskId] });
-    }
-    async assignDocumentRequest(requestAssignmentTaskId) {
-        const session = this.documentRequestAssignmentTaskCollectionService.session;
-        const requestAssignmentTaskProperties = session.$with('requestAssignmentTaskProperty').as(session
-            .select({
-            requestAssignmentTaskId: documentRequestAssignmentTaskPropertyValue.requestAssignmentTaskId,
-            propertyId: documentRequestAssignmentTaskPropertyValue.propertyId,
-            label: documentProperty.label,
-            value: coalesce(toJsonb(documentRequestAssignmentTaskPropertyValue.text), toJsonb(documentRequestAssignmentTaskPropertyValue.integer), toJsonb(documentRequestAssignmentTaskPropertyValue.decimal), toJsonb(documentRequestAssignmentTaskPropertyValue.boolean), toJsonb(documentRequestAssignmentTaskPropertyValue.date)).as('value')
-        })
-            .from(documentRequestAssignmentTaskPropertyValue)
-            .innerJoin(documentProperty, eq(documentProperty.id, documentRequestAssignmentTaskPropertyValue.propertyId)));
-        const [task] = await session
-            .with(requestAssignmentTaskProperties)
-            .select({
-            fileId: documentRequestAssignmentTask.fileId,
-            collectionIds: arrayAgg(documentRequestAssignmentTaskCollection.collectionId),
-            typeCategory: documentCategory.label,
-            typeGroup: documentType.group,
-            typeLabel: documentType.label,
-            title: documentRequestAssignmentTask.title,
-            subtitle: documentRequestAssignmentTask.subtitle,
-            pages: documentRequestAssignmentTask.pages,
-            date: documentRequestAssignmentTask.date,
-            summary: documentRequestAssignmentTask.summary,
-            tags: documentRequestAssignmentTask.tags,
-            assignmentTries: documentRequestAssignmentTask.assignmentTries,
-            properties: sql `coalesce(${jsonAgg(requestAssignmentTaskProperties)} FILTER (WHERE ${requestAssignmentTaskProperties.propertyId} IS NOT NULL), '[]'::json)`
-        })
-            .from(documentRequestAssignmentTask)
-            .innerJoin(documentRequestAssignmentTaskCollection, eq(documentRequestAssignmentTaskCollection.requestAssignmentTaskId, documentRequestAssignmentTask.id))
-            .innerJoin(documentType, eq(documentType.id, documentRequestAssignmentTask.typeId))
-            .innerJoin(documentCategory, eq(documentCategory.id, documentType.categoryId))
-            .leftJoin(requestAssignmentTaskProperties, eq(requestAssignmentTaskProperties.requestAssignmentTaskId, documentRequestAssignmentTask.id))
-            .where(eq(documentRequestAssignmentTask.id, requestAssignmentTaskId))
-            .groupBy(documentRequestAssignmentTask.fileId, requestAssignmentTaskProperties.label, documentCategory.label, documentType.group, documentType.label, documentRequestAssignmentTask.title, documentRequestAssignmentTask.subtitle, documentRequestAssignmentTask.pages, documentRequestAssignmentTask.date, documentRequestAssignmentTask.summary, documentRequestAssignmentTask.tags, documentRequestAssignmentTask.assignmentTries);
-        assertDefined(task);
-        if (task.assignmentTries >= 3) {
-            this.logger.error(`Ignoring assignment task "${requestAssignmentTaskId}" because max tries are reached.`);
-            return;
-        }
-        const requestsWithoutFiles = await session
-            .select({
-            id: documentRequest.id,
-            collectionIds: arrayAgg(documentRequestCollection.collectionId),
-            documentCategory: documentCategory.label,
-            documentGroup: documentType.group,
-            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, task.collectionIds), notExists(session
-            .select()
-            .from(documentRequestFile)
-            .where(and(eq(documentRequestFile.requestId, documentRequest.id), ne(documentRequestFile.approval, false))))))
-            .groupBy(documentRequest.id, documentCategory.label, documentType.group, documentType.label, documentRequest.comment);
-        const requestsCollectionIds = distinct(requestsWithoutFiles.flatMap((request) => request.collectionIds));
-        const collectionNamesMap = await this.resolveNamesMap(...requestsCollectionIds);
-        const requests = requestsWithoutFiles.map((request) => ({
-            id: request.id,
-            collections: request.collectionIds.map((collectionId) => assertDefinedPass(collectionNamesMap[collectionId])),
-            documentCategory: request.documentCategory,
-            documentGroup: request.documentGroup ?? undefined,
-            documentType: request.documentType,
-            comment: request.comment ?? undefined
-        }));
-        const propertyEntries = task.properties.map((property) => [property.label, assertNotNullPass(property.value)]);
-        const context = {
-            file: {
-                documentCategory: task.typeCategory,
-                documentGroup: task.typeGroup ?? undefined,
-                documentType: task.typeLabel,
-                properties: fromEntries(propertyEntries)
-            },
-            requests
+        const mappedCategories = categoryEntries.map(([key]) => [key, assertDefinedPass(categoryMap.get(key), 'Could not map document category.')]);
+        const mappedTypes = typeEntries.map(([key]) => [key, assertDefinedPass(typeMap.get(key), 'Could not map document type.')]);
+        return {
+            categories: fromEntries(mappedCategories),
+            types: fromEntries(mappedTypes),
         };
-        const result = await this.#aiService.generate({
-            ...defaultGenerationOptions,
-            generationOptions: {
-                maxOutputTokens: 100,
-                temperature: 0,
-                topP: 0.2
-            },
-            generationSchema: object({ requestId: nullable(string()) }),
-            contents: [{
-                    role: 'user',
-                    parts: [
-                        {
-                            text: `<context>
-${JSON.stringify(context, null, 2)}
-</context>
-
-Ordne die Datei unter "file" der passenden Anforderungen unter "requests" zu. Gib es als JSON im angegebenen Schema aus. Wenn keine Anforderung passt, setze requestId auf null.`
-                        }
-                    ]
-                }]
-        });
-        await this.documentRequestAssignmentTaskService.update(requestAssignmentTaskId, { assignmentTries: sql `${documentRequestAssignmentTask.assignmentTries} + 1` });
-        if (isNull(result.json.requestId)) {
-            return;
-        }
-        await this.documentRequestFileService.transaction(async (_, transaction) => {
-            const requestFile = await this.documentRequestFileService.withTransaction(transaction).insert({
-                requestId: result.json.requestId,
-                fileId: task.fileId,
-                title: task.title,
-                subtitle: task.subtitle,
-                pages: task.pages,
-                date: task.date,
-                summary: task.summary,
-                tags: task.tags,
-                createdDocumentId: null,
-                approval: null,
-                approvalComment: null,
-                approvalTimestamp: null
-            });
-            await this.setPropertyValues({ requestFileId: requestFile.id, properties: task.properties }, transaction);
-        });
-        this.publishChange({ collectionIds: requestsCollectionIds });
-    }
-    async extractFileInformation(fileId, assumeTypeId) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const file = await this.documentFileService.load(fileId);
-            const fileContentStream = this.getDocumentFileContentStream(fileId);
-            const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
-            const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: file.mimeType });
-            const pages = file.mimeType.includes('pdf')
-                ? await tryIgnoreLogAsync(this.logger, async () => {
-                    this.logger.trace(`Extracting pdf page count for file ${fileId}`);
-                    return getPdfPageCount(tmpFile.path);
-                }, null)
-                : null;
-            const types = await this.documentTypeService.session
-                .select({
-                typeId: documentType.id,
-                categoryLabel: documentCategory.label,
-                typeGroup: documentType.group,
-                typeLabel: documentType.label
-            })
-                .from(documentType)
-                .leftJoin(documentCategory, eq(documentCategory.id, documentType.categoryId))
-                .where(isString(assumeTypeId) ? eq(documentType.id, assumeTypeId) : undefined);
-            const typeLabelEntries = types.map((type) => ({ id: type.typeId, label: `${type.categoryLabel} | ${type.typeGroup} | ${type.typeLabel}` }));
-            const typeLabels = typeLabelEntries.map(({ label }) => label);
-            this.logger.trace(`Classifying document file ${fileId}`);
-            const documentTypeGeneration = await this.#aiService.generate({
-                ...defaultGenerationOptions,
-                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;
-            const typeProperties = isDefined(typeId) ? await this.documentTypePropertyService.loadManyByQuery({ typeId }) : undefined;
-            const propertyIds = typeProperties?.map((property) => property.propertyId);
-            const properties = isDefined(propertyIds) ? await this.documentPropertyService.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 file ${fileId}`);
-            const { json: extraction } = await this.#aiService.generate({
-                model: 'gemini-2.0-flash',
-                generationOptions: {
-                    maxOutputTokens: 2048,
-                    temperature: 0.2,
-                    topP: 0.2
-                },
-                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 {
-                typeId: typeId ?? null,
-                title: extraction.documentTitle,
-                subtitle: extraction.documentSubtitle,
-                pages,
-                date,
-                summary: extraction.documentSummary,
-                tags: filteredDocumentTags,
-                properties: parsedProperties
-            };
-        }
-        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 getDocumentFileContent(fileId) {
-        const key = getDocumentFileKey(fileId);
-        return this.fileObjectStorage.getContent(key);
-    }
-    getDocumentFileContentStream(fileId) {
-        const key = getDocumentFileKey(fileId);
-        return this.fileObjectStorage.getContentStream(key);
-    }
-    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)}"`
-        });
-    }
-    publishChange({ collectionIds, documentIds, requestIds, requestFileIds, requestAssignmentTaskIds: requestAssignmentTasksIds }) {
-        void tryIgnoreLogAsync(this.logger, async () => {
-            const queries = [
-                isUndefined(documentIds)
-                    ? undefined
-                    : this.session
-                        .selectDistinct({ collectionId: documentCollectionDocument.collectionId })
-                        .from(documentCollectionDocument)
-                        .where(inArray(documentCollectionDocument.documentId, documentIds)),
-                isUndefined(requestIds)
-                    ? undefined
-                    : this.session
-                        .selectDistinct({ collectionId: documentRequestCollection.collectionId })
-                        .from(documentRequestCollection)
-                        .where(inArray(documentRequestCollection.requestId, requestIds)),
-                isUndefined(requestFileIds)
-                    ? undefined
-                    : this.session
-                        .selectDistinct({ collectionId: documentRequestCollection.collectionId })
-                        .from(documentRequestFile)
-                        .innerJoin(documentRequestCollection, eq(documentRequestCollection.requestId, documentRequestFile.requestId))
-                        .where(inArray(documentRequestFile.requestId, requestFileIds)),
-                isUndefined(requestAssignmentTasksIds)
-                    ? undefined
-                    : this.session
-                        .selectDistinct({ collectionId: documentRequestAssignmentTaskCollection.collectionId })
-                        .from(documentRequestAssignmentTaskCollection)
-                        .where(inArray(documentRequestAssignmentTaskCollection.requestAssignmentTaskId, requestAssignmentTasksIds))
-            ];
-            const filteredQueries = queries.filter(isDefined);
-            const mappings = (filteredQueries.length == 1)
-                ? await filteredQueries[0]
-                : (filteredQueries.length > 1)
-                    ? await union(filteredQueries[0], filteredQueries[1], ...filteredQueries.slice(2))
-                    : [];
-            const allCollectionIds = distinct([
-                ...(collectionIds ?? []),
-                ...mappings.map((mapping) => mapping.collectionId)
-            ]);
-            if (allCollectionIds.length == 0) {
-                return;
-            }
-            this.collectionChangeMessageBus.publishAndForget(allCollectionIds);
-        });
-    }
-};
-DocumentManagementService = DocumentManagementService_1 = __decorate([
-    Singleton({
-        providers: [
-            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(DocumentManagementConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }
-        ]
-    })
-], DocumentManagementService);
-export { DocumentManagementService };
-function getDocumentFileKey(id) {
-    return `${id.slice(0, 2)} /${id.slice(0, 4)}/${id} `;
-}
-const validators = {
-    [DocumentPropertyDataType.Text]: (value) => isString(value) || isNull(value),
-    [DocumentPropertyDataType.Integer]: (value) => isNumber(value) || isNull(value),
-    [DocumentPropertyDataType.Decimal]: (value) => isNumber(value) || isNull(value),
-    [DocumentPropertyDataType.Boolean]: (value) => isBoolean(value) || isNull(value),
-    [DocumentPropertyDataType.Date]: (value) => isNumber(value) || isNull(value)
-};
-function validatePropertyValue(propertyId, dataType, value) {
-    const valid = validators[dataType](value);
-    if (!valid) {
-        throw new BadRequestError(`Invalid value for data type ${dataType} for property ${propertyId}.`);
     }
 }