@tstdl/base 0.91.49 → 0.91.51

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

@@ -0,0 +1,50 @@
+import { EntityMetadata } from '../../../orm/entity.js';
+import { array, assign, nullable, object, omit, oneOrMany, optional, partial, pick, record, string, unknown } from '../../../schema/index.js';
+import { DocumentCategory } from '../document-category.model.js';
+import { DocumentCollectionDocument } from '../document-collection-document.model.js';
+import { DocumentFile } from '../document-file.model.js';
+import { DocumentPropertyValueBase } from '../document-property-value.model.js';
+import { DocumentProperty } from '../document-property.model.js';
+import { DocumentRequestFile } from '../document-request-file.model.js';
+import { DocumentRequestTemplate } from '../document-request-template.js';
+import { DocumentRequest } from '../document-request.model.js';
+import { DocumentRequestsTemplate } from '../document-requests-template.js';
+import { DocumentTypeProperty } from '../document-type-property.model.js';
+import { DocumentType } from '../document-type.model.js';
+import { Document } from '../document.model.js';
+export const metadataParameterSchema = optional(partial(pick(EntityMetadata, 'attributes')));
+export const metadataParameterObjectSchema = object({ metadata: metadataParameterSchema });
+export const setDocumentPropertyParametersSchema = assign(pick(DocumentPropertyValueBase, ['documentId', 'propertyId']), object({ value: unknown() }), metadataParameterObjectSchema);
+export const createDocumentParametersSchema = assign(pick(Document, ['typeId', 'addition', 'date', 'expiration']), pick(DocumentFile, ['originalFileName']), object({
+    collectionIds: oneOrMany(string()),
+    properties: optional(array(omit(setDocumentPropertyParametersSchema, ['documentId'])))
+}), metadataParameterObjectSchema);
+export const updateDocumentParametersSchema = assign(pick(Document, ['id']), partial(omit(Document, ['id', 'metadata'])), object({ properties: optional(array(omit(setDocumentPropertyParametersSchema, ['documentId']))) }), metadataParameterObjectSchema);
+export const createDocumentRequestsTemplateParametersSchema = assign(pick(DocumentRequestsTemplate, ['label', 'description']), metadataParameterObjectSchema);
+export const updateDocumentRequestsTemplateParametersSchema = assign(pick(DocumentRequestsTemplate, ['id']), partial(omit(DocumentRequestsTemplate, ['id', 'metadata'])), metadataParameterObjectSchema);
+export const applyDocumentRequestsTemplateParametersSchema = assign(pick(DocumentRequestsTemplate, ['id']), object({ collectionIds: array(string()) }), metadataParameterObjectSchema);
+export const deleteDocumentRequestsTemplateParametersSchema = assign(pick(DocumentRequestsTemplate, ['id']), metadataParameterObjectSchema);
+export const createDocumentRequestTemplateParametersSchema = assign(pick(DocumentRequestTemplate, ['requestsTemplateId', 'typeId', 'requiredFilesCount', 'comment']), metadataParameterObjectSchema);
+export const updateDocumentRequestTemplateParametersSchema = assign(pick(DocumentRequestTemplate, ['id']), partial(omit(DocumentRequestTemplate, ['id', 'requestsTemplateId', 'metadata'])), metadataParameterObjectSchema);
+export const deleteDocumentRequestTemplateParametersSchema = assign(pick(DocumentRequestTemplate, ['id']), metadataParameterObjectSchema);
+export const createDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['typeId', 'requiredFilesCount', 'comment']), object({ collectionIds: array(string()) }), metadataParameterObjectSchema);
+export const updateDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['id']), partial(omit(DocumentRequest, ['id', 'metadata'])), metadataParameterObjectSchema);
+export const deleteDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['id']), metadataParameterObjectSchema);
+export const updateDocumentRequestFileParametersSchema = assign(pick(DocumentRequestFile, ['id']), partial(omit(DocumentRequestFile, ['id', 'requestId', 'fileId', 'createdDocumentId', 'approval', 'metadata'])), metadataParameterObjectSchema);
+export const deleteDocumentRequestFileParametersSchema = assign(pick(DocumentRequestFile, ['id']), metadataParameterObjectSchema);
+export const loadDataCollectionMetadataParametersSchema = object({ name: optional(nullable(string())), group: optional(nullable(string())) });
+export const loadDataCollectionsMetadataParametersSchema = record(string(), loadDataCollectionMetadataParametersSchema);
+export const loadDataParametersSchema = object({ collectionIds: oneOrMany(string()), collectionsMetadata: loadDataCollectionsMetadataParametersSchema });
+export const createCollectionParametersSchema = metadataParameterObjectSchema;
+export const setDocumentPropertiesParametersSchema = array(setDocumentPropertyParametersSchema);
+export const createDocumentCategoryParametersSchema = assign(pick(DocumentCategory, ['label']), metadataParameterObjectSchema);
+export const createDocumentTypeParametersSchema = assign(pick(DocumentType, ['categoryId', 'group', 'label']), metadataParameterObjectSchema);
+export const createDocumentRequestFileParametersSchema = assign(object({ requestId: string() }), pick(DocumentRequestFile, ['addition']), pick(DocumentFile, ['originalFileName']), metadataParameterObjectSchema);
+export const approveDocumentRequestFileParametersSchema = assign(pick(DocumentRequestFile, ['id', 'approvalComment']), object({
+    documentMetadata: metadataParameterSchema,
+    requestFileMetadata: metadataParameterSchema
+}));
+export const rejectDocumentRequestFileParametersSchema = assign(pick(DocumentRequestFile, ['id', 'approvalComment']), metadataParameterObjectSchema);
+export const createDocumentPropertyParametersSchema = assign(pick(DocumentProperty, ['label', 'dataType']), metadataParameterObjectSchema);
+export const assignPropertyToTypeParametersSchema = assign(pick(DocumentTypeProperty, ['typeId', 'propertyId']), metadataParameterObjectSchema);
+export const addOrArchiveDocumentToOrFromCollectionParametersSchema = assign(pick(DocumentCollectionDocument, ['collectionId', 'documentId']), metadataParameterObjectSchema);

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

