@tstdl/base 0.93.95 → 0.93.97

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

@@ -18,7 +18,7 @@ import { distinct } from '../../../utils/array/index.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 { assertDefinedPass, isDefined, isNotNull, isNotNullOrUndefined, isNull, isUndefined } from '../../../utils/type-guards.js';
+import { assertDefinedPass, isDefined, isNotNull, isNull, isUndefined } from '../../../utils/type-guards.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';
@@ -29,7 +29,6 @@ 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 = DocumentManagementService_1 = class DocumentManagementService extends Transactional {
     #documentCollectionService = injectTransactional(DocumentCollectionService);
@@ -92,7 +91,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             throw new BadRequestError('At least one collection ID must be provided to load document management data.');
         }
         return await this.transaction(async (tx) => {
-            const [collections, documentCollectionAssignments, requestAssignments, assignmentScopes, { categories, types }] = await Promise.all([
+            const [collections, documentCollectionAssignments, requestAssignments, assignmentScopes, { categories, types, properties }] = 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 } }),
@@ -110,9 +109,8 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             const requestDocumentIds = requests.map((request) => request.documentId).filter(isNotNull);
             const assignmentTaskDocumentIds = assignmentTasks.map((task) => task.documentId);
             const documentIds = distinct([...assignmentDocumentIds, ...requestDocumentIds, ...assignmentTaskDocumentIds]);
-            const [documents, propertyViews, propertyValues, workflows] = await Promise.all([
+            const [documents, 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),
             ]);
@@ -164,7 +162,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
                 categories,
                 types,
                 tags,
-                properties: propertyViews,
+                properties,
             };
         });
     }
@@ -182,25 +180,27 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
         });
     }
     async initializeCategoriesAndTypes(tenantId, data) {
+        this.#documentCategoryTypeService.invalidateCache(tenantId);
+        this.#documentPropertyService.invalidateCache(tenantId);
         const categoryEntries = objectEntries(data.categoryLabels);
         const typeEntries = objectEntries(data.typeLabels);
         const propertyEntries = objectEntries(data.propertyConfigurations);
         const { categoryMap, typeMap, propertyMap } = await this.transaction(async (tx) => {
             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]);
+            const categories = dbCategories.filter((category) => isNotNull(category.key));
+            const types = dbTypes.filter((type) => isNotNull(type.key));
+            const properties = dbProperties.filter((property) => isNotNull(property.key));
+            const enumKeyCategoryMap = groupToSingleMap(categories, (category) => category.key);
+            const enumKeyTypeMap = groupToSingleMap(types, (type) => type.key);
+            const enumKeyPropertyMap = groupToSingleMap(properties, (property) => property.key);
             for (const [enumKey, label] of categoryEntries) {
                 const category = enumKeyCategoryMap.get(enumKey);
                 const parentKey = assertDefinedPass(data.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({ tenantId, label, parentId: parentCategoryId, enumKey });
+                    const category = await this.#documentCategoryTypeService.withTransaction(tx).createCategory({ tenantId, label, parentId: parentCategoryId, key: enumKey });
                     enumKeyCategoryMap.set(enumKey, category);
                     this.#logger.info(`Created category "${category.label}"`);
                 }
@@ -215,7 +215,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
                 const enumCategory = data.typeCategories[enumKey];
                 const category = assertDefinedPass(enumKeyCategoryMap.get(enumCategory));
                 if (isUndefined(type)) {
-                    const type = await this.#documentCategoryTypeService.withTransaction(tx).createType({ tenantId, label, categoryId: category.id, enumKey });
+                    const type = await this.#documentCategoryTypeService.withTransaction(tx).createType({ tenantId, label, categoryId: category.id, key: enumKey });
                     enumKeyTypeMap.set(enumKey, type);
                     this.#logger.info(`Created type "${type.label}" in category "${category.label}"`);
                 }
@@ -228,7 +228,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             for (const [enumKey, [dataType, label]] of propertyEntries) {
                 const property = enumKeyPropertyMap.get(enumKey);
                 if (isUndefined(property)) {
-                    const newProperty = await this.#documentPropertyService.withTransaction(tx).createProperty({ tenantId, label, dataType, enumKey });
+                    const newProperty = await this.#documentPropertyService.withTransaction(tx).createProperty({ tenantId, label, dataType, key: enumKey });
                     enumKeyPropertyMap.set(enumKey, newProperty);
                     this.#logger.info(`Created property "${newProperty.label}" of type "${dataType}"`);
                 }
@@ -249,6 +249,8 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
             }
             return { categoryMap: enumKeyCategoryMap, typeMap: enumKeyTypeMap, propertyMap: enumKeyPropertyMap };
         });
