@tstdl/base 0.92.123 → 0.92.124

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

@@ -0,0 +1,87 @@
+import { and, isNotNull as drizzleIsNotNull, eq, inArray } from 'drizzle-orm';
+import { DocumentPropertyDataType, DocumentPropertyValue, DocumentTypeProperty } from '../../../document-management/models/index.js';
+import { BadRequestError } from '../../../errors/bad-request.error.js';
+import { coalesce, getEntityMap, toJsonb } from '../../../orm/index.js';
+import { Transactional } from '../../../orm/server/index.js';
+import { injectRepository } from '../../../orm/server/repository.js';
+import { toArray } from '../../../utils/array/index.js';
+import { assertBooleanPass, assertDefinedPass, assertNumberPass, assertStringPass, isBoolean, isNotNull, isNull, isNumber, isString } from '../../../utils/type-guards.js';
+import { Document, DocumentProperty } from '../../models/index.js';
+import { document, documentProperty, documentPropertyValue, documentType, documentTypeProperty } from '../schemas.js';
+const documentPropertyValueValidators = {
+    [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),
+};
+export class DocumentPropertyService extends Transactional {
+    #documentPropertyRepository = injectRepository(DocumentProperty);
+    #documentPropertyValueRepository = injectRepository(DocumentPropertyValue);
+    #documentTypePropertyRepository = injectRepository(DocumentTypeProperty);
+    repository = injectRepository(Document).withSession(this.session);
+    documentProperties = this.session.$with('documentProperties').as(this.session
+        .select({
+        documentId: document.id,
+        propertyId: documentProperty.id,
+        label: documentProperty.label,
+        dataType: documentProperty.dataType,
+        value: coalesce(toJsonb(documentPropertyValue.text), toJsonb(documentPropertyValue.integer), toJsonb(documentPropertyValue.decimal), toJsonb(documentPropertyValue.boolean), toJsonb(documentPropertyValue.date)).as('value'),
+    })
+        .from(document)
+        .innerJoin(documentType, eq(documentType.id, document.typeId))
+        .innerJoin(documentTypeProperty, eq(documentTypeProperty.typeId, documentType.id))
+        .innerJoin(documentProperty, eq(documentProperty.id, documentTypeProperty.propertyId))
+        .leftJoin(documentPropertyValue, and(eq(documentPropertyValue.documentId, document.id), eq(documentPropertyValue.propertyId, documentProperty.id))));
+    async createProperty(label, dataType) {
+        return this.#documentPropertyRepository.insert({ label, dataType });
+    }
+    async assignPropertyToType(typeId, propertyId) {
+        await this.#documentTypePropertyRepository.insert({ typeId, propertyId });
+    }
+    async loadDocumentProperties(documentId, includeNulls = false) {
+        return this.session
+            .select({
+            documentId: this.documentProperties.documentId,
+            propertyId: this.documentProperties.propertyId,
+            label: this.documentProperties.label,
+            dataType: this.documentProperties.dataType,
+            value: this.documentProperties.value,
+        })
+            .from(this.documentProperties)
+            .where(and(inArray(this.documentProperties.documentId, toArray(documentId)), includeNulls ? undefined : drizzleIsNotNull(this.documentProperties.value)));
+    }
+    async setPropertyValues(documentId, propertyValues) {
+        if ((propertyValues.length == 0)) {
+            return;
+        }
+        await this.transaction(async (tx) => {
+            const propertyIds = propertyValues.map((property) => property.propertyId);
+            const properties = await this.#documentPropertyRepository.withTransaction(tx).loadManyByQuery({ id: { $in: propertyIds } });
+            const propertiesMap = getEntityMap(properties);
+            const upserts = propertyValues.filter((value) => isNotNull(value.value)).map(({ propertyId, value, metadata }) => {
+                const property = assertDefinedPass(propertiesMap.get(propertyId));
+                validatePropertyValue(propertyId, property.dataType, value);
+                return {
+                    documentId,
+                    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,
+                };
+            });
+            const deletePropertyIds = propertyValues.filter((value) => isNull(value.value)).map(({ propertyId }) => propertyId);
+            await this.#documentPropertyValueRepository.withTransaction(tx).hardDeleteManyByQuery({ documentId, propertyId: { $in: deletePropertyIds } });
+            await this.#documentPropertyValueRepository.withTransaction(tx).upsertMany(['documentId', 'propertyId'], upserts);
+        });
+    }
+}
+function validatePropertyValue(propertyId, dataType, value) {
+    const valid = documentPropertyValueValidators[dataType](value);
+    if (!valid) {
+        throw new BadRequestError(`Invalid value for data type ${dataType} for property ${propertyId}.`);
+    }
+}

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

