@tstdl/base 0.92.142 → 0.92.144

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

@@ -4,109 +4,125 @@ 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 { eq } from 'drizzle-orm';
+var _a;
+var DocumentManagementService_1;
+import { and, eq } from 'drizzle-orm';
 import { union } from 'drizzle-orm/pg-core';
 import { Enumerable } from '../../../enumerable/index.js';
 import { inject } from '../../../injector/index.js';
-import { Transactional, injectRepository } from '../../../orm/server/index.js';
+import { Logger } from '../../../logger/logger.js';
+import { Transactional, injectRepository, injectTransactional } from '../../../orm/server/index.js';
+import { DeferredPromise } from '../../../promise/deferred-promise.js';
 import { distinct } from '../../../utils/array/index.js';
-import { compareByValueSelectionToOrder } from '../../../utils/comparison.js';
+import { compareByValueSelection } from '../../../utils/comparison.js';
 import { groupToMap, groupToSingleMap } from '../../../utils/iterable-helpers/index.js';
 import { fromEntries, objectEntries } from '../../../utils/object/index.js';
-import { timeout } from '../../../utils/timing.js';
 import { assertDefinedPass, isDefined, isNotNull, isNotNullOrUndefined, isNull, isUndefined } from '../../../utils/type-guards.js';
-import { DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentTypeProperty, DocumentValidationExecution, DocumentWorkflowStep } from '../../models/index.js';
+import { filter, merge } from 'rxjs';
+import { DocumentAssignmentScope, DocumentAssignmentTask, DocumentCategory, DocumentCollectionAssignment, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentTypeProperty, DocumentValidationExecution, DocumentWorkflowStep } from '../../models/index.js';
 import { documentAssignmentScope, documentAssignmentTask, documentCollectionAssignment, documentRequest, documentRequestCollectionAssignment } from '../schemas.js';
 import { DocumentCategoryTypeService } from './document-category-type.service.js';
-import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
+import { DocumentCollectionService } from './document-collection.service.js';
+import { DocumentManagementObservationService } from './document-management-observation.service.js';
 import { DocumentPropertyService } from './document-property.service.js';
+import { DocumentTagService } from './document-tag.service.js';
 import { DocumentWorkflowService } from './document-workflow.service.js';
 import { DocumentService } from './document.service.js';
 import { enumTypeKey } from './enum-type-key.js';
 import { DocumentManagementSingleton } from './singleton.js';
-let DocumentManagementService = class DocumentManagementService extends Transactional {
-    #ancillaryService = inject(DocumentManagementAncillaryService);
-    #documentCategoryTypeService = inject(DocumentCategoryTypeService);
-    #documentCollectionRepository = injectRepository(DocumentCollection);
-    #documentCategoryRepository = injectRepository(DocumentCategory);
+let DocumentManagementService = DocumentManagementService_1 = class DocumentManagementService extends Transactional {
+    #documentCollectionService = injectTransactional(DocumentCollectionService);
+    #documentCategoryTypeService = injectTransactional(DocumentCategoryTypeService);
+    #documentService = injectTransactional(DocumentService);
+    #documentPropertyService = injectTransactional(DocumentPropertyService);
+    #documentWorkflowService = injectTransactional(DocumentWorkflowService);
+    #documentTagService = injectTransactional(DocumentTagService);
     #documentCollectionAssignmentRepository = injectRepository(DocumentCollectionAssignment);
-    #documentService = inject(DocumentService);
-    #documentPropertyService = inject(DocumentPropertyService);
     #documentRequestCollectionAssignmentRepository = injectRepository(DocumentRequestCollectionAssignment);
     #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
     #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
     #documentRequestRepository = injectRepository(DocumentRequest);
     #documentRequestsTemplateRepository = injectRepository(DocumentRequestsTemplate);
     #documentRequestTemplateRepository = injectRepository(DocumentRequestTemplate);
-    #documentTypeRepository = injectRepository(DocumentType);
     #documentTypePropertyRepository = injectRepository(DocumentTypeProperty);
-    #documentWorkflowService = inject(DocumentWorkflowService);
     #documentValidationExecutionRepository = injectRepository(DocumentValidationExecution);
+    #observationService = inject(DocumentManagementObservationService);
+    #logger = inject(Logger, DocumentManagementService_1.name);
     /**
      * Get all relevant document collection IDs for a given document. This includes direct assignments, request assignments, and assignment scopes.
      * This method is used to determine which collections a document is associated with, either directly or through requests and assignments.
      * @param documentId The ID of the document to retrieve collection IDs for.
      */
-    async getRelevantDocumentCollectionIds(documentId) {
-        const directAssignments = this.#documentCollectionRepository.session.$with('directAssignments').as((qb) => qb
+    async getRelevantDocumentCollectionIds(tenantId, documentId) {
+        const directAssignments = this.#documentCollectionService.session.$with('directAssignments').as((qb) => qb
             .select({ collectionId: documentCollectionAssignment.id })
             .from(documentCollectionAssignment)
-            .where(eq(documentCollectionAssignment.documentId, documentId)));
+            .where(and(eq(documentCollectionAssignment.tenantId, tenantId), eq(documentCollectionAssignment.documentId, documentId))));
         const requestAssignments = this.#documentRequestCollectionAssignmentRepository.session.$with('requestAssignments').as((qb) => qb
             .select({ collectionId: documentRequestCollectionAssignment.collectionId })
             .from(documentRequest)
             .innerJoin(documentRequestCollectionAssignment, eq(documentRequestCollectionAssignment.requestId, documentRequest.id))
-            .where(eq(documentRequest.documentId, documentId)));
+            .where(and(eq(documentRequest.tenantId, tenantId), eq(documentRequest.documentId, documentId))));
         const assignmentScopes = this.#documentAssignmentScopeRepository.session.$with('assignmentScopes').as((qb) => qb
             .select({ collectionId: documentAssignmentScope.collectionId })
             .from(documentAssignmentTask)
             .innerJoin(documentAssignmentScope, eq(documentAssignmentScope.taskId, documentAssignmentTask.id))
