@tstdl/base 0.92.138 → 0.92.140

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

@@ -1,4 +1,5 @@
 export * from './api/index.js';
+export * from './configure.js';
 export * from './module.js';
 export * as schemas from './schemas.js';
 export * from './services/index.js';

package/document-management/server/index.js

@@ -1,4 +1,5 @@
 export * from './api/index.js';
+export * from './configure.js';
 export * from './module.js';
 export * as schemas from './schemas.js';
 export * from './services/index.js';

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

@@ -1,14 +1,15 @@
 import './schemas.js';
 import { type InjectionToken } from '../../injector/index.js';
 import type { DatabaseConfig } from '../../orm/server/module.js';
-import { DocumentManagementAncillaryService } from './services/document-management-ancillary.service.js';
+import type { DocumentManagementAncillaryService } from './services/document-management-ancillary.service.js';
+import type { DocumentManagementAuthorizationService } from './services/document-management-authorization.service.js';
 export declare class DocumentManagementConfig {
     ancillaryService: InjectionToken<DocumentManagementAncillaryService>;
+    authorizationService: InjectionToken<DocumentManagementAuthorizationService>;
     fileObjectStorageModule: string;
     fileUploadObjectStorageModule: string;
     filePreviewObjectStorageModule: string;
     database?: DatabaseConfig;
     maxFileSize?: number;
 }
-export declare function configureDocumentManagement(config: DocumentManagementConfig): void;
 export declare function migrateDocumentManagementSchema(): Promise<void>;

package/document-management/server/module.js

@@ -1,9 +1,9 @@
 import './schemas.js';
-import { inject, Injector } from '../../injector/index.js';
+import { inject } from '../../injector/index.js';
 import { Database, migrate } from '../../orm/server/database.js';
