@tstdl/base 0.92.123 → 0.92.125

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

@@ -0,0 +1,132 @@
+var _a;
+import { match } from 'ts-pattern';
+import { DocumentAssignmentScope } from '../../../document-management/models/document-assignment-scope.model.js';
+import { DocumentAssignmentTask } from '../../../document-management/models/document-assignment-task.model.js';
+import { DocumentWorkflow, DocumentWorkflowFailReason, DocumentWorkflowState, DocumentWorkflowStep } from '../../../document-management/models/document-workflow.model.js';
+import { DocumentApproval } from '../../../document-management/models/document.model.js';
+import { BadRequestError } from '../../../errors/bad-request.error.js';
+import { NotImplementedError } from '../../../errors/not-implemented.error.js';
+import { inject } from '../../../injector/inject.js';
+import { afterResolve } from '../../../injector/interfaces.js';
+import { Logger } from '../../../logger/index.js';
+import { injectRepository } from '../../../orm/server/repository.js';
+import { Transactional } from '../../../orm/server/transactional.js';
+import { Queue } from '../../../queue/queue.js';
+import { _throw } from '../../../utils/throw.js';
+import { isNotNull, isNull } from '../../../utils/type-guards.js';
+import { DocumentCollectionService } from './document-collection.service.js';
+import { DocumentManagementAiService } from './document-management-ai.service.js';
+import { DocumentRequestService } from './document-request.service.js';
+import { DocumentService } from './document.service.js';
+export class DocumentWorkflowService extends Transactional {
+    #documentManagementAiService = inject(DocumentManagementAiService);
+    #documentService = inject(DocumentService);
+    #documentCollectionService = inject(DocumentCollectionService);
+    #documentRequestService = inject(DocumentRequestService);
+    #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
+    #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
+    #queue = inject((Queue), { name: 'DocumentWorkflow', processTimeout: 5 * 60 * 1000, maxTries: 3 });
+    #logger = inject(Logger, _a.name);
+    repository = injectRepository(DocumentWorkflow).withSession(this.session);
+    [afterResolve](_, { cancellationSignal }) {
+        if (this.isInTransaction) {
+            return;
+        }
+        this.#queue.process({ concurrency: 5, cancellationSignal }, async (job) => this.processWorkflowJob(job), this.#logger);
+    }
+    async loadLatestWorkflow(documentId) {
+        return this.repository.loadByQuery({ documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
+    }
+    async tryLoadLatestWorkflow(documentId) {
+        return this.repository.tryLoadByQuery({ documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
+    }
+    async loadLatestWorkflows(documentIds) {
+        return this.repository.loadManyByQuery({ documentId: { $in: documentIds } }, { distinct: ['documentId'], order: { 'metadata.createTimestamp': 'desc' } });
+    }
+    async proceedWorkflow(documentId, userId) {
+        return this.transaction(async (tx) => {
+            const workflow = await this.withTransaction(tx).loadLatestWorkflow(documentId);
+            if (workflow.state != DocumentWorkflowState.Completed) {
+                throw new BadRequestError('Current workflow is not completed');
+            }
+            if (isNotNull(workflow.completeUserId)) {
+                throw new BadRequestError('Latest workflow is already completed');
+            }
+            await this.repository.withTransaction(tx).update(workflow.id, { completeUserId: userId });
+            await match(workflow.step)
+                .with(DocumentWorkflowStep.Classification, () => _throw(new BadRequestError('Proceeding from classification occurs automatically.')))
+                .with(DocumentWorkflowStep.Extraction, async () => this.withTransaction(tx).initiateWorkflow(documentId, DocumentWorkflowStep.Assignment))
+                .with(DocumentWorkflowStep.Assignment, async () => this.withTransaction(tx).initiateWorkflow(documentId, DocumentWorkflowStep.Validation))
+                .with(DocumentWorkflowStep.Validation, () => { })
+                .exhaustive();
+        });
+    }
+    async initiateWorkflow(documentId, step) {
+        const workflow = await this.repository.insert({ documentId, step, state: 'pending', failReason: null, completeUserId: null });
+        await this.#queue.enqueue({ workflowId: workflow.id });
+        return workflow;
+    }
+    async setWorkflowState(id, state, failReason = null) {
+        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);
+        try {
+            await this.setWorkflowState(workflow.id, DocumentWorkflowState.Running);
+            await match(workflow.step)
+                .with(DocumentWorkflowStep.Classification, async () => this.processClassificationWorkflow(workflow))
+                .with(DocumentWorkflowStep.Extraction, async () => this.processExtractionWorkflow(workflow))
+                .with(DocumentWorkflowStep.Assignment, async () => this.processAssignmentWorkflow(workflow))
+                .with(DocumentWorkflowStep.Validation, async () => this.processValidationWorkflow(workflow))
+                .exhaustive();
+            await this.setWorkflowState(workflow.id, DocumentWorkflowState.Completed);
+            if (workflow.step == DocumentWorkflowStep.Classification) {
+                // automatically start extraction after classification
+                await this.initiateWorkflow(workflow.documentId, DocumentWorkflowStep.Extraction);
+            }
+        }
+        catch (error) {
+            this.#logger.error(error);
+            const isLastTry = job.tries == this.#queue.maxTries;
+            if (isLastTry) {
+                await this.repository.update(workflow.id, { state: DocumentWorkflowState.Error });
+            }
+        }
+    }
+    async processClassificationWorkflow(workflow) {
+        const typeId = await this.#documentManagementAiService.classifyDocumentType(workflow.documentId);
+        await this.#documentService.repository.update(workflow.documentId, { typeId, approval: DocumentApproval.Pending });
+    }
+    async processExtractionWorkflow(workflow) {
+        const extraction = await this.#documentManagementAiService.extractDocumentInformation(workflow.documentId);
+        await this.#documentService.updateDocument(workflow.documentId, extraction);
+    }
+    async processAssignmentWorkflow(workflow) {
+        const assignmentTask = await this.#documentAssignmentTaskRepository.loadByQuery({ documentId: workflow.documentId });
+        const assignmentScopes = await this.#documentAssignmentScopeRepository.loadManyByQuery({ taskId: assignmentTask.id });
+        const collectionIds = assignmentScopes.map((scope) => scope.collectionId);
+        await match(assignmentTask.target)
+            .with('collection', async () => {
+            const suitableCollectionIds = await this.#documentManagementAiService.findSuitableCollectionsForDocument(workflow.documentId, collectionIds);
+            if (suitableCollectionIds.length == 0) {
+                await this.setWorkflowState(workflow.id, DocumentWorkflowState.Failed, DocumentWorkflowFailReason.NoSuitableCollection);
+                return;
+            }
+            await this.#documentCollectionService.assignDocument(workflow.documentId, suitableCollectionIds);
+        })
+            .with('request', async () => {
+            const suitableRequestId = await this.#documentManagementAiService.findSuitableRequestForDocument(workflow.documentId, collectionIds);
+            if (isNull(suitableRequestId)) {
+                await this.setWorkflowState(workflow.id, DocumentWorkflowState.Failed, DocumentWorkflowFailReason.NoSuitableRequest);
+                return;
+            }
+            await this.#documentRequestService.assignDocument(suitableRequestId, workflow.documentId);
+        })
+            .exhaustive();
+    }
+    async processValidationWorkflow(_workflow) {
+        throw new NotImplementedError();
+    }
+}
+_a = DocumentWorkflowService;

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

@@ -0,0 +1,16 @@
+import { type UpdatableDocumentProperties } from '../../../document-management/models/index.js';
+import type { CreateDocumentParameters, SetDocumentPropertyParameters } from '../../../document-management/models/service-models/index.js';
+import { Transactional } from '../../../orm/server/index.js';
+import { Document } from '../../models/index.js';
+export declare class DocumentService extends Transactional {
+    #private;
+    readonly repository: import("../../../orm/server/repository.js").EntityRepository<Document>;
+    createDocument({ typeId, title, subtitle, date, summary, tags, approval, comment, createUserId, originalFileName, assignment, properties, metadata }: CreateDocumentParameters, content: Uint8Array | ReadableStream<Uint8Array>): Promise<Document>;
+    updateDocument(id: string, update: Partial<Pick<Document, UpdatableDocumentProperties>> & {
+        properties?: SetDocumentPropertyParameters[];
+    }): Promise<void>;
+    /**
+     * @returns collectionIds from either direct assignment or automatic assignment scope
+     */
+    private createAssignment;
+}

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

@@ -0,0 +1,81 @@
+var _a;
+import { match, P } from 'ts-pattern';
+import { DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentWorkflowStep } from '../../../document-management/models/index.js';
+import { BadRequestError } from '../../../errors/bad-request.error.js';
+import { inject } from '../../../injector/inject.js';
+import { Logger } from '../../../logger/logger.js';
+import { Transactional } from '../../../orm/server/index.js';
+import { injectRepository } from '../../../orm/server/repository.js';
+import { getPdfPageCount } from '../../../pdf/utils.js';
+import { toArray } from '../../../utils/array/index.js';
+import { objectKeys } from '../../../utils/object/object.js';
+import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
+import { isDefined, isUndefined } from '../../../utils/type-guards.js';
+import { Document } from '../../models/index.js';
+import { DocumentCollectionService } from './document-collection.service.js';
+import { DocumentFileService } from './document-file.service.js';
+import { DocumentPropertyService } from './document-property.service.js';
+import { DocumentRequestService } from './document-request.service.js';
+import { DocumentWorkflowService } from './document-workflow.service.js';
+export class DocumentService extends Transactional {
+    #documentFileService = inject(DocumentFileService);
+    #requestService = inject(DocumentRequestService);
+    #workflowService = inject(DocumentWorkflowService, undefined, { forwardRef: true });
+    #documentPropertyService = inject(DocumentPropertyService);
+    #documentCollectionService = inject(DocumentCollectionService);
+    #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
+    #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
+    #logger = inject(Logger, _a.name);
+    repository = injectRepository(Document).withSession(this.session);
+    async createDocument({ typeId, title, subtitle, date, summary, tags, approval, comment, createUserId, originalFileName, assignment, properties, metadata }, content) {
+        const document = await this.transaction(async (tx) => {
+            const documentFile = await this.#documentFileService.withTransaction(tx).create(content, originalFileName);
+            const pages = documentFile.mimeType.includes('pdf') ? await tryIgnoreLogAsync(this.#logger, async () => getPdfPageCount(content), null) : null;
+            const document = await this.repository.withTransaction(tx).insert({ fileId: documentFile.id, typeId, title, subtitle, pages, date, summary, tags, metadata, approval, comment, createUserId });
+            if (isDefined(properties)) {
+                await this.#documentPropertyService.withTransaction(tx).setPropertyValues(document.id, properties);
+            }
+            await this.withTransaction(tx).createAssignment(document.id, assignment, tx);
+            await this.#workflowService.withTransaction(tx).initiateWorkflow(document.id, DocumentWorkflowStep.Classification);
+            return document;
+        });
+        return document;
+    }
+    async updateDocument(id, update) {
+        await this.transaction(async (tx) => {
+            const document = await this.repository.withTransaction(tx).load(id);
+            if (document.approval == DocumentApproval.Approved) {
+                throw new BadRequestError('Cannot update approved documents.');
+            }
+            const updateKeyLength = objectKeys(update).length;
+            if ((updateKeyLength > 1) || (isUndefined(update.properties) && (updateKeyLength > 0))) {
+                await this.repository.withTransaction(tx).update(id, update);
+            }
+            if (isDefined(update.properties)) {
+                await this.#documentPropertyService.withTransaction(tx).setPropertyValues(id, update.properties);
+            }
+        });
+    }
+    /**
+     * @returns collectionIds from either direct assignment or automatic assignment scope
+     */
+    async createAssignment(documentId, assignment, transaction) {
+        return match(assignment)
+            .with({ collections: P.select() }, async (collectionIds) => {
+            const collectionIdsArray = toArray(collectionIds);
+            await this.#documentCollectionService.withTransaction(transaction).assignDocument(documentId, collectionIdsArray);
+        })
+            .with({ request: P.select() }, async (requestId) => {
+            await this.#requestService.withTransaction(transaction).assignDocument(requestId, documentId);
+        })
+            .with({ automatic: P.select() }, async ({ target, scope }) => {
+            const collectionIdsArray = toArray(scope);
+            const assignmentTask = await this.#documentAssignmentTaskRepository.withTransaction(transaction).insert({ documentId: documentId, target });
+            for (const collectionId of collectionIdsArray) {
+                await this.#documentAssignmentScopeRepository.withTransaction(transaction).insert({ taskId: assignmentTask.id, collectionId });
+            }
+        })
+            .exhaustive();
+    }
+}
+_a = DocumentService;

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

@@ -1,2 +1,11 @@
+export * from './document-category-type.service.js';
+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.service.js';
+export * from './document-property.service.js';
+export * from './document-request.service.js';
+export * from './document-validation.service.js';
+export * from './document-workflow.service.js';
+export * from './document.service.js';

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

@@ -1,2 +1,11 @@
+export * from './document-category-type.service.js';
+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.service.js';
+export * from './document-property.service.js';
+export * from './document-request.service.js';
+export * from './document-validation.service.js';
+export * from './document-workflow.service.js';
+export * from './document.service.js';

package/document-management/server/validators/ai-validation-executor.d.ts

@@ -0,0 +1,19 @@
+import { AiService } from '../../../ai/index.js';
+import { type EnumType } from '../../../enumeration/enumeration.js';
+import type { SchemaTestable } from '../../../schema/schema.js';
+import { DocumentValidationExecutor, type DocumentValidationExecutorContext, type DocumentValidationExecutorResult } from './validator.js';
+export declare const AiValidationDifficulty: {
+    readonly Easy: "easy";
+    readonly MediumLow: "medium-low";
+    readonly MediumHigh: "medium-high";
+    readonly Hard: "hard";
+};
+export type AiValidationDifficulty = EnumType<typeof AiValidationDifficulty>;
+export declare abstract class AiValidationExecutor<R> extends DocumentValidationExecutor {
+    protected readonly aiService: AiService;
+    abstract readonly schema: SchemaTestable<R>;
+    abstract readonly difficulty: AiValidationDifficulty;
+    execute(context: DocumentValidationExecutorContext): Promise<DocumentValidationExecutorResult>;
+    abstract getPrompt(context: DocumentValidationExecutorContext): string | Promise<string>;
+    abstract getResult(output: R): DocumentValidationExecutorResult | Promise<DocumentValidationExecutorResult>;
+}

package/document-management/server/validators/ai-validation-executor.js

@@ -0,0 +1,51 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { AiService } from '../../../ai/index.js';
+import { defineEnum } from '../../../enumeration/enumeration.js';
+import { Singleton } from '../../../injector/decorators.js';
+import { inject } from '../../../injector/inject.js';
+import { match } from 'ts-pattern';
+import { DocumentValidationExecutor } from './validator.js';
+export const AiValidationDifficulty = defineEnum('AiValidationDifficulty', {
+    Easy: 'easy',
+    MediumLow: 'medium-low',
+    MediumHigh: 'medium-high',
+    Hard: 'hard',
+});
+let AiValidationExecutor = class AiValidationExecutor extends DocumentValidationExecutor {
+    aiService = inject(AiService);
+    async execute(context) {
+        const validationPrompt = await this.getPrompt(context);
+        const model = match(this.difficulty)
+            .with('easy', () => 'gemini-2.0-flash-lite')
+            .with('medium-low', () => 'gemini-2.5-flash-exp-04-17')
+            .with('medium-high', () => 'gemini-2.5-flash-exp-04-17')
+            .with('hard', () => 'gemini-2.5-pro-exp-03-25')
+            .exhaustive();
+        const prompt = `Deine Aufgabe ist es ein Dokument zu validieren.
+
+Validierungsaufgabe:
+${validationPrompt}`;
+        const generation = await this.aiService.generate({
+            model,
+            generationOptions: {
+                temperature: 0.2,
+                topK: 20,
+            },
+            generationSchema: this.schema,
+            contents: [{
+                    role: 'user',
+                    parts: [{ text: prompt }],
+                }],
+        });
+        return await this.getResult(generation.json);
+    }
+};
+AiValidationExecutor = __decorate([
+    Singleton()
+], AiValidationExecutor);
+export { AiValidationExecutor };

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

@@ -0,0 +1,2 @@
+export * from './ai-validation-executor.js';
+export * from './validator.js';

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

@@ -0,0 +1,2 @@
+export * from './ai-validation-executor.js';
+export * from './validator.js';

package/document-management/server/validators/single-document-validation-executor.d.ts

@@ -0,0 +1,16 @@
+import { type SchemaOutput } from '../../../schema/index.js';
+import { AiValidationExecutor } from './ai-validation-executor.js';
+import type { DocumentValidationExecutorResult } from './validator.js';
+export declare class SingleDocumentValidationExecutor extends AiValidationExecutor<{
+    hasMultipleDocuments: boolean;
+    reason?: string;
+}> {
+    readonly identifier = "single-document";
+    readonly difficulty: "medium-low";
+    schema: import("../../../schema/index.js").ObjectSchema<{
+        hasMultipleDocuments: boolean;
+        reason?: string | undefined;
+    }>;
+    getPrompt(): string;
+    getResult(output: SchemaOutput<typeof this['schema']>): DocumentValidationExecutorResult;
+}

package/document-management/server/validators/single-document-validation-executor.js

@@ -0,0 +1,20 @@
+import { DocumentValidationResultStatus } from '../../../document-management/models/document-validation-execution.model.js';
+import { boolean, object, optional, string } from '../../../schema/index.js';
+import { AiValidationDifficulty, AiValidationExecutor } from './ai-validation-executor.js';
+export class SingleDocumentValidationExecutor extends AiValidationExecutor {
+    identifier = 'single-document';
+    difficulty = AiValidationDifficulty.MediumLow;
+    schema = object({
+        hasMultipleDocuments: boolean(),
+        reason: optional(string()),
+    });
+    getPrompt() {
+        return 'Überprüfe ob das Dokument aus mehreren Dokumenten zusammengesetzt ist. Falls ja, begründe in wenigen Worten. Antworte auf deutsch.';
+    }
+    getResult(output) {
+        if (output.hasMultipleDocuments) {
+            return { status: DocumentValidationResultStatus.Warning, message: output.reason ?? null };
+        }
+        return { status: DocumentValidationResultStatus.Passed };
+    }
+}

package/document-management/server/validators/validator.d.ts

@@ -0,0 +1,21 @@
+import type { Document, DocumentCategory, DocumentCollection, DocumentProperty, DocumentPropertyValue, DocumentType, DocumentValidationDefinition, DocumentValidationExecution, DocumentValidationResultStatus } from '../../../document-management/models/index.js';
+export type DocumentValidationExecutorContextDocumentData = {
+    document: Document;
+    collections: DocumentCollection[];
+    category: DocumentCategory;
+    type: DocumentType;
+    properties: DocumentProperty[];
+    propertyValues: DocumentPropertyValue[];
+};
+export type DocumentValidationExecutorContext = {
+    execution: DocumentValidationExecution;
+    definition: DocumentValidationDefinition;
+} & DocumentValidationExecutorContextDocumentData;
+export type DocumentValidationExecutorResult = {
+    status: DocumentValidationResultStatus;
+    message?: string | null;
+};
+export declare abstract class DocumentValidationExecutor {
+    abstract readonly identifier: string;
+    abstract execute(execution: DocumentValidationExecutorContext): Promise<DocumentValidationExecutorResult>;
+}

package/document-management/server/validators/validator.js

@@ -0,0 +1,2 @@
+export class DocumentValidationExecutor {
+}

package/eslint.config.js

@@ -12,25 +12,24 @@ export default [
       parser: tsParser,
       parserOptions: {
         projectService: {
-          allowDefaultProject: ['*.js']
-        }
+          allowDefaultProject: ['*.js'],
+        },
       },
-      globals: { ...globals.browser, ...globals.node }
-    }
+      globals: { ...globals.browser, ...globals.node },
+    },
   },
   stylistic.configs.customize({
     semi: true,
     arrowParens: true,
-    commaDangle: 'never'
   }),
   {
     rules: {
-      'prefer-named-capture-group': ['warn']
-    }
+      'prefer-named-capture-group': ['warn'],
+    },
   },
   {
     plugins: {
-      '@typescript-eslint': tseslint
+      '@typescript-eslint': tseslint,
     },
     rules: {
       ...tseslint.configs['strict-type-checked'].rules,
@@ -48,24 +47,39 @@ export default [
       '@typescript-eslint/no-unsafe-assignment': 'off',
       '@typescript-eslint/no-unused-vars': ['warn', { varsIgnorePattern: '^_', argsIgnorePattern: '^_' }],
       '@typescript-eslint/promise-function-async': 'error',
-      '@typescript-eslint/restrict-template-expressions': ['warn', { allowNumber: true, allowBoolean: true, allowNullish: true }]
-    }
+      '@typescript-eslint/restrict-template-expressions': ['warn', { allowNumber: true, allowBoolean: true, allowNullish: true }],
+    },
   },
   {
     rules: {
       '@stylistic/member-delimiter-style': ['warn', {
-        multiline: { delimiter: 'comma', requireLast: false },
+        multiline: { delimiter: 'comma', requireLast: true },
         singleline: { delimiter: 'comma', requireLast: false },
         overrides: {
           interface: {
             multiline: { delimiter: 'semi', requireLast: true },
-            singleline: { delimiter: 'semi', requireLast: true }
-          }
-        }
+            singleline: { delimiter: 'semi', requireLast: true },
+          },
+        },
       }],
       '@stylistic/yield-star-spacing': ['warn', 'after'],
       '@stylistic/generator-star-spacing': ['warn', 'before'],
