@tstdl/base 0.92.137 → 0.92.139

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,20 @@
 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[]>;
     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';
@@ -12,12 +14,14 @@ 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, 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 +38,32 @@ 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);
+    }
     async loadData(collectionIds) {
         return await this.transaction(async (tx) => {
             const [collections, collectionsMetadataMap, documentCollectionAssignments, requestAssignments, assignmentScopes, categories, types] = await Promise.all([
@@ -96,7 +124,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 +148,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 +188,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 });

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

@@ -89,8 +89,8 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
         await this.repository.update(id, { state, failReason });
     }
     async processWorkflowJob(job) {
-        this.#logger.verbose(`Processing workflow job for workflow "${job.data.workflowId}"`);
         const workflow = await this.repository.load(job.data.workflowId);
+        this.#logger.verbose(`Processing workflow "${workflow.step}" for document "${workflow.documentId}"`);
         try {
             await this.setWorkflowState(workflow.id, DocumentWorkflowState.Running);
             await match(workflow.step)
@@ -106,11 +106,11 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
             }
         }
         catch (error) {
-            this.#logger.error(error);
             const isLastTry = job.tries == this.#queue.maxTries;
             if (isLastTry) {
                 await this.repository.update(workflow.id, { state: DocumentWorkflowState.Error });
             }
+            throw error;
         }
     }
     async processClassificationWorkflow(workflow) {

package/document-management/server/services/enum-type-key.d.ts

@@ -0,0 +1 @@
+export declare const enumTypeKey = "enum-type";

package/document-management/server/services/enum-type-key.js

@@ -0,0 +1 @@
+export const enumTypeKey = 'enum-type';

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

@@ -3,6 +3,7 @@ export * from './document-collection.service.js';
 export * from './document-file.service.js';
 export * from './document-management-ai.service.js';
 export * from './document-management-ancillary.service.js';
+export * from './document-management-authorization.service.js';
 export * from './document-management.service.js';
 export * from './document-property.service.js';
 export * from './document-request.service.js';

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

@@ -3,6 +3,7 @@ export * from './document-collection.service.js';
 export * from './document-file.service.js';
 export * from './document-management-ai.service.js';
 export * from './document-management-ancillary.service.js';
+export * from './document-management-authorization.service.js';
 export * from './document-management.service.js';
 export * from './document-property.service.js';
 export * from './document-request.service.js';

package/document-management/service-models/enriched/enriched-document-category.view.d.ts

@@ -6,6 +6,7 @@ export declare class EnrichedDocumentCategory implements Pick<DocumentCategory,
     readonly id: string;
     readonly label: string;
     readonly parent: EnrichedDocumentCategory | null;
+    get rootCategory(): EnrichedDocumentCategory;
     get children(): EnrichedDocumentCategory[];
     get childrenDeep(): EnrichedDocumentCategory[];
     get types(): EnrichedDocumentType[];

package/document-management/service-models/enriched/enriched-document-category.view.js

@@ -14,6 +14,9 @@ export class EnrichedDocumentCategory {
     id;
     label;
     parent;
+    get rootCategory() {
+        return (this.parent?.rootCategory ?? this);
+    }
     get children() {
         return this.#data.rawData.categories.filter((category) => category.parentId == this.id).map((category) => new EnrichedDocumentCategory(this.#data, category, this));
     }
@@ -30,6 +33,11 @@ export class EnrichedDocumentCategory {
         this.parent = parent;
     }
 }
+__decorate([
+    Memoize(),
+    __metadata("design:type", EnrichedDocumentCategory),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCategory.prototype, "rootCategory", null);
 __decorate([
     Memoize(),
     __metadata("design:type", Array),

package/document-management/service-models/enriched/enriched-document.view.d.ts

@@ -1,10 +1,11 @@
+import type { EntityMetadata } from '../../../orm/entity.js';
 import type { TypedOmit } from '../../../types.js';
 import type { DocumentApproval, DocumentValidationExecution, DocumentWorkflow } from '../../models/index.js';
 import type { DocumentPropertyValueView, DocumentView } from '../document-management.view-model.js';
 import { EnrichedDocumentAssignment } from './enriched-document-assignment.view.js';
 import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
 import type { EnrichedDocumentType } from './enriched-document-type.view.js';
-export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId' | 'assignment' | 'createUserId' | 'metadata'> {
+export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId' | 'assignment' | 'createUserId'> {
     #private;
     readonly id: string;
     readonly title: string | null;
@@ -22,6 +23,7 @@ export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId
     readonly properties: DocumentPropertyValueView[];
     readonly currentWorkflow: DocumentWorkflow | null;
     readonly validations: DocumentValidationExecution[] | null;
+    readonly metadata: EntityMetadata;
     get type(): EnrichedDocumentType | null;
     get assignments(): EnrichedDocumentAssignment;
     constructor(data: EnrichedDocumentManagementData, document: DocumentView);

package/document-management/service-models/enriched/enriched-document.view.js

@@ -29,6 +29,7 @@ export class EnrichedDocument {
     properties;
     currentWorkflow;
     validations;
+    metadata;
     get type() {
         if (isNull(this.#documentView.typeId)) {
             return null;
@@ -57,6 +58,7 @@ export class EnrichedDocument {
         this.properties = document.properties;
         this.currentWorkflow = document.currentWorkflow;
         this.validations = document.validations;
+        this.metadata = document.metadata;
     }
 }
 __decorate([