@tstdl/base 0.91.50 → 0.91.52

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

@@ -0,0 +1,110 @@
+import { group, map } from '../../../utils/iterable-helpers/index.js';
+import { assertDefinedPass, isNull, isString } from '../../../utils/type-guards.js';
+import { distinct } from '../../../utils/array/array.js';
+import { compareByValueSelection } from '../../../utils/comparison.js';
+/**
+ * @param primaryCollectionId - if a document request is for multiple collections, remove the primary collection from the request to avoid duplication
+ * @returns
+ */
+export function toNormalizedDocumentManagementData(data, options) {
+    const normalizedTypes = data.types.map((type) => ({
+        ...type,
+        category: assertDefinedPass(data.categories.find((category) => category.id == type.categoryId))
+    }));
+    const normalizedCategories = data.categories.map((category) => {
+        const categoryTypes = normalizedTypes.filter((type) => type.category.id == category.id);
+        const categoryGroups = [...group(categoryTypes, (type) => type.group)].map(([label, types]) => ({ label, types })).toSorted(compareByValueSelection(({ label }) => label));
+        return {
+            ...category,
+            types: categoryTypes,
+            groups: categoryGroups
+        };
+    });
+    const normalizedDocuments = data.documents.map((document) => ({
+        ...document,
+        file: assertDefinedPass(data.files.find((file) => file.id == document.fileId)),
+        type: isNull(document.typeId) ? null : assertDefinedPass(normalizedTypes.find((type) => type.id == document.typeId))
+    }));
+    const filteredRequests = isString(options?.primaryCollectionId)
+        ? data.requests.map((request) => ((request.collectionIds.length >= 2) && request.collectionIds.includes(options.primaryCollectionId))
+            ? { ...request, collectionIds: request.collectionIds.filter((collectionId) => collectionId != options.primaryCollectionId) }
+            : request)
+        : data.requests;
+    const normalizedDocumentRequests = filteredRequests.map((request) => ({
+        ...request,
+        collections: [],
+        type: isNull(request.typeId) ? null : assertDefinedPass(normalizedTypes.find((type) => type.id == request.typeId)),
+        files: request.requestFiles.map((requestFile) => assertDefinedPass(data.files.find((file) => file.id == requestFile.fileId))),
+        requestFiles: request.requestFiles.map((requestFile) => ({
+            ...requestFile,
+            file: assertDefinedPass(data.files.find((file) => file.id == requestFile.fileId))
+        })),
+        ...calculateRequestMetadata(request)
+    }));
+    const normalizedCollections = data.collections.map((collection) => {
+        const collectionRequests = normalizedDocumentRequests.filter((request) => request.collectionIds.includes(collection.id));
+        const groupedCollectionRequests = [...map(group(collectionRequests, (request) => request.type?.category.id), ([categoryId, requests]) => ({
+                category: normalizedCategories.find((c) => c.id == categoryId) ?? null,
+                groups: [...map(group(requests, (request) => request.type?.group), ([groupLabel, groupRequests]) => ({ label: groupLabel ?? null, requests: groupRequests, ...calculateRequestsMetadata(groupRequests) }))]
+            }))];
+        return {
+            ...collection,
+            documents: normalizedDocuments.filter((document) => document.collectionAssignments.some((assignment) => assignment.collectionId == collection.id)),
+            requests: collectionRequests,
+            groupedRequests: groupedCollectionRequests,
+            ...calculateRequestsMetadata(collectionRequests)
+        };
+    });
+    for (const collection of normalizedCollections) {
+        for (const request of collection.requests) {
+            request.collections.push(collection);
+        }
+    }
+    const groupedCollections = [
+        ...map(group(normalizedCollections, (collection) => collection.group), ([group, collections]) => {
+            const collectionsRequests = distinct(collections.flatMap((collection) => collection.requests), (request) => request.id);
+            return {
+                group,
+                collections,
+                ...calculateRequestsMetadata(collectionsRequests)
+            };
+        })
+    ];
+    return {
+        ...data,
+        collections: normalizedCollections,
+        groupedCollections,
+        requests: normalizedDocumentRequests,
+        documents: normalizedDocuments,
+        categories: normalizedCategories,
+        types: normalizedTypes,
+        ...calculateRequestsMetadata(filteredRequests)
+    };
+}
+function calculateRequestsMetadata(requests) {
+    const requestMetadatas = requests.map(calculateRequestMetadata);
+    const requiredFilesCount = requests.reduce((sum, request) => (sum + request.requiredFilesCount), 0);
+    const pendingRequestFilesCount = requestMetadatas.reduce((sum, metadata) => (sum + metadata.pendingRequestFilesCount), 0);
+    const approvedRequestFilesCount = requestMetadatas.reduce((sum, metadata) => (sum + metadata.approvedRequestFilesCount), 0);
+    const rejectedRequestFilesCount = requestMetadatas.reduce((sum, metadata) => (sum + metadata.rejectedRequestFilesCount), 0);
+    const requiredFilesLeft = requestMetadatas.reduce((sum, metadata) => (sum + metadata.requiredFilesLeft), 0);
+    return {
+        requiredFilesCount,
+        pendingRequestFilesCount,
+        approvedRequestFilesCount,
+        rejectedRequestFilesCount,
+        requiredFilesLeft
+    };
+}
+function calculateRequestMetadata(request) {
+    const pendingRequestFilesCount = request.completed ? 0 : request.requestFiles.reduce((sum, requestFile) => (sum + (isNull(requestFile.approval) ? 1 : 0)), 0);
+    const approvedRequestFilesCount = request.requestFiles.reduce((sum, requestFile) => (sum + ((requestFile.approval == true) ? 1 : 0)), 0);
+    const rejectedRequestFilesCount = request.requestFiles.reduce((sum, requestFile) => (sum + ((requestFile.approval == false) ? 1 : 0)), 0);
+    const requiredFilesLeft = request.completed ? 0 : Math.max(0, request.requiredFilesCount - approvedRequestFilesCount);
+    return {
+        pendingRequestFilesCount,
+        approvedRequestFilesCount,
+        rejectedRequestFilesCount,
+        requiredFilesLeft
+    };
+}