-      '@stylistic/indent': 'off'
-    }
-  }
+      '@stylistic/indent': 'off',
+      '@stylistic/comma-dangle': [
+        'error',
+        {
+          arrays: 'always-multiline',
+          objects: 'always-multiline',
+          imports: 'always-multiline',
+          exports: 'always-multiline',
+          functions: 'only-multiline',
+          importAttributes: 'always-multiline',
+          dynamicImports: 'always-multiline',
+          enums: 'always-multiline',
+          generics: 'always-multiline',
+          tuples: 'always-multiline',
+        },
+      ],
+    },
+  },
 ];

package/examples/document-management/main.d.ts

@@ -1,6 +1,21 @@
 import '../../polyfills.js';
-import type { DocumentCollection } from '../../document-management/index.js';
-import { DocumentManagementAncillaryService } from '../../document-management/server/index.js';
+import type { DocumentCollection, DocumentWorkflowStep } from '../../document-management/index.js';
+import { DocumentManagementAncillaryService, type DocumentCollectionMetadata } from '../../document-management/server/index.js';
 export declare class TestDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
-    resolveNames(collections: DocumentCollection[]): Promise<string[]>;
+    _resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[];
+    canReadCollection(_collectionId: string, _token?: unknown): boolean;
+    canWriteCollection(_collectionId: string, _token?: unknown): boolean;
+    canApproveDocument(_documentId: string, _token?: unknown): boolean;
+    canRejectDocument(_documentId: string, _token?: unknown): boolean;
+    canReadDocumentRequest(_requestId: string, _token?: unknown): boolean;
+    canAssignDocumentToRequest(_requestId: string, _documentId: string, _token?: unknown): boolean;
+    canManageCategoriesAndTypes(_token?: unknown): boolean;
+    canReadDocumentRequestsTemplates(_token?: unknown): boolean;
+    canManageDocumentRequestsTemplates(_token?: unknown): boolean;
+    canCreateUnassignedDocument(_token?: unknown): boolean;
+    canCreateRequestAssignedDocument(_token?: unknown): boolean;
+    canDeleteDocument(_documentId: string, _token?: unknown): boolean;
+    canManageDocumentRequest(_token?: unknown): boolean;
+    canManageValidationDefinitions(_token?: unknown): boolean;
+    canProgressDocumentWorkflow(_documentId: string, _currentWorkflowStep: DocumentWorkflowStep, _token?: unknown): boolean;
 }