@@ -0,0 +1,138 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { count, isNotNull as dbIsNotNull, isNull as dbIsNull, eq, inArray, sql } from 'drizzle-orm';
+import { BadRequestError } from '../../../errors/index.js';
+import { Injectable } from '../../../injector/index.js';
+import { Transactional, injectRepository } from '../../../orm/server/index.js';
+import { toArray } from '../../../utils/array/index.js';
+import { assertDefinedPass, isNotNull } from '../../../utils/type-guards.js';
+import { DocumentApproval, DocumentCollectionAssignment, DocumentRequest, DocumentRequestCollection, DocumentRequestState, DocumentRequestTemplate, DocumentRequestsTemplate } from '../../models/index.js';
+import { document, documentRequest, documentRequestCollection } from '../schemas.js';
+let DocumentRequestService = class DocumentRequestService extends Transactional {
+    #documentRequestCollectionRepository = injectRepository(DocumentRequestCollection);
+    #documentRequestRepository = injectRepository(DocumentRequest);
+    #documentRequestTemplateRepository = injectRepository(DocumentRequestTemplate);
+    #documentRequestsTemplateRepository = injectRepository(DocumentRequestsTemplate);
+    #documentCollectionAssignmentRepository = injectRepository(DocumentCollectionAssignment);
+    async getRequestStats(collectionIds) {
+        const relevantRequests = this.session.$with('relevant_requests').as(this.session.selectDistinct({ id: documentRequest.id })
+            .from(documentRequest)
+            .innerJoin(documentRequestCollection, eq(documentRequestCollection.requestId, documentRequest.id))
+            .where(inArray(documentRequestCollection.collectionId, toArray(collectionIds))));
+        const [result] = await this.session.with(relevantRequests)
+            .select({
+            total: count(sql `${documentRequest.id})`),
+            documentPending: count(sql `CASE WHEN ${eq(documentRequest.state, DocumentRequestState.Open)} AND ${dbIsNull(documentRequest.documentId)}  THEN 1 END`),
+            approvalPending: count(sql `CASE WHEN ${eq(documentRequest.state, DocumentRequestState.Open)} AND ${dbIsNotNull(documentRequest.documentId)} AND ${eq(document.approval, DocumentApproval.Pending)} THEN 1 END`),
+            approvals: count(sql `CASE WHEN ${eq(documentRequest.state, DocumentRequestState.Closed)} AND ${dbIsNotNull(documentRequest.documentId)} AND ${eq(document.approval, DocumentApproval.Approved)} THEN 1 END`),
+            rejections: count(sql `CASE WHEN ${eq(documentRequest.state, DocumentRequestState.Closed)} AND ${dbIsNotNull(documentRequest.documentId)} AND ${eq(document.approval, DocumentApproval.Rejected)} THEN 1 END`),
+            closedWithoutDocument: count(sql `CASE WHEN ${eq(documentRequest.state, DocumentRequestState.Closed)} AND ${dbIsNull(documentRequest.documentId)} THEN 1 END`),
+        })
+            .from(documentRequest)
+            .leftJoin(document, eq(document.id, documentRequest.documentId))
+            .where(inArray(documentRequest.id, this.session.select({ id: relevantRequests.id }).from(relevantRequests)));
+        return assertDefinedPass(result);
+    }
+    async createRequestsTemplate(parameters) {
+        return this.#documentRequestsTemplateRepository.insert(parameters);
+    }
+    async updateRequestsTemplate(id, parameters) {
+        return this.#documentRequestsTemplateRepository.update(id, parameters);
+    }
+    async applyRequestsTemplate(id, collectionIds) {
+        const requestTemplates = await this.#documentRequestTemplateRepository.loadManyByQuery({ requestsTemplateId: id });
+        await this.transaction(async (tx) => {
+            for (const { typeId, comment } of requestTemplates) {
+                await this.withTransaction(tx).createRequest(typeId, collectionIds, comment);
+            }
+        });
+    }
+    async deleteRequestsTemplate(id) {
+        return this.#documentRequestsTemplateRepository.delete(id);
+    }
+    async createRequestTemplate(requestsTemplateId, typeId, comment) {
+        return this.#documentRequestTemplateRepository.insert({ requestsTemplateId, typeId, comment });
+    }
+    async updateRequestTemplate(id, parameters) {
+        return this.#documentRequestTemplateRepository.update(id, parameters);
+    }
+    async deleteRequestTemplate(id) {
+        return this.#documentRequestTemplateRepository.delete(id);
+    }
+    async createRequest(typeId, collectionIds, comment) {
+        if (collectionIds.length == 0) {
+            throw new BadRequestError('No target collectionId specified.');
+        }
+        return this.transaction(async (tx) => {
+            const request = await this.#documentRequestRepository.withTransaction(tx).insert({ typeId, documentId: null, comment, state: DocumentRequestState.Open });
+            const newDocumentRequestCollections = collectionIds.map((collectionId) => ({ requestId: request.id, collectionId }));
+            await this.#documentRequestCollectionRepository.withTransaction(tx).insertMany(newDocumentRequestCollections);
+            return request;
+        });
+    }
+    async updateRequest(id, update) {
+        await this.transaction(async (tx) => {
+            const request = await this.#documentRequestRepository.withTransaction(tx).load(id);
+            if (isNotNull(request.documentId)) {
+                throw new BadRequestError('Cannot update document requests which have an assigned document.');
+            }
+            await this.#documentRequestRepository.withTransaction(tx).update(id, update);
+        });
+    }
+    async deleteRequest(id) {
+        await this.transaction(async (tx) => {
+            const request = await this.#documentRequestRepository.withTransaction(tx).load(id);
+            if (isNotNull(request.documentId)) {
+                throw new BadRequestError('Cannot delete requests which have an assigned document.');
+            }
+            await this.#documentRequestCollectionRepository.withTransaction(tx).deleteManyByQuery({ requestId: id });
+            await this.#documentRequestRepository.withTransaction(tx).delete(id);
+        });
+    }
+    async assignDocument(requestId, documentId) {
+        await this.transaction(async (tx) => {
+            const request = await this.#documentRequestRepository.withTransaction(tx).load(requestId);
+            if (isNotNull(request.documentId)) {
+                throw new BadRequestError('Document request already has a document assigned.');
+            }
+            await this.#documentRequestRepository.withTransaction(tx).update(requestId, { documentId });
+        });
+    }
+    /**
+     * Fulfills a document request.
+     * Marks the request as fulfilled and creates associations between the document
+     * and the target collections defined in the request.
+     *
+     * @param requestId The ID of the DocumentRequest to fulfill.
+     * @param documentId The ID of the Document fulfilling the request.
+     * @param userId The ID of the user performing the action (for audit purposes).
+     * @throws NotFoundError if the DocumentRequest with the given ID does not exist.
+     */
+    async fulfillRequest(requestId, documentId) {
+        await this.transaction(async (tx) => {
+            const request = await this.#documentRequestRepository.withTransaction(tx).load(requestId);
+            if (request.state == DocumentRequestState.Fulfilled) {
+                throw new BadRequestError('Document request is already fulfilled.');
+            }
+            const targetCollectionIds = await this.#documentRequestCollectionRepository.withTransaction(tx).loadManyByQuery({ requestId });
+            if (targetCollectionIds.length == 0) {
+                throw new Error('No document request collection for document request found.');
+            }
+            const links = targetCollectionIds.map((target) => ({
+                collectionId: target.collectionId,
+                documentId,
+                archiveTimestamp: null,
+            }));
+            await this.#documentCollectionAssignmentRepository.withTransaction(tx).insertMany(links);
+            await this.#documentRequestRepository.withTransaction(tx).update(requestId, { state: DocumentRequestState.Fulfilled });
+        });
+    }
+};
+DocumentRequestService = __decorate([
+    Injectable()
+], DocumentRequestService);
+export { DocumentRequestService };

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