package/document-management/models/service-models/normalized-requests-template-data.model.d.ts

@@ -0,0 +1,16 @@
+import type { TypedOmit } from '../../../types.js';
+import type { DocumentRequestTemplate } from '../document-request-template.js';
+import type { DocumentRequestsTemplateData, DocumentRequestsTemplateView } from './document-requests-template.view-model.js';
+import type { NormalizedDocumentCategory, NormalizedDocumentManagementData, NormalizedDocumentType } from './normalized-document-collection-view.model.js';
+export type NormalizedDocumentRequestsTemplateData = TypedOmit<DocumentRequestsTemplateData, 'templates'> & {
+    templates: NormalizedDocumentRequestsTemplateView[];
+    categories: NormalizedDocumentCategory[];
+    types: NormalizedDocumentType[];
+};
+export type NormalizedDocumentRequestsTemplateView = TypedOmit<DocumentRequestsTemplateView, 'requestTemplates'> & {
+    requestTemplates: NormalizedDocumentRequestTemplate[];
+};
+export type NormalizedDocumentRequestTemplate = TypedOmit<DocumentRequestTemplate, 'typeId'> & {
+    type: NormalizedDocumentType | null;
+};
+export declare function toNormalizedDocumentRequestsTemplateData(templateData: DocumentRequestsTemplateData, documentManagementData: NormalizedDocumentManagementData): NormalizedDocumentRequestsTemplateData;

package/document-management/models/service-models/normalized-requests-template-data.model.js

@@ -0,0 +1,13 @@
+export function toNormalizedDocumentRequestsTemplateData(templateData, documentManagementData) {
+    return {
+        templates: templateData.templates.map((template) => ({
+            ...template,
+            requestTemplates: template.requestTemplates.map((requestTemplate) => ({
+                ...requestTemplate,
+                type: documentManagementData.types.find((type) => type.id == requestTemplate.typeId) ?? null
+            }))
+        })),
+        categories: documentManagementData.categories,
+        types: documentManagementData.types
+    };
+}

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

@@ -0,0 +1,6 @@
+export declare class RequestFilesStats {
+    requiredFilesCount: number;
+    requiredFilesLeft: number;
+    pendingFilesCount: number;
+    approvedFilesCount: number;
+}

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

