@tstdl/base 0.92.142 → 0.92.144

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

@@ -4,25 +4,27 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { count, isNotNull as dbIsNotNull, isNull as dbIsNull, eq, inArray, sql } from 'drizzle-orm';
+import { and, count, isNotNull as dbIsNotNull, isNull as dbIsNull, eq, inArray, sql } from 'drizzle-orm';
 import { BadRequestError } from '../../../errors/index.js';
+import { inject } from '../../../injector/inject.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, DocumentRequestCollectionAssignment, DocumentRequestState, DocumentRequestTemplate, DocumentRequestsTemplate } from '../../models/index.js';
 import { document, documentRequest, documentRequestCollectionAssignment } from '../schemas.js';
+import { DocumentManagementObservationService } from './document-management-observation.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
 let DocumentRequestService = class DocumentRequestService extends Transactional {
     #documentRequestCollectionAssignmentRepository = injectRepository(DocumentRequestCollectionAssignment);
     #documentRequestRepository = injectRepository(DocumentRequest);
     #documentRequestTemplateRepository = injectRepository(DocumentRequestTemplate);
     #documentRequestsTemplateRepository = injectRepository(DocumentRequestsTemplate);
-    #documentCollectionAssignmentRepository = injectRepository(DocumentCollectionAssignment);
-    async getRequestStats(collectionIds) {
+    #observationService = inject(DocumentManagementObservationService);
+    async getRequestStats(tenantId, collectionIds) {
         const relevantRequests = this.session.$with('relevant_requests').as(this.session.selectDistinct({ id: documentRequest.id })
             .from(documentRequest)
             .innerJoin(documentRequestCollectionAssignment, eq(documentRequestCollectionAssignment.requestId, documentRequest.id))
-            .where(inArray(documentRequestCollectionAssignment.collectionId, toArray(collectionIds))));
+            .where(and(eq(documentRequest.tenantId, tenantId), eq(documentRequestCollectionAssignment.tenantId, tenantId), inArray(documentRequestCollectionAssignment.collectionId, toArray(collectionIds)))));
         const [result] = await this.session.with(relevantRequests)
             .select({
             total: count(sql `${documentRequest.id})`),
@@ -37,98 +39,73 @@ let DocumentRequestService = class DocumentRequestService extends Transactional
             .where(inArray(documentRequest.id, this.session.select({ id: relevantRequests.id }).from(relevantRequests)));
         return assertDefinedPass(result);
     }
-    async createRequestsTemplate(parameters) {
-        return this.#documentRequestsTemplateRepository.insert(parameters);
+    async createRequestsTemplate(tenantId, parameters) {
+        return await this.#documentRequestsTemplateRepository.insert({ ...parameters, tenantId });
     }
-    async updateRequestsTemplate(id, parameters) {
-        return this.#documentRequestsTemplateRepository.update(id, parameters);
+    async updateRequestsTemplate(tenantId, id, parameters) {
+        return await this.#documentRequestsTemplateRepository.updateByQuery({ tenantId, id }, parameters);
     }
-    async applyRequestsTemplate(id, collectionIds) {
-        const requestTemplates = await this.#documentRequestTemplateRepository.loadManyByQuery({ requestsTemplateId: id });
+    async applyRequestsTemplate(tenantId, id, collectionIds) {
+        const requestTemplates = await this.#documentRequestTemplateRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, requestsTemplateId: id });
         await this.transaction(async (tx) => {
             for (const { typeId, comment } of requestTemplates) {
-                await this.withTransaction(tx).createRequest(typeId, collectionIds, comment);
+                await this.withTransaction(tx).createRequest(tenantId, typeId, collectionIds, comment);
             }
         });
     }
-    async deleteRequestsTemplate(id) {
-        return this.#documentRequestsTemplateRepository.delete(id);
+    async deleteRequestsTemplate(tenantId, id) {
+        return await this.#documentRequestsTemplateRepository.deleteByQuery({ tenantId, id });
     }
-    async createRequestTemplate(requestsTemplateId, typeId, comment) {
-        return this.#documentRequestTemplateRepository.insert({ requestsTemplateId, typeId, comment });
+    async createRequestTemplate(tenantId, requestsTemplateId, typeId, comment) {
+        return await this.#documentRequestTemplateRepository.insert({ tenantId, requestsTemplateId, typeId, comment });
     }
-    async updateRequestTemplate(id, parameters) {
-        return this.#documentRequestTemplateRepository.update(id, parameters);
+    async updateRequestTemplate(tenantId, id, parameters) {
+        return await this.#documentRequestTemplateRepository.updateByQuery({ tenantId, id }, parameters);
     }
-    async deleteRequestTemplate(id) {
-        return this.#documentRequestTemplateRepository.delete(id);
+    async deleteRequestTemplate(tenantId, id) {
+        return await this.#documentRequestTemplateRepository.deleteByQuery({ tenantId, id });
     }
-    async createRequest(typeId, collectionIds, comment) {
+    async createRequest(tenantId, 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 newDocumentRequestCollectionAssignments = collectionIds.map((collectionId) => ({ requestId: request.id, collectionId }));
+        return await this.transaction(async (tx) => {
+            const request = await this.#documentRequestRepository.withTransaction(tx).insert({ tenantId, typeId, documentId: null, comment, state: DocumentRequestState.Open });
+            const newDocumentRequestCollectionAssignments = collectionIds.map((collectionId) => ({ tenantId, requestId: request.id, collectionId }));
             await this.#documentRequestCollectionAssignmentRepository.withTransaction(tx).insertMany(newDocumentRequestCollectionAssignments);
+            this.#observationService.collectionChange(collectionIds, tx);
             return request;
         });
     }
-    async updateRequest(id, update) {
+    async updateRequest(tenantId, id, update) {
         await this.transaction(async (tx) => {
-            const request = await this.#documentRequestRepository.withTransaction(tx).load(id);
+            const request = await this.#documentRequestRepository.withTransaction(tx).loadByQuery({ tenantId, 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);
+            await this.#documentRequestRepository.withTransaction(tx).updateByQuery({ tenantId, id }, update);
+            this.#observationService.requestChange(id, tx);
         });
     }
-    async deleteRequest(id) {
+    async deleteRequest(tenantId, id) {
         await this.transaction(async (tx) => {
-            const request = await this.#documentRequestRepository.withTransaction(tx).load(id);
+            const request = await this.#documentRequestRepository.withTransaction(tx).loadByQuery({ tenantId, id });
             if (isNotNull(request.documentId)) {
                 throw new BadRequestError('Cannot delete requests which have an assigned document.');
             }
-            await this.#documentRequestCollectionAssignmentRepository.withTransaction(tx).deleteManyByQuery({ requestId: id });
-            await this.#documentRequestRepository.withTransaction(tx).delete(id);
+            await this.#documentRequestCollectionAssignmentRepository.withTransaction(tx).deleteManyByQuery({ tenantId, requestId: id });
+            await this.#documentRequestRepository.withTransaction(tx).deleteByQuery({ tenantId, id });
+            this.#observationService.requestChange(id, tx);
         });
     }
-    async assignDocument(requestId, documentId) {
+    async assignDocument(document, requestId) {
         await this.transaction(async (tx) => {
-            const request = await this.#documentRequestRepository.withTransaction(tx).load(requestId);
+            const request = await this.#documentRequestRepository.withTransaction(tx).loadByQuery({ tenantId: document.tenantId, id: 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.#documentRequestCollectionAssignmentRepository.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 });
+            await this.#documentRequestRepository.withTransaction(tx).updateByQuery({ tenantId: document.tenantId, id: requestId }, { documentId: document.id });
+            this.#observationService.requestChange(requestId, tx);
         });
     }
 };

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

@@ -0,0 +1,10 @@
+import { Transactional } from '../../../orm/server/index.js';
+import { DocumentTag, DocumentTagAssignment, type Document } from '../../models/index.js';
+export declare class DocumentTagService extends Transactional {
+    readonly tagRepository: import("../../../orm/server/index.js").EntityRepository<DocumentTag>;
+    readonly tagAssignmentRepository: import("../../../orm/server/index.js").EntityRepository<DocumentTagAssignment>;
+    loadTags(tenantId: string | null): Promise<DocumentTag[]>;
+    loadOrCreate(tenantId: string, labels: string[]): Promise<DocumentTag[]>;
+    loadDocumentTags(tenantId: string, documentId: string): Promise<DocumentTag[]>;
+    assignTags(document: Document, labels: string[]): Promise<void>;
+}

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

@@ -0,0 +1,59 @@
+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 { getEntityIds } from '../../../orm/index.js';
+import { injectRepository, Transactional } from '../../../orm/server/index.js';
+import { and, eq } from 'drizzle-orm';
+import { DocumentTag, DocumentTagAssignment } from '../../models/index.js';
+import { documentTag, documentTagAssignment } from '../schemas.js';
+import { DocumentManagementSingleton } from './singleton.js';
+let DocumentTagService = class DocumentTagService extends Transactional {
+    tagRepository = injectRepository(DocumentTag);
+    tagAssignmentRepository = injectRepository(DocumentTagAssignment);
+    async loadTags(tenantId) {
+        return await this.tagRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } }, { order: { label: 'asc' } });
+    }
+    async loadOrCreate(tenantId, labels) {
+        if (labels.length === 0) {
+            return [];
+        }
+        return await this.tagRepository.transaction(async (tx) => {
+            const existingTags = await this.tagRepository.withTransaction(tx).loadManyByQuery({
+                tenantId: { $or: [null, tenantId] },
+                label: { $in: labels },
+            });
+            const newLabels = labels.filter((label) => !existingTags.some((tag) => tag.label == label));
+            const newTags = newLabels.map((label) => ({
+                tenantId,
+                label,
+            }));
+            const insertedTags = await this.tagRepository.withTransaction(tx).insertMany(newTags);
+            return [...existingTags, ...insertedTags];
+        });
+    }
+    async loadDocumentTags(tenantId, documentId) {
+        const result = await this.tagAssignmentRepository.session
+            .select({ tag: documentTag })
+            .from(documentTagAssignment)
+            .innerJoin(documentTag, eq(documentTag.id, documentTagAssignment.tagId))
+            .where(and(eq(documentTagAssignment.tenantId, tenantId), eq(documentTagAssignment.documentId, documentId)));
+        const tags = result.map((row) => row.tag);
+        return await this.tagRepository.mapManyToEntity(tags);
+    }
+    async assignTags(document, labels) {
+        await this.tagAssignmentRepository.transaction(async (tx) => {
+            const tags = await this.withTransaction(tx).loadOrCreate(document.tenantId, labels);
+            const tagIds = getEntityIds(tags);
+            const newAssignments = tagIds.map((tagId) => ({ tenantId: document.tenantId, documentId: document.id, tagId }));
+            await this.tagAssignmentRepository.withTransaction(tx).insertManyIfNotExists(['documentId', 'tagId'], newAssignments);
+            await this.tagAssignmentRepository.withTransaction(tx).hardDeleteManyByQuery({ tenantId: document.tenantId, documentId: document.id, tagId: { $nin: tagIds } });
+        });
+    }
+};
+DocumentTagService = __decorate([
+    DocumentManagementSingleton()
+], DocumentTagService);
+export { DocumentTagService };

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

@@ -8,13 +8,13 @@ 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>;
+    startValidationWorkflow(tenantId: string, documentId: string): Promise<void>;
+    setExecutionRunning(tenantId: string, executionId: string): Promise<void>;
+    setExecutionCompleted(tenantId: string, executionId: string, status: DocumentValidationResultStatus, message: string | null): Promise<void>;
+    setExecutionError(tenantId: string, executionId: string, reason: string | null): Promise<void>;
+    loadRelatedDocument(tenantId: string, executionId: string, documentId: string): Promise<DocumentValidationExecutorContextDocumentData>;
+    loadDocumentData(tenantId: string, documentId: string): Promise<DocumentValidationExecutorContextDocumentData>;
+    protected loadDocumentValidationExecutorContext(tenantId: string, executionId: string): Promise<DocumentValidationExecutorContext>;
+    processValidationExecution(tenantId: string, executionId: string): Promise<void>;
 }
 export declare function registerDocumentValidationExecutor(...executors: Type<DocumentValidationExecutor>[]): void;

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

@@ -47,19 +47,20 @@ let DocumentValidationService = DocumentValidationService_1 = class DocumentVali
     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);
+            await this.processValidationExecution(job.data.tenantId, job.data.executionId);
         }, this.#logger);
     }
-    async startValidationWorkflow(documentId) {
-        const document = await this.#documentService.load(documentId);
+    async startValidationWorkflow(tenantId, documentId) {
+        const document = await this.#documentService.loadByQuery({ tenantId, id: 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 });
+        const workflow = await this.#documentWorkflowService.initiateWorkflow(document.tenantId, documentId, DocumentWorkflowStep.Validation);
+        const typeValidations = await this.#documentTypeValidationService.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, typeId: document.typeId });
         for (const typeValidation of typeValidations) {
-            const validationDefinition = await this.#validationDefinitionService.load(typeValidation.validationId);
+            const validationDefinition = await this.#validationDefinitionService.loadByQuery({ tenantId: { $or: [null, tenantId] }, id: typeValidation.validationId });
             const execution = await this.#validationExecutionService.insert({
+                tenantId: document.tenantId,
                 definitionId: validationDefinition.id,
                 workflowId: workflow.id,
                 state: DocumentValidationExecutionState.Pending,
@@ -68,42 +69,42 @@ let DocumentValidationService = DocumentValidationService_1 = class DocumentVali
                 startedAt: null,
                 completedAt: null,
             });
-            await this.#queue.enqueue({ executionId: execution.id });
+            await this.#queue.enqueue({ tenantId, executionId: execution.id });
         }
     }
-    async setExecutionRunning(executionId) {
-        await this.#validationExecutionService.update(executionId, { state: DocumentValidationExecutionState.Running, resultStatus: null, resultMessage: null, startedAt: currentTimestamp(), completedAt: null });
+    async setExecutionRunning(tenantId, executionId) {
+        await this.#validationExecutionService.updateByQuery({ tenantId, 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 setExecutionCompleted(tenantId, executionId, status, message) {
+        await this.#validationExecutionService.updateByQuery({ tenantId, 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 setExecutionError(tenantId, executionId, reason) {
+        await this.#validationExecutionService.updateByQuery({ tenantId, 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 });
+    async loadRelatedDocument(tenantId, executionId, documentId) {
+        const execution = await this.#validationExecutionService.loadByQuery({ tenantId, id: executionId });
+        const workflow = await this.#documentWorkflowService.repository.loadByQuery({ tenantId, id: execution.workflowId });
+        const documentData = await this.loadDocumentData(tenantId, documentId);
+        await this.#validationExecutionRelatedDocumentService.upsert(['executionId', 'documentId'], { tenantId, executionId, documentId: workflow.documentId });
         return documentData;
     }
-    async loadDocumentData(documentId) {
-        const document = await this.#documentService.load(documentId);
+    async loadDocumentData(tenantId, documentId) {
+        const document = await this.#documentService.loadByQuery({ tenantId, id: 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 [documentCollections, documentTypeProperties, type] = await Promise.all([
+            this.#documentCollectionAssignmentRepository.loadManyByQuery({ tenantId, documentId: document.id }),
+            this.#documentTypePropertyService.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, typeId: document.typeId }),
+            this.#documentTypeService.loadByQuery({ tenantId: { $or: [null, tenantId] }, id: 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 }),
+        const [collections, category, properties, propertyValues] = await Promise.all([
+            this.#documentManagementService.loadManyByQuery({ tenantId, id: { $in: documentCollectionIds } }),
+            this.#documentCategoryService.loadByQuery({ tenantId: { $or: [null, tenantId] }, id: type.categoryId }),
+            this.#documentPropertyService.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, id: { $in: documentPropertyIds } }),
+            this.#documentPropertyValueService.loadManyByQuery({ tenantId, documentId: document.id }),
         ]);
         return {
             document,
@@ -114,34 +115,34 @@ let DocumentValidationService = DocumentValidationService_1 = class DocumentVali
             propertyValues,
         };
     }
-    async loadDocumentValidationExecutorContext(executionId) {
-        const execution = await this.#validationExecutionService.load(executionId);
+    async loadDocumentValidationExecutorContext(tenantId, executionId) {
+        const execution = await this.#validationExecutionService.loadByQuery({ tenantId, id: executionId });
         const [definition, workflow] = await Promise.all([
-            this.#validationDefinitionService.load(execution.definitionId),
-            this.#documentWorkflowService.repository.load(execution.workflowId),
+            this.#validationDefinitionService.loadByQuery({ tenantId, id: execution.definitionId }),
+            this.#documentWorkflowService.repository.loadByQuery({ tenantId, id: execution.workflowId }),
         ]);
-        const documentData = await this.loadDocumentData(workflow.documentId);
+        const documentData = await this.loadDocumentData(tenantId, workflow.documentId);
         return {
             execution,
             definition,
             ...documentData,
         };
     }
-    async processValidationExecution(executionId) {
-        const context = await this.loadDocumentValidationExecutorContext(executionId);
+    async processValidationExecution(tenantId, executionId) {
+        const context = await this.loadDocumentValidationExecutorContext(tenantId, executionId);
         const executor = this.#executorMap.get(context.definition.identifier);
         if (isUndefined(executor)) {
-            await this.setExecutionError(executionId, `Invalid validation identifier`);
+            await this.setExecutionError(tenantId, executionId, `Invalid validation identifier`);
             return;
         }
         try {
-            await this.setExecutionRunning(executionId);
+            await this.setExecutionRunning(tenantId, executionId);
             const result = await executor.execute(context);
-            await this.setExecutionCompleted(executionId, result.status, result.message ?? null);
+            await this.setExecutionCompleted(tenantId, executionId, result.status, result.message ?? null);
         }
         catch (error) {
             this.#logger.error(error);
-            await this.setExecutionError(executionId, 'Internal error');
+            await this.setExecutionError(tenantId, executionId, 'Internal error');
         }
     }
 };

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

@@ -2,16 +2,17 @@ import { DocumentWorkflow, DocumentWorkflowStep } from '../../../document-manage
 import type { AfterResolveContext } from '../../../injector/index.js';
 import { afterResolve } from '../../../injector/interfaces.js';
 import { Transactional } from '../../../orm/server/transactional.js';
+import type { OneOrMany } from '../../../types.js';
 export declare class DocumentWorkflowService extends Transactional {
     #private;
     private readonly documentService;
     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>;
+    loadLatestWorkflow(tenantId: string, documentId: string): Promise<DocumentWorkflow>;
+    loadLatestWorkflows(tenantId: string, documentIds: string[]): Promise<DocumentWorkflow[]>;
+    loadWorkflows(tenantId: string, documentId: OneOrMany<string>): Promise<DocumentWorkflow[]>;
+    proceedWorkflow(tenantId: string, documentId: string, userId: string): Promise<void>;
+    initiateWorkflow(tenantId: string, documentId: string, step: DocumentWorkflowStep): Promise<DocumentWorkflow>;
     private setWorkflowState;
     private processWorkflowJob;
     private processClassificationWorkflow;

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

@@ -17,76 +17,79 @@ 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 { injectTransactional, Transactional } from '../../../orm/server/transactional.js';
 import { Queue } from '../../../queue/queue.js';
+import { toArray } from '../../../utils/array/array.js';
+import { currentTimestamp } from '../../../utils/date-time.js';
 import { _throw } from '../../../utils/throw.js';
 import { isNotNull, isNull } from '../../../utils/type-guards.js';
-import { desc, inArray } from 'drizzle-orm';
+import { and, desc, eq, inArray } from 'drizzle-orm';
 import { documentWorkflow } from '../schemas.js';
 import { DocumentCollectionService } from './document-collection.service.js';
 import { DocumentManagementAiService } from './document-management-ai.service.js';
+import { DocumentManagementObservationService } from './document-management-observation.service.js';
 import { DocumentRequestService } from './document-request.service.js';
 import { DocumentService } from './document.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
 let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflowService extends Transactional {
     #documentManagementAiService = inject(DocumentManagementAiService);
-    #documentCollectionService = inject(DocumentCollectionService);
-    #documentRequestService = inject(DocumentRequestService);
+    #documentCollectionService = injectTransactional(DocumentCollectionService);
+    #documentRequestService = injectTransactional(DocumentRequestService);
     #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
     #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
+    #observationService = inject(DocumentManagementObservationService);
     #queue = inject((Queue), { name: 'DocumentWorkflow', processTimeout: 5 * 60 * 1000, maxTries: 3 });
     #logger = inject(Logger, DocumentWorkflowService_1.name);
     documentService = inject(DocumentService, undefined, { forwardRef: true });
-    repository = injectRepository(DocumentWorkflow).withSession(this.session);
+    repository = injectRepository(DocumentWorkflow);
     [afterResolve](_, { cancellationSignal }) {
         if (this.isInTransaction) {
             return;
         }
         this.#queue.process({ concurrency: 5, cancellationSignal }, async (job) => await this.processWorkflowJob(job), this.#logger);
     }
-    async loadLatestWorkflow(documentId) {
-        return await this.repository.loadByQuery({ documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
+    async loadLatestWorkflow(tenantId, documentId) {
+        return await this.repository.loadByQuery({ tenantId, documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
     }
-    async tryLoadLatestWorkflow(documentId) {
-        return await this.repository.tryLoadByQuery({ documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
-    }
-    async loadLatestWorkflows(documentIds) {
-        const orderedDocumentWorkflows = this.repository.session.$with('orderedDocumentWorkflows').as((qb) => qb
-            .select()
-            .from(documentWorkflow)
-            .where(inArray(documentWorkflow.documentId, documentIds))
-            .orderBy(desc(documentWorkflow.createTimestamp)));
+    async loadLatestWorkflows(tenantId, documentIds) {
         const latestWorkflows = await this.repository.session
-            .with(orderedDocumentWorkflows)
-            .selectDistinctOn([orderedDocumentWorkflows.documentId])
-            .from(orderedDocumentWorkflows);
+            .selectDistinctOn([documentWorkflow.documentId])
+            .from(documentWorkflow)
+            .where(and(eq(documentWorkflow.tenantId, tenantId), inArray(documentWorkflow.documentId, documentIds)))
+            .orderBy(documentWorkflow.documentId, desc(documentWorkflow.createTimestamp));
         return await this.repository.mapManyToEntity(latestWorkflows);
     }
-    async proceedWorkflow(documentId, userId) {
+    async loadWorkflows(tenantId, documentId) {
+        return await this.repository.loadManyByQuery({ tenantId, documentId: { $in: toArray(documentId) } }, { order: { 'documentId': 'asc', 'metadata.createTimestamp': 'desc' } });
+    }
+    async proceedWorkflow(tenantId, documentId, userId) {
         await 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');
+            const workflow = await this.withTransaction(tx).loadLatestWorkflow(tenantId, documentId);
+            if (workflow.state != DocumentWorkflowState.Review) {
+                throw new BadRequestError('Current workflow is not in review state.');
             }
             if (isNotNull(workflow.completeUserId)) {
-                throw new BadRequestError('Latest workflow is already completed');
+                throw new BadRequestError('Latest workflow is already completed.');
             }
-            await this.repository.withTransaction(tx).update(workflow.id, { completeUserId: userId });
+            await this.repository.withTransaction(tx).update(workflow.id, { state: DocumentWorkflowState.Completed, completeUserId: userId });
             await match(workflow.step)
                 .with(DocumentWorkflowStep.Classification, () => _throw(new BadRequestError('Proceeding from classification occurs automatically.')))
-                .with(DocumentWorkflowStep.Extraction, async () => await this.withTransaction(tx).initiateWorkflow(documentId, DocumentWorkflowStep.Assignment))
-                .with(DocumentWorkflowStep.Assignment, async () => await this.withTransaction(tx).initiateWorkflow(documentId, DocumentWorkflowStep.Validation))
+                .with(DocumentWorkflowStep.Extraction, async () => await this.withTransaction(tx).initiateWorkflow(tenantId, documentId, DocumentWorkflowStep.Assignment))
+                .with(DocumentWorkflowStep.Assignment, async () => await this.withTransaction(tx).initiateWorkflow(tenantId, documentId, DocumentWorkflowStep.Validation))
                 .with(DocumentWorkflowStep.Validation, () => { })
                 .exhaustive();
+            this.#observationService.documentChange(workflow.id, tx);
         });
     }
-    async initiateWorkflow(documentId, step) {
-        const workflow = await this.repository.insert({ documentId, step, state: 'pending', failReason: null, completeUserId: null });
+    async initiateWorkflow(tenantId, documentId, step) {
+        const workflow = await this.repository.insert({ tenantId, documentId, step, state: 'pending', failReason: null, completeTimestamp: null, completeUserId: null });
         await this.#queue.enqueue({ workflowId: workflow.id });
+        this.#observationService.documentChange(workflow.id, this.session);
         return workflow;
     }
     async setWorkflowState(id, state, failReason = null) {
-        await this.repository.update(id, { state, failReason });
+        await this.repository.update(id, { state, completeTimestamp: (state == DocumentWorkflowState.Completed) ? currentTimestamp() : undefined, failReason });
+        this.#observationService.workflowChange(id, this.session);
     }
     async processWorkflowJob(job) {
         const workflow = await this.repository.load(job.data.workflowId);
@@ -99,48 +102,56 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
                 .with(DocumentWorkflowStep.Assignment, async () => await this.processAssignmentWorkflow(workflow))
                 .with(DocumentWorkflowStep.Validation, async () => await 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);
+                // no need for after classification review. Automatically start extraction.
+                await this.setWorkflowState(workflow.id, DocumentWorkflowState.Completed);
+                await this.initiateWorkflow(workflow.tenantId, workflow.documentId, DocumentWorkflowStep.Extraction);
+            }
+            else {
+                await this.setWorkflowState(workflow.id, DocumentWorkflowState.Review);
             }
         }
         catch (error) {
-            const isLastTry = job.tries == this.#queue.maxTries;
+            const isLastTry = job.tries >= this.#queue.maxTries;
             if (isLastTry) {
                 await this.repository.update(workflow.id, { state: DocumentWorkflowState.Error });
+                this.#observationService.documentChange(workflow.id, this.session);
             }
             throw error;
         }
     }
     async processClassificationWorkflow(workflow) {
-        const typeId = await this.#documentManagementAiService.classifyDocumentType(workflow.documentId);
+        const typeId = await this.#documentManagementAiService.classifyDocumentType(workflow.tenantId, workflow.documentId);
         await this.documentService.repository.update(workflow.documentId, { typeId, approval: DocumentApproval.Pending });
+        this.#observationService.documentChange(workflow.documentId, this.session);
     }
     async processExtractionWorkflow(workflow) {
-        const extraction = await this.#documentManagementAiService.extractDocumentInformation(workflow.documentId);
-        await this.documentService.update(workflow.documentId, extraction);
+        const extraction = await this.#documentManagementAiService.extractDocumentInformation(workflow.tenantId, workflow.documentId);
+        await this.documentService.update(workflow.tenantId, 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 [document, assignmentTask] = await Promise.all([
+            this.documentService.repository.loadByQuery({ tenantId: workflow.tenantId, id: workflow.documentId }),
+            this.#documentAssignmentTaskRepository.loadByQuery({ tenantId: workflow.tenantId, documentId: workflow.documentId }),
+        ]);
+        const assignmentScopes = await this.#documentAssignmentScopeRepository.loadManyByQuery({ tenantId: workflow.tenantId, 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);
+            const suitableCollectionIds = await this.#documentManagementAiService.findSuitableCollectionsForDocument(document, collectionIds);
             if (suitableCollectionIds.length == 0) {
                 await this.setWorkflowState(workflow.id, DocumentWorkflowState.Failed, DocumentWorkflowFailReason.NoSuitableCollection);
                 return;
             }
-            await this.#documentCollectionService.assignDocument(workflow.documentId, suitableCollectionIds);
+            await this.#documentCollectionService.assignDocument(document, suitableCollectionIds);
         })
             .with('request', async () => {
-            const suitableRequestId = await this.#documentManagementAiService.findSuitableRequestForDocument(workflow.documentId, collectionIds);
+            const suitableRequestId = await this.#documentManagementAiService.findSuitableRequestForDocument(document, collectionIds);
             if (isNull(suitableRequestId)) {
                 await this.setWorkflowState(workflow.id, DocumentWorkflowState.Failed, DocumentWorkflowFailReason.NoSuitableRequest);
                 return;
             }
-            await this.#documentRequestService.assignDocument(suitableRequestId, workflow.documentId);
+            await this.#documentRequestService.assignDocument(document, suitableRequestId);
         })
             .exhaustive();
     }