@@ -0,0 +1,145 @@
+var _a;
+import { DocumentWorkflowStep } from '../../../document-management/models/document-workflow.model.js';
+import { Document, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentProperty, DocumentPropertyValue, DocumentType, DocumentTypeProperty, DocumentTypeValidation, DocumentValidationDefinition, DocumentValidationExecution, DocumentValidationExecutionRelatedDocument, DocumentValidationExecutionState, DocumentValidationResultStatus } from '../../../document-management/models/index.js';
+import { BadRequestError } from '../../../errors/bad-request.error.js';
+import { inject, injectAll } from '../../../injector/inject.js';
+import { Injector } from '../../../injector/injector.js';
+import { afterResolve } from '../../../injector/interfaces.js';
+import { injectionToken } from '../../../injector/token.js';
+import { Logger } from '../../../logger/logger.js';
+import { injectRepository } from '../../../orm/server/repository.js';
+import { getEntityIds } from '../../../orm/utils.js';
+import { Queue } from '../../../queue/queue.js';
+import { currentTimestamp } from '../../../utils/date-time.js';
+import { isNull, isUndefined } from '../../../utils/type-guards.js';
+import { millisecondsPerMinute } from '../../../utils/units.js';
+import { DocumentWorkflowService } from './document-workflow.service.js';
+const DOCUMENT_VALIDATION_EXECUTORS = injectionToken('DocumentValidationExecutors');
+export class DocumentValidationService {
+    #documentManagementService = injectRepository(DocumentCollection);
+    #documentCollectionAssignmentRepository = injectRepository(DocumentCollectionAssignment);
+    #documentService = injectRepository(Document);
+    #documentCategoryService = injectRepository(DocumentCategory);
+    #documentTypeService = injectRepository(DocumentType);
+    #documentTypePropertyService = injectRepository(DocumentTypeProperty);
+    #documentPropertyService = injectRepository(DocumentProperty);
+    #documentPropertyValueService = injectRepository(DocumentPropertyValue);
+    #documentWorkflowService = inject(DocumentWorkflowService);
+    #validationDefinitionService = injectRepository(DocumentValidationDefinition);
+    #validationExecutionService = injectRepository(DocumentValidationExecution);
+    #validationExecutionRelatedDocumentService = injectRepository(DocumentValidationExecutionRelatedDocument);
+    #documentTypeValidationService = injectRepository(DocumentTypeValidation);
+    #queue = inject((Queue), { name: 'DocumentManagement: validation', processTimeout: 5 * millisecondsPerMinute, maxTries: 3 });
+    #executors = injectAll(DOCUMENT_VALIDATION_EXECUTORS);
+    #logger = inject(Logger, _a.name);
+    #executorMap = new Map(this.#executors.map((executor) => [executor.identifier, executor]));
+    [afterResolve](_, { cancellationSignal }) {
+        this.processQueue(cancellationSignal);
+    }
+    processQueue(cancellationSignal) {
+        this.#queue.process({ concurrency: 5, cancellationSignal }, async (job) => {
+            this.#logger.verbose(`Processing validation execution "${job.data.executionId}"`);
+            await this.processValidationExecution(job.data.executionId);
+        }, this.#logger);
+    }
+    async startValidationWorkflow(documentId) {
+        const document = await this.#documentService.load(documentId);
+        if (isNull(document.typeId)) {
+            throw new BadRequestError('Document has no type');
+        }
+        const workflow = await this.#documentWorkflowService.initiateWorkflow(documentId, DocumentWorkflowStep.Validation);
+        const typeValidations = await this.#documentTypeValidationService.loadManyByQuery({ typeId: document.typeId });
+        for (const typeValidation of typeValidations) {
+            const validationDefinition = await this.#validationDefinitionService.load(typeValidation.validationId);
+            const execution = await this.#validationExecutionService.insert({
+                definitionId: validationDefinition.id,
+                workflowId: workflow.id,
+                state: DocumentValidationExecutionState.Pending,
+                resultStatus: null,
+                resultMessage: null,
+                startedAt: null,
+                completedAt: null,
+            });
+            await this.#queue.enqueue({ executionId: execution.id });
+        }
+    }
+    async setExecutionRunning(executionId) {
+        await this.#validationExecutionService.update(executionId, { state: DocumentValidationExecutionState.Running, resultStatus: null, resultMessage: null, startedAt: currentTimestamp(), completedAt: null });
+    }
+    async setExecutionCompleted(executionId, status, message) {
+        await this.#validationExecutionService.update(executionId, { state: DocumentValidationExecutionState.Completed, resultStatus: status, resultMessage: message, completedAt: currentTimestamp() });
+    }
+    async setExecutionError(executionId, reason) {
+        await this.#validationExecutionService.update(executionId, { state: DocumentValidationExecutionState.Error, resultStatus: DocumentValidationResultStatus.Failed, resultMessage: reason, completedAt: currentTimestamp() });
+    }
+    async loadRelatedDocument(executionId, documentId) {
+        const execution = await this.#validationExecutionService.load(executionId);
+        const workflow = await this.#documentWorkflowService.repository.load(execution.workflowId);
+        const documentData = await this.loadDocumentData(documentId);
+        await this.#validationExecutionRelatedDocumentService.upsert(['executionId', 'documentId'], { executionId, documentId: workflow.documentId });
+        return documentData;
+    }
+    async loadDocumentData(documentId) {
+        const document = await this.#documentService.load(documentId);
+        if (isNull(document.typeId)) {
+            throw new Error('Document has no type');
+        }
+        const [documentCollections, documentTypeProperties] = await Promise.all([
+            this.#documentCollectionAssignmentRepository.loadManyByQuery({ documentId: document.id }),
+            this.#documentTypePropertyService.loadManyByQuery({ typeId: document.typeId }),
+        ]);
+        const documentCollectionIds = getEntityIds(documentCollections);
+        const documentPropertyIds = getEntityIds(documentTypeProperties);
+        const [collections, category, type, properties, propertyValues] = await Promise.all([
+            this.#documentManagementService.loadManyByQuery({ id: { $in: documentCollectionIds } }),
+            this.#documentCategoryService.load(document.typeId),
+            this.#documentTypeService.load(document.typeId),
+            this.#documentPropertyService.loadManyByQuery({ id: { $in: documentPropertyIds } }),
+            this.#documentPropertyValueService.loadManyByQuery({ documentId: document.id }),
+        ]);
+        return {
+            document,
+            collections,
+            category,
+            type,
+            properties,
+            propertyValues,
+        };
+    }
+    async loadDocumentValidationExecutorContext(executionId) {
+        const execution = await this.#validationExecutionService.load(executionId);
+        const [definition, workflow] = await Promise.all([
+            this.#validationDefinitionService.load(execution.definitionId),
+            this.#documentWorkflowService.repository.load(execution.workflowId),
+        ]);
+        const documentData = await this.loadDocumentData(workflow.documentId);
+        return {
+            execution,
+            definition,
+            ...documentData,
+        };
+    }
+    async processValidationExecution(executionId) {
+        const context = await this.loadDocumentValidationExecutorContext(executionId);
+        const executor = this.#executorMap.get(context.definition.identifier);
+        if (isUndefined(executor)) {
+            await this.setExecutionError(executionId, `Invalid validation identifier`);
+            return;
+        }
+        try {
+            await this.setExecutionRunning(executionId);
+            const result = await executor.execute(context);
+            await this.setExecutionCompleted(executionId, result.status, result.message ?? null);
+        }
+        catch (error) {
+            this.#logger.error(error);
+            await this.setExecutionError(executionId, 'Internal error');
+        }
+    }
+}
+_a = DocumentValidationService;
+export function registerDocumentValidationExecutor(...executors) {
+    for (const executor of executors) {
+        Injector.register(DOCUMENT_VALIDATION_EXECUTORS, { useToken: executor }, { multi: true });
+    }
+}

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