package/examples/document-management/main.js

@@ -6,16 +6,31 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import '../../polyfills.js';
 import { Application } from '../../application/application.js';
-import { DocumentManagementAncillaryService } from '../../document-management/server/index.js';
+import { DocumentCategoryTypeService, DocumentCollectionService, DocumentManagementAncillaryService, DocumentRequestService } from '../../document-management/server/index.js';
 import { configureDocumentManagement, migrateDocumentManagementSchema } from '../../document-management/server/module.js';
 import { DocumentManagementService } from '../../document-management/server/services/document-management.service.js';
 import { Singleton } from '../../injector/index.js';
-import { injectAsync } from '../../injector/inject.js';
+import { injectManyAsync } from '../../injector/inject.js';
 import { configureS3ObjectStorage } from '../../object-storage/index.js';
 let TestDocumentManagementAncillaryService = class TestDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
-    async resolveNames(collections) {
-        return collections.map((collection) => collection.metadata.attributes['name']);
+    _resolveMetadata(collections) {
+        return collections.map((collection) => ({ name: collection.metadata.attributes['name'], group: null }));
     }
+    canReadCollection(_collectionId, _token) { return true; }
+    canWriteCollection(_collectionId, _token) { return true; }
+    canApproveDocument(_documentId, _token) { return true; }
+    canRejectDocument(_documentId, _token) { return true; }
+    canReadDocumentRequest(_requestId, _token) { return true; }
+    canAssignDocumentToRequest(_requestId, _documentId, _token) { return true; }
+    canManageCategoriesAndTypes(_token) { return true; }
+    canReadDocumentRequestsTemplates(_token) { return true; }
+    canManageDocumentRequestsTemplates(_token) { return true; }
+    canCreateUnassignedDocument(_token) { return true; }
+    canCreateRequestAssignedDocument(_token) { return true; }
+    canDeleteDocument(_documentId, _token) { return true; }
+    canManageDocumentRequest(_token) { return true; }
+    canManageValidationDefinitions(_token) { return true; }
+    canProgressDocumentWorkflow(_documentId, _currentWorkflowStep, _token) { return true; }
 };
 TestDocumentManagementAncillaryService = __decorate([
     Singleton()
@@ -25,23 +40,24 @@ async function bootstrap() {
     configureDocumentManagement({
         ancillaryService: TestDocumentManagementAncillaryService,
         fileObjectStorageModule: 'documents',
+        filePreviewObjectStorageModule: 'document-previews',
         database: {
             connection: {
                 database: 'xxx',
                 user: 'xxx',
-                password: 'xxx'
-            }
-        }
+                password: 'xxx',
+            },
+        },
     });
     configureS3ObjectStorage({ endpoint: 'http://localhost:10000', accessKey: 'tstdl-dev', secretKey: 'tstdl-dev', bucketPerModule: true });
     await migrateDocumentManagementSchema();
 }
 async function main() {
-    const documentManagementService = await injectAsync(DocumentManagementService);
-    const collection = await documentManagementService.createCollection();
-    const category = await documentManagementService.createCategory({ label: 'Testkategorie' });
-    const type = await documentManagementService.createType({ categoryId: category.id, group: null, label: 'Testtyp' });
-    const request = await documentManagementService.createDocumentRequest({ typeId: type.id, requiredFilesCount: 1, comment: null, collectionIds: [collection.id] });
+    const [documentManagementService, documentCollectionService, documentCategoryTypeService, documentRequestService] = await injectManyAsync(DocumentManagementService, DocumentCollectionService, DocumentCategoryTypeService, DocumentRequestService);
+    const collection = await documentCollectionService.createCollection(null);
+    const category = await documentCategoryTypeService.createCategory('Testkategorie', null);
+    const type = await documentCategoryTypeService.createType('Testtyp', category.id);
+    const request = await documentRequestService.createRequest(type.id, [collection.id], null);
     const data = await documentManagementService.loadData([collection.id]);
     console.log(data);
 }