+        this.#documentCategoryTypeService.invalidateCache(tenantId);
+        this.#documentPropertyService.invalidateCache(tenantId);
         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.')]);

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

@@ -5,6 +5,8 @@ import type { DocumentPropertyValueView, DocumentPropertyView, SetDocumentProper
 export declare class DocumentPropertyService extends Transactional {
     #private;
     readonly repository: import("../../../orm/server/index.js").EntityRepository<DocumentProperty>;
+    invalidateCache(tenantId: string): void;
+    getPropertyId(tenantId: string, key: string): Promise<string>;
     readonly documentProperties: import("drizzle-orm/pg-core").WithSubqueryWithSelection<{
         documentId: import("drizzle-orm").SQL.Aliased<string>;
         propertyId: import("drizzle-orm").SQL.Aliased<string>;
@@ -51,7 +53,7 @@ export declare class DocumentPropertyService extends Transactional {
         tenantId: string;
         label: string;
         dataType: DocumentPropertyDataType;
-        enumKey?: string;
+        key?: string;
     }): Promise<DocumentProperty>;
     updateProperty(tenantId: string, id: string, update: {
         label?: string;

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

@@ -15,7 +15,6 @@ import { assertBooleanPass, assertNumberPass, assertStringPass, isBoolean, isNot
 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 = {
     [DocumentPropertyDataType.Text]: (value) => isString(value) || isNull(value),
@@ -30,6 +29,18 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
     #documentTypePropertyRepository = injectRepository(DocumentTypeProperty);
     #observationService = inject(DocumentManagementObservationService);
     repository = injectRepository(DocumentProperty);
+    #propertyCache = new Map();
+    invalidateCache(tenantId) {
+        this.#propertyCache.delete(tenantId);
+    }
+    async getPropertyId(tenantId, key) {
+        const cache = await this.#getPropertyCache(tenantId);
+        const id = cache.get(key);
+        if (isUndefined(id)) {
+            throw new NotFoundError(`Document property with key "${key}" not found for tenant "${tenantId}".`);
+        }
+        return id;
+    }
     documentProperties = this.session.$with('documentProperties').as((qb) => qb
         .select({
         documentId: autoAlias(document.id),
@@ -55,6 +66,7 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
             return {
                 id: property.id,
                 tenantId: property.tenantId,
+                key: property.key,
                 label: property.label,
                 dataType: property.dataType,
                 typeIds,
@@ -66,7 +78,7 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
             tenantId: data.tenantId,
             label: data.label,
             dataType: data.dataType,
-            metadata: { attributes: { [enumTypeKey]: data.enumKey } },
+            key: data.key ?? null,
         });
     }
     async updateProperty(tenantId, id, update) {
@@ -120,6 +132,15 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
             this.#observationService.documentChange(document.id, tx);
         });
     }
+    async #getPropertyCache(tenantId) {
+        let cache = this.#propertyCache.get(tenantId);
+        if (isUndefined(cache)) {
+            const properties = await this.#documentPropertyRepository.loadManyByQuery({ tenantId, key: { $neq: null } });
+            cache = new Map(properties.map((property) => [property.key, property.id]));
+            this.#propertyCache.set(tenantId, cache);
+        }
+        return cache;
+    }
 };
 DocumentPropertyService = __decorate([
     DocumentManagementSingleton()

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

@@ -56,7 +56,8 @@ let DocumentValidationService = DocumentValidationService_1 = class DocumentVali
         if (isNull(document.typeId)) {
             throw new BadRequestError('Document has no type');
         }
-        const workflow = await this.#documentWorkflowService.initiateWorkflow(document.tenantId, documentId, DocumentWorkflowStep.Validation);
+        const latestWorkflow = await this.#documentWorkflowService.loadLatestWorkflow(tenantId, documentId);
+        const workflow = await this.#documentWorkflowService.initiateWorkflow(document.tenantId, documentId, DocumentWorkflowStep.Validation, latestWorkflow?.skipAi ?? false);
         const typeValidations = await this.#documentTypeValidationService.loadManyByQuery({ tenantId, typeId: document.typeId });
         for (const typeValidation of typeValidations) {
             const validationDefinition = await this.#validationDefinitionService.loadByQuery({ tenantId, id: typeValidation.validationId });

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

@@ -2,7 +2,7 @@ import type { AfterResolveContext } from '../../../injector/index.js';
 import { afterResolve } from '../../../injector/interfaces.js';
 import { Transactional } from '../../../orm/server/index.js';
 import type { OneOrMany } from '../../../types/index.js';
-import { DocumentWorkflow, DocumentWorkflowStep } from '../../models/document-workflow.model.js';
+import { DocumentWorkflow, DocumentWorkflowState, DocumentWorkflowStep } from '../../models/document-workflow.model.js';
 export declare class DocumentWorkflowService extends Transactional {
     #private;
     private readonly documentService;
@@ -11,8 +11,8 @@ export declare class DocumentWorkflowService extends Transactional {
     loadLatestWorkflow(tenantId: string, documentId: string): Promise<DocumentWorkflow>;
     loadLatestWorkflows(tenantId: string, documentIds: string[]): Promise<DocumentWorkflow[]>;
     loadWorkflows(tenantId: string, documentId: OneOrMany<string>): Promise<DocumentWorkflow[]>;
-    proceedWorkflow(tenantId: string, documentId: string, userId: string): Promise<void>;
-    initiateWorkflow(tenantId: string, documentId: string, step: DocumentWorkflowStep): Promise<DocumentWorkflow>;
+    proceedWorkflow(tenantId: string, documentId: string, userId: string, targetState: DocumentWorkflowState): Promise<void>;
+    initiateWorkflow(tenantId: string, documentId: string, step: DocumentWorkflowStep, skipAi: boolean): Promise<DocumentWorkflow>;
     private setWorkflowState;
     private processWorkflowJob;
     private processClassificationWorkflow;

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

@@ -16,7 +16,6 @@ import { injectRepository, injectTransactional, Transactional } from '../../../o
 import { TaskProcessResult, TaskQueue } from '../../../task-queue/task-queue.js';
 import { toArray } from '../../../utils/array/array.js';
 import { currentTimestamp } from '../../../utils/date-time.js';
-import { _throw } from '../../../utils/throw.js';
 import { isNotNull, isNull } from '../../../utils/type-guards.js';
 import { and, desc, eq, inArray } from 'drizzle-orm';
 import { DocumentAssignmentScope } from '../../models/document-assignment-scope.model.js';
@@ -61,28 +60,48 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
     async loadWorkflows(tenantId, documentId) {
         return await this.repository.loadManyByQuery({ tenantId, documentId: { $in: toArray(documentId) } }, { order: { 'documentId': 'asc', 'metadata.createTimestamp': 'desc' } });
     }
-    async proceedWorkflow(tenantId, documentId, userId) {
+    async proceedWorkflow(tenantId, documentId, userId, targetState) {
         await this.transaction(async (tx) => {
             const workflow = await this.withTransaction(tx).loadLatestWorkflow(tenantId, documentId);
-            if (workflow.state != DocumentWorkflowState.Review) {
-                throw new BadRequestError('Current workflow is not in review state.');
+            const canProceed = (workflow.state == DocumentWorkflowState.Review) || (workflow.skipAi && (workflow.state == DocumentWorkflowState.Pending));
+            if (!canProceed) {
+                throw new BadRequestError('Current workflow is not in a state that can be proceeded.');
+            }
+            if ((workflow.state == DocumentWorkflowState.Review) && (targetState != DocumentWorkflowState.Completed)) {
+                throw new BadRequestError('Can only proceed to completed state from review.');
+            }
+            if ((targetState != DocumentWorkflowState.Review) && (targetState != DocumentWorkflowState.Completed)) {
+                throw new BadRequestError('Invalid target state.');
             }
             if (isNotNull(workflow.completeUserId)) {
                 throw new BadRequestError('Latest workflow is already completed.');
             }
-            await this.repository.withTransaction(tx).update(workflow.id, { state: DocumentWorkflowState.Completed, completeUserId: userId });
-            await match(workflow.step)
-                .with(DocumentWorkflowStep.Classification, () => _throw(new BadRequestError('Proceeding from classification occurs automatically.')))
-                .with(DocumentWorkflowStep.Extraction, async () => await this.withTransaction(tx).initiateWorkflow(tenantId, documentId, DocumentWorkflowStep.Assignment))
-                .with(DocumentWorkflowStep.Assignment, async () => await this.withTransaction(tx).initiateWorkflow(tenantId, documentId, DocumentWorkflowStep.Validation))
-                .with(DocumentWorkflowStep.Validation, () => { })
-                .exhaustive();
+            await this.repository.withTransaction(tx).update(workflow.id, {
+                state: targetState,
+                completeUserId: (targetState == DocumentWorkflowState.Completed) ? userId : undefined,
+                completeTimestamp: (targetState == DocumentWorkflowState.Completed) ? currentTimestamp() : undefined,
+            });
+            if (targetState == DocumentWorkflowState.Completed) {
+                await match(workflow.step)
+                    .with(DocumentWorkflowStep.Classification, async () => {
+                    if (!workflow.skipAi) {
+                        throw new BadRequestError('Proceeding from classification occurs automatically.');
+                    }
+                    await this.withTransaction(tx).initiateWorkflow(tenantId, documentId, DocumentWorkflowStep.Extraction, workflow.skipAi);
+                })
+                    .with(DocumentWorkflowStep.Extraction, async () => await this.withTransaction(tx).initiateWorkflow(tenantId, documentId, DocumentWorkflowStep.Assignment, workflow.skipAi))
+                    .with(DocumentWorkflowStep.Assignment, async () => await this.withTransaction(tx).initiateWorkflow(tenantId, documentId, DocumentWorkflowStep.Validation, workflow.skipAi))
+                    .with(DocumentWorkflowStep.Validation, () => { })
+                    .exhaustive();
+            }
             this.#observationService.documentChange(workflow.id, tx);
         });
     }
-    async initiateWorkflow(tenantId, documentId, step) {
-        const workflow = await this.repository.insert({ tenantId, documentId, step, state: 'pending', failReason: null, completeTimestamp: null, completeUserId: null });
-        await this.#taskQueue.enqueue('workflow', { workflowId: workflow.id });
+    async initiateWorkflow(tenantId, documentId, step, skipAi) {
+        const workflow = await this.repository.insert({ tenantId, documentId, step, state: 'pending', failReason: null, completeTimestamp: null, completeUserId: null, skipAi });
+        if (!skipAi) {
+            await this.#taskQueue.enqueue('workflow', { workflowId: workflow.id });
+        }
         this.#observationService.documentChange(workflow.id, this.session);
         return workflow;
     }
@@ -104,7 +123,7 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
             if (workflow.step == DocumentWorkflowStep.Classification) {
                 // no need for after classification review. Automatically start extraction.
                 await this.setWorkflowState(workflow.id, DocumentWorkflowState.Completed);
-                await this.initiateWorkflow(workflow.tenantId, workflow.documentId, DocumentWorkflowStep.Extraction);
+                await this.initiateWorkflow(workflow.tenantId, workflow.documentId, DocumentWorkflowStep.Extraction, workflow.skipAi);
             }
             else {
                 await this.setWorkflowState(workflow.id, DocumentWorkflowState.Review);

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

@@ -5,7 +5,7 @@ import type { CreateDocumentParameters, SetDocumentPropertyParameters, UpdateDoc
 export declare class DocumentService extends Transactional {
     #private;
     readonly repository: import("../../../orm/server/index.js").EntityRepository<Document>;
-    create(tenantId: string, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }: TypedOmit<CreateDocumentParameters, 'uploadId'>, contentSource: Uint8Array<ArrayBuffer> | ReadableStream<Uint8Array<ArrayBuffer>> | {
+    create(tenantId: string, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, skipAi, skipWorkflow, metadata }: TypedOmit<CreateDocumentParameters, 'uploadId'>, contentSource: Uint8Array<ArrayBuffer> | ReadableStream<Uint8Array<ArrayBuffer>> | {
         uploadId: string;
         uploadKey: string;
     }): Promise<Document>;

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

@@ -18,6 +18,7 @@ import { readableStreamFromPromise } from '../../../utils/stream/from-promise.js
 import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
 import { isDefined, isNotReadableStream, isNotUint8Array, isUndefined } from '../../../utils/type-guards.js';
 import { Document, DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentWorkflowStep } from '../../models/index.js';
+import { DocumentManagementConfiguration } from '../module.js';
 import { DocumentCollectionService } from './document-collection.service.js';
 import { DocumentFileService } from './document-file.service.js';
 import { DocumentManagementObservationService } from './document-management-observation.service.js';
@@ -27,6 +28,7 @@ import { DocumentTagService } from './document-tag.service.js';
 import { DocumentWorkflowService } from './document-workflow.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
 let DocumentService = DocumentService_1 = class DocumentService extends Transactional {
+    #configuration = inject(DocumentManagementConfiguration);
     #documentFileService = injectTransactional(DocumentFileService);
     #documentTagService = injectTransactional(DocumentTagService);
     #requestService = injectTransactional(DocumentRequestService);
@@ -38,7 +40,7 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
     #observationService = inject(DocumentManagementObservationService);
     #logger = inject(Logger, DocumentService_1.name);
     repository = injectRepository(Document);
-    async create(tenantId, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }, contentSource) {
+    async create(tenantId, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, skipAi, skipWorkflow, metadata }, contentSource) {
         const document = await this.transaction(async (tx) => {
             const isUpload = isNotUint8Array(contentSource) && isNotReadableStream(contentSource);
             const document = await this.repository.withTransaction(tx).insert({
@@ -74,7 +76,10 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
                 await this.#documentPropertyService.withTransaction(tx).setPropertyValues(document, properties);
             }
             await this.withTransaction(tx).createAssignment(document, assignment, tx);
-            await this.#workflowService.withTransaction(tx).initiateWorkflow(tenantId, document.id, DocumentWorkflowStep.Classification);
+            if (skipWorkflow != true) {
+                const effectiveSkipAi = this.#configuration.skipAi ?? skipAi ?? false;
+                await this.#workflowService.withTransaction(tx).initiateWorkflow(tenantId, document.id, DocumentWorkflowStep.Classification, effectiveSkipAi);
+            }
             return document;
         });
         this.#observationService.documentChange(document.id);

package/document-management/service-models/categories-and-types.view-model.d.ts

@@ -1,5 +1,11 @@
 import { DocumentCategory, DocumentType } from '../models/index.js';
+import { DocumentPropertyView } from './document-management.view-model.js';
 export declare class DocumentCategoryView extends DocumentCategory {
     children: DocumentCategoryView[];
     types: DocumentType[];
 }
+export declare class CategoriesAndTypesData {
+    categories: DocumentCategory[];
+    types: DocumentType[];
+    properties: DocumentPropertyView[];
+}

package/document-management/service-models/categories-and-types.view-model.js

@@ -9,6 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { Array, deferred } from '../../schema/index.js';
 import { DocumentCategory, DocumentType } from '../models/index.js';
+import { DocumentPropertyView } from './document-management.view-model.js';
 export class DocumentCategoryView extends DocumentCategory {
     children;
     types;
@@ -21,3 +22,20 @@ __decorate([
     Array(DocumentType),
     __metadata("design:type", Array)
 ], DocumentCategoryView.prototype, "types", void 0);
+export class CategoriesAndTypesData {
+    categories;
+    types;
+    properties;
+}
+__decorate([
+    Array(DocumentCategory),
+    __metadata("design:type", Array)
+], CategoriesAndTypesData.prototype, "categories", void 0);
+__decorate([
+    Array(DocumentType),
+    __metadata("design:type", Array)
+], CategoriesAndTypesData.prototype, "types", void 0);
+__decorate([
+    Array(DocumentPropertyView),
+    __metadata("design:type", Array)
+], CategoriesAndTypesData.prototype, "properties", void 0);

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

@@ -41,6 +41,7 @@ export declare class DocumentRequestView extends DocumentRequest {
 export declare class DocumentPropertyView implements TypedOmit<DocumentProperty, 'metadata'> {
     id: string;
     tenantId: string;
+    key: string | null;
     label: string;
     dataType: DocumentPropertyDataType;
     typeIds: string[];

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

@@ -134,6 +134,7 @@ __decorate([
 export class DocumentPropertyView {
     id;
     tenantId;
+    key;
     label;
     dataType;
     typeIds;
@@ -146,6 +147,10 @@ __decorate([
     StringProperty({ nullable: true }),
     __metadata("design:type", String)
 ], DocumentPropertyView.prototype, "tenantId", void 0);
+__decorate([
+    StringProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], DocumentPropertyView.prototype, "key", void 0);
 __decorate([
     StringProperty(),
     __metadata("design:type", String)

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

@@ -46,6 +46,8 @@ export declare const createDocumentParametersSchema: import("../../schema/index.
         }> | undefined;
     }[] | undefined;
     tags?: string[] | undefined;
+    skipAi?: boolean | undefined;
+    skipWorkflow?: boolean | undefined;
     metadata?: Partial<{
         attributes: import("../../orm/index.js").HasDefault<import("../../orm/index.js").Json<import("../../orm/index.js").EntityMetadataAttributes>>;
     }> | undefined;
@@ -232,6 +234,10 @@ export declare const addOrArchiveDocumentToOrFromCollectionParametersSchema: imp
         attributes: import("../../orm/index.js").HasDefault<import("../../orm/index.js").Json<import("../../orm/index.js").EntityMetadataAttributes>>;
     }> | undefined;
 }>;
+export declare const proceedDocumentWorkflowParametersSchema: import("../../schema/index.js").ObjectSchema<{
+    id: string;
+    state: "error" | "pending" | "running" | "completed" | "review" | "failed";
+}>;
 export type MetadataParameter = SchemaOutput<typeof metadataParameterObjectSchema>;
 export type LoadDataParameters = SchemaOutput<typeof loadDataParametersSchema>;
 export type CreateCollectionParameters = SchemaOutput<typeof createCollectionParametersSchema>;
@@ -257,3 +263,4 @@ export type AddOrArchiveDocumentToOrFromCollectionParameters = SchemaOutput<type
 export type UpdateDocumentParameters = SchemaOutput<typeof updateDocumentParametersSchema>;
 export type UpdateDocumentRequestParameters = SchemaOutput<typeof updateDocumentRequestParametersSchema>;
 export type DeleteDocumentRequestParameters = SchemaOutput<typeof deleteDocumentRequestParametersSchema>;
+export type ProceedDocumentWorkflowParameters = SchemaOutput<typeof proceedDocumentWorkflowParametersSchema>;

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

@@ -1,6 +1,6 @@
 import { EntityMetadata } from '../../orm/index.js';
 import { array, assign, boolean, enumeration, never, nullable, number, object, omit, oneOrMany, optional, partial, pick, string, union } from '../../schema/index.js';
-import { Document, DocumentAssignmentTarget, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentProperty, DocumentPropertyValue, DocumentRequest, DocumentRequestsTemplate, DocumentRequestTemplate, DocumentType, DocumentTypeProperty } from '../models/index.js';
+import { Document, DocumentAssignmentTarget, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentProperty, DocumentPropertyValue, DocumentRequest, DocumentRequestsTemplate, DocumentRequestTemplate, DocumentType, DocumentTypeProperty, DocumentWorkflowState } from '../models/index.js';
 export const metadataParameterSchema = optional(partial(pick(EntityMetadata, 'attributes')));
 export const metadataParameterObjectSchema = object({ metadata: metadataParameterSchema });
 export const setDocumentPropertyParametersSchema = assign(pick(DocumentPropertyValue, ['propertyId']), object({ value: union(string(), number(), boolean(), nullable(never())) }), metadataParameterObjectSchema);
@@ -19,6 +19,8 @@ export const createDocumentParametersSchema = assign(partial(pick(Document, ['ty
     })),
     tags: optional(array(string())),
     properties: optional(array(setDocumentPropertyParametersSchema)),
+    skipAi: optional(boolean()),
+    skipWorkflow: optional(boolean()),
 }), metadataParameterObjectSchema);
 export const updateDocumentParametersSchema = assign(pick(Document, ['id']), partial(pick(Document, ['title', 'subtitle', 'date', 'comment', 'typeId'])), object({
     tags: optional(array(string())),
@@ -53,3 +55,7 @@ export const rejectDocumentRequestParametersSchema = assign(pick(DocumentRequest
 export const createDocumentPropertyParametersSchema = assign(pick(DocumentProperty, ['label', 'dataType']), metadataParameterObjectSchema);
 export const assignPropertyToTypeParametersSchema = assign(pick(DocumentTypeProperty, ['typeId', 'propertyId']), metadataParameterObjectSchema);
 export const addOrArchiveDocumentToOrFromCollectionParametersSchema = assign(pick(DocumentCollectionAssignment, ['collectionId', 'documentId']), metadataParameterObjectSchema);
+export const proceedDocumentWorkflowParametersSchema = object({
+    id: string(),
+    state: enumeration(DocumentWorkflowState),
+});

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

@@ -7,6 +7,7 @@ export declare class EnrichedDocumentCategory implements TypedOmit<DocumentCateg
     #private;
     readonly id: string;
     readonly tenantId: string;
+    readonly key: string | null;
     readonly label: string;
     readonly parent: EnrichedDocumentCategory | null;
     readonly helper: {

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

@@ -16,6 +16,7 @@ export class EnrichedDocumentCategory {
     #data;
     id;
     tenantId;
+    key;
     label;
     parent;
     helper = lazyObject({
@@ -52,6 +53,7 @@ export class EnrichedDocumentCategory {
         this.#data = data;
         this.id = category.id;
         this.tenantId = category.tenantId;
+        this.key = category.key;
         this.label = category.label;
         this.parent = parent;
     }

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

@@ -7,6 +7,7 @@ export declare class EnrichedDocumentType implements TypedOmit<DocumentType, 'ca
     #private;
     readonly id: string;
     readonly tenantId: string;
+    readonly key: string | null;
     readonly label: string;
     readonly category: EnrichedDocumentCategory;
     readonly helper: {

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

@@ -14,6 +14,7 @@ export class EnrichedDocumentType {
     #data;
     id;
     tenantId;
+    key;
     label;
     category;
     helper = lazyObject({
@@ -26,6 +27,7 @@ export class EnrichedDocumentType {
         this.#data = data;
         this.id = type.id;
         this.tenantId = type.tenantId;
+        this.key = type.key;
         this.label = type.label;
         this.category = category;
     }

package/document-management/tests/document-management-core.test.d.ts

@@ -0,0 +1 @@
+export {};