@tstdl/base 0.92.142 → 0.92.144

package/document-management/models/document-validation-execution-related-document.model.js

@@ -7,16 +7,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { References } from '../../orm/decorators.js';
+import { ForeignKey, References } from '../../orm/decorators.js';
 import { Entity } from '../../orm/entity.js';
 import { Unique, Uuid } from '../../orm/types.js';
 import { DocumentManagementTable } from './document-management-table.js';
 import { DocumentValidationExecution } from './document-validation-execution.model.js';
 import { Document } from './document.model.js';
 let DocumentValidationExecutionRelatedDocument = class DocumentValidationExecutionRelatedDocument extends Entity {
+    tenantId;
     executionId;
     documentId;
 };
+__decorate([
+    Uuid(),
+    __metadata("design:type", String)
+], DocumentValidationExecutionRelatedDocument.prototype, "tenantId", void 0);
 __decorate([
     Uuid(),
     References(() => DocumentValidationExecution),
@@ -28,7 +33,9 @@ __decorate([
     __metadata("design:type", String)
 ], DocumentValidationExecutionRelatedDocument.prototype, "documentId", void 0);
 DocumentValidationExecutionRelatedDocument = __decorate([
-    DocumentManagementTable(),
-    Unique(['executionId', 'documentId'], { naming: 'abbreviated-table' })
+    DocumentManagementTable({ name: 'validation_execution_related_document' }),
+    Unique(['tenantId', 'executionId', 'documentId']),
+    ForeignKey(() => DocumentValidationExecution, ['tenantId', 'executionId'], ['tenantId', 'id']),
+    ForeignKey(() => Document, ['tenantId', 'documentId'], ['tenantId', 'id'])
 ], DocumentValidationExecutionRelatedDocument);
 export { DocumentValidationExecutionRelatedDocument };

package/document-management/models/document-validation-execution.model.d.ts

@@ -16,6 +16,7 @@ export declare const DocumentValidationResultStatus: {
 export type DocumentValidationResultStatus = EnumType<typeof DocumentValidationResultStatus>;
 export declare class DocumentValidationExecution extends Entity {
     static readonly entityName: 'DocumentValidationExecution';
+    tenantId: Uuid;
     workflowId: Uuid;
     definitionId: Uuid;
     state: DocumentValidationExecutionState;

package/document-management/models/document-validation-execution.model.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { defineEnum } from '../../enumeration/enumeration.js';
-import { References } from '../../orm/decorators.js';
+import { ForeignKey, References } from '../../orm/decorators.js';
 import { Entity } from '../../orm/entity.js';
 import { Timestamp, Unique, Uuid } from '../../orm/types.js';
 import { Enumeration, StringProperty } from '../../schema/index.js';
@@ -27,6 +27,7 @@ export const DocumentValidationResultStatus = defineEnum('DocumentValidationResu
     Warning: 'warning',
 });
 let DocumentValidationExecution = class DocumentValidationExecution extends Entity {
+    tenantId;
     workflowId;
     definitionId;
     state;
@@ -35,6 +36,10 @@ let DocumentValidationExecution = class DocumentValidationExecution extends Enti
     startedAt;
     completedAt;
 };
+__decorate([
+    Uuid(),
+    __metadata("design:type", String)
+], DocumentValidationExecution.prototype, "tenantId", void 0);
 __decorate([
     Uuid(),
     References(() => DocumentWorkflow),
@@ -66,7 +71,8 @@ __decorate([
     __metadata("design:type", Object)
 ], DocumentValidationExecution.prototype, "completedAt", void 0);
 DocumentValidationExecution = __decorate([
-    DocumentManagementTable(),
-    Unique(['workflowId', 'definitionId'])
+    DocumentManagementTable({ name: 'validation_execution' }),
+    Unique(['tenantId', 'workflowId', 'definitionId']),
+    ForeignKey(() => DocumentWorkflow, ['tenantId', 'workflowId'], ['tenantId', 'id'])
 ], DocumentValidationExecution);
 export { DocumentValidationExecution };

package/document-management/models/document-workflow.model.d.ts

@@ -1,6 +1,6 @@
 import { type EnumType } from '../../enumeration/enumeration.js';
 import { Entity } from '../../orm/entity.js';
-import { Uuid } from '../../orm/types.js';
+import { Timestamp, Uuid } from '../../orm/types.js';
 export declare const DocumentWorkflowStep: {
     readonly Classification: "classification";
     readonly Extraction: "extraction";
@@ -11,6 +11,7 @@ export type DocumentWorkflowStep = EnumType<typeof DocumentWorkflowStep>;
 export declare const DocumentWorkflowState: {
     readonly Pending: "pending";
     readonly Running: "running";
+    readonly Review: "review";
     readonly Completed: "completed";
     /** Unexpected error happened */
     readonly Error: "error";
@@ -27,9 +28,11 @@ export declare const DocumentWorkflowFailReason: {
 export type DocumentWorkflowFailReason = EnumType<typeof DocumentWorkflowFailReason>;
 export declare class DocumentWorkflow extends Entity {
     static readonly entityName: 'DocumentWorkflow';
+    tenantId: Uuid;
     documentId: Uuid;
     step: DocumentWorkflowStep;
     state: DocumentWorkflowState;
     failReason: DocumentWorkflowFailReason | null;
+    completeTimestamp: Timestamp | null;
     completeUserId: Uuid | null;
 }

package/document-management/models/document-workflow.model.js

@@ -8,9 +8,9 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { defineEnum } from '../../enumeration/enumeration.js';
-import { References } from '../../orm/decorators.js';
+import { ForeignKey, References } from '../../orm/decorators.js';
 import { Entity } from '../../orm/entity.js';
-import { Index, Uuid } from '../../orm/types.js';
+import { Index, Timestamp, Uuid } from '../../orm/types.js';
 import { Enumeration } from '../../schema/index.js';
 import { DocumentManagementTable } from './document-management-table.js';
 import { Document } from './document.model.js';
@@ -23,6 +23,7 @@ export const DocumentWorkflowStep = defineEnum('DocumentWorkflowStep', {
 export const DocumentWorkflowState = defineEnum('DocumentWorkflowState', {
     Pending: 'pending',
     Running: 'running',
+    Review: 'review',
     Completed: 'completed',
     /** Unexpected error happened */
     Error: 'error',
@@ -36,12 +37,18 @@ export const DocumentWorkflowFailReason = defineEnum('DocumentWorkflowFailReason
     NoSuitableRequest: 'no-suitable-request',
 });
 let DocumentWorkflow = class DocumentWorkflow extends Entity {
+    tenantId;
     documentId;
     step;
     state;
     failReason;
+    completeTimestamp;
     completeUserId;
 };
+__decorate([
+    Uuid(),
+    __metadata("design:type", String)
+], DocumentWorkflow.prototype, "tenantId", void 0);
 __decorate([
     Uuid(),
     References(() => Document),
@@ -59,12 +66,17 @@ __decorate([
     Enumeration(DocumentWorkflowFailReason, { nullable: true }),
     __metadata("design:type", Object)
 ], DocumentWorkflow.prototype, "failReason", void 0);
+__decorate([
+    Timestamp({ nullable: true }),
+    __metadata("design:type", Object)
+], DocumentWorkflow.prototype, "completeTimestamp", void 0);
 __decorate([
     Uuid({ nullable: true }),
     __metadata("design:type", Object)
 ], DocumentWorkflow.prototype, "completeUserId", void 0);
 DocumentWorkflow = __decorate([
-    DocumentManagementTable(),
-    Index(['documentId'], { unique: true, where: () => ({ state: { $neq: DocumentWorkflowState.Completed } }) })
+    DocumentManagementTable({ name: 'workflow' }),
+    Index(['documentId'], { unique: true, where: () => ({ state: { $neq: DocumentWorkflowState.Completed } }) }),
+    ForeignKey(() => Document, ['tenantId', 'documentId'], ['tenantId', 'id'])
 ], DocumentWorkflow);
 export { DocumentWorkflow };

package/document-management/models/document.model.d.ts

@@ -7,16 +7,16 @@ export declare const DocumentApproval: {
     readonly Rejected: "rejected";
 };
 export type DocumentApproval = EnumType<typeof DocumentApproval>;
-export type UpdatableDocumentProperties = keyof Pick<Document, 'typeId' | 'title' | 'subtitle' | 'date' | 'summary' | 'tags' | 'comment'>;
+export type UpdatableDocumentProperties = keyof Pick<Document, 'typeId' | 'title' | 'subtitle' | 'date' | 'summary' | 'comment'>;
 export declare class Document extends Entity {
     static readonly entityName: 'Document';
+    tenantId: Uuid;
     typeId: Uuid | null;
     title: string | null;
     subtitle: string | null;
     pages: number | null;
     date: NumericDate | null;
     summary: string | null;
-    tags: string[] | null;
     approval: DocumentApproval;
     comment: string | null;
     originalFileName: string | null;

package/document-management/models/document.model.js

@@ -10,8 +10,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { defineEnum } from '../../enumeration/enumeration.js';
 import { References } from '../../orm/decorators.js';
 import { Entity } from '../../orm/entity.js';
-import { NumericDate, Uuid } from '../../orm/types.js';
-import { Array, Enumeration, Integer, string, StringProperty } from '../../schema/index.js';
+import { NumericDate, Unique, Uuid } from '../../orm/types.js';
+import { Enumeration, Integer, StringProperty } from '../../schema/index.js';
 import { DocumentManagementTable } from './document-management-table.js';
 import { DocumentType } from './document-type.model.js';
 export const DocumentApproval = defineEnum('DocumentApproval', {
@@ -20,13 +20,13 @@ export const DocumentApproval = defineEnum('DocumentApproval', {
     Rejected: 'rejected',
 });
 let Document = class Document extends Entity {
+    tenantId;
     typeId;
     title;
     subtitle;
     pages;
     date;
     summary;
-    tags;
     approval;
     comment;
     originalFileName;
@@ -35,6 +35,10 @@ let Document = class Document extends Entity {
     size;
     createUserId;
 };
+__decorate([
+    Uuid(),
+    __metadata("design:type", String)
+], Document.prototype, "tenantId", void 0);
 __decorate([
     Uuid({ nullable: true }),
     References(() => DocumentType),
@@ -60,10 +64,6 @@ __decorate([
     StringProperty({ nullable: true }),
     __metadata("design:type", Object)
 ], Document.prototype, "summary", void 0);
-__decorate([
-    Array(string(), { nullable: true }),
-    __metadata("design:type", Object)
-], Document.prototype, "tags", void 0);
 __decorate([
     Enumeration(DocumentApproval),
     __metadata("design:type", String)
@@ -93,6 +93,7 @@ __decorate([
     __metadata("design:type", Object)
 ], Document.prototype, "createUserId", void 0);
 Document = __decorate([
-    DocumentManagementTable()
+    DocumentManagementTable(),
+    Unique(['tenantId', 'id'])
 ], Document);
 export { Document };

package/document-management/models/index.d.ts

@@ -7,10 +7,11 @@ export * from './document-management-table.js';
 export * from './document-property-value.model.js';
 export * from './document-property.model.js';
 export * from './document-request-collection-assignment.model.js';
-export * from './document-request-submission.model.js';
 export * from './document-request-template.js';
 export * from './document-request.model.js';
 export * from './document-requests-template.js';
+export * from './document-tag-assignment.model.js';
+export * from './document-tag.model.js';
 export * from './document-type-property.model.js';
 export * from './document-type-validation.model.js';
 export * from './document-type.model.js';

package/document-management/models/index.js

@@ -7,10 +7,11 @@ export * from './document-management-table.js';
 export * from './document-property-value.model.js';
 export * from './document-property.model.js';
 export * from './document-request-collection-assignment.model.js';
-export * from './document-request-submission.model.js';
 export * from './document-request-template.js';
 export * from './document-request.model.js';
 export * from './document-requests-template.js';
+export * from './document-tag-assignment.model.js';
+export * from './document-tag.model.js';
 export * from './document-type-property.model.js';
 export * from './document-type-validation.model.js';
 export * from './document-type.model.js';

package/document-management/server/api/document-management.api.d.ts

@@ -26,5 +26,8 @@ export declare class DocumentManagementApiController implements ApiController<Do
     deleteDocumentRequest(_context: ApiRequestContext<DocumentManagementApiDefinition, 'deleteDocumentRequest'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'deleteDocumentRequest'>>;
     assignDocumentToCollection(_context: ApiRequestContext<DocumentManagementApiDefinition, 'assignDocumentToCollection'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'assignDocumentToCollection'>>;
     archiveDocumentInCollection(_context: ApiRequestContext<DocumentManagementApiDefinition, 'archiveDocumentInCollection'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'archiveDocumentInCollection'>>;
-    updateDocument(_context: ApiRequestContext<DocumentManagementApiDefinition, 'updateDocument'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'updateDocument'>>;
+    updateDocument({ parameters, getToken }: ApiRequestContext<DocumentManagementApiDefinition, 'updateDocument'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'updateDocument'>>;
+    proceedDocumentWorkflow({ parameters, getToken }: ApiRequestContext<DocumentManagementApiDefinition, 'proceedDocumentWorkflow'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'proceedDocumentWorkflow'>>;
+    testAuthorization({ parameters, getToken }: ApiRequestContext<DocumentManagementApiDefinition, 'testAuthorization'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'testAuthorization'>>;
+    private canReadDocument;
 }

package/document-management/server/api/document-management.api.js

@@ -6,10 +6,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 var _a;
 var DocumentManagementApiController_1;
+import { create as createDiffPatch } from 'jsondiffpatch';
 import { match, P } from 'ts-pattern';
 import { createErrorResponse } from '../../../api/index.js';
 import { apiController } from '../../../api/server/index.js';
+import { CancellationSignal } from '../../../cancellation/token.js';
 import { documentManagementApiDefinition } from '../../../document-management/api/index.js';
+import { DocumentManagementAuthorizationService } from '../../../document-management/authorization/index.js';
 import { DocumentRequestCollectionAssignment } from '../../../document-management/models/document-request-collection-assignment.model.js';
 import { ForbiddenError, NotImplementedError } from '../../../errors/index.js';
 import { HttpServerResponse } from '../../../http/index.js';
@@ -19,40 +22,68 @@ import { injectRepository } from '../../../orm/server/repository.js';
 import { ServerSentEventsSource } from '../../../sse/server-sent-events-source.js';
 import { toArray } from '../../../utils/array/index.js';
 import { tryIgnoreAsync } from '../../../utils/try-ignore.js';
-import { DocumentCategoryTypeService, DocumentFileService, DocumentManagementAuthorizationService, DocumentManagementService, DocumentRequestService, DocumentService } from '../services/index.js';
+import { isDefined, isUndefined } from '../../../utils/type-guards.js';
+import { DocumentCategoryTypeService, DocumentFileService, DocumentManagementService, DocumentRequestService, DocumentService, DocumentWorkflowService } from '../services/index.js';
+const jsonDiffPatch = createDiffPatch({
+    omitRemovedValues: true,
+    arrays: {
+        detectMove: true,
+        includeValueOnMove: false,
+    },
+    objectHash(item, index) {
+        return item['id'] ?? String(index);
+    },
+});
 let DocumentManagementApiController = DocumentManagementApiController_1 = class DocumentManagementApiController {
+    #documentManagementService = inject(DocumentManagementService);
     #authorizationService = inject(DocumentManagementAuthorizationService);
     #documentCategoryTypeService = inject(DocumentCategoryTypeService);
     #documentFileService = inject(DocumentFileService);
-    #documentManagementService = inject(DocumentManagementService);
     #documentRequestService = inject(DocumentRequestService);
     #documentRequestCollectionAssignmentRepository = injectRepository(DocumentRequestCollectionAssignment);
     #documentService = inject(DocumentService);
+    #workflowService = inject(DocumentWorkflowService);
+    #cancellationSignal = inject(CancellationSignal);
     #logger = inject(Logger, DocumentManagementApiController_1.name);
     async loadData(context) {
         const token = await context.getToken();
+        const tenantId = await this.#authorizationService.getTenantId(token);
         for (const collectionId of context.parameters.collectionIds) {
             const allowed = await this.#authorizationService.canReadCollection(collectionId, token);
             if (!allowed) {
                 throw new ForbiddenError(`You are not allowed to read collection ${collectionId}`);
             }
         }
-        return await this.#documentManagementService.loadData(toArray(context.parameters.collectionIds));
+        return await this.#documentManagementService.loadData(tenantId, toArray(context.parameters.collectionIds));
     }
     async loadDataStream(context) {
         const token = await context.getToken();
+        const tenantId = await this.#authorizationService.getTenantId(token);
         for (const collectionId of context.parameters.collectionIds) {
             const allowed = await this.#authorizationService.canReadCollection(collectionId, token);
             if (!allowed) {
                 throw new ForbiddenError(`You are not allowed to read collection ${collectionId}`);
             }
         }
-        const stream = this.#documentManagementService.loadDataStream(toArray(context.parameters.collectionIds));
+        const stream = this.#documentManagementService.loadDataStream(tenantId, toArray(context.parameters.collectionIds), this.#cancellationSignal);
         const eventSource = new ServerSentEventsSource();
         void (async () => {
+            let lastData;
             try {
-                for await (const chunk of stream) {
-                    await eventSource.sendJson({ name: 'data', data: chunk });
+                for await (const data of stream) {
+                    if (eventSource.closed()) {
+                        break;
+                    }
+                    if (isUndefined(lastData)) {
+                        await eventSource.sendJson({ name: 'data', data });
+                    }
+                    else {
+                        const delta = jsonDiffPatch.diff(lastData, data);
+                        if (isDefined(delta)) {
+                            await eventSource.sendJson({ name: 'delta', data: delta });
+                        }
+                    }
+                    lastData = data;
                 }
             }
             catch (error) {
@@ -60,70 +91,81 @@ let DocumentManagementApiController = DocumentManagementApiController_1 = class
                 await tryIgnoreAsync(async () => await eventSource.sendJson({ name: 'error', data: createErrorResponse(error).error }));
                 await tryIgnoreAsync(async () => await eventSource.close());
             }
+            finally {
+                await tryIgnoreAsync(async () => await eventSource.close());
+            }
         })();
         return eventSource;
     }
     async loadDocumentRequestsTemplateData(context) {
         const token = await context.getToken();
+        const tenantId = await this.#authorizationService.getTenantId(token);
         const allowed = await this.#authorizationService.canReadDocumentRequestsTemplates(token);
         if (!allowed) {
             throw new ForbiddenError('You are not allowed to load document requests template data.');
         }
-        return await this.#documentManagementService.loadDocumentRequestsTemplateData();
+        return await this.#documentManagementService.loadDocumentRequestsTemplateData(tenantId);
     }
     async loadAvailableCategories(context) {
         const token = await context.getToken();
-        return await this.#documentCategoryTypeService.loadCategoryViews();
+        const tenantId = await this.#authorizationService.getTenantId(token);
+        return await this.#documentCategoryTypeService.loadCategoryViews(tenantId);
     }
     async loadContent(context) {
         const token = await context.getToken();
-        const allowed = await this.#authorizationService.canReadDocument(context.parameters.id, token);
+        const tenantId = await this.#authorizationService.getTenantId(token);
+        const allowed = await this.canReadDocument(tenantId, context.parameters.id, token);
         if (!allowed) {
             throw new ForbiddenError(`You are not allowed to load content for document ${context.parameters.id}.`);
         }
-        const url = await this.#documentService.getContentUrl(context.parameters.id, context.parameters.download);
+        const url = await this.#documentService.getContentUrl(tenantId, context.parameters.id, context.parameters.download);
         return HttpServerResponse.redirect(url);
     }
     async getContentUrl(context) {
         const token = await context.getToken();
-        const allowed = await this.#authorizationService.canReadDocument(context.parameters.id, token);
+        const tenantId = await this.#authorizationService.getTenantId(token);
+        const allowed = await this.canReadDocument(tenantId, context.parameters.id, token);
         if (!allowed) {
             throw new ForbiddenError(`You are not allowed to get content URL for document ${context.parameters.id}.`);
         }
-        return await this.#documentService.getContentUrl(context.parameters.id, context.parameters.download);
+        return await this.#documentService.getContentUrl(tenantId, context.parameters.id, context.parameters.download);
     }
     async loadPreview(context) {
         const token = await context.getToken();
-        const allowed = await this.#authorizationService.canReadDocument(context.parameters.id, token);
+        const tenantId = await this.#authorizationService.getTenantId(token);
+        const allowed = await this.canReadDocument(tenantId, context.parameters.id, token);
         if (!allowed) {
             throw new ForbiddenError(`You are not allowed to get content preview for document ${context.parameters.id}.`);
         }
-        const url = await this.#documentService.getPreviewUrl(context.parameters.id, context.parameters.page);
+        const url = await this.#documentService.getPreviewUrl(tenantId, context.parameters.id, context.parameters.page);
         return HttpServerResponse.redirect(url);
     }
     async getPreviewUrl(context) {
         const token = await context.getToken();
-        const allowed = await this.#authorizationService.canReadDocument(context.parameters.id, token);
+        const tenantId = await this.#authorizationService.getTenantId(token);
+        const allowed = await this.canReadDocument(tenantId, context.parameters.id, token);
         if (!allowed) {
             throw new ForbiddenError(`You are not allowed to get content preview for document ${context.parameters.id}.`);
         }
-        return await this.#documentService.getPreviewUrl(context.parameters.id, context.parameters.page);
+        return await this.#documentService.getPreviewUrl(tenantId, context.parameters.id, context.parameters.page);
     }
     async createCategory(context) {
         const token = await context.getToken();
+        const tenantId = await this.#authorizationService.getTenantId(token);
         const allowed = await this.#authorizationService.canManageCategoriesAndTypes(token);
         if (!allowed) {
             throw new ForbiddenError('You are not allowed to create document categories.');
         }
-        return await this.#documentCategoryTypeService.createCategory(context.parameters.label, context.parameters.parentId);
+        return await this.#documentCategoryTypeService.createCategory({ tenantId, label: context.parameters.label, parentId: context.parameters.parentId });
     }
     async createType(context) {
         const token = await context.getToken();
+        const tenantId = await this.#authorizationService.getTenantId(token);
         const allowed = await this.#authorizationService.canManageCategoriesAndTypes(token);
         if (!allowed) {
             throw new ForbiddenError('You are not allowed to create document types.');
         }
-        return await this.#documentCategoryTypeService.createType(context.parameters.label, context.parameters.categoryId);
+        return await this.#documentCategoryTypeService.createType({ tenantId, label: context.parameters.label, categoryId: context.parameters.categoryId });
     }
     async initiateDocumentUpload(context) {
         const token = await context.getToken();
@@ -132,6 +174,7 @@ let DocumentManagementApiController = DocumentManagementApiController_1 = class
     }
     async createDocument(context) {
         const token = await context.getToken();
+        const tenantId = await this.#authorizationService.getTenantId(token);
         const subject = await this.#authorizationService.getSubject(token);
         const { uploadId, ...createParameters } = context.parameters;
         const [collectionIds, requiresAssign] = await match(context.parameters.assignment)
@@ -156,15 +199,16 @@ let DocumentManagementApiController = DocumentManagementApiController_1 = class
             }
         }
         const actionUserId = await this.#authorizationService.getSubject(token);
-        return await this.#documentService.create(createParameters, { uploadId, uploadKey: subject }, { createUserId: actionUserId });
+        return await this.#documentService.create(tenantId, createParameters, { uploadId, uploadKey: subject }, { createUserId: actionUserId });
     }
     async createDocumentRequestsTemplate(context) {
         const token = await context.getToken();
+        const tenantId = await this.#authorizationService.getTenantId(token);
         const allowed = await this.#authorizationService.canManageDocumentRequestsTemplates(token);
         if (!allowed) {
             throw new ForbiddenError('You are not allowed to create document requests template.');
         }
-        return await this.#documentRequestService.createRequestsTemplate(context.parameters);
+        return await this.#documentRequestService.createRequestsTemplate(tenantId, context.parameters);
     }
     async updateDocumentRequestsTemplate(_context) {
         throw new NotImplementedError();
@@ -199,8 +243,55 @@ let DocumentManagementApiController = DocumentManagementApiController_1 = class
     async archiveDocumentInCollection(_context) {
         throw new NotImplementedError();
     }
-    async updateDocument(_context) {
-        throw new NotImplementedError();
+    async updateDocument({ parameters, getToken }) {
+        const token = await getToken();
+        const tenantId = await this.#authorizationService.getTenantId(token);
+        const { id, ...update } = parameters;
+        for (const id of [...(update.collections?.assign ?? []), ...(update.collections?.archive ?? [])]) {
+            const allowed = await this.#authorizationService.canAssignDocuments(id, token);
+            if (!allowed) {
+                throw new ForbiddenError('You are not allowed to assign to or archive documents in collection.');
+            }
+        }
+        await this.#documentService.update(tenantId, id, update);
+        return 'ok';
+    }
+    async proceedDocumentWorkflow({ parameters, getToken }) {
+        const token = await getToken();
+        const tenantId = await this.#authorizationService.getTenantId(token);
+        const userId = await this.#authorizationService.getSubject(token);
+        await this.#workflowService.proceedWorkflow(tenantId, parameters.id, userId);
+        return 'ok';
+    }
+    async testAuthorization({ parameters, getToken }) {
+        const token = await getToken();
+        return await match(parameters)
+            .with({ type: 'canReadCollection' }, async (parameters) => await this.#authorizationService.canReadCollection(parameters.collectionId, token))
+            .with({ type: 'canCreateDocuments' }, async (parameters) => await this.#authorizationService.canCreateDocuments(parameters.collectionId, token))
+            .with({ type: 'canDeleteDocuments' }, async (parameters) => await this.#authorizationService.canDeleteDocuments(parameters.collectionId, token))
+            .with({ type: 'canAssignDocuments' }, async (parameters) => await this.#authorizationService.canAssignDocuments(parameters.collectionId, token))
+            .with({ type: 'canManageRequests' }, async (parameters) => await this.#authorizationService.canManageRequests(parameters.collectionId, token))
+            .with({ type: 'canUpdateDocument' }, async (parameters) => await this.#authorizationService.canUpdateDocument(parameters.documentId, token))
+            .with({ type: 'canApproveDocument' }, async (parameters) => await this.#authorizationService.canApproveDocument(parameters.documentId, token))
+            .with({ type: 'canRejectDocument' }, async (parameters) => await this.#authorizationService.canRejectDocument(parameters.documentId, token))
+            .with({ type: 'canProgressDocumentWorkflow' }, async (parameters) => await this.#authorizationService.canProgressDocumentWorkflow(parameters.documentId, token))
+            .with({ type: 'canManageCategoriesAndTypes' }, async () => await this.#authorizationService.canManageCategoriesAndTypes(token))
+            .with({ type: 'canReadDocumentRequestsTemplates' }, async () => await this.#authorizationService.canReadDocumentRequestsTemplates(token))
+            .with({ type: 'canManageDocumentRequestsTemplates' }, async () => await this.#authorizationService.canManageDocumentRequestsTemplates(token))
+            .with({ type: 'canManageValidationDefinitions' }, async () => await this.#authorizationService.canManageValidationDefinitions(token))
+            .otherwise(() => {
+            throw new NotImplementedError(`Authorization test for type ${parameters.type} is not implemented.`);
+        });
+    }
+    async canReadDocument(tenantId, documentId, token) {
+        const relevantCollectionIds = await this.#documentManagementService.getRelevantDocumentCollectionIds(tenantId, documentId);
+        for (const collectionId of relevantCollectionIds) {
+            const canReadCollection = await this.#authorizationService.canReadCollection(collectionId, token);
+            if (canReadCollection) {
+                return true;
+            }
+        }
+        return false;
     }
 };
 DocumentManagementApiController = DocumentManagementApiController_1 = __decorate([

package/document-management/server/configure.d.ts

@@ -1,2 +1,2 @@
-import { DocumentManagementConfig } from './module.js';
-export declare function configureDocumentManagement(config: DocumentManagementConfig): void;
+import { DocumentManagementConfiguration } from './module.js';
+export declare function configureDocumentManagement(configuration: DocumentManagementConfiguration): void;

package/document-management/server/configure.js

@@ -1,9 +1,9 @@
 import { Injector } from '../../injector/injector.js';
-import { DocumentManagementConfig } from './module.js';
-import { DocumentManagementAncillaryService } from './services/document-management-ancillary.service.js';
-import { DocumentManagementAuthorizationService } from './services/document-management-authorization.service.js';
-export function configureDocumentManagement(config) {
-    Injector.register(DocumentManagementConfig, { useValue: config });
-    Injector.register(DocumentManagementAncillaryService, { useToken: config.ancillaryService });
-    Injector.register(DocumentManagementAuthorizationService, { useToken: config.authorizationService });
+import { DocumentManagementAuthorizationService } from '../authorization/document-management-authorization.service.js';
+import { DocumentManagementConfiguration } from './module.js';
+import { DocumentManagementAncillaryService } from './services/index.js';
+export function configureDocumentManagement(configuration) {
+    Injector.register(DocumentManagementConfiguration, { useValue: configuration });
+    Injector.register(DocumentManagementAncillaryService, { useToken: configuration.ancillaryService });
+    Injector.register(DocumentManagementAuthorizationService, { useToken: configuration.authorizationService });
 }