@@ -0,0 +1,33 @@
+import { Timestamp } from '../../../orm/types.js';
+import { DocumentCategory } from '../document-category.model.js';
+import { DocumentCollection } from '../document-collection.model.js';
+import { DocumentFile } from '../document-file.model.js';
+import { DocumentPropertyValue } from '../document-property-value.model.js';
+import { DocumentRequestFile } from '../document-request-file.model.js';
+import { DocumentRequest } from '../document-request.model.js';
+import { DocumentType } from '../document-type.model.js';
+import { Document } from '../document.model.js';
+export declare class DocumentCollectionView extends DocumentCollection {
+    name: string | null;
+    group: string | null;
+}
+export declare class DocumentViewCollectionAssignment {
+    collectionId: string;
+    archiveTimestamp: Timestamp | null;
+}
+export declare class DocumentView extends Document {
+    collectionAssignments: DocumentViewCollectionAssignment[];
+    properties: DocumentPropertyValue[];
+}
+export declare class DocumentRequestView extends DocumentRequest {
+    collectionIds: string[];
+    requestFiles: DocumentRequestFile[];
+}
+export declare class DocumentManagementData {
+    collections: DocumentCollectionView[];
+    documents: DocumentView[];
+    requests: DocumentRequestView[];
+    files: DocumentFile[];
+    categories: DocumentCategory[];
+    types: DocumentType[];
+}

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

@@ -0,0 +1,99 @@
+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 { Timestamp } from '../../../orm/types.js';
+import { Array, StringProperty } from '../../../schema/index.js';
+import { DocumentCategory } from '../document-category.model.js';
+import { DocumentCollection } from '../document-collection.model.js';
+import { DocumentFile } from '../document-file.model.js';
+import { documentPropertyValueSchema } from '../document-property-value.model.js';
+import { DocumentRequestFile } from '../document-request-file.model.js';
+import { DocumentRequest } from '../document-request.model.js';
+import { DocumentType } from '../document-type.model.js';
+import { Document } from '../document.model.js';
+export class DocumentCollectionView extends DocumentCollection {
+    name;
+    group;
+}
+__decorate([
+    StringProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], DocumentCollectionView.prototype, "name", void 0);
+__decorate([
+    StringProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], DocumentCollectionView.prototype, "group", void 0);
+export class DocumentViewCollectionAssignment {
+    collectionId;
+    archiveTimestamp;
+}
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], DocumentViewCollectionAssignment.prototype, "collectionId", void 0);
+__decorate([
+    Timestamp({ nullable: true }),
+    __metadata("design:type", Object)
+], DocumentViewCollectionAssignment.prototype, "archiveTimestamp", void 0);
+export class DocumentView extends Document {
+    collectionAssignments;
+    properties;
+}
+__decorate([
+    Array(DocumentViewCollectionAssignment),
+    __metadata("design:type", Array)
+], DocumentView.prototype, "collectionAssignments", void 0);
+__decorate([
+    Array(documentPropertyValueSchema),
+    __metadata("design:type", Array)
+], DocumentView.prototype, "properties", void 0);
+export class DocumentRequestView extends DocumentRequest {
+    collectionIds;
+    requestFiles;
+}
+__decorate([
+    Array(String),
+    __metadata("design:type", Array)
+], DocumentRequestView.prototype, "collectionIds", void 0);
+__decorate([
+    Array(DocumentRequestFile),
+    __metadata("design:type", Array)
+], DocumentRequestView.prototype, "requestFiles", void 0);
+export class DocumentManagementData {
+    collections;
+    documents;
+    requests;
+    files;
+    categories;
+    types;
+}
+__decorate([
+    Array(DocumentCollectionView),
+    __metadata("design:type", Array)
+], DocumentManagementData.prototype, "collections", void 0);
+__decorate([
+    Array(DocumentView),
+    __metadata("design:type", Array)
+], DocumentManagementData.prototype, "documents", void 0);
+__decorate([
+    Array(DocumentRequestView),
+    __metadata("design:type", Array)
+], DocumentManagementData.prototype, "requests", void 0);
+__decorate([
+    Array(DocumentFile),
+    __metadata("design:type", Array)
+], DocumentManagementData.prototype, "files", void 0);
+__decorate([
+    Array(DocumentCategory),
+    __metadata("design:type", Array)
+], DocumentManagementData.prototype, "categories", void 0);
+__decorate([
+    Array(DocumentType),
+    __metadata("design:type", Array)
+], DocumentManagementData.prototype, "types", void 0);

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

