@tstdl/base 0.92.123 → 0.92.125

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

@@ -0,0 +1,84 @@
+import { DocumentPropertyDataType } from '../../../document-management/models/index.js';
+import type { DocumentPropertyValueView, SetDocumentPropertyParameters } from '../../../document-management/models/service-models/index.js';
+import { Transactional } from '../../../orm/server/index.js';
+import type { OneOrMany } from '../../../types.js';
+import { Document, DocumentProperty } from '../../models/index.js';
+export declare class DocumentPropertyService extends Transactional {
+    #private;
+    readonly repository: import("../../../orm/server/repository.js").EntityRepository<Document>;
+    readonly documentProperties: import("drizzle-orm/pg-core").WithSubqueryWithSelection<{
+        documentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "document";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        propertyId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "document_property";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        label: import("drizzle-orm/pg-core").PgColumn<{
+            name: "label";
+            tableName: "document_property";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dataType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dataType";
+            tableName: "document_property";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "boolean" | "date" | "decimal" | "text" | "integer";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["boolean", "date", "decimal", "text", "integer"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        value: import("drizzle-orm").SQL.Aliased<string | number | boolean | null>;
+    }, "documentProperties">;
+    createProperty(label: string, dataType: DocumentPropertyDataType): Promise<DocumentProperty>;
+    assignPropertyToType(typeId: string, propertyId: string): Promise<void>;
+    loadDocumentProperties(documentId: OneOrMany<string>, includeNulls?: boolean): Promise<DocumentPropertyValueView[]>;
+    setPropertyValues(documentId: string, propertyValues: SetDocumentPropertyParameters[]): Promise<void>;
+}

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.d.ts

@@ -0,0 +1,30 @@
+import type { RequestStats } from '../../../document-management/models/service-models/index.js';
+import { Transactional } from '../../../orm/server/index.js';
+import type { OneOrMany } from '../../../types.js';
+import { DocumentRequest, DocumentRequestTemplate, DocumentRequestsTemplate } from '../../models/index.js';
+export declare class DocumentRequestService extends Transactional {
+    #private;
+    getRequestStats(collectionIds: OneOrMany<string>): Promise<RequestStats>;
+    createRequestsTemplate(parameters: Pick<DocumentRequestsTemplate, 'label' | 'description'>): Promise<DocumentRequestsTemplate>;
+    updateRequestsTemplate(id: string, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description' | 'metadata'>): Promise<DocumentRequestsTemplate>;
+    applyRequestsTemplate(id: string, collectionIds: string[]): Promise<void>;
+    deleteRequestsTemplate(id: string): Promise<DocumentRequestsTemplate>;
+    createRequestTemplate(requestsTemplateId: string, typeId: string, comment: string): Promise<DocumentRequestTemplate>;
+    updateRequestTemplate(id: string, parameters: Pick<DocumentRequestTemplate, 'typeId' | 'comment'>): Promise<DocumentRequestTemplate>;
+    deleteRequestTemplate(id: string): Promise<DocumentRequestTemplate>;
+    createRequest(typeId: string, collectionIds: string[], comment: string | null): Promise<DocumentRequest>;
+    updateRequest(id: string, update: Partial<Pick<DocumentRequest, 'typeId' | 'comment'>>): Promise<void>;
+    deleteRequest(id: string): Promise<void>;
+    assignDocument(requestId: string, documentId: string): Promise<void>;
+    /**
+     * 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.
+     */
+    fulfillRequest(requestId: string, documentId: string): Promise<void>;
+}

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.d.ts

@@ -0,0 +1,20 @@
+import type { CancellationSignal } from '../../../cancellation/token.js';
+import { DocumentValidationResultStatus } from '../../../document-management/models/index.js';
+import { afterResolve } from '../../../injector/interfaces.js';
+import type { AfterResolveContext } from '../../../injector/types.js';
+import type { Type } from '../../../types.js';
+import type { DocumentValidationExecutor, DocumentValidationExecutorContext, DocumentValidationExecutorContextDocumentData } from '../validators/index.js';
+export declare class DocumentValidationService {
+    #private;
+    [afterResolve](_: unknown, { cancellationSignal }: AfterResolveContext<any>): void;
+    processQueue(cancellationSignal: CancellationSignal): void;
+    startValidationWorkflow(documentId: string): Promise<void>;
+    setExecutionRunning(executionId: string): Promise<void>;
+    setExecutionCompleted(executionId: string, status: DocumentValidationResultStatus, message: string | null): Promise<void>;
+    setExecutionError(executionId: string, reason: string | null): Promise<void>;
+    loadRelatedDocument(executionId: string, documentId: string): Promise<DocumentValidationExecutorContextDocumentData>;
+    loadDocumentData(documentId: string): Promise<DocumentValidationExecutorContextDocumentData>;
+    protected loadDocumentValidationExecutorContext(executionId: string): Promise<DocumentValidationExecutorContext>;
+    processValidationExecution(executionId: string): Promise<void>;
+}
+export declare function registerDocumentValidationExecutor(...executors: Type<DocumentValidationExecutor>[]): void;

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.d.ts

@@ -0,0 +1,20 @@
+import { DocumentWorkflow, DocumentWorkflowStep } from '../../../document-management/models/document-workflow.model.js';
+import type { AfterResolveContext } from '../../../injector/index.js';
+import { afterResolve } from '../../../injector/interfaces.js';
+import { Transactional } from '../../../orm/server/transactional.js';
+export declare class DocumentWorkflowService extends Transactional {
+    #private;
+    readonly repository: import("../../../orm/server/repository.js").EntityRepository<DocumentWorkflow>;
+    [afterResolve](_: unknown, { cancellationSignal }: AfterResolveContext<any>): void;
+    loadLatestWorkflow(documentId: string): Promise<DocumentWorkflow>;
+    tryLoadLatestWorkflow(documentId: string): Promise<DocumentWorkflow | undefined>;
+    loadLatestWorkflows(documentIds: string[]): Promise<DocumentWorkflow[]>;
+    proceedWorkflow(documentId: string, userId: string): Promise<void>;
+    initiateWorkflow(documentId: string, step: DocumentWorkflowStep): Promise<DocumentWorkflow>;
+    private setWorkflowState;
+    private processWorkflowJob;
+    private processClassificationWorkflow;
+    private processExtractionWorkflow;
+    private processAssignmentWorkflow;
+    private processValidationWorkflow;
+}