package/file/mime-type.js

@@ -12,16 +12,9 @@ export function getMimeTypeExtensions(mimeType) {
 async function spawnFileCommand(args, file) {
     const process = await spawnCommand('file', args);
     if (isDefined(file)) {
-        try {
-            await process.write(file);
-        }
-        catch { /* ignore as file command closes stdin early */ }
-    }
-    const { code } = await process.wait();
-    if (code != 0) {
-        const errorOutput = await process.readError();
-        throw new Error(errorOutput.trim());
+        process.autoWrite(file);
     }
+    await process.wait({ throwOnNonZeroExitCode: true });
     const output = await process.readOutput();
     if (output.includes('file or directory')) {
         throw new Error(output.trim());

package/formats.d.ts

@@ -13,8 +13,8 @@ export declare const dateShort: Intl.DateTimeFormatOptions;
 export declare const dateMedium: Intl.DateTimeFormatOptions;
 export declare const dateLong: Intl.DateTimeFormatOptions;
 export declare const timeShort: Intl.DateTimeFormatOptions;
-export declare const euroFormat: Intl.NumberFormatOptions;
-export declare const euroFormatWithoutCents: Intl.NumberFormatOptions;
+export declare const currencyFormat: Intl.NumberFormatOptions;
+export declare const currencyFormatWithoutCents: Intl.NumberFormatOptions;
 export declare const percentFormat: Intl.NumberFormatOptions;
 export declare function formatNumber(value: number, format?: Intl.NumberFormatOptions): string;
 export declare function formatInteger(value: number): string;
@@ -24,7 +24,10 @@ export declare function formatTimeShort(value: number): string;
 export declare function formatDateShort(value: Date | number): string;
 export declare function formatDate(dateOrTimestamp: number | Date): string;
 export declare function formatNumericDate(numericDate: number): string;
+export declare function formatCurrency(value: number, currency: string): string;
+export declare function formatCurrencyWithoutCents(value: number, currency: string): string;
 export declare function formatEuro(value: number): string;
+export declare function formatEuroWithoutCents(value: number): string;
 export declare function formatPercent(value: number): string;
 export type FormatPersonNameOptions<F = unknown> = {
     lastNameFirst?: boolean;