@@ -0,0 +1,132 @@
+var _a;
+import { match } from 'ts-pattern';
+import { DocumentAssignmentScope } from '../../../document-management/models/document-assignment-scope.model.js';
+import { DocumentAssignmentTask } from '../../../document-management/models/document-assignment-task.model.js';
+import { DocumentWorkflow, DocumentWorkflowFailReason, DocumentWorkflowState, DocumentWorkflowStep } from '../../../document-management/models/document-workflow.model.js';
+import { DocumentApproval } from '../../../document-management/models/document.model.js';
+import { BadRequestError } from '../../../errors/bad-request.error.js';
+import { NotImplementedError } from '../../../errors/not-implemented.error.js';
+import { inject } from '../../../injector/inject.js';
+import { afterResolve } from '../../../injector/interfaces.js';
+import { Logger } from '../../../logger/index.js';
+import { injectRepository } from '../../../orm/server/repository.js';
+import { Transactional } from '../../../orm/server/transactional.js';
+import { Queue } from '../../../queue/queue.js';
+import { _throw } from '../../../utils/throw.js';
+import { isNotNull, isNull } from '../../../utils/type-guards.js';
+import { DocumentCollectionService } from './document-collection.service.js';
+import { DocumentManagementAiService } from './document-management-ai.service.js';
+import { DocumentRequestService } from './document-request.service.js';
+import { DocumentService } from './document.service.js';
+export class DocumentWorkflowService extends Transactional {
+    #documentManagementAiService = inject(DocumentManagementAiService);
+    #documentService = inject(DocumentService);
+    #documentCollectionService = inject(DocumentCollectionService);
+    #documentRequestService = inject(DocumentRequestService);
+    #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
+    #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
+    #queue = inject((Queue), { name: 'DocumentWorkflow', processTimeout: 5 * 60 * 1000, maxTries: 3 });
+    #logger = inject(Logger, _a.name);
+    repository = injectRepository(DocumentWorkflow).withSession(this.session);
+    [afterResolve](_, { cancellationSignal }) {
+        if (this.isInTransaction) {
+            return;
+        }
+        this.#queue.process({ concurrency: 5, cancellationSignal }, async (job) => this.processWorkflowJob(job), this.#logger);
+    }
+    async loadLatestWorkflow(documentId) {
+        return this.repository.loadByQuery({ documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
+    }
+    async tryLoadLatestWorkflow(documentId) {
+        return this.repository.tryLoadByQuery({ documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
+    }
+    async loadLatestWorkflows(documentIds) {
+        return this.repository.loadManyByQuery({ documentId: { $in: documentIds } }, { distinct: ['documentId'], order: { 'metadata.createTimestamp': 'desc' } });
+    }
+    async proceedWorkflow(documentId, userId) {
+        return this.transaction(async (tx) => {
+            const workflow = await this.withTransaction(tx).loadLatestWorkflow(documentId);
+            if (workflow.state != DocumentWorkflowState.Completed) {
+                throw new BadRequestError('Current workflow is not completed');
+            }
+            if (isNotNull(workflow.completeUserId)) {
+                throw new BadRequestError('Latest workflow is already completed');
+            }
+            await this.repository.withTransaction(tx).update(workflow.id, { completeUserId: userId });
+            await match(workflow.step)
+                .with(DocumentWorkflowStep.Classification, () => _throw(new BadRequestError('Proceeding from classification occurs automatically.')))
+                .with(DocumentWorkflowStep.Extraction, async () => this.withTransaction(tx).initiateWorkflow(documentId, DocumentWorkflowStep.Assignment))
+                .with(DocumentWorkflowStep.Assignment, async () => this.withTransaction(tx).initiateWorkflow(documentId, DocumentWorkflowStep.Validation))
+                .with(DocumentWorkflowStep.Validation, () => { })
+                .exhaustive();
+        });
+    }
+    async initiateWorkflow(documentId, step) {
+        const workflow = await this.repository.insert({ documentId, step, state: 'pending', failReason: null, completeUserId: null });
+        await this.#queue.enqueue({ workflowId: workflow.id });
+        return workflow;
+    }
+    async setWorkflowState(id, state, failReason = null) {
+        await this.repository.update(id, { state, failReason });
+    }
+    async processWorkflowJob(job) {
+        this.#logger.verbose(`Processing workflow job for workflow "${job.data.workflowId}"`);
+        const workflow = await this.repository.load(job.data.workflowId);
+        try {
+            await this.setWorkflowState(workflow.id, DocumentWorkflowState.Running);
+            await match(workflow.step)
+                .with(DocumentWorkflowStep.Classification, async () => this.processClassificationWorkflow(workflow))
+                .with(DocumentWorkflowStep.Extraction, async () => this.processExtractionWorkflow(workflow))
+                .with(DocumentWorkflowStep.Assignment, async () => this.processAssignmentWorkflow(workflow))
+                .with(DocumentWorkflowStep.Validation, async () => this.processValidationWorkflow(workflow))
+                .exhaustive();
+            await this.setWorkflowState(workflow.id, DocumentWorkflowState.Completed);
+            if (workflow.step == DocumentWorkflowStep.Classification) {
+                // automatically start extraction after classification
+                await this.initiateWorkflow(workflow.documentId, DocumentWorkflowStep.Extraction);
+            }
+        }
+        catch (error) {
+            this.#logger.error(error);
+            const isLastTry = job.tries == this.#queue.maxTries;
+            if (isLastTry) {
+                await this.repository.update(workflow.id, { state: DocumentWorkflowState.Error });
+            }
+        }
+    }
+    async processClassificationWorkflow(workflow) {
+        const typeId = await this.#documentManagementAiService.classifyDocumentType(workflow.documentId);
+        await this.#documentService.repository.update(workflow.documentId, { typeId, approval: DocumentApproval.Pending });
+    }
+    async processExtractionWorkflow(workflow) {
+        const extraction = await this.#documentManagementAiService.extractDocumentInformation(workflow.documentId);
+        await this.#documentService.updateDocument(workflow.documentId, extraction);
+    }
+    async processAssignmentWorkflow(workflow) {
+        const assignmentTask = await this.#documentAssignmentTaskRepository.loadByQuery({ documentId: workflow.documentId });
+        const assignmentScopes = await this.#documentAssignmentScopeRepository.loadManyByQuery({ taskId: assignmentTask.id });
+        const collectionIds = assignmentScopes.map((scope) => scope.collectionId);
+        await match(assignmentTask.target)
+            .with('collection', async () => {
+            const suitableCollectionIds = await this.#documentManagementAiService.findSuitableCollectionsForDocument(workflow.documentId, collectionIds);
+            if (suitableCollectionIds.length == 0) {
+                await this.setWorkflowState(workflow.id, DocumentWorkflowState.Failed, DocumentWorkflowFailReason.NoSuitableCollection);
+                return;
+            }
+            await this.#documentCollectionService.assignDocument(workflow.documentId, suitableCollectionIds);
+        })
+            .with('request', async () => {
+            const suitableRequestId = await this.#documentManagementAiService.findSuitableRequestForDocument(workflow.documentId, collectionIds);
+            if (isNull(suitableRequestId)) {
+                await this.setWorkflowState(workflow.id, DocumentWorkflowState.Failed, DocumentWorkflowFailReason.NoSuitableRequest);
+                return;
+            }
+            await this.#documentRequestService.assignDocument(suitableRequestId, workflow.documentId);
+        })
+            .exhaustive();
+    }
+    async processValidationWorkflow(_workflow) {
+        throw new NotImplementedError();
+    }
+}
+_a = DocumentWorkflowService;

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

@@ -0,0 +1,81 @@
+var _a;
+import { match, P } from 'ts-pattern';
+import { DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentWorkflowStep } from '../../../document-management/models/index.js';
+import { BadRequestError } from '../../../errors/bad-request.error.js';
+import { inject } from '../../../injector/inject.js';
+import { Logger } from '../../../logger/logger.js';
+import { Transactional } from '../../../orm/server/index.js';
+import { injectRepository } from '../../../orm/server/repository.js';
+import { getPdfPageCount } from '../../../pdf/utils.js';
+import { toArray } from '../../../utils/array/index.js';
+import { objectKeys } from '../../../utils/object/object.js';
+import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
+import { isDefined, isUndefined } from '../../../utils/type-guards.js';
+import { Document } from '../../models/index.js';
+import { DocumentCollectionService } from './document-collection.service.js';
+import { DocumentFileService } from './document-file.service.js';
+import { DocumentPropertyService } from './document-property.service.js';
+import { DocumentRequestService } from './document-request.service.js';
+import { DocumentWorkflowService } from './document-workflow.service.js';
+export class DocumentService extends Transactional {
+    #documentFileService = inject(DocumentFileService);
+    #requestService = inject(DocumentRequestService);
+    #workflowService = inject(DocumentWorkflowService, undefined, { forwardRef: true });
+    #documentPropertyService = inject(DocumentPropertyService);
+    #documentCollectionService = inject(DocumentCollectionService);
+    #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
+    #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
+    #logger = inject(Logger, _a.name);
+    repository = injectRepository(Document).withSession(this.session);
+    async createDocument({ typeId, title, subtitle, date, summary, tags, approval, comment, createUserId, originalFileName, assignment, properties, metadata }, content) {
+        const document = await this.transaction(async (tx) => {
+            const documentFile = await this.#documentFileService.withTransaction(tx).create(content, originalFileName);
+            const pages = documentFile.mimeType.includes('pdf') ? await tryIgnoreLogAsync(this.#logger, async () => getPdfPageCount(content), null) : null;
+            const document = await this.repository.withTransaction(tx).insert({ fileId: documentFile.id, typeId, title, subtitle, pages, date, summary, tags, metadata, approval, comment, createUserId });
+            if (isDefined(properties)) {
+                await this.#documentPropertyService.withTransaction(tx).setPropertyValues(document.id, properties);
+            }
+            await this.withTransaction(tx).createAssignment(document.id, assignment, tx);
+            await this.#workflowService.withTransaction(tx).initiateWorkflow(document.id, DocumentWorkflowStep.Classification);
+            return document;
+        });
+        return document;
+    }
+    async updateDocument(id, update) {
+        await this.transaction(async (tx) => {
+            const document = await this.repository.withTransaction(tx).load(id);
+            if (document.approval == DocumentApproval.Approved) {
+                throw new BadRequestError('Cannot update approved documents.');
+            }
+            const updateKeyLength = objectKeys(update).length;
+            if ((updateKeyLength > 1) || (isUndefined(update.properties) && (updateKeyLength > 0))) {
+                await this.repository.withTransaction(tx).update(id, update);
+            }
+            if (isDefined(update.properties)) {
+                await this.#documentPropertyService.withTransaction(tx).setPropertyValues(id, update.properties);
+            }
+        });
+    }
+    /**
+     * @returns collectionIds from either direct assignment or automatic assignment scope
+     */
+    async createAssignment(documentId, assignment, transaction) {
+        return match(assignment)
+            .with({ collections: P.select() }, async (collectionIds) => {
+            const collectionIdsArray = toArray(collectionIds);
+            await this.#documentCollectionService.withTransaction(transaction).assignDocument(documentId, collectionIdsArray);
+        })
+            .with({ request: P.select() }, async (requestId) => {
+            await this.#requestService.withTransaction(transaction).assignDocument(requestId, documentId);
+        })
+            .with({ automatic: P.select() }, async ({ target, scope }) => {
+            const collectionIdsArray = toArray(scope);
+            const assignmentTask = await this.#documentAssignmentTaskRepository.withTransaction(transaction).insert({ documentId: documentId, target });
+            for (const collectionId of collectionIdsArray) {
+                await this.#documentAssignmentScopeRepository.withTransaction(transaction).insert({ taskId: assignmentTask.id, collectionId });
+            }
+        })
+            .exhaustive();
+    }
+}
+_a = DocumentService;

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

@@ -1,2 +1,11 @@
+export * from './document-category-type.service.js';
+export * from './document-collection.service.js';
+export * from './document-file.service.js';
+export * from './document-management-ai.service.js';
 export * from './document-management-ancillary.service.js';
 export * from './document-management.service.js';
+export * from './document-property.service.js';
+export * from './document-request.service.js';
+export * from './document-validation.service.js';
+export * from './document-workflow.service.js';
+export * from './document.service.js';

package/document-management/server/validators/ai-validation-executor.js

@@ -0,0 +1,51 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { AiService } from '../../../ai/index.js';
+import { defineEnum } from '../../../enumeration/enumeration.js';
+import { Singleton } from '../../../injector/decorators.js';
+import { inject } from '../../../injector/inject.js';
+import { match } from 'ts-pattern';
+import { DocumentValidationExecutor } from './validator.js';
+export const AiValidationDifficulty = defineEnum('AiValidationDifficulty', {
+    Easy: 'easy',
+    MediumLow: 'medium-low',
+    MediumHigh: 'medium-high',
+    Hard: 'hard',
+});
+let AiValidationExecutor = class AiValidationExecutor extends DocumentValidationExecutor {
+    aiService = inject(AiService);
+    async execute(context) {
+        const validationPrompt = await this.getPrompt(context);
+        const model = match(this.difficulty)
+            .with('easy', () => 'gemini-2.0-flash-lite')
+            .with('medium-low', () => 'gemini-2.5-flash-exp-04-17')
+            .with('medium-high', () => 'gemini-2.5-flash-exp-04-17')
+            .with('hard', () => 'gemini-2.5-pro-exp-03-25')
+            .exhaustive();
+        const prompt = `Deine Aufgabe ist es ein Dokument zu validieren.
+
+Validierungsaufgabe:
+${validationPrompt}`;
+        const generation = await this.aiService.generate({
+            model,
+            generationOptions: {
+                temperature: 0.2,
+                topK: 20,
+            },
+            generationSchema: this.schema,
+            contents: [{
+                    role: 'user',
+                    parts: [{ text: prompt }],
+                }],
+        });
+        return await this.getResult(generation.json);
+    }
+};
+AiValidationExecutor = __decorate([
+    Singleton()
+], AiValidationExecutor);
+export { AiValidationExecutor };