@tstdl/base 0.92.129 → 0.92.131

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

@@ -1,3 +1,9 @@
+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 { Enumerable } from '../../../enumerable/index.js';
 import { inject } from '../../../injector/index.js';
 import { getEntityMap } from '../../../orm/index.js';
@@ -6,14 +12,15 @@ import { distinct } from '../../../utils/array/index.js';
 import { compareByValueSelectionToOrder } from '../../../utils/comparison.js';
 import { groupToMap, groupToSingleMap } from '../../../utils/iterable-helpers/index.js';
 import { fromEntries, objectEntries } from '../../../utils/object/index.js';
-import { assertDefinedPass, isNotNull, isNull, isUndefined } from '../../../utils/type-guards.js';
-import { DocumentApproval, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentRequest, DocumentRequestCollection, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentValidationExecution, DocumentWorkflowStep } from '../../models/index.js';
+import { assertDefinedPass, isNotNull, isNotNullOrUndefined, isNull, isUndefined } from '../../../utils/type-guards.js';
+import { DocumentApproval, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentValidationExecution, DocumentWorkflowStep } from '../../models/index.js';
 import { DocumentCategoryTypeService, enumTypeKey } from './document-category-type.service.js';
 import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
 import { DocumentPropertyService } from './document-property.service.js';
 import { DocumentWorkflowService } from './document-workflow.service.js';
 import { DocumentService } from './document.service.js';