@@ -0,0 +1,32 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { NumberProperty } from '../../../schema/index.js';
+export class RequestFilesStats {
+    requiredFilesCount;
+    requiredFilesLeft;
+    pendingFilesCount;
+    approvedFilesCount;
+}
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestFilesStats.prototype, "requiredFilesCount", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestFilesStats.prototype, "requiredFilesLeft", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestFilesStats.prototype, "pendingFilesCount", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestFilesStats.prototype, "approvedFilesCount", void 0);

package/document-management/module.d.ts

@@ -0,0 +1,11 @@
+import './models/schemas.js';
+import { type InjectionToken } from '../injector/index.js';
+import type { DatabaseConfig } from '../orm/module.js';
+import { DocumentManagementService } from './services/document-management.service.js';
+export declare class DocumentManagementConfig {
+    fileObjectStorageModule: string;
+    database: DatabaseConfig;
+    customService?: InjectionToken<DocumentManagementService>;
+}
+export declare function configureDocumentManagement(config: DocumentManagementConfig): void;
+export declare function migrateDocumentManagementSchema(): Promise<void>;

package/document-management/module.js

@@ -0,0 +1,27 @@
+import './models/schemas.js';
+import { migrate } from 'drizzle-orm/node-postgres/migrator';
+import { inject, Injector } from '../injector/index.js';
+import { Database } from '../orm/database.js';
+import { isDefined } from '../utils/type-guards.js';
+import { DocumentManagementService } from './services/document-management.service.js';
+export class DocumentManagementConfig {
+    fileObjectStorageModule;
+    database;
+    customService;
+}
+;
+export function configureDocumentManagement(config) {
+    Injector.register(DocumentManagementConfig, { useValue: config });
+    if (isDefined(config.customService)) {
+        Injector.register(DocumentManagementService, { useToken: config.customService });
+    }
+}
+export async function migrateDocumentManagementSchema() {
+    const config = inject(DocumentManagementConfig);
+    const database = inject(Database, config.database.connection);
+    await migrate(database, {
+        migrationsSchema: 'document_management',
+        migrationsTable: '_migrations',
+        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', '')
+    });
+}

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

