@tstdl/base 0.92.123 → 0.92.125

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

@@ -1,4 +1,128 @@
-import type { DocumentCollection } from '../../models/document-collection.model.js';
-export declare abstract class DocumentManagementAncillaryService {
-    abstract resolveNames(collections: DocumentCollection[]): Promise<string[]>;
+import { DocumentCollection, type DocumentWorkflowStep } from '../../models/index.js';
+export type DocumentCollectionMetadata = {
+    /**
+     * User-friendly name of the collection
+     * @example <name of person>
+     * @example <address of real estate>
+     */
+    name: string;
+    /**
+     * Group of the collection, used to group multiple collections to the same "type"
+     * @example 'Applicants'
+     * @example 'Real estates'
+     */
+    group: string | null;
+};
+export declare abstract class DocumentManagementAncillaryService<Token = unknown> {
+    #private;
+    resolveMetadata<const T extends (DocumentCollection | string)[]>(...collectionsOrIds: T): Promise<{
+        [K in keyof T]: DocumentCollectionMetadata;
+    }>;
+    resolveMetadataMap(...collectionsOrIds: (DocumentCollection | string)[]): Promise<Record<string, DocumentCollectionMetadata>>;
+    /**
+     * 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[]>;
+    /**
+     * 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 write to/modify a specific document collection.
+     * This could include changing collection metadata or managing documents within it,
+     * such as adding documents or creating document requests for this collection.
+     * @param collectionId The ID of the document collection.
+     * @param token The token of the request
+     */
+    abstract canWriteCollection(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 read/view a specific document request.
+     * @param requestId The ID of the document request.
+     * @param token The token of the request
+     */
+    abstract canReadDocumentRequest(requestId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can assign an existing document to a document request.
+     * This links the document to the request, usually before final fulfillment.
+     * @param requestId The ID of the document request.
+     * @param documentId The ID of the document to be assigned.
+     * @param token The token of the request
+     * @returns A promise that resolves to true if assignment is allowed, false otherwise.
+     */
+    abstract canAssignDocumentToRequest(requestId: string, documentId: 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 create/upload a new unassigned document (which then requires assigning to request/collection).
+     * @param token The token of the request.
+     */
+    abstract canCreateUnassignedDocument(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can create/upload a new document assigned to an request.
+     * @param token The token of the request.
+     */
+    abstract canCreateRequestAssignedDocument(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can delete a document.
+     * This might be restricted (e.g., only for documents not yet approved, or by administrators).
+     * @param documentId The ID of the document.
+     * @param token The token of the request.
+     * @returns A promise that resolves to true if deletion is allowed, false otherwise.
+     */
+    abstract canDeleteDocument(documentId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can create and close document requests.
+     * @param token The token of the request.
+     */
+    abstract canManageDocumentRequest(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

@@ -5,7 +5,31 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Singleton } from '../../../injector/index.js';
+import { injectRepository } from '../../../orm/server/index.js';
+import { fromEntries } from '../../../utils/object/index.js';
+import { assertDefinedPass, isString } from '../../../utils/type-guards.js';
+import { DocumentCollection } from '../../models/index.js';
 let DocumentManagementAncillaryService = class DocumentManagementAncillaryService {
+    #documentCollectionRepository = injectRepository(DocumentCollection);
+    async resolveMetadata(...collectionsOrIds) {
+        if (collectionsOrIds.length == 0) {
+            return [];
+        }
+        const loadIds = collectionsOrIds.filter((collection) => isString(collection));
+        if (loadIds.length == 0) {
+            return this._resolveMetadata(collectionsOrIds);
+        }
+        const loadedCollections = await this.#documentCollectionRepository.loadManyByQuery({ id: { $in: loadIds } });
+        const collections = collectionsOrIds.map((collectionOrId) => isString(collectionOrId)
+            ? assertDefinedPass(loadedCollections.find((collection) => collection.id == collectionOrId), `Could not load collection "${collectionOrId}".`)
+            : collectionOrId);
+        return this._resolveMetadata(collections);
+    }
+    async resolveMetadataMap(...collectionsOrIds) {
+        const names = await this.resolveMetadata(...collectionsOrIds);
+        const entries = collectionsOrIds.map((collectionOrId, index) => [isString(collectionOrId) ? collectionOrId : collectionOrId.id, names[index]]);
+        return fromEntries(entries);
+    }
 };
 DocumentManagementAncillaryService = __decorate([
     Singleton()

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

@@ -1,125 +1,13 @@
-import type { RequireExactlyOne, Stringified } from 'type-fest';
-import type { CancellationSignal } from '../../../cancellation/token.js';
-import { type AfterResolveContext, afterResolve } from '../../../injector/index.js';
-import { Logger } from '../../../logger/logger.js';
-import { MessageBus } from '../../../message-bus/message-bus.js';
-import { ObjectStorage } from '../../../object-storage/index.js';
-import type { Query } from '../../../orm/index.js';
-import { type Transaction } from '../../../orm/server/index.js';
-import { Queue } from '../../../queue/queue.js';
-import type { OneOrMany, Record } from '../../../types.js';
-import { type Observable } from 'rxjs';
-import { type AddOrArchiveDocumentToOrFromCollectionParameters, type ApplyDocumentRequestsTemplateParameters, type ApproveDocumentRequestFileParameters, type AssignPropertyToTypeParameters, type CategoryAndTypesView, type CreateCollectionParameters, type CreateDocumentCategoryParameters, type CreateDocumentParameters, type CreateDocumentPropertyParameters, type CreateDocumentRequestFileParameters, type CreateDocumentRequestParameters, type CreateDocumentRequestTemplateParameters, type CreateDocumentRequestsTemplateParameters, type CreateDocumentTypeParameters, type DeleteDocumentRequestFileParameters, type DeleteDocumentRequestParameters, type DeleteDocumentRequestTemplateParameters, type DeleteDocumentRequestsTemplateParameters, Document, DocumentCategory, DocumentCollection, DocumentCollectionDocument, DocumentFile, type DocumentManagementData, DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentRequest, DocumentRequestAssignmentTask, DocumentRequestAssignmentTaskCollection, DocumentRequestAssignmentTaskPropertyValue, DocumentRequestCollection, DocumentRequestFile, DocumentRequestFilePropertyValue, DocumentRequestTemplate, DocumentRequestsTemplate, type DocumentRequestsTemplateData, DocumentType, DocumentTypeProperty, type LoadDataCollectionsMetadataParameters, type RejectDocumentRequestFileParameters, type RequestFilesStats, type SetDocumentPropertiesParameters, type UpdateDocumentParameters, type UpdateDocumentRequestFileParameters, type UpdateDocumentRequestParameters, type UpdateDocumentRequestTemplateParameters, type UpdateDocumentRequestsTemplateParameters } from '../../models/index.js';
-import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
-type DocumentInformationExtractionPropertyResult = {
-    propertyId: string;
-    dataType: DocumentPropertyDataType;
-    value: string | number | boolean;
-};
-export type DocumentInformationExtractionResult = {
-    typeId: string | null;
-    title: string;
-    subtitle: string | null;
-    pages: number | null;
-    date: number | null;
-    summary: string;
-    tags: string[];
-    properties: DocumentInformationExtractionPropertyResult[];
-};
-type ExtractionJobData = RequireExactlyOne<{
-    documentId: string;
-    requestFileId: string;
-    requestAssignmentTaskId: string;
-}>;
-type AssignmentJobData = RequireExactlyOne<{
-    requestAssignmentTaskId: string;
-}>;
-declare const DocumentManagementService_base: import("../../../types.js").Type<import("../../../orm/server/index.js").EntityRepository<DocumentCollection>>;
-export declare class DocumentManagementService extends DocumentManagementService_base {
+import type { DocumentManagementData, DocumentRequestsTemplateData } from '../../../document-management/models/service-models/index.js';
+import { Transactional } from '../../../orm/server/index.js';
+import type { Record } from '../../../types.js';
+import { DocumentCategory, DocumentType } from '../../models/index.js';
+export declare class DocumentManagementService extends Transactional {
     #private;
-    protected readonly ancillaryService: DocumentManagementAncillaryService;
-    protected readonly documentCategoryService: import("../../../orm/server/index.js").EntityRepository<DocumentCategory>;
-    protected readonly documentCollectionDocumentService: import("../../../orm/server/index.js").EntityRepository<DocumentCollectionDocument>;
-    protected readonly documentFileService: import("../../../orm/server/index.js").EntityRepository<DocumentFile>;
-    protected readonly documentPropertyService: import("../../../orm/server/index.js").EntityRepository<DocumentProperty>;
-    protected readonly documentPropertyValueService: import("../../../orm/server/index.js").EntityRepository<DocumentPropertyValue>;
-    protected readonly documentRequestAssignmentTaskCollectionService: import("../../../orm/server/index.js").EntityRepository<DocumentRequestAssignmentTaskCollection>;
-    protected readonly documentRequestAssignmentTaskService: import("../../../orm/server/index.js").EntityRepository<DocumentRequestAssignmentTask>;
-    protected readonly documentRequestCollectionService: import("../../../orm/server/index.js").EntityRepository<DocumentRequestCollection>;
-    protected readonly documentRequestFilePropertyValueService: import("../../../orm/server/index.js").EntityRepository<DocumentRequestFilePropertyValue>;
-    protected readonly documentRequestAssignmentTaskPropertyValueService: import("../../../orm/server/index.js").EntityRepository<DocumentRequestAssignmentTaskPropertyValue>;
-    protected readonly documentRequestFileService: import("../../../orm/server/index.js").EntityRepository<DocumentRequestFile>;
-    protected readonly documentRequestService: import("../../../orm/server/index.js").EntityRepository<DocumentRequest>;
-    protected readonly documentRequestsTemplateService: import("../../../orm/server/index.js").EntityRepository<DocumentRequestsTemplate>;
-    protected readonly documentRequestTemplateService: import("../../../orm/server/index.js").EntityRepository<DocumentRequestTemplate>;
-    protected readonly documentService: import("../../../orm/server/index.js").EntityRepository<Document>;
-    protected readonly documentTypePropertyService: import("../../../orm/server/index.js").EntityRepository<DocumentTypeProperty>;
-    protected readonly documentTypeService: import("../../../orm/server/index.js").EntityRepository<DocumentType>;
-    protected readonly fileObjectStorage: ObjectStorage;
-    protected readonly extractionQueue: Queue<ExtractionJobData>;
-    protected readonly assignmentQueue: Queue<AssignmentJobData>;
-    protected readonly collectionChangeMessageBus: MessageBus<string[] | undefined>;
-    protected readonly logger: Logger;
-    [afterResolve](_: unknown, { cancellationSignal }: AfterResolveContext<any>): void;
-    changes$(collectionIds: OneOrMany<string>): Observable<void>;
-    processQueues(cancellationSignal: CancellationSignal): void;
-    resolveNames<const T extends (DocumentCollection | string)[]>(...collectionsOrIds: T): Promise<Stringified<T>>;
-    resolveNamesMap(...collectionsOrIds: (DocumentCollection | string)[]): Promise<Record<string, string>>;
-    loadData(collectionIds: string[], collectionsMetadata?: LoadDataCollectionsMetadataParameters): Promise<DocumentManagementData>;
+    loadData(collectionIds: string[]): Promise<DocumentManagementData>;
     loadDocumentRequestsTemplateData(): Promise<DocumentRequestsTemplateData>;
-    loadCategoriesAndTypes(): Promise<CategoryAndTypesView>;
-    loadDocument(id: string): Promise<Document>;
-    loadDocumentFile(id: string): Promise<DocumentFile>;
-    loadType(id: string): Promise<DocumentType>;
-    getFileContent(fileId: string): Promise<Uint8Array>;
-    getFileContentStream(fileId: string): ReadableStream<Uint8Array>;
-    getFileContentUrl(fileId: string, title: string | null, download?: boolean): Promise<string>;
-    createCategory(parameters: CreateDocumentCategoryParameters): Promise<DocumentCategory>;
-    createType(parameters: CreateDocumentTypeParameters): Promise<DocumentType>;
-    createCollection(parameters?: CreateCollectionParameters): Promise<DocumentCollection>;
-    collectionHasDocumentByFilter(collectionId: string, filter: Query<Document>): Promise<boolean>;
-    getRequestFilesStats(collectionIds: OneOrMany<string>): Promise<RequestFilesStats>;
-    createDocumentRequestsTemplate(parameters: CreateDocumentRequestsTemplateParameters): Promise<DocumentRequestsTemplate>;
-    updateDocumentRequestsTemplate({ id, label, metadata }: UpdateDocumentRequestsTemplateParameters): Promise<DocumentRequestsTemplate>;
-    applyDocumentRequestsTemplate({ id, collectionIds, metadata }: ApplyDocumentRequestsTemplateParameters): Promise<void>;
-    deleteDocumentRequestsTemplate(parameters: DeleteDocumentRequestsTemplateParameters): Promise<DocumentRequestsTemplate>;
-    createDocumentRequestTemplate(parameters: CreateDocumentRequestTemplateParameters): Promise<DocumentRequestTemplate>;
-    updateDocumentRequestTemplate({ id, typeId, requiredFilesCount, comment, metadata }: UpdateDocumentRequestTemplateParameters): Promise<DocumentRequestTemplate>;
-    deleteDocumentRequestTemplate(parameters: DeleteDocumentRequestTemplateParameters): Promise<DocumentRequestTemplate>;
-    createDocument({ typeId, title, subtitle, pages, date, summary, tags, validated, originalFileName, collectionIds, properties, metadata }: CreateDocumentParameters, content: Uint8Array | ReadableStream<Uint8Array>): Promise<Document>;
-    approveDocumentRequestFile({ id, approvalComment, documentMetadata, requestFileMetadata }: ApproveDocumentRequestFileParameters): Promise<Document>;
-    rejectDocumentRequestFile({ id, approvalComment, metadata }: RejectDocumentRequestFileParameters): Promise<void>;
-    updateDocumentRequestFile({ id, title, approvalComment, metadata }: UpdateDocumentRequestFileParameters): Promise<DocumentRequestFile>;
-    deleteDocumentRequestFile({ id, metadata }: DeleteDocumentRequestFileParameters): Promise<void>;
-    createDocumentFile(content: Uint8Array | ReadableStream<Uint8Array>, originalFileName: string | null, transaction?: Transaction): Promise<DocumentFile>;
-    createDocumentRequestFile({ requestId, title, subtitle, date, summary, tags, originalFileName, metadata }: CreateDocumentRequestFileParameters, content: Uint8Array | ReadableStream<Uint8Array>): Promise<DocumentRequestFile>;
-    createDocumentRequest(parameters: CreateDocumentRequestParameters, transaction?: Transaction): Promise<DocumentRequest>;
-    createDocumentRequestAssignmentTask({ originalFileName, collectionIds }: {
-        originalFileName: string;
-        collectionIds: string[];
-    }, content: Uint8Array | ReadableStream<Uint8Array>): Promise<DocumentRequestAssignmentTask>;
-    updateDocument(parameters: UpdateDocumentParameters, transaction?: Transaction): Promise<void>;
-    updateDocumentRequest(parameters: UpdateDocumentRequestParameters, transaction?: Transaction): Promise<void>;
-    deleteDocumentRequest({ id, metadata }: DeleteDocumentRequestParameters, transaction?: Transaction): Promise<void>;
-    setPropertyValues({ documentId, requestFileId, requestAssignmentTaskId, properties: items }: SetDocumentPropertiesParameters, transaction?: Transaction): Promise<void>;
-    addDocumentToCollection(parameters: AddOrArchiveDocumentToOrFromCollectionParameters, transaction?: Transaction): Promise<void>;
-    archiveDocument({ collectionId, documentId, metadata }: AddOrArchiveDocumentToOrFromCollectionParameters): Promise<void>;
-    createProperty(parameters: CreateDocumentPropertyParameters): Promise<DocumentProperty>;
-    assignPropertyToType(parameters: AssignPropertyToTypeParameters): Promise<void>;
-    protected enrichDocument(documentId: string): Promise<void>;
-    protected enrichDocumentRequestFile(requestFileId: string): Promise<void>;
-    protected enrichDocumentRequestAssignmentTask(requestAssignmentTaskId: string): Promise<void>;
-    protected assignDocumentRequest(requestAssignmentTaskId: string): Promise<void>;
-    protected extractFileInformation(fileId: string, assumeTypeId?: string | null): Promise<DocumentInformationExtractionResult>;
-    protected getDocumentFileContent(fileId: string): Promise<Uint8Array>;
-    protected getDocumentFileContentStream(fileId: string): ReadableStream<Uint8Array>;
-    protected getDocumentFileContentObjectUrl(title: string, file: DocumentFile, download: boolean): Promise<string>;
-    protected publishChange({ collectionIds, documentIds, requestIds, requestFileIds, requestAssignmentTaskIds: requestAssignmentTasksIds }: {
-        collectionIds?: string[];
-        documentIds?: string[];
-        requestIds?: string[];
-        requestFileIds?: string[];
-        requestAssignmentTaskIds?: string[];
-    }): void;
+    initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string>(categoryNames: Record<CategoryKey, string>, categoryParents: Record<CategoryKey, CategoryKey | null>, typeNames: Record<TypeKey, string>, typeCategories: Record<TypeKey, CategoryKey>): Promise<{
+        categories: Record<CategoryKey, DocumentCategory>;
+        types: Record<TypeKey, DocumentType>;
+    }>;
 }
-export {};