-export class DocumentManagementService extends Transactional {
+import { DocumentManagementSingleton } from './singleton.js';
+let DocumentManagementService = class DocumentManagementService extends Transactional {
     #ancillaryService = inject(DocumentManagementAncillaryService);
     #documentCategoryTypeService = inject(DocumentCategoryTypeService);
     #documentCollectionRepository = injectRepository(DocumentCollection);
@@ -22,7 +29,7 @@ export class DocumentManagementService extends Transactional {
     #documentFileRepository = injectRepository(DocumentFile);
     #documentService = inject(DocumentService);
     #documentPropertyService = inject(DocumentPropertyService);
-    #documentRequestCollectionRepository = injectRepository(DocumentRequestCollection);
+    #documentRequestCollectionAssignmentRepository = injectRepository(DocumentRequestCollectionAssignment);
     #documentRequestRepository = injectRepository(DocumentRequest);
     #documentRequestsTemplateRepository = injectRepository(DocumentRequestsTemplate);
     #documentRequestTemplateRepository = injectRepository(DocumentRequestTemplate);
@@ -30,20 +37,20 @@ export class DocumentManagementService extends Transactional {
     #documentWorkflowService = inject(DocumentWorkflowService);
     #documentValidationExecutionRepository = injectRepository(DocumentValidationExecution);
     async loadData(collectionIds) {
-        return this.transaction(async (tx) => {
-            const [collections, collectionsMetadataMap, collectionAssignments, requestCollections, categories, types] = await Promise.all([
+        return await this.transaction(async (tx) => {
+            const [collections, collectionsMetadataMap, documentAssignments, requestAssignments, categories, types] = await Promise.all([
                 this.#documentCollectionRepository.withTransaction(tx).loadMany(collectionIds),
                 this.#ancillaryService.resolveMetadataMap(...collectionIds),
                 this.#documentCollectionAssignmentRepository.withTransaction(tx).loadManyByQuery({ collectionId: { $in: collectionIds } }),
-                this.#documentRequestCollectionRepository.withTransaction(tx).loadManyByQuery({ collectionId: { $in: collectionIds } }),
+                this.#documentRequestCollectionAssignmentRepository.withTransaction(tx).loadManyByQuery({ collectionId: { $in: collectionIds } }),
                 this.#documentCategoryRepository.withTransaction(tx).loadManyByQuery({}, { order: 'label' }),
                 this.#documentTypeRepository.withTransaction(tx).loadManyByQuery({}, { order: 'label' }),
             ]);
-            const requestIds = requestCollections.map((requestCollection) => requestCollection.requestId);
+            const requestIds = requestAssignments.map((requestCollection) => requestCollection.requestId);
             const requests = await this.#documentRequestRepository.withTransaction(tx).loadManyByQuery({ id: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } });
-            const collectionDocumentIds = collectionAssignments.map((document) => document.documentId);
+            const assignmentDocumentIds = documentAssignments.map((assignment) => assignment.documentId);
             const requestDocumentIds = requests.map((request) => request.documentId).filter(isNotNull);
-            const documentIds = distinct([...collectionDocumentIds, ...requestDocumentIds]);
+            const documentIds = distinct([...assignmentDocumentIds, ...requestDocumentIds]);
             const [documents, propertyValues] = await Promise.all([
                 this.#documentService.withTransaction(tx).repository.loadManyByQuery({ id: { $in: documentIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
                 this.#documentPropertyService.withTransaction(tx).loadDocumentProperties(documentIds),
@@ -73,7 +80,7 @@ export class DocumentManagementService extends Transactional {
                 const validations = (isNotNull(currentWorkflow) && (currentWorkflow.step == DocumentWorkflowStep.Validation)) ? workflowValidationMap.get(currentWorkflow.id) ?? [] : null;
                 return {
                     ...document,
-                    collectionAssignments: collectionAssignments.filter((collectionDocument) => collectionDocument.documentId == document.id),
+                    collectionAssignments: documentAssignments.filter((collectionDocument) => collectionDocument.documentId == document.id),
                     properties: valuesMap.get(document.id) ?? [],
                     currentWorkflow,
                     validations,
@@ -81,7 +88,7 @@ export class DocumentManagementService extends Transactional {
             });
             const requestViews = requests.map((request) => ({
                 ...request,
-                collectionIds: requestCollections.filter((requestCollection) => requestCollection.requestId == request.id).map((requestCollection) => requestCollection.collectionId),
+                collectionIds: requestAssignments.filter((requestCollection) => requestCollection.requestId == request.id).map((requestCollection) => requestCollection.collectionId),
                 document: isNull(request.documentId) ? null : documentIdMap.get(request.documentId) ?? null,
             }));
             return {
@@ -95,32 +102,39 @@ export class DocumentManagementService extends Transactional {
         });
     }
     async loadDocumentRequestsTemplateData() {
-        const [requestsTemplates, requestTemplates] = await Promise.all([
-            this.#documentRequestsTemplateRepository.loadManyByQuery({}, { order: 'label' }),
-            this.#documentRequestTemplateRepository.loadManyByQuery({}),
-        ]);
-        const templates = requestsTemplates.map((requestsTemplate) => ({
-            ...requestsTemplate,
-            requestTemplates: requestTemplates.filter((requestTemplate) => requestTemplate.requestsTemplateId == requestsTemplate.id),
-        }));
-        return { templates };
+        return await this.transaction(async (tx) => {
+            const [requestsTemplates, requestTemplates] = await Promise.all([
+                this.#documentRequestsTemplateRepository.withTransaction(tx).loadManyByQuery({}, { order: 'label' }),
+                this.#documentRequestTemplateRepository.withTransaction(tx).loadManyByQuery({}),
+            ]);
+            const templates = requestsTemplates.map((requestsTemplate) => ({
+                ...requestsTemplate,
+                requestTemplates: requestTemplates.filter((requestTemplate) => requestTemplate.requestsTemplateId == requestsTemplate.id),
+            }));
+            return { templates };
+        });
     }
-    async initializeCategoriesAndTypes(categoryNames, categoryParents, typeNames, typeCategories) {
-        const categoryEntries = objectEntries(categoryNames);
-        const typeEntries = objectEntries(typeNames);
+    async initializeCategoriesAndTypes(categoryLabels, categoryParents, typeLabels, typeCategories) {
+        const categoryEntries = objectEntries(categoryLabels);
+        const typeEntries = objectEntries(typeLabels);
         const { categoryMap, typeMap } = await this.transaction(async (tx) => {
-            const { categories, types } = await this.#documentCategoryTypeService.loadCategoriesAndTypes();
+            const { categories: dbCategories, types: dbTypes } = await this.#documentCategoryTypeService.withTransaction(tx).loadCategoriesAndTypes();
+            const categories = dbCategories.filter((category) => isNotNullOrUndefined(category.metadata.attributes[enumTypeKey]));
+            const types = dbTypes.filter((type) => isNotNullOrUndefined(type.metadata.attributes[enumTypeKey]));
             const enumKeyCategoryMap = groupToSingleMap(categories, (category) => category.metadata.attributes[enumTypeKey]);
             const enumKeyTypeMap = groupToSingleMap(types, (type) => type.metadata.attributes[enumTypeKey]);
             for (const [key, label] of categoryEntries) {
                 const category = enumKeyCategoryMap.get(key);
-                const parentId = assertDefinedPass(categoryParents[key], `Parent category not defined for ${key}`);
+                const parentKey = assertDefinedPass(categoryParents[key], `Parent category not defined for ${key}`);
+                const parentCategory = isNull(parentKey) ? null : assertDefinedPass(enumKeyCategoryMap.get(parentKey));
+                const parentCategoryId = parentCategory?.id ?? null;
                 if (isUndefined(category)) {
-                    const category = await this.#documentCategoryTypeService.withTransaction(tx).createCategory(label, parentId, key);
-                    categories.push(category);
+                    const category = await this.#documentCategoryTypeService.withTransaction(tx).createCategory(label, parentCategoryId, key);
+                    enumKeyCategoryMap.set(key, category);
                 }
-                else if ((category.label != label) || (category.parentId != parentId)) {
-                    await this.#documentCategoryTypeService.withTransaction(tx).updateCategory(category.id, { label, parentId });
+                else if ((category.label != label) || (category.parentId != parentCategoryId)) {
+                    const updatedCategory = await this.#documentCategoryTypeService.withTransaction(tx).updateCategory(category.id, { label, parentId: parentCategoryId });
+                    enumKeyCategoryMap.set(key, updatedCategory);
                 }
             }
             for (const [key, label] of typeEntries) {
@@ -128,11 +142,12 @@ export class DocumentManagementService extends Transactional {
                 const enumCategory = typeCategories[key];
                 const category = assertDefinedPass(enumKeyCategoryMap.get(enumCategory));
                 if (isUndefined(type)) {
-                    const type = await this.#documentCategoryTypeService.createType(label, category.id, key);
-                    types.push(type);
+                    const type = await this.#documentCategoryTypeService.withTransaction(tx).createType(label, category.id, key);
+                    enumKeyTypeMap.set(key, type);
                 }
                 else if ((type.categoryId != category.id) || (type.label != label)) {
-                    await this.#documentCategoryTypeService.withTransaction(tx).updateType(type.id, { categoryId: category.id, label: label });
+                    const updatedType = await this.#documentCategoryTypeService.withTransaction(tx).updateType(type.id, { categoryId: category.id, label: label });
+                    enumKeyTypeMap.set(key, updatedType);
                 }
             }
             return { categoryMap: enumKeyCategoryMap, typeMap: enumKeyTypeMap };
@@ -144,4 +159,8 @@ export class DocumentManagementService extends Transactional {
             types: fromEntries(mappedTypes),
         };
     }
-}
+};
+DocumentManagementService = __decorate([
+    DocumentManagementSingleton()
+], DocumentManagementService);
+export { DocumentManagementService };

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

@@ -6,40 +6,8 @@ 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;
-        }, {}, {}>;
+        documentId: import("drizzle-orm").SQL.Aliased<string>;
+        propertyId: import("drizzle-orm").SQL.Aliased<string>;
         label: import("drizzle-orm/pg-core").PgColumn<{
             name: "label";
             tableName: "document_property";

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

@@ -1,12 +1,19 @@
+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 { and, isNotNull as drizzleIsNotNull, eq, inArray } from 'drizzle-orm';
 import { BadRequestError } from '../../../errors/bad-request.error.js';
-import { coalesce, getEntityMap, toJsonb } from '../../../orm/index.js';
+import { autoAlias, 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, DocumentPropertyDataType, DocumentPropertyValue, DocumentTypeProperty } from '../../models/index.js';
 import { document, documentProperty, documentPropertyValue, documentType, documentTypeProperty } from '../schemas.js';
+import { DocumentManagementSingleton } from './singleton.js';
 const documentPropertyValueValidators = {
     [DocumentPropertyDataType.Text]: (value) => isString(value) || isNull(value),
     [DocumentPropertyDataType.Integer]: (value) => isNumber(value) || isNull(value),
@@ -14,15 +21,15 @@ const documentPropertyValueValidators = {
     [DocumentPropertyDataType.Boolean]: (value) => isBoolean(value) || isNull(value),
     [DocumentPropertyDataType.Date]: (value) => isNumber(value) || isNull(value),
 };
-export class DocumentPropertyService extends Transactional {
+let DocumentPropertyService = 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
+    documentProperties = this.session.$with('documentProperties').as((qb) => qb
         .select({
-        documentId: document.id,
-        propertyId: documentProperty.id,
+        documentId: autoAlias(document.id),
+        propertyId: autoAlias(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'),
@@ -33,13 +40,14 @@ export class DocumentPropertyService extends Transactional {
         .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 });
+        return await this.#documentPropertyRepository.insert({ label, dataType });
     }
     async assignPropertyToType(typeId, propertyId) {
         await this.#documentTypePropertyRepository.insert({ typeId, propertyId });
     }
     async loadDocumentProperties(documentId, includeNulls = false) {
-        return this.session
+        return await this.session
+            .with(this.documentProperties)
             .select({
             documentId: this.documentProperties.documentId,
             propertyId: this.documentProperties.propertyId,
@@ -77,7 +85,11 @@ export class DocumentPropertyService extends Transactional {
             await this.#documentPropertyValueRepository.withTransaction(tx).upsertMany(['documentId', 'propertyId'], upserts);
         });
     }
-}
+};
+DocumentPropertyService = __decorate([
+    DocumentManagementSingleton()
+], DocumentPropertyService);
+export { DocumentPropertyService };
 function validatePropertyValue(propertyId, dataType, value) {
     const valid = documentPropertyValueValidators[dataType](value);
     if (!valid) {

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

@@ -6,14 +6,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 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';
+import { DocumentApproval, DocumentCollectionAssignment, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestState, DocumentRequestTemplate, DocumentRequestsTemplate } from '../../models/index.js';
+import { document, documentRequest, documentRequestCollectionAssignment } from '../schemas.js';
+import { DocumentManagementSingleton } from './singleton.js';
 let DocumentRequestService = class DocumentRequestService extends Transactional {
-    #documentRequestCollectionRepository = injectRepository(DocumentRequestCollection);
+    #documentRequestCollectionAssignmentRepository = injectRepository(DocumentRequestCollectionAssignment);
     #documentRequestRepository = injectRepository(DocumentRequest);
     #documentRequestTemplateRepository = injectRepository(DocumentRequestTemplate);
     #documentRequestsTemplateRepository = injectRepository(DocumentRequestsTemplate);
@@ -21,8 +21,8 @@ let DocumentRequestService = class DocumentRequestService extends Transactional
     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))));
+            .innerJoin(documentRequestCollectionAssignment, eq(documentRequestCollectionAssignment.requestId, documentRequest.id))
+            .where(inArray(documentRequestCollectionAssignment.collectionId, toArray(collectionIds))));
         const [result] = await this.session.with(relevantRequests)
             .select({
             total: count(sql `${documentRequest.id})`),
@@ -69,8 +69,8 @@ let DocumentRequestService = class DocumentRequestService extends Transactional
         }
         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);
+            const newDocumentRequestCollectionAssignments = collectionIds.map((collectionId) => ({ requestId: request.id, collectionId }));
+            await this.#documentRequestCollectionAssignmentRepository.withTransaction(tx).insertMany(newDocumentRequestCollectionAssignments);
             return request;
         });
     }
@@ -89,7 +89,7 @@ let DocumentRequestService = class DocumentRequestService extends Transactional
             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.#documentRequestCollectionAssignmentRepository.withTransaction(tx).deleteManyByQuery({ requestId: id });
             await this.#documentRequestRepository.withTransaction(tx).delete(id);
         });
     }
@@ -118,7 +118,7 @@ let DocumentRequestService = class DocumentRequestService extends Transactional
             if (request.state == DocumentRequestState.Fulfilled) {
                 throw new BadRequestError('Document request is already fulfilled.');
             }
-            const targetCollectionIds = await this.#documentRequestCollectionRepository.withTransaction(tx).loadManyByQuery({ requestId });
+            const targetCollectionIds = await this.#documentRequestCollectionAssignmentRepository.withTransaction(tx).loadManyByQuery({ requestId });
             if (targetCollectionIds.length == 0) {
                 throw new Error('No document request collection for document request found.');
             }
@@ -133,6 +133,6 @@ let DocumentRequestService = class DocumentRequestService extends Transactional
     }
 };
 DocumentRequestService = __decorate([
-    Injectable()
+    DocumentManagementSingleton()
 ], DocumentRequestService);
 export { DocumentRequestService };

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

@@ -1,4 +1,11 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 var _a;
+var DocumentValidationService_1;
 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';
@@ -14,8 +21,9 @@ 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';
+import { DocumentManagementSingleton } from './singleton.js';
 const DOCUMENT_VALIDATION_EXECUTORS = injectionToken('DocumentValidationExecutors');
-export class DocumentValidationService {
+let DocumentValidationService = DocumentValidationService_1 = class DocumentValidationService {
     #documentManagementService = injectRepository(DocumentCollection);
     #documentCollectionAssignmentRepository = injectRepository(DocumentCollectionAssignment);
     #documentService = injectRepository(Document);
@@ -31,7 +39,7 @@ export class DocumentValidationService {
     #documentTypeValidationService = injectRepository(DocumentTypeValidation);
     #queue = inject((Queue), { name: 'DocumentManagement: validation', processTimeout: 5 * millisecondsPerMinute, maxTries: 3 });
     #executors = injectAll(DOCUMENT_VALIDATION_EXECUTORS);
-    #logger = inject(Logger, _a.name);
+    #logger = inject(Logger, DocumentValidationService_1.name);
     #executorMap = new Map(this.#executors.map((executor) => [executor.identifier, executor]));
     [afterResolve](_, { cancellationSignal }) {
         this.processQueue(cancellationSignal);
@@ -136,8 +144,11 @@ export class DocumentValidationService {
             await this.setExecutionError(executionId, 'Internal error');
         }
     }
-}
-_a = DocumentValidationService;
+};
+DocumentValidationService = DocumentValidationService_1 = __decorate([
+    DocumentManagementSingleton()
+], DocumentValidationService);
+export { DocumentValidationService };
 export function registerDocumentValidationExecutor(...executors) {
     for (const executor of executors) {
         Injector.register(DOCUMENT_VALIDATION_EXECUTORS, { useToken: executor }, { multi: true });

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

@@ -1,4 +1,11 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 var _a;
+var DocumentWorkflowService_1;
 import { match } from 'ts-pattern';
 import { DocumentAssignmentScope } from '../../../document-management/models/document-assignment-scope.model.js';
 import { DocumentAssignmentTask } from '../../../document-management/models/document-assignment-task.model.js';
@@ -18,7 +25,8 @@ import { DocumentCollectionService } from './document-collection.service.js';
 import { DocumentManagementAiService } from './document-management-ai.service.js';
 import { DocumentRequestService } from './document-request.service.js';
 import { DocumentService } from './document.service.js';
-export class DocumentWorkflowService extends Transactional {
+import { DocumentManagementSingleton } from './singleton.js';
+let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflowService extends Transactional {
     #documentManagementAiService = inject(DocumentManagementAiService);
     #documentService = inject(DocumentService);
     #documentCollectionService = inject(DocumentCollectionService);
@@ -26,25 +34,25 @@ export class DocumentWorkflowService extends Transactional {
     #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
     #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
     #queue = inject((Queue), { name: 'DocumentWorkflow', processTimeout: 5 * 60 * 1000, maxTries: 3 });
-    #logger = inject(Logger, _a.name);
+    #logger = inject(Logger, DocumentWorkflowService_1.name);
     repository = injectRepository(DocumentWorkflow).withSession(this.session);
     [afterResolve](_, { cancellationSignal }) {
         if (this.isInTransaction) {
             return;
         }
-        this.#queue.process({ concurrency: 5, cancellationSignal }, async (job) => this.processWorkflowJob(job), this.#logger);
+        this.#queue.process({ concurrency: 5, cancellationSignal }, async (job) => await this.processWorkflowJob(job), this.#logger);
     }
     async loadLatestWorkflow(documentId) {
-        return this.repository.loadByQuery({ documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
+        return await this.repository.loadByQuery({ documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
     }
     async tryLoadLatestWorkflow(documentId) {
-        return this.repository.tryLoadByQuery({ documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
+        return await this.repository.tryLoadByQuery({ documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
     }
     async loadLatestWorkflows(documentIds) {
-        return this.repository.loadManyByQuery({ documentId: { $in: documentIds } }, { distinct: ['documentId'], order: { 'metadata.createTimestamp': 'desc' } });
+        return await this.repository.loadManyByQuery({ documentId: { $in: documentIds } }, { distinct: ['metadata.createTimestamp', 'documentId'], order: { 'metadata.createTimestamp': 'desc' } });
     }
     async proceedWorkflow(documentId, userId) {
-        return this.transaction(async (tx) => {
+        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');
@@ -55,8 +63,8 @@ export class DocumentWorkflowService extends Transactional {
             await this.repository.withTransaction(tx).update(workflow.id, { completeUserId: userId });
             await match(workflow.step)
                 .with(DocumentWorkflowStep.Classification, () => _throw(new BadRequestError('Proceeding from classification occurs automatically.')))
-                .with(DocumentWorkflowStep.Extraction, async () => this.withTransaction(tx).initiateWorkflow(documentId, DocumentWorkflowStep.Assignment))
-                .with(DocumentWorkflowStep.Assignment, async () => this.withTransaction(tx).initiateWorkflow(documentId, DocumentWorkflowStep.Validation))
+                .with(DocumentWorkflowStep.Extraction, async () => await this.withTransaction(tx).initiateWorkflow(documentId, DocumentWorkflowStep.Assignment))
+                .with(DocumentWorkflowStep.Assignment, async () => await this.withTransaction(tx).initiateWorkflow(documentId, DocumentWorkflowStep.Validation))
                 .with(DocumentWorkflowStep.Validation, () => { })
                 .exhaustive();
         });
@@ -75,10 +83,10 @@ export class DocumentWorkflowService extends Transactional {
         try {
             await this.setWorkflowState(workflow.id, DocumentWorkflowState.Running);
             await match(workflow.step)
-                .with(DocumentWorkflowStep.Classification, async () => this.processClassificationWorkflow(workflow))
-                .with(DocumentWorkflowStep.Extraction, async () => this.processExtractionWorkflow(workflow))
-                .with(DocumentWorkflowStep.Assignment, async () => this.processAssignmentWorkflow(workflow))
-                .with(DocumentWorkflowStep.Validation, async () => this.processValidationWorkflow(workflow))
+                .with(DocumentWorkflowStep.Classification, async () => await this.processClassificationWorkflow(workflow))
+                .with(DocumentWorkflowStep.Extraction, async () => await this.processExtractionWorkflow(workflow))
+                .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) {
@@ -100,7 +108,7 @@ export class DocumentWorkflowService extends Transactional {
     }
     async processExtractionWorkflow(workflow) {
         const extraction = await this.#documentManagementAiService.extractDocumentInformation(workflow.documentId);
-        await this.#documentService.updateDocument(workflow.documentId, extraction);
+        await this.#documentService.update(workflow.documentId, extraction);
     }
     async processAssignmentWorkflow(workflow) {
         const assignmentTask = await this.#documentAssignmentTaskRepository.loadByQuery({ documentId: workflow.documentId });
@@ -128,5 +136,8 @@ export class DocumentWorkflowService extends Transactional {
     async processValidationWorkflow(_workflow) {
         throw new NotImplementedError();
     }
-}
-_a = DocumentWorkflowService;
+};
+DocumentWorkflowService = DocumentWorkflowService_1 = __decorate([
+    DocumentManagementSingleton()
+], DocumentWorkflowService);
+export { DocumentWorkflowService };

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

@@ -5,10 +5,18 @@ import { Document } from '../../models/index.js';
 export declare class DocumentService extends Transactional {
     #private;
     readonly repository: import("../../../orm/server/repository.js").EntityRepository<Document>;
-    createDocument({ typeId, title, subtitle, date, summary, tags, approval, comment, createUserId, originalFileName, assignment, properties, metadata }: CreateDocumentParameters, content: Uint8Array | ReadableStream<Uint8Array>): Promise<Document>;
-    updateDocument(id: string, update: Partial<Pick<Document, UpdatableDocumentProperties>> & {
+    create({ typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }: CreateDocumentParameters, content: Uint8Array | ReadableStream<Uint8Array>, { createUserId }: {
+        createUserId?: string;
+    }): Promise<Document>;
+    update(id: string, update: Partial<Pick<Document, UpdatableDocumentProperties>> & {
         properties?: SetDocumentPropertyParameters[];
     }): Promise<void>;
+    getContent(documentOrId: Document | string): Promise<Uint8Array>;
+    getContentStream(documentOrId: Document | string): ReadableStream<Uint8Array>;
+    getContentUrl(documentOrId: Document | string, download?: boolean): Promise<string>;
+    getPreview(documentOrId: Document | string, page?: number): Promise<Uint8Array>;
+    getPreviewStream(documentOrId: Document | string, page?: number): ReadableStream<Uint8Array>;
+    getPreviewUrl(documentOrId: Document | string, page?: number): Promise<string>;
     /**
      * @returns collectionIds from either direct assignment or automatic assignment scope
      */