@@ -0,0 +1,65 @@
+import { Resolvable, resolveArgumentType } from '../../injector/index.js';
+import { ObjectStorage } from '../../object-storage/index.js';
+import { Query, Transaction } from '../../orm/index.js';
+import { OneOrMany } from '../../types.js';
+import { AddOrArchiveDocumentToOrFromCollectionParameters, ApplyDocumentRequestsTemplateParameters, ApproveDocumentRequestFileParameters, AssignPropertyToTypeParameters, CategoryAndTypesView, CreateCollectionParameters, CreateDocumentCategoryParameters, CreateDocumentParameters, CreateDocumentPropertyParameters, CreateDocumentRequestFileParameters, CreateDocumentRequestParameters, CreateDocumentRequestTemplateParameters, CreateDocumentRequestsTemplateParameters, CreateDocumentTypeParameters, DeleteDocumentRequestFileParameters, DeleteDocumentRequestParameters, DeleteDocumentRequestTemplateParameters, DeleteDocumentRequestsTemplateParameters, Document, DocumentCategory, DocumentCollection, DocumentCollectionDocument, DocumentFile, DocumentManagementData, DocumentProperty, DocumentPropertyBooleanValue, DocumentPropertyDataType, DocumentPropertyDecimalValue, DocumentPropertyIntegerValue, DocumentPropertyTextValue, DocumentRequest, DocumentRequestCollection, DocumentRequestFile, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentRequestsTemplateData, DocumentType, DocumentTypeProperty, LoadDataCollectionsMetadataParameters, RejectDocumentRequestFileParameters, RequestFilesStats, SetDocumentPropertiesParameters, UpdateDocumentParameters, UpdateDocumentRequestFileParameters, UpdateDocumentRequestParameters, UpdateDocumentRequestTemplateParameters, UpdateDocumentRequestsTemplateParameters } from '../models/index.js';
+import { DocumentManagementConfig } from '../module.js';
+export type DocumentServiceArgument = DocumentManagementConfig;
+export declare class DocumentManagementService implements Resolvable<DocumentServiceArgument> {
+    protected readonly documentService: import("../../orm/index.js").EntityRepository<Document>;
+    protected readonly documentFileService: import("../../orm/index.js").EntityRepository<DocumentFile>;
+    protected readonly documentCollectionService: import("../../orm/index.js").EntityRepository<DocumentCollection>;
+    protected readonly documentCategoryService: import("../../orm/index.js").EntityRepository<DocumentCategory>;
+    protected readonly documentTypeService: import("../../orm/index.js").EntityRepository<DocumentType>;
+    protected readonly documentRequestService: import("../../orm/index.js").EntityRepository<DocumentRequest>;
+    protected readonly documentRequestsTemplateService: import("../../orm/index.js").EntityRepository<DocumentRequestsTemplate>;
+    protected readonly documentRequestTemplateService: import("../../orm/index.js").EntityRepository<DocumentRequestTemplate>;
+    protected readonly documentRequestCollectionService: import("../../orm/index.js").EntityRepository<DocumentRequestCollection>;
+    protected readonly documentRequestFileService: import("../../orm/index.js").EntityRepository<DocumentRequestFile>;
+    protected readonly documentPropertyService: import("../../orm/index.js").EntityRepository<DocumentProperty>;
+    protected readonly documentTypePropertyService: import("../../orm/index.js").EntityRepository<DocumentTypeProperty>;
+    protected readonly documentPropertyTextValueService: import("../../orm/index.js").EntityRepository<DocumentPropertyTextValue>;
+    protected readonly documentPropertyIntegerValueService: import("../../orm/index.js").EntityRepository<DocumentPropertyIntegerValue>;
+    protected readonly documentPropertyDecimalValueService: import("../../orm/index.js").EntityRepository<DocumentPropertyDecimalValue>;
+    protected readonly documentPropertyBooleanValueService: import("../../orm/index.js").EntityRepository<DocumentPropertyBooleanValue>;
+    protected readonly documentCollectionDocumentService: import("../../orm/index.js").EntityRepository<DocumentCollectionDocument>;
+    protected readonly fileObjectStorage: ObjectStorage;
+    readonly [resolveArgumentType]: DocumentServiceArgument;
+    loadData(collectionIds: string[], collectionsMetadata?: LoadDataCollectionsMetadataParameters): Promise<DocumentManagementData>;
+    loadDocumentRequestsTemplateData(): Promise<DocumentRequestsTemplateData>;
+    loadCategoriesAndTypes(): Promise<CategoryAndTypesView>;
+    loadDocument(id: string): Promise<Document>;
+    loadDocumentFile(id: string): Promise<DocumentFile>;
+    loadType(id: string): Promise<DocumentType>;
+    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, addition, date, expiration, 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, addition, approvalComment, metadata }: UpdateDocumentRequestFileParameters): Promise<DocumentRequestFile>;
+    deleteDocumentRequestFile({ id, metadata }: DeleteDocumentRequestFileParameters): Promise<void>;
+    createDocumentFile(content: Uint8Array | ReadableStream<Uint8Array>, originalFileName: string | null, dbTransaction?: Transaction): Promise<DocumentFile>;
+    createDocumentRequestFile({ requestId, addition, originalFileName, metadata }: CreateDocumentRequestFileParameters, content: Uint8Array | ReadableStream<Uint8Array>): Promise<DocumentRequestFile>;
+    createDocumentRequest(parameters: CreateDocumentRequestParameters, transaction?: Transaction): Promise<DocumentRequest>;
+    updateDocument(parameters: UpdateDocumentParameters, transaction?: Transaction): Promise<void>;
+    updateDocumentRequest(parameters: UpdateDocumentRequestParameters, transaction?: Transaction): Promise<void>;
+    deleteDocumentRequest({ id, metadata }: DeleteDocumentRequestParameters, transaction?: Transaction): Promise<void>;
+    setDocumentProperties(setDocumentPropertyItems: 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 getDocumentPropertyValueService(dataType: DocumentPropertyDataType): import("../../orm/index.js").EntityRepository<DocumentPropertyTextValue> | import("../../orm/index.js").EntityRepository<DocumentPropertyIntegerValue> | import("../../orm/index.js").EntityRepository<DocumentPropertyBooleanValue>;
+    protected getDocumentFileContentObjectUrl(title: string, file: DocumentFile, download: boolean): Promise<string>;
+}