-import { DocumentManagementAncillaryService } from './services/document-management-ancillary.service.js';
 export class DocumentManagementConfig {
     ancillaryService;
+    authorizationService;
     fileObjectStorageModule;
     fileUploadObjectStorageModule;
     filePreviewObjectStorageModule;
@@ -11,10 +11,6 @@ export class DocumentManagementConfig {
     maxFileSize;
 }
 ;
-export function configureDocumentManagement(config) {
-    Injector.register(DocumentManagementConfig, { useValue: config });
-    Injector.register(DocumentManagementAncillaryService, { useToken: config.ancillaryService });
-}
 export async function migrateDocumentManagementSchema() {
     const connection = inject(DocumentManagementConfig, undefined, { optional: true })?.database?.connection;
     const database = inject(Database, connection);

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

@@ -1,7 +1,6 @@
 import { Transactional } from '../../../orm/server/index.js';
 import { DocumentCategory, DocumentType } from '../../models/index.js';
 import type { DocumentCategoryView } from '../../service-models/index.js';
-export declare const enumTypeKey = "enum-type";
 export declare class DocumentCategoryTypeService extends Transactional {
     #private;
     readonly categoryRepository: import("../../../orm/server/repository.js").EntityRepository<DocumentCategory>;

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

@@ -13,29 +13,29 @@ import { injectRepository } from '../../../orm/server/repository.js';
 import { groupToMap } from '../../../utils/iterable-helpers/group-to-map.js';
 import { isUndefined } from '../../../utils/type-guards.js';
 import { DocumentCategory, DocumentType } from '../../models/index.js';
+import { enumTypeKey } from './enum-type-key.js';
 import { DocumentManagementSingleton } from './singleton.js';
-export const enumTypeKey = 'enum-type';
 let DocumentCategoryTypeService = DocumentCategoryTypeService_1 = class DocumentCategoryTypeService extends Transactional {
     #logger = inject(Logger, DocumentCategoryTypeService_1.name);
     categoryRepository = injectRepository(DocumentCategory);
     typeRepository = injectRepository(DocumentType);
     async loadCategory(id) {
-        return this.categoryRepository.load(id);
+        return await this.categoryRepository.load(id);
     }
     async loadType(id) {
-        return this.typeRepository.load(id);
+        return await this.typeRepository.load(id);
     }
     async createCategory(label, parentId, enumKey) {
-        return this.categoryRepository.insert({ label, parentId, metadata: { attributes: { [enumTypeKey]: enumKey } } });
+        return await this.categoryRepository.insert({ label, parentId, metadata: { attributes: { [enumTypeKey]: enumKey } } });
     }
     async createType(label, categoryId, enumKey) {
-        return this.typeRepository.insert({ label, categoryId, metadata: { attributes: { [enumTypeKey]: enumKey } } });
+        return await this.typeRepository.insert({ label, categoryId, metadata: { attributes: { [enumTypeKey]: enumKey } } });
     }
     async updateCategory(id, update) {
-        return this.categoryRepository.update(id, update);
+        return await this.categoryRepository.update(id, update);
     }
     async updateType(id, update) {
-        return this.typeRepository.update(id, update);
+        return await this.typeRepository.update(id, update);
     }
     async loadCategoryGraph(categoryId) {
         const category = await this.categoryRepository.load(categoryId);

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

@@ -63,7 +63,7 @@ import { match } from 'ts-pattern';
 import { AiService } from '../../../ai/ai.service.js';
 import { ForbiddenError } from '../../../errors/forbidden.error.js';
 import { NotImplementedError } from '../../../errors/not-implemented.error.js';
-import { getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
+import { getMimeType, getMimeTypeExtensions, mimeTypes } from '../../../file/index.js';
 import { TemporaryFile } from '../../../file/server/index.js';
 import { inject } from '../../../injector/inject.js';
 import { Logger } from '../../../logger/logger.js';
@@ -122,7 +122,7 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
             ? await this.#fileUploadObjectStorage.getContent(content.uploadId)
             : (isUint8Array(content) ? content : await readBinaryStream(content));
         const hash = await digest('SHA-256', contentAsUint8Array).toHex();
-        const mimeType = await getMimeType(contentAsUint8Array);
+        const mimeType = await getMimeType(contentAsUint8Array, 'application/octet-stream');
         const metadata = {
             mimeType,
             size: contentAsUint8Array.length,

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

@@ -188,6 +188,7 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
                             {
                                 text: `Extrahiere den Inhalt des Dokuments in das angegebenen JSON Schema.
 
+Vermeide es, den Titel im Untertitel zu wiederholen.
 Gib in der summary ausführlich an, welche Informationen in dem Dokument vorkommen (ohne konkrete Werte).
 Erstelle bis zu 7 möglichst spezifische Tags.
 Antworte auf deutsch.`,
@@ -346,5 +347,8 @@ DocumentManagementAiService = DocumentManagementAiService_1 = __decorate([
 ], DocumentManagementAiService);
 export { DocumentManagementAiService };
 function getDescriptiveTypeLabels(categories, prefix = 'Category: ') {
-    return categories.flatMap((category) => [...category.types.map((type) => ({ id: type.id, label: `${prefix}${category.label} | Type: ${type.label}` }), ...getDescriptiveTypeLabels(category.children, `${prefix}${category.label} -> `))]);
+    return categories.flatMap((category) => [
+        ...category.types.map((type) => ({ id: type.id, label: `${prefix}${category.label} | Type: ${type.label}` })),
+        ...getDescriptiveTypeLabels(category.children, `${prefix}${category.label} -> `),
+    ]);
 }

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

@@ -1,4 +1,4 @@
-import { DocumentCollection, type DocumentWorkflowStep } from '../../models/index.js';
+import { DocumentCollection } from '../../models/index.js';
 export type DocumentCollectionMetadata = {
     /**
      * User-friendly name of the collection
@@ -13,97 +13,16 @@ export type DocumentCollectionMetadata = {
      */
     group: string | null;
 };
-export declare abstract class DocumentManagementAncillaryService<Token = unknown> {
+export declare abstract class DocumentManagementAncillaryService {
     #private;
     resolveMetadata<const T extends (DocumentCollection | string)[]>(...collectionsOrIds: T): Promise<{
         [K in keyof T]: DocumentCollectionMetadata;
     }>;
     resolveMetadataMap(...collectionsOrIds: (DocumentCollection | string)[]): Promise<Record<string, DocumentCollectionMetadata>>;
-    canReadDocument(documentId: string, token?: Token): Promise<boolean>;
-    canManageRequest(requestId: string, token?: Token): Promise<boolean>;
     /**
      * Resolves application-specific metadata for a list of document collections.
      * @param collections An array of DocumentCollection entities.
      * @returns A promise that resolves to an array of DocumentCollectionMetadata, corresponding to the input collections.
      */
     abstract _resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[] | Promise<DocumentCollectionMetadata[]>;
-    /**
-     * Gets the subject from the request token.
-     * @param token The token of the request
-     */
-    abstract getSubject(token?: Token): string | Promise<string>;
-    /**
-     * Checks if a user can read/view a specific document collection and its documents.
-     * @param collectionId The ID of the document collection.
-     * @param token The token of the request
-     */
-    abstract canReadCollection(collectionId: string, token?: Token): boolean | Promise<boolean>;
-    /**
-     * Checks if a user can create new *unassigned* documents (lands in "inbox", which then require assigning to request/collection) in a specific collection.
-     * @param collectionId The ID of the document collection.
-     * @param token The token of the request.
-     */
-    abstract canCreateDocuments(collectionId: string, token?: Token): boolean | Promise<boolean>;
-    abstract canUpdateDocuments(collectionId: string, token?: Token): boolean | Promise<boolean>;
-    abstract canDeleteDocuments(collectionId: string, token?: Token): boolean | Promise<boolean>;
-    /**
-     * Checks if a user can assign documents to requests in the collection or directly to the collection.
-     * @param collectionId The ID of the document collection.
-     * @param token The token of the request.
-     */
-    abstract canAssignDocuments(collectionId: string, token?: Token): boolean | Promise<boolean>;
-    /**
-     * Checks if a user can approve a specific document. This implicitly allows fulfilling document requests by approving their linked document.
-     * This is usually a privileged action for staff members.
-     * @param documentId The ID of the document.
-     * @param token The token of the request
-     * @returns A promise that resolves to true if approval is allowed, false otherwise.
-     */
-    abstract canApproveDocument(documentId: string, token?: Token): boolean | Promise<boolean>;
-    /**
-     * Checks if a user can reject a specific document.
-     * This is usually a privileged action for staff members, often an alternative to approval.
-     * @param documentId The ID of the document.
-     * @param token The token of the request.
-     * @returns A promise that resolves to true if rejection is allowed, false otherwise.
-     */
-    abstract canRejectDocument(documentId: string, token?: Token): boolean | Promise<boolean>;
-    /**
-     * Checks if a user can create, update, delete requests and assign documents to them in a collection.
-     * @param collectionId The ID of the document collection.
-     * @param token The token of the request
-     */
-    abstract canManageRequests(collectionId: string, token?: Token): boolean | Promise<boolean>;
-    /**
-     * Checks if a user can manage document categories, types and their properties (create, update, delete).
-     * Typically an administrator function.
-     * @param token The token of the request.
-     */
-    abstract canManageCategoriesAndTypes(token?: Token): boolean | Promise<boolean>;
-    /**
-     * Checks if a user can read document request templates.
-     * @param token The token of the request.
-     */
-    abstract canReadDocumentRequestsTemplates(token?: Token): boolean | Promise<boolean>;
-    /**
-     * Checks if a user can manage document request templates (create, update, delete).
-     * Typically an administrator function.
-     * @param token The token of the request.
-     */
-    abstract canManageDocumentRequestsTemplates(token?: Token): boolean | Promise<boolean>;
-    /**
-     * Checks if a user can manage document validation definitions and their assignment to types.
-     * Typically an administrator function.
-     * @param token The token of the request.
-     */
-    abstract canManageValidationDefinitions(token?: Token): boolean | Promise<boolean>;
-    /**
-     * Checks if a user can progress a document through its workflow.
-     * This implies reviewing the current step's output, making corrections if necessary,
-     * and then confirming to proceed to the next phase or finalization.
-     * @param documentId The ID of the document.
-     * @param currentWorkflowStep The current step of the workflow the user is interacting with.
-     * @param token The token of the request.
-     */
-    abstract canProgressDocumentWorkflow(documentId: string, currentWorkflowStep: DocumentWorkflowStep, token?: Token): boolean | Promise<boolean>;
 }

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

@@ -1,11 +1,9 @@
 import { injectRepository } from '../../../orm/server/index.js';
 import { fromEntries } from '../../../utils/object/index.js';
 import { assertDefinedPass, isString } from '../../../utils/type-guards.js';
-import { DocumentCollection, DocumentCollectionAssignment, DocumentRequestCollectionAssignment } from '../../models/index.js';
+import { DocumentCollection } from '../../models/index.js';
 export class DocumentManagementAncillaryService {
     #documentCollectionRepository = injectRepository(DocumentCollection);
-    #documentCollectionAssignmentRepository = injectRepository(DocumentCollectionAssignment);
-    #documentRequestCollectionAssignmentRepository = injectRepository(DocumentRequestCollectionAssignment);
     async resolveMetadata(...collectionsOrIds) {
         if (collectionsOrIds.length == 0) {
             return [];
@@ -25,24 +23,4 @@ export class DocumentManagementAncillaryService {
         const entries = collectionsOrIds.map((collectionOrId, index) => [isString(collectionOrId) ? collectionOrId : collectionOrId.id, names[index]]);
         return fromEntries(entries);
     }
-    async canReadDocument(documentId, token) {
-        const assignments = await this.#documentCollectionAssignmentRepository.loadManyByQuery({ documentId });
-        for (const assignment of assignments) {
-            const canReadCollection = await this.canReadCollection(assignment.collectionId, token);
-            if (canReadCollection) {
-                return true;
-            }
-        }
-        return false;
-    }
-    async canManageRequest(requestId, token) {
-        const assignments = await this.#documentRequestCollectionAssignmentRepository.loadManyByQuery({ requestId });
-        for (const assignment of assignments) {
-            const canManageRequest = await this.canManageRequests(assignment.collectionId, token);
-            if (!canManageRequest) {
-                return false;
-            }
-        }
-        return true;
-    }
 }

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

@@ -0,0 +1,85 @@
+import { type DocumentWorkflowStep } from '../../models/index.js';
+export declare abstract class DocumentManagementAuthorizationService<Token = unknown> {
+    #private;
+    canReadDocument(documentId: string, token?: Token): Promise<boolean>;
+    canManageRequest(requestId: string, token?: Token): Promise<boolean>;
+    /**
+     * Gets the subject from the request token.
+     * @param token The token of the request
+     */
+    abstract getSubject(token?: Token): string | Promise<string>;
+    /**
+     * Checks if a user can read/view a specific document collection and its documents.
+     * @param collectionId The ID of the document collection.
+     * @param token The token of the request
+     */
+    abstract canReadCollection(collectionId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can create new *unassigned* documents (lands in "inbox", which then require assigning to request/collection) in a specific collection.
+     * @param collectionId The ID of the document collection.
+     * @param token The token of the request.
+     */
+    abstract canCreateDocuments(collectionId: string, token?: Token): boolean | Promise<boolean>;
+    abstract canUpdateDocuments(collectionId: string, token?: Token): boolean | Promise<boolean>;
+    abstract canDeleteDocuments(collectionId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can assign documents to requests in the collection or directly to the collection.
+     * @param collectionId The ID of the document collection.
+     * @param token The token of the request.
+     */
+    abstract canAssignDocuments(collectionId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can approve a specific document. This implicitly allows fulfilling document requests by approving their linked document.
+     * This is usually a privileged action for staff members.
+     * @param documentId The ID of the document.
+     * @param token The token of the request
+     * @returns A promise that resolves to true if approval is allowed, false otherwise.
+     */
+    abstract canApproveDocument(documentId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can reject a specific document.
+     * This is usually a privileged action for staff members, often an alternative to approval.
+     * @param documentId The ID of the document.
+     * @param token The token of the request.
+     * @returns A promise that resolves to true if rejection is allowed, false otherwise.
+     */
+    abstract canRejectDocument(documentId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can create, update, delete requests and assign documents to them in a collection.
+     * @param collectionId The ID of the document collection.
+     * @param token The token of the request
+     */
+    abstract canManageRequests(collectionId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can manage document categories, types and their properties (create, update, delete).
+     * Typically an administrator function.
+     * @param token The token of the request.
+     */
+    abstract canManageCategoriesAndTypes(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can read document request templates.
+     * @param token The token of the request.
+     */
+    abstract canReadDocumentRequestsTemplates(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can manage document request templates (create, update, delete).
+     * Typically an administrator function.
+     * @param token The token of the request.
+     */
+    abstract canManageDocumentRequestsTemplates(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can manage document validation definitions and their assignment to types.
+     * Typically an administrator function.
+     * @param token The token of the request.
+     */
+    abstract canManageValidationDefinitions(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can progress a document through its workflow.
+     * This implies reviewing the current step's output, making corrections if necessary,
+     * and then confirming to proceed to the next phase or finalization.
+     * @param documentId The ID of the document.
+     * @param currentWorkflowStep The current step of the workflow the user is interacting with.
+     * @param token The token of the request.
+     */
+    abstract canProgressDocumentWorkflow(documentId: string, currentWorkflowStep: DocumentWorkflowStep, token?: Token): boolean | Promise<boolean>;
+}

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

@@ -0,0 +1,28 @@
+import { inject } from '../../../injector/inject.js';
+import { injectRepository } from '../../../orm/server/index.js';
+import { DocumentRequestCollectionAssignment } from '../../models/index.js';
+import { DocumentManagementService } from './document-management.service.js';
+export class DocumentManagementAuthorizationService {
+    #documentManagementService = inject(DocumentManagementService);
+    #documentRequestCollectionAssignmentRepository = injectRepository(DocumentRequestCollectionAssignment);
+    async canReadDocument(documentId, token) {
+        const relevantCollectionIds = await this.#documentManagementService.getRelevantDocumentCollectionIds(documentId);
+        for (const collectionId of relevantCollectionIds) {
+            const canReadCollection = await this.canReadCollection(collectionId, token);
+            if (canReadCollection) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async canManageRequest(requestId, token) {
+        const assignments = await this.#documentRequestCollectionAssignmentRepository.loadManyByQuery({ requestId });
+        for (const assignment of assignments) {
+            const canManageRequest = await this.canManageRequests(assignment.collectionId, token);
+            if (!canManageRequest) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

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

@@ -1,13 +1,21 @@
 import { Transactional } from '../../../orm/server/index.js';
 import type { Record } from '../../../types.js';
-import { DocumentCategory, DocumentType } from '../../models/index.js';
+import { DocumentCategory, DocumentType, type DocumentProperty, type DocumentPropertyDataType } from '../../models/index.js';
 import type { DocumentManagementData, DocumentRequestsTemplateData } from '../../service-models/index.js';
 export declare class DocumentManagementService extends Transactional {
     #private;
+    /**
+     * 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.
+     */
+    getRelevantDocumentCollectionIds(documentId: string): Promise<string[]>;
+    loadDataStream(collectionIds: string[]): ReadableStream<DocumentManagementData>;
     loadData(collectionIds: string[]): Promise<DocumentManagementData>;
     loadDocumentRequestsTemplateData(): Promise<DocumentRequestsTemplateData>;
-    initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string>(categoryLabels: Record<CategoryKey, string>, categoryParents: Record<CategoryKey, CategoryKey | null>, typeLabels: Record<TypeKey, string>, typeCategories: Record<TypeKey, CategoryKey>): Promise<{
+    initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string, DocumentPropertyKey extends string>(categoryLabels: Record<CategoryKey, string>, categoryParents: Record<CategoryKey, CategoryKey | null>, typeLabels: Record<TypeKey, string>, typeCategories: Record<TypeKey, CategoryKey>, propertyKeys: Record<DocumentPropertyKey, [DocumentPropertyDataType, string]>, typeProperties: Record<TypeKey, DocumentPropertyKey[]>): Promise<{
         categories: Record<CategoryKey, DocumentCategory>;
         types: Record<TypeKey, DocumentType>;
+        properties: Record<DocumentPropertyKey, DocumentProperty>;
     }>;
 }

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

@@ -4,6 +4,8 @@ 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';
+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';
@@ -11,13 +13,16 @@ 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 { 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, DocumentValidationExecution, DocumentWorkflowStep } from '../../models/index.js';
-import { DocumentCategoryTypeService, enumTypeKey } from './document-category-type.service.js';
+import { DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentCategory, DocumentCollection, 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 { DocumentPropertyService } from './document-property.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);
@@ -34,8 +39,41 @@ let DocumentManagementService = class DocumentManagementService extends Transact
     #documentRequestsTemplateRepository = injectRepository(DocumentRequestsTemplate);
     #documentRequestTemplateRepository = injectRepository(DocumentRequestTemplate);
     #documentTypeRepository = injectRepository(DocumentType);
+    #documentTypePropertyRepository = injectRepository(DocumentTypeProperty);
     #documentWorkflowService = inject(DocumentWorkflowService);
     #documentValidationExecutionRepository = injectRepository(DocumentValidationExecution);
+    /**
+     * 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
+            .select({ collectionId: documentCollectionAssignment.id })
+            .from(documentCollectionAssignment)
+            .where(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)));
+        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));
+        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 loadData(collectionIds) {
         return await this.transaction(async (tx) => {
             const [collections, collectionsMetadataMap, documentCollectionAssignments, requestAssignments, assignmentScopes, categories, types] = await Promise.all([
@@ -96,7 +134,7 @@ let DocumentManagementService = class DocumentManagementService extends Transact
             });
             const requestViews = requests.map((request) => ({
                 ...request,
-                collectionIds: requestAssignments.filter((requestCollection) => requestCollection.requestId == request.id).map((requestCollection) => requestCollection.collectionId)
+                collectionIds: requestAssignments.filter((requestCollection) => requestCollection.requestId == request.id).map((requestCollection) => requestCollection.collectionId),
             }));
             return {
                 collections: collectionViews,
@@ -120,15 +158,19 @@ let DocumentManagementService = class DocumentManagementService extends Transact
             return { templates };
         });
     }
-    async initializeCategoriesAndTypes(categoryLabels, categoryParents, typeLabels, typeCategories) {
+    async initializeCategoriesAndTypes(categoryLabels, categoryParents, typeLabels, typeCategories, propertyKeys, typeProperties) {
         const categoryEntries = objectEntries(categoryLabels);
         const typeEntries = objectEntries(typeLabels);
-        const { categoryMap, typeMap } = await this.transaction(async (tx) => {
+        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.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}`);
@@ -156,13 +198,34 @@ let DocumentManagementService = class DocumentManagementService extends Transact
                     enumKeyTypeMap.set(key, updatedType);
                 }
             }
-            return { categoryMap: enumKeyCategoryMap, typeMap: enumKeyTypeMap };
+            for (const [key, [dataType, label]] of propertyEntries) {
+                const property = enumKeyPropertyMap.get(key);
+                if (isUndefined(property)) {
+                    const newProperty = await this.#documentPropertyService.withTransaction(tx).createProperty(label, dataType, key);
+                    enumKeyPropertyMap.set(key, newProperty);
+                }
+                else if ((property.label != label) || (property.dataType != dataType)) {
+                    const updatedProperty = await this.#documentPropertyService.withTransaction(tx).updateProperty(property.id, { label, dataType });
+                    enumKeyPropertyMap.set(key, updatedProperty);
+                }
+            }
+            for (const [typeKey, propertyKeys] of objectEntries(typeProperties)) {
+                const type = assertDefinedPass(enumKeyTypeMap.get(typeKey), `Type ${typeKey} not found.`);
+                const newEntities = propertyKeys.map((propertyKey) => ({
+                    typeId: type.id,
+                    propertyId: assertDefinedPass(enumKeyPropertyMap.get(propertyKey), 'Could not get property').id,
+                }));
+                await this.#documentTypePropertyRepository.withTransaction(tx).upsertMany(['typeId', 'propertyId'], newEntities);
+            }
+            return { categoryMap: enumKeyCategoryMap, typeMap: enumKeyTypeMap, propertyMap: enumKeyPropertyMap };
         });
         const mappedCategories = categoryEntries.map(([key]) => [key, assertDefinedPass(categoryMap.get(key), 'Could not map document category.')]);
         const mappedTypes = typeEntries.map(([key]) => [key, assertDefinedPass(typeMap.get(key), 'Could not map document type.')]);
+        const mappedProperties = propertyEntries.map(([key]) => [key, assertDefinedPass(propertyMap.get(key), 'Could not map document property.')]);
         return {
             categories: fromEntries(mappedCategories),
             types: fromEntries(mappedTypes),
+            properties: fromEntries(mappedProperties),
         };
     }
 };

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

@@ -1,10 +1,10 @@
 import { Transactional } from '../../../orm/server/index.js';
 import type { OneOrMany } from '../../../types.js';
-import { Document, DocumentProperty, DocumentPropertyDataType } from '../../models/index.js';
+import { DocumentProperty, DocumentPropertyDataType } from '../../models/index.js';
 import type { DocumentPropertyValueView, SetDocumentPropertyParameters } from '../../service-models/index.js';
 export declare class DocumentPropertyService extends Transactional {
     #private;
-    readonly repository: import("../../../orm/server/repository.js").EntityRepository<Document>;
+    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>;
@@ -44,7 +44,11 @@ export declare class DocumentPropertyService extends Transactional {
         }, {}, {}>;
         value: import("drizzle-orm").SQL.Aliased<string | number | boolean | null>;
     }, "documentProperties">;
-    createProperty(label: string, dataType: DocumentPropertyDataType): Promise<DocumentProperty>;
+    createProperty(label: string, dataType: DocumentPropertyDataType, enumKey?: string): Promise<DocumentProperty>;
+    updateProperty(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>;

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

@@ -11,8 +11,9 @@ 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 { DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentTypeProperty } from '../../models/index.js';
 import { document, documentProperty, documentPropertyValue, documentType, documentTypeProperty } from '../schemas.js';
+import { enumTypeKey } from './enum-type-key.js';
 import { DocumentManagementSingleton } from './singleton.js';
 const documentPropertyValueValidators = {
     [DocumentPropertyDataType.Text]: (value) => isString(value) || isNull(value),
@@ -25,7 +26,7 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
     #documentPropertyRepository = injectRepository(DocumentProperty);
     #documentPropertyValueRepository = injectRepository(DocumentPropertyValue);
     #documentTypePropertyRepository = injectRepository(DocumentTypeProperty);
-    repository = injectRepository(Document).withSession(this.session);
+    repository = injectRepository(DocumentProperty).withSession(this.session);
     documentProperties = this.session.$with('documentProperties').as((qb) => qb
         .select({
         documentId: autoAlias(document.id),
@@ -39,8 +40,11 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
         .innerJoin(documentTypeProperty, eq(documentTypeProperty.typeId, documentType.id))
         .innerJoin(documentProperty, eq(documentProperty.id, documentTypeProperty.propertyId))
         .leftJoin(documentPropertyValue, and(eq(documentPropertyValue.documentId, document.id), eq(documentPropertyValue.propertyId, documentProperty.id))));
-    async createProperty(label, dataType) {
-        return await this.#documentPropertyRepository.insert({ label, dataType });
+    async createProperty(label, dataType, enumKey) {
+        return await this.#documentPropertyRepository.insert({ label, dataType, metadata: { attributes: { [enumTypeKey]: enumKey } } });
+    }
+    async updateProperty(id, update) {
+        return await this.#documentPropertyRepository.update(id, update);
     }
     async assignPropertyToType(typeId, propertyId) {
         await this.#documentTypePropertyRepository.insert({ typeId, propertyId });