@@ -0,0 +1,8 @@
+export * from './categories-and-types.view-model.js';
+export * from './document-folders.view-model.js';
+export * from './document-requests-template.view-model.js';
+export * from './document.service-model.js';
+export * from './document.view-model.js';
+export * from './normalized-document-collection-view.model.js';
+export * from './normalized-requests-template-data.model.js';
+export * from './stats.view-model.js';

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

@@ -0,0 +1,8 @@
+export * from './categories-and-types.view-model.js';
+export * from './document-folders.view-model.js';
+export * from './document-requests-template.view-model.js';
+export * from './document.service-model.js';
+export * from './document.view-model.js';
+export * from './normalized-document-collection-view.model.js';
+export * from './normalized-requests-template-data.model.js';
+export * from './stats.view-model.js';

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

@@ -0,0 +1,73 @@
+import type { TypedOmit } from '../../../types.js';
+import type { DocumentCategory } from '../document-category.model.js';
+import type { DocumentCollection } from '../document-collection.model.js';
+import type { DocumentFile } from '../document-file.model.js';
+import type { DocumentRequestFile } from '../document-request-file.model.js';
+import type { DocumentType } from '../document-type.model.js';
+import type { DocumentManagementData, DocumentRequestView, DocumentView } from './document.view-model.js';
+export type RequestMetadata = {
+    pendingRequestFilesCount: number;
+    approvedRequestFilesCount: number;
+    rejectedRequestFilesCount: number;
+    requiredFilesLeft: number;
+};
+export type RequestsMetadata = RequestMetadata & {
+    requiredFilesCount: number;
+};
+export type GroupedCollectionsItem = RequestsMetadata & {
+    group: string | null;
+    collections: NormalizedDocumentCollectionView[];
+};
+export type NormalizedDocumentManagementData = TypedOmit<DocumentManagementData, 'collections' | 'documents' | 'requests' | 'categories' | 'types'> & RequestsMetadata & {
+    collections: NormalizedDocumentCollectionView[];
+    groupedCollections: GroupedCollectionsItem[];
+    documents: NormalizedDocumentView[];
+    requests: NormalizedDocumentRequestView[];
+    categories: NormalizedDocumentCategory[];
+    types: NormalizedDocumentType[];
+};
+export type GroupedRequestsItem = {
+    category: NormalizedDocumentCategory | null;
+    groups: ({
+        label: string | null;
+        requests: NormalizedDocumentRequestView[];
+    } & RequestsMetadata)[];
+};
+export type NormalizedDocumentCollectionView = DocumentCollection & RequestsMetadata & {
+    name: string | null;
+    group: string | null;
+    documents: NormalizedDocumentView[];
+    requests: NormalizedDocumentRequestView[];
+    groupedRequests: GroupedRequestsItem[];
+};
+export type NormalizedDocumentView = TypedOmit<DocumentView, 'typeId'> & {
+    type: NormalizedDocumentType | null;
+    file: DocumentFile;
+};
+export type NormalizedDocumentRequestView = TypedOmit<DocumentRequestView, 'typeId' | 'requestFiles'> & RequestMetadata & {
+    collections: NormalizedDocumentCollectionView[];
+    type: NormalizedDocumentType | null;
+    files: DocumentFile[];
+    requestFiles: NormalizedDocumentRequestFileView[];
+};
+export type NormalizedDocumentRequestFileView = TypedOmit<DocumentRequestFile, 'fileId'> & {
+    file: DocumentFile;
+};
+export type NormalizedDocumentTypeGroup = {
+    label: string | null;
+    types: NormalizedDocumentType[];
+};
+export type NormalizedDocumentCategory = DocumentCategory & {
+    groups: NormalizedDocumentTypeGroup[];
+    types: NormalizedDocumentType[];
+};
+export type NormalizedDocumentType = TypedOmit<DocumentType, 'categoryId'> & {
+    category: DocumentCategory;
+};
+/**
+ * @param primaryCollectionId - if a document request is for multiple collections, remove the primary collection from the request to avoid duplication
+ * @returns
+ */
+export declare function toNormalizedDocumentManagementData(data: DocumentManagementData, options?: {
+    primaryCollectionId?: string | null;
+}): NormalizedDocumentManagementData;

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>;
+}