-            .where(eq(documentAssignmentTask.documentId, documentId)));
-        const result = await union(this.#documentService.session.with(directAssignments).selectDistinct().from(directAssignments), this.#documentService.session.with(requestAssignments).selectDistinct().from(requestAssignments), this.#documentService.session.with(assignmentScopes).selectDistinct().from(assignmentScopes));
+            .where(and(eq(documentAssignmentTask.tenantId, tenantId), eq(documentAssignmentTask.documentId, documentId))));
+        const result = await union(this.#documentService.session.with(directAssignments).select().from(directAssignments), this.#documentService.session.with(requestAssignments).select().from(requestAssignments), this.#documentService.session.with(assignmentScopes).select().from(assignmentScopes));
         return result.map((row) => row.collectionId);
     }
-    loadDataStream(collectionIds) {
-        return new ReadableStream({
-            pull: async (controller) => {
-                const data = await this.loadData(collectionIds);
-                controller.enqueue(data);
-                await timeout(1000);
-            },
-        });
+    async *loadDataStream(tenantId, collectionIds, cancellationSignal) {
+        const continuePromise = new DeferredPromise();
+        const newData$ = this.#observationService.collectionsChangedMessageBus.allMessages$.pipe(filter((changedCollectionIds) => collectionIds.some((id) => changedCollectionIds.includes(id))));
+        const subscription = merge(newData$, cancellationSignal).subscribe(() => continuePromise.resolveIfPending());
+        try {
+            while (cancellationSignal.isUnset) {
+                yield await this.loadData(tenantId, collectionIds);
+                await continuePromise;
+                continuePromise.reset();
+            }
+        }
+        finally {
+            subscription.unsubscribe();
+        }
     }
-    async loadData(collectionIds) {
+    async loadData(tenantId, collectionIds) {
         return await this.transaction(async (tx) => {
-            const [collections, collectionsMetadataMap, documentCollectionAssignments, requestAssignments, assignmentScopes, categories, types] = await Promise.all([
-                this.#documentCollectionRepository.withTransaction(tx).loadMany(collectionIds),
-                this.#ancillaryService.resolveMetadataMap(...collectionIds),
-                this.#documentCollectionAssignmentRepository.withTransaction(tx).loadManyByQuery({ collectionId: { $in: collectionIds } }),
-                this.#documentRequestCollectionAssignmentRepository.withTransaction(tx).loadManyByQuery({ collectionId: { $in: collectionIds } }),
-                this.#documentAssignmentScopeRepository.withTransaction(tx).loadManyByQuery({ collectionId: { $in: collectionIds } }),
-                this.#documentCategoryRepository.withTransaction(tx).loadManyByQuery({}, { order: 'label' }),
-                this.#documentTypeRepository.withTransaction(tx).loadManyByQuery({}, { order: 'label' }),
+            const [collections, documentCollectionAssignments, requestAssignments, assignmentScopes, { categories, types }] = await Promise.all([
+                this.#documentCollectionService.repository.withTransaction(tx).loadManyByQuery({ tenantId, id: { $in: collectionIds } }),
+                this.#documentCollectionAssignmentRepository.withTransaction(tx).loadManyByQuery({ tenantId, collectionId: { $in: collectionIds } }),
+                this.#documentRequestCollectionAssignmentRepository.withTransaction(tx).loadManyByQuery({ tenantId, collectionId: { $in: collectionIds } }),
+                this.#documentAssignmentScopeRepository.withTransaction(tx).loadManyByQuery({ tenantId, collectionId: { $in: collectionIds } }),
+                this.#documentCategoryTypeService.withTransaction(tx).loadCategoriesAndTypes(tenantId),
             ]);
+            const collectionsMetadataMap = await this.#documentCollectionService.withTransaction(tx).resolveMetadataMap(tenantId, collections);
             const requestIds = requestAssignments.map((requestCollection) => requestCollection.requestId);
             const taskIds = assignmentScopes.map((scope) => scope.taskId);
             const [requests, assignmentTasks] = await Promise.all([
-                this.#documentRequestRepository.withTransaction(tx).loadManyByQuery({ id: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
-                this.#documentAssignmentTaskRepository.withTransaction(tx).loadMany(taskIds),
+                this.#documentRequestRepository.withTransaction(tx).loadManyByQuery({ tenantId, id: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
+                this.#documentAssignmentTaskRepository.withTransaction(tx).loadManyByQuery({ tenantId, ids: { $in: taskIds } }),
             ]);
             const assignmentDocumentIds = documentCollectionAssignments.map((assignment) => assignment.documentId);
             const requestDocumentIds = requests.map((request) => request.documentId).filter(isNotNull);
             const assignmentTaskDocumentIds = assignmentTasks.map((task) => task.documentId);
             const documentIds = distinct([...assignmentDocumentIds, ...requestDocumentIds, ...assignmentTaskDocumentIds]);
-            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),
+            const [documents, propertyViews, propertyValues, workflows] = await Promise.all([
+                this.#documentService.repository.withTransaction(tx).loadManyByQuery({ tenantId, id: { $in: documentIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
+                this.#documentPropertyService.withTransaction(tx).loadViews(tenantId),
+                this.#documentPropertyService.withTransaction(tx).loadDocumentPropertyValues(tenantId, documentIds),
+                this.#documentWorkflowService.withTransaction(tx).loadWorkflows(tenantId, documentIds),
             ]);
-            const workflowRelevantDocumentIds = documents.map((document) => (document.approval == DocumentApproval.Pending) ? document.id : null).filter(isNotNull);
-            const currentWorkflows = await this.#documentWorkflowService.loadLatestWorkflows(workflowRelevantDocumentIds);
-            const documentWorkflowMap = groupToSingleMap(currentWorkflows, (workflow) => workflow.documentId);
+            const documentTagAssignments = await this.#documentTagService.tagAssignmentRepository.withTransaction(tx).loadManyByQuery({ tenantId, documentId: { $in: documentIds } });
+            const tags = await this.#documentTagService.withTransaction(tx).loadTags(tenantId);
+            const documentTagsMap = groupToMap(documentTagAssignments, (assignment) => assignment.documentId);
+            const documentWorkflowsMap = groupToMap(workflows, (workflow) => workflow.documentId);
             const valuesMap = Enumerable.from(propertyValues).groupToMap((value) => value.documentId);
-            const validationWorkflowIds = currentWorkflows.map((workflow) => (workflow.step == DocumentWorkflowStep.Validation) ? workflow.id : null).filter(isNotNull);
-            const validations = await this.#documentValidationExecutionRepository.loadManyByQuery({ workflowId: { $in: validationWorkflowIds } });
-            const workflowValidationMap = groupToMap(validations, (validation) => validation.workflowId);
-            const collectionViews = collections.toSorted(compareByValueSelectionToOrder(collectionIds, (collection) => collection.id)).map((collection) => {
+            const validationWorkflowIds = workflows.map((workflow) => (workflow.step == DocumentWorkflowStep.Validation) ? workflow.id : null).filter(isNotNull);
+            const validations = await this.#documentValidationExecutionRepository.withTransaction(tx).loadManyByQuery({ tenantId, workflowId: { $in: validationWorkflowIds } });
+            const workflowValidationsMap = groupToMap(validations, (validation) => validation.workflowId);
+            const collectionViews = collections
+                .toSorted(compareByValueSelection((collection) => collectionIds.indexOf(collection.id)))
+                .map((collection) => {
                 const metadata = assertDefinedPass(collectionsMetadataMap[collection.id]);
                 return ({
                     ...collection,
@@ -115,21 +131,22 @@ let DocumentManagementService = class DocumentManagementService extends Transact
                 });
             });
             const documentViews = documents.map((document) => {
-                const currentWorkflow = documentWorkflowMap.get(document.id) ?? null;
-                const validations = (isNotNull(currentWorkflow) && (currentWorkflow.step == DocumentWorkflowStep.Validation)) ? workflowValidationMap.get(currentWorkflow.id) ?? [] : null;
-                const assignmentTask = assignmentTasks.find((task) => task.documentId == document.id);
-                const assignmentTaskScope = isDefined(assignmentTask) ? assignmentScopes.filter((scope) => scope.taskId == assignmentTask.id).map((scope) => scope.collectionId) : [];
+                const documentWorkflows = documentWorkflowsMap.get(document.id) ?? [];
+                const documentValidations = documentWorkflows.flatMap((workflow) => workflowValidationsMap.get(workflow.id) ?? []);
+                const documentAssignmentTask = assignmentTasks.find((task) => task.documentId == document.id);
+                const documentAssignmentTaskScope = isDefined(documentAssignmentTask) ? assignmentScopes.filter((scope) => scope.taskId == documentAssignmentTask.id).map((scope) => scope.collectionId) : [];
                 return {
                     ...document,
                     assignment: {
                         collections: documentCollectionAssignments.filter((collectionDocument) => collectionDocument.documentId == document.id),
-                        assignmentTask: isDefined(assignmentTask)
-                            ? { target: assignmentTask.target, scope: assignmentTaskScope }
+                        assignmentTask: isDefined(documentAssignmentTask)
+                            ? { target: documentAssignmentTask.target, scope: documentAssignmentTaskScope }
                             : null,
                     },
+                    tagIds: documentTagsMap.get(document.id)?.map((assignment) => assignment.tagId) ?? [],
                     properties: valuesMap.get(document.id) ?? [],
-                    currentWorkflow,
-                    validations,
+                    workflows: documentWorkflows,
+                    validations: documentValidations,
                 };
             });
             const requestViews = requests.map((request) => ({
@@ -142,14 +159,16 @@ let DocumentManagementService = class DocumentManagementService extends Transact
                 requests: requestViews,
                 categories,
                 types,
+                tags,
+                properties: propertyViews,
             };
         });
     }
-    async loadDocumentRequestsTemplateData() {
+    async loadDocumentRequestsTemplateData(tenantId) {
         return await this.transaction(async (tx) => {
             const [requestsTemplates, requestTemplates] = await Promise.all([
-                this.#documentRequestsTemplateRepository.withTransaction(tx).loadManyByQuery({}, { order: 'label' }),
-                this.#documentRequestTemplateRepository.withTransaction(tx).loadManyByQuery({}),
+                this.#documentRequestsTemplateRepository.withTransaction(tx).loadManyByQuery({ tenantId }, { order: 'label' }),
+                this.#documentRequestTemplateRepository.withTransaction(tx).loadManyByQuery({ tenantId }),
             ]);
             const templates = requestsTemplates.map((requestsTemplate) => ({
                 ...requestsTemplate,
@@ -158,64 +177,71 @@ let DocumentManagementService = class DocumentManagementService extends Transact
             return { templates };
         });
     }
-    async initializeCategoriesAndTypes(categoryLabels, categoryParents, typeLabels, typeCategories, propertyKeys, typeProperties) {
+    async initializeCategoriesAndTypes(tenantId, categoryLabels, categoryParents, typeLabels, typeCategories, propertyKeys, typeProperties) {
         const categoryEntries = objectEntries(categoryLabels);
         const typeEntries = objectEntries(typeLabels);
         const propertyEntries = objectEntries(propertyKeys);
         const { categoryMap, typeMap, propertyMap } = await this.transaction(async (tx) => {
-            const { categories: dbCategories, types: dbTypes } = await this.#documentCategoryTypeService.withTransaction(tx).loadCategoriesAndTypes();
-            const dbProperties = await this.#documentPropertyService.withTransaction(tx).repository.loadAll();
+            const { categories: dbCategories, types: dbTypes } = await this.#documentCategoryTypeService.withTransaction(tx).loadCategoriesAndTypes(tenantId);
+            const dbProperties = await this.#documentPropertyService.withTransaction(tx).repository.loadManyByQuery({ tenantId });
             const categories = dbCategories.filter((category) => isNotNullOrUndefined(category.metadata.attributes[enumTypeKey]));
             const types = dbTypes.filter((type) => isNotNullOrUndefined(type.metadata.attributes[enumTypeKey]));
             const properties = dbProperties.filter((property) => isNotNullOrUndefined(property.metadata.attributes[enumTypeKey]));
             const enumKeyCategoryMap = groupToSingleMap(categories, (category) => category.metadata.attributes[enumTypeKey]);
             const enumKeyTypeMap = groupToSingleMap(types, (type) => type.metadata.attributes[enumTypeKey]);
             const enumKeyPropertyMap = groupToSingleMap(properties, (property) => property.metadata.attributes[enumTypeKey]);
-            for (const [key, label] of categoryEntries) {
-                const category = enumKeyCategoryMap.get(key);
-                const parentKey = assertDefinedPass(categoryParents[key], `Parent category not defined for ${key}`);
+            for (const [enumKey, label] of categoryEntries) {
+                const category = enumKeyCategoryMap.get(enumKey);
+                const parentKey = assertDefinedPass(categoryParents[enumKey], `Parent category not defined for ${enumKey}`);
                 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, parentCategoryId, key);
-                    enumKeyCategoryMap.set(key, category);
+                    const category = await this.#documentCategoryTypeService.withTransaction(tx).createCategory({ tenantId, label, parentId: parentCategoryId, enumKey });
+                    enumKeyCategoryMap.set(enumKey, category);
+                    this.#logger.info(`Created category ${category.label}`);
                 }
                 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);
+                    const updatedCategory = await this.#documentCategoryTypeService.withTransaction(tx).updateCategory(tenantId, category.id, { label, parentId: parentCategoryId });
+                    enumKeyCategoryMap.set(enumKey, updatedCategory);
+                    this.#logger.info(`Updated category ${updatedCategory.label}`);
                 }
             }
-            for (const [key, label] of typeEntries) {
-                const type = enumKeyTypeMap.get(key);
-                const enumCategory = typeCategories[key];
+            for (const [enumKey, label] of typeEntries) {
+                const type = enumKeyTypeMap.get(enumKey);
+                const enumCategory = typeCategories[enumKey];
                 const category = assertDefinedPass(enumKeyCategoryMap.get(enumCategory));
                 if (isUndefined(type)) {
-                    const type = await this.#documentCategoryTypeService.withTransaction(tx).createType(label, category.id, key);
-                    enumKeyTypeMap.set(key, type);
+                    const type = await this.#documentCategoryTypeService.withTransaction(tx).createType({ tenantId, label, categoryId: category.id, enumKey });
+                    enumKeyTypeMap.set(enumKey, type);
+                    this.#logger.info(`Created type ${type.label} in category ${category.label}`);
                 }
                 else if ((type.categoryId != category.id) || (type.label != label)) {
-                    const updatedType = await this.#documentCategoryTypeService.withTransaction(tx).updateType(type.id, { categoryId: category.id, label: label });
-                    enumKeyTypeMap.set(key, updatedType);
+                    const updatedType = await this.#documentCategoryTypeService.withTransaction(tx).updateType(tenantId, type.id, { categoryId: category.id, label: label });
+                    enumKeyTypeMap.set(enumKey, updatedType);
+                    this.#logger.info(`Updated type ${updatedType.label} in category ${category.label}`);
                 }
             }
-            for (const [key, [dataType, label]] of propertyEntries) {
-                const property = enumKeyPropertyMap.get(key);
+            for (const [enumKey, [dataType, label]] of propertyEntries) {
+                const property = enumKeyPropertyMap.get(enumKey);
                 if (isUndefined(property)) {
-                    const newProperty = await this.#documentPropertyService.withTransaction(tx).createProperty(label, dataType, key);
-                    enumKeyPropertyMap.set(key, newProperty);
+                    const newProperty = await this.#documentPropertyService.withTransaction(tx).createProperty({ tenantId, label, dataType, enumKey });
+                    enumKeyPropertyMap.set(enumKey, newProperty);
+                    this.#logger.info(`Created property ${newProperty.label} of type ${dataType}`);
                 }
                 else if ((property.label != label) || (property.dataType != dataType)) {
-                    const updatedProperty = await this.#documentPropertyService.withTransaction(tx).updateProperty(property.id, { label, dataType });
-                    enumKeyPropertyMap.set(key, updatedProperty);
+                    const updatedProperty = await this.#documentPropertyService.withTransaction(tx).updateProperty(tenantId, property.id, { label, dataType });
+                    enumKeyPropertyMap.set(enumKey, updatedProperty);
+                    this.#logger.info(`Updated property ${updatedProperty.label} of type ${updatedProperty.dataType}`);
                 }
             }
             for (const [typeKey, propertyKeys] of objectEntries(typeProperties)) {
                 const type = assertDefinedPass(enumKeyTypeMap.get(typeKey), `Type ${typeKey} not found.`);
                 const newEntities = propertyKeys.map((propertyKey) => ({
+                    tenantId,
                     typeId: type.id,
                     propertyId: assertDefinedPass(enumKeyPropertyMap.get(propertyKey), 'Could not get property').id,
                 }));
-                await this.#documentTypePropertyRepository.withTransaction(tx).upsertMany(['typeId', 'propertyId'], newEntities);
+                await this.#documentTypePropertyRepository.withTransaction(tx).upsertMany(['tenantId', 'typeId', 'propertyId'], newEntities);
             }
             return { categoryMap: enumKeyCategoryMap, typeMap: enumKeyTypeMap, propertyMap: enumKeyPropertyMap };
         });
@@ -229,7 +255,7 @@ let DocumentManagementService = class DocumentManagementService extends Transact
         };
     }
 };
-DocumentManagementService = __decorate([
+DocumentManagementService = DocumentManagementService_1 = __decorate([
     DocumentManagementSingleton()
 ], DocumentManagementService);
 export { DocumentManagementService };

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

@@ -1,13 +1,15 @@
 import { Transactional } from '../../../orm/server/index.js';
 import type { OneOrMany } from '../../../types.js';
-import { DocumentProperty, DocumentPropertyDataType } from '../../models/index.js';
-import type { DocumentPropertyValueView, SetDocumentPropertyParameters } from '../../service-models/index.js';
+import { DocumentProperty, DocumentPropertyDataType, type Document } from '../../models/index.js';
+import type { DocumentPropertyValueView, DocumentPropertyView, SetDocumentPropertyParameters } from '../../service-models/index.js';
 export declare class DocumentPropertyService extends Transactional {
     #private;
     readonly repository: import("../../../orm/server/repository.js").EntityRepository<DocumentProperty>;
     readonly documentProperties: import("drizzle-orm/pg-core").WithSubqueryWithSelection<{
         documentId: import("drizzle-orm").SQL.Aliased<string>;
         propertyId: import("drizzle-orm").SQL.Aliased<string>;
+        documentTenantId: import("drizzle-orm").SQL.Aliased<string>;
+        propertyTenantId: import("drizzle-orm").SQL.Aliased<string>;
         label: import("drizzle-orm/pg-core").PgColumn<{
             name: "label";
             tableName: "document_property";
@@ -44,12 +46,18 @@ export declare class DocumentPropertyService extends Transactional {
         }, {}, {}>;
         value: import("drizzle-orm").SQL.Aliased<string | number | boolean | null>;
     }, "documentProperties">;
-    createProperty(label: string, dataType: DocumentPropertyDataType, enumKey?: string): Promise<DocumentProperty>;
-    updateProperty(id: string, update: {
+    loadViews(tenantId: string | null): Promise<DocumentPropertyView[]>;
+    createProperty(data: {
+        tenantId: string | null;
+        label: string;
+        dataType: DocumentPropertyDataType;
+        enumKey?: string;
+    }): Promise<DocumentProperty>;
+    updateProperty(tenantId: string | null, id: string, update: {
         label?: string;
         dataType?: DocumentPropertyDataType;
     }): Promise<DocumentProperty>;
-    assignPropertyToType(typeId: string, propertyId: string): Promise<void>;
-    loadDocumentProperties(documentId: OneOrMany<string>, includeNulls?: boolean): Promise<DocumentPropertyValueView[]>;
-    setPropertyValues(documentId: string, propertyValues: SetDocumentPropertyParameters[]): Promise<void>;
+    assignPropertyToType(tenantId: string | null, typeId: string, propertyId: string): Promise<void>;
+    loadDocumentPropertyValues(tenantId: string, documentId: OneOrMany<string>, includeNulls?: boolean): Promise<DocumentPropertyValueView[]>;
+    setPropertyValues(document: Document, propertyValues: SetDocumentPropertyParameters[]): Promise<void>;
 }

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

@@ -4,15 +4,18 @@ 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 { and, isNotNull as drizzleIsNotNull, eq, inArray } from 'drizzle-orm';
+import { and, isNotNull as drizzleIsNotNull, isNull as drizzleIsNull, eq, inArray, or } from 'drizzle-orm';
 import { BadRequestError } from '../../../errors/bad-request.error.js';
+import { NotFoundError } from '../../../errors/not-found.error.js';
+import { inject } from '../../../injector/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 { assertBooleanPass, assertNumberPass, assertStringPass, isBoolean, isNotNull, isNull, isNumber, isString, isUndefined } from '../../../utils/type-guards.js';
 import { DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentTypeProperty } from '../../models/index.js';
 import { document, documentProperty, documentPropertyValue, documentType, documentTypeProperty } from '../schemas.js';
+import { DocumentManagementObservationService } from './document-management-observation.service.js';
 import { enumTypeKey } from './enum-type-key.js';
 import { DocumentManagementSingleton } from './singleton.js';
 const documentPropertyValueValidators = {
@@ -26,30 +29,54 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
     #documentPropertyRepository = injectRepository(DocumentProperty);
     #documentPropertyValueRepository = injectRepository(DocumentPropertyValue);
     #documentTypePropertyRepository = injectRepository(DocumentTypeProperty);
-    repository = injectRepository(DocumentProperty).withSession(this.session);
+    #observationService = inject(DocumentManagementObservationService);
+    repository = injectRepository(DocumentProperty);
     documentProperties = this.session.$with('documentProperties').as((qb) => qb
         .select({
         documentId: autoAlias(document.id),
         propertyId: autoAlias(documentProperty.id),
+        documentTenantId: autoAlias(document.tenantId),
+        propertyTenantId: autoAlias(documentProperty.tenantId),
         label: documentProperty.label,
         dataType: documentProperty.dataType,
         value: coalesce(toJsonb(documentPropertyValue.text), toJsonb(documentPropertyValue.integer), toJsonb(documentPropertyValue.decimal), toJsonb(documentPropertyValue.boolean), toJsonb(documentPropertyValue.date)).as('value'),
     })
         .from(document)
-        .innerJoin(documentType, eq(documentType.id, document.typeId))
-        .innerJoin(documentTypeProperty, eq(documentTypeProperty.typeId, documentType.id))
-        .innerJoin(documentProperty, eq(documentProperty.id, documentTypeProperty.propertyId))
-        .leftJoin(documentPropertyValue, and(eq(documentPropertyValue.documentId, document.id), eq(documentPropertyValue.propertyId, documentProperty.id))));
-    async createProperty(label, dataType, enumKey) {
-        return await this.#documentPropertyRepository.insert({ label, dataType, metadata: { attributes: { [enumTypeKey]: enumKey } } });
+        .innerJoin(documentType, and(eq(documentType.id, document.typeId), or(drizzleIsNull(documentType.tenantId), eq(documentType.tenantId, document.tenantId))))
+        .innerJoin(documentTypeProperty, and(eq(documentTypeProperty.typeId, documentType.id), or(drizzleIsNull(documentTypeProperty.tenantId), eq(documentTypeProperty.tenantId, document.tenantId))))
+        .innerJoin(documentProperty, and(eq(documentProperty.id, documentTypeProperty.propertyId), or(drizzleIsNull(documentProperty.tenantId), eq(documentProperty.tenantId, document.tenantId))))
+        .leftJoin(documentPropertyValue, and(eq(documentPropertyValue.tenantId, document.tenantId), eq(documentPropertyValue.documentId, document.id), eq(documentPropertyValue.propertyId, documentProperty.id))));
+    async loadViews(tenantId) {
+        const properties = await this.#documentPropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } });
+        const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } });
+        return properties.map((property) => {
+            const typeIds = typeProperties
+                .filter((typeProperty) => typeProperty.propertyId == property.id)
+                .map((typeProperty) => typeProperty.typeId);
+            return {
+                id: property.id,
+                tenantId: property.tenantId,
+                label: property.label,
+                dataType: property.dataType,
+                typeIds,
+            };
+        });
+    }
+    async createProperty(data) {
+        return await this.#documentPropertyRepository.insert({
+            tenantId: data.tenantId,
+            label: data.label,
+            dataType: data.dataType,
+            metadata: { attributes: { [enumTypeKey]: data.enumKey } },
+        });
     }
-    async updateProperty(id, update) {
-        return await this.#documentPropertyRepository.update(id, update);
+    async updateProperty(tenantId, id, update) {
+        return await this.#documentPropertyRepository.updateByQuery({ tenantId, id }, update);
     }
-    async assignPropertyToType(typeId, propertyId) {
-        await this.#documentTypePropertyRepository.insert({ typeId, propertyId });
+    async assignPropertyToType(tenantId, typeId, propertyId) {
+        await this.#documentTypePropertyRepository.insert({ tenantId, typeId, propertyId });
     }
-    async loadDocumentProperties(documentId, includeNulls = false) {
+    async loadDocumentPropertyValues(tenantId, documentId, includeNulls = false) {
         return await this.session
             .with(this.documentProperties)
             .select({
@@ -60,21 +87,25 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
             value: this.documentProperties.value,
         })
             .from(this.documentProperties)
-            .where(and(inArray(this.documentProperties.documentId, toArray(documentId)), includeNulls ? undefined : drizzleIsNotNull(this.documentProperties.value)));
+            .where(and(eq(this.documentProperties.documentTenantId, tenantId), inArray(this.documentProperties.documentId, toArray(documentId)), inArray(this.documentProperties.propertyTenantId, [null, tenantId]), includeNulls ? undefined : drizzleIsNotNull(this.documentProperties.value)));
     }
-    async setPropertyValues(documentId, propertyValues) {
+    async setPropertyValues(document, propertyValues) {
         if ((propertyValues.length == 0)) {
             return;
         }
         await this.transaction(async (tx) => {
             const propertyIds = propertyValues.map((property) => property.propertyId);
-            const properties = await this.#documentPropertyRepository.withTransaction(tx).loadManyByQuery({ id: { $in: propertyIds } });
+            const properties = await this.#documentPropertyRepository.withTransaction(tx).loadManyByQuery({ tenantId: { $or: [null, document.tenantId] }, id: { $in: propertyIds } });
             const propertiesMap = getEntityMap(properties);
             const upserts = propertyValues.filter((value) => isNotNull(value.value)).map(({ propertyId, value, metadata }) => {
-                const property = assertDefinedPass(propertiesMap.get(propertyId));
+                const property = propertiesMap.get(propertyId);
+                if (isUndefined(property)) {
+                    throw new NotFoundError(`Property "${propertyId}" not found.`);
+                }
                 validatePropertyValue(propertyId, property.dataType, value);
                 return {
-                    documentId,
+                    tenantId: document.tenantId,
+                    documentId: document.id,
                     propertyId,
                     text: (property.dataType == 'text') ? assertStringPass(value) : null,
                     integer: (property.dataType == 'integer') ? assertNumberPass(value) : null,
@@ -85,8 +116,9 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
                 };
             });
             const deletePropertyIds = propertyValues.filter((value) => isNull(value.value)).map(({ propertyId }) => propertyId);
-            await this.#documentPropertyValueRepository.withTransaction(tx).hardDeleteManyByQuery({ documentId, propertyId: { $in: deletePropertyIds } });
+            await this.#documentPropertyValueRepository.withTransaction(tx).hardDeleteManyByQuery({ tenantId: document.tenantId, documentId: document.id, propertyId: { $in: deletePropertyIds } });
             await this.#documentPropertyValueRepository.withTransaction(tx).upsertMany(['documentId', 'propertyId'], upserts);
+            this.#observationService.documentChange(document.id, tx);
         });
     }
 };

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

@@ -1,30 +1,19 @@
 import type { RequestStats } from '../../../document-management/service-models/index.js';
 import { Transactional } from '../../../orm/server/index.js';
 import type { OneOrMany } from '../../../types.js';
-import { DocumentRequest, DocumentRequestTemplate, DocumentRequestsTemplate } from '../../models/index.js';
+import { DocumentRequest, DocumentRequestTemplate, DocumentRequestsTemplate, type Document } from '../../models/index.js';
 export declare class DocumentRequestService extends Transactional {
     #private;
-    getRequestStats(collectionIds: OneOrMany<string>): Promise<RequestStats>;
-    createRequestsTemplate(parameters: Pick<DocumentRequestsTemplate, 'label' | 'description'>): Promise<DocumentRequestsTemplate>;
-    updateRequestsTemplate(id: string, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description' | 'metadata'>): Promise<DocumentRequestsTemplate>;
-    applyRequestsTemplate(id: string, collectionIds: string[]): Promise<void>;
-    deleteRequestsTemplate(id: string): Promise<DocumentRequestsTemplate>;
-    createRequestTemplate(requestsTemplateId: string, typeId: string, comment: string): Promise<DocumentRequestTemplate>;
-    updateRequestTemplate(id: string, parameters: Pick<DocumentRequestTemplate, 'typeId' | 'comment'>): Promise<DocumentRequestTemplate>;
-    deleteRequestTemplate(id: string): Promise<DocumentRequestTemplate>;
-    createRequest(typeId: string, collectionIds: string[], comment: string | null): Promise<DocumentRequest>;
-    updateRequest(id: string, update: Partial<Pick<DocumentRequest, 'typeId' | 'comment'>>): Promise<void>;
-    deleteRequest(id: string): Promise<void>;
-    assignDocument(requestId: string, documentId: string): Promise<void>;
-    /**
-     * Fulfills a document request.
-     * Marks the request as fulfilled and creates associations between the document
-     * and the target collections defined in the request.
-     *
-     * @param requestId The ID of the DocumentRequest to fulfill.
-     * @param documentId The ID of the Document fulfilling the request.
-     * @param userId The ID of the user performing the action (for audit purposes).
-     * @throws NotFoundError if the DocumentRequest with the given ID does not exist.
-     */
-    fulfillRequest(requestId: string, documentId: string): Promise<void>;
+    getRequestStats(tenantId: string, collectionIds: OneOrMany<string>): Promise<RequestStats>;
+    createRequestsTemplate(tenantId: string | null, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description'>): Promise<DocumentRequestsTemplate>;
+    updateRequestsTemplate(tenantId: string | null, id: string, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description' | 'metadata'>): Promise<DocumentRequestsTemplate>;
+    applyRequestsTemplate(tenantId: string, id: string, collectionIds: string[]): Promise<void>;
+    deleteRequestsTemplate(tenantId: string, id: string): Promise<DocumentRequestsTemplate>;
+    createRequestTemplate(tenantId: string, requestsTemplateId: string, typeId: string, comment: string): Promise<DocumentRequestTemplate>;
+    updateRequestTemplate(tenantId: string, id: string, parameters: Pick<DocumentRequestTemplate, 'typeId' | 'comment'>): Promise<DocumentRequestTemplate>;
+    deleteRequestTemplate(tenantId: string, id: string): Promise<DocumentRequestTemplate>;
+    createRequest(tenantId: string, typeId: string, collectionIds: string[], comment: string | null): Promise<DocumentRequest>;
+    updateRequest(tenantId: string, id: string, update: Partial<Pick<DocumentRequest, 'typeId' | 'comment'>>): Promise<void>;
+    deleteRequest(tenantId: string, id: string): Promise<void>;
+    assignDocument(document: Document, requestId: string): Promise<void>;
 }