@tstdl/base 0.92.123 → 0.92.125

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

@@ -1,11 +1,12 @@
 import { EntityMetadata } from '../../../orm/entity.js';
-import { array, assign, nullable, object, omit, oneOrMany, optional, partial, pick, record, string, unknown } from '../../../schema/index.js';
+import { array, assign, boolean, enumeration, never, nullable, number, object, omit, oneOrMany, optional, partial, pick, string, union } from '../../../schema/index.js';
+import { DocumentAssignmentTarget } from '../document-assignment-task.model.js';
 import { DocumentCategory } from '../document-category.model.js';
-import { DocumentCollectionDocument } from '../document-collection-document.model.js';
+import { DocumentCollectionAssignment } from '../document-collection-assignment.model.js';
+import { DocumentCollection } from '../document-collection.model.js';
 import { DocumentFile } from '../document-file.model.js';
-import { DocumentPropertyValueBase } from '../document-property-value.model.js';
+import { DocumentPropertyValue } 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';
@@ -14,42 +15,43 @@ 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, ['propertyId']), object({ value: unknown() }), metadataParameterObjectSchema);
-export const createDocumentParametersSchema = assign(pick(Document, ['typeId', 'title', 'subtitle', 'pages', 'date', 'summary', 'tags', 'validated']), pick(DocumentFile, ['originalFileName']), object({
-    collectionIds: oneOrMany(string()),
-    properties: optional(array(setDocumentPropertyParametersSchema))
+export const setDocumentPropertyParametersSchema = assign(pick(DocumentPropertyValue, ['propertyId']), object({ value: union(string(), number(), boolean(), nullable(never())) }), metadataParameterObjectSchema);
+export const createDocumentParametersSchema = assign(pick(Document, ['typeId', 'title', 'subtitle', 'date', 'summary', 'tags', 'approval', 'comment', 'createUserId']), pick(DocumentFile, ['originalFileName']), object({
+    assignment: union(object({ collections: oneOrMany(string(), { minimum: 1 }) }), object({ request: string() }), object({
+        automatic: object({
+            /** collection ids to assign in */
+            scope: oneOrMany(string(), { minimum: 1 }),
+            target: enumeration(DocumentAssignmentTarget),
+        }),
+    })),
+    properties: optional(array(setDocumentPropertyParametersSchema)),
 }), metadataParameterObjectSchema);
 export const updateDocumentParametersSchema = assign(pick(Document, ['id']), partial(omit(Document, ['id', 'metadata'])), object({ properties: optional(array(setDocumentPropertyParametersSchema)) }), metadataParameterObjectSchema);
+export const approveDocumentParametersSchema = assign(pick(Document, ['id', 'comment']), metadataParameterObjectSchema);
+export const rejectDocumentParametersSchema = assign(pick(Document, ['id', 'comment']), 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 createDocumentRequestTemplateParametersSchema = assign(pick(DocumentRequestTemplate, ['requestsTemplateId', 'typeId', '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 createDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['typeId', 'comment']), object({ collectionIds: array(string()) }), metadataParameterObjectSchema);
+export const updateDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['id']), partial(pick(DocumentRequest, ['typeId', 'comment'])), 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 loadDataParametersSchema = object({ collectionIds: oneOrMany(string()) });
+export const createCollectionParametersSchema = assign(pick(DocumentCollection, ['parentId']), metadataParameterObjectSchema);
 export const setDocumentPropertiesParametersSchema = object({
-    documentId: optional(string()),
-    requestFileId: optional(string()),
-    requestAssignmentTaskId: optional(string()),
-    properties: array(setDocumentPropertyParametersSchema)
+    documentId: string(),
+    properties: 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, ['title', 'subtitle', 'pages', 'date', 'summary', 'tags']), pick(DocumentFile, ['originalFileName']), metadataParameterObjectSchema);
-export const approveDocumentRequestFileParametersSchema = assign(pick(DocumentRequestFile, ['id', 'approvalComment']), object({
+export const createDocumentCategoryParametersSchema = assign(pick(DocumentCategory, ['parentId', 'label']), metadataParameterObjectSchema);
+export const createDocumentTypeParametersSchema = assign(pick(DocumentType, ['categoryId', 'label']), metadataParameterObjectSchema);
+export const approveDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['id', 'comment']), object({
     documentMetadata: metadataParameterSchema,
-    requestFileMetadata: metadataParameterSchema
+    requestMetadata: metadataParameterSchema,
 }));
-export const rejectDocumentRequestFileParametersSchema = assign(pick(DocumentRequestFile, ['id', 'approvalComment']), metadataParameterObjectSchema);
+export const rejectDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['id', 'comment']), 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);
+export const addOrArchiveDocumentToOrFromCollectionParametersSchema = assign(pick(DocumentCollectionAssignment, ['collectionId', 'documentId']), metadataParameterObjectSchema);

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

@@ -0,0 +1,11 @@
+import type { TypedOmit } from '../../../../types.js';
+import type { DocumentCollectionAssignment } from '../../document-collection-assignment.model.js';
+import type { EnrichedDocumentCollection } from './enriched-document-collection.view.js';
+import type { EnrichedDocument } from './enriched-document.view.js';
+export declare class EnrichedDocumentAssignment implements TypedOmit<DocumentCollectionAssignment, 'collectionId' | 'documentId' | 'metadata'> {
+    readonly id: string;
+    readonly collection: EnrichedDocumentCollection;
+    readonly document: EnrichedDocument;
+    readonly archiveTimestamp: number | null;
+    constructor(id: string, collection: EnrichedDocumentCollection, document: EnrichedDocument, archiveTimestamp: number | null);
+}

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

@@ -0,0 +1,12 @@
+export class EnrichedDocumentAssignment {
+    id;
+    collection;
+    document;
+    archiveTimestamp;
+    constructor(id, collection, document, archiveTimestamp) {
+        this.id = id;
+        this.collection = collection;
+        this.document = document;
+        this.archiveTimestamp = archiveTimestamp;
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { DocumentCategory } from '../../document-category.model.js';
+import { EnrichedDocumentType } from './enriched-document-type.view.js';
+import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+export declare class EnrichedDocumentCategory implements Pick<DocumentCategory, 'id' | 'label'> {
+    #private;
+    readonly id: string;
+    readonly label: string;
+    readonly parent: EnrichedDocumentCategory | null;
+    get children(): EnrichedDocumentCategory[];
+    get childrenDeep(): EnrichedDocumentCategory[];
+    get types(): EnrichedDocumentType[];
+    constructor(data: EnrichedDocumentManagementData, category: DocumentCategory, parent: EnrichedDocumentCategory | null);
+}

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

@@ -0,0 +1,47 @@
+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 { Memoize } from '../../../../utils/function/memoize.js';
+import { EnrichedDocumentType } from './enriched-document-type.view.js';
+export class EnrichedDocumentCategory {
+    #data;
+    id;
+    label;
+    parent;
+    get children() {
+        return this.#data.rawData.categories.filter((category) => category.parentId == this.id).map((category) => new EnrichedDocumentCategory(this.#data, category, this));
+    }
+    get childrenDeep() {
+        return this.children.flatMap((child) => [child, ...child.childrenDeep]);
+    }
+    get types() {
+        return this.#data.rawData.types.filter((type) => type.categoryId == this.id).map((type) => new EnrichedDocumentType(type, this));
+    }
+    constructor(data, category, parent) {
+        this.#data = data;
+        this.id = category.id;
+        this.label = category.label;
+        this.parent = parent;
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCategory.prototype, "children", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCategory.prototype, "childrenDeep", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCategory.prototype, "types", null);

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

@@ -0,0 +1,22 @@
+import type { TypedOmit } from '../../../../types.js';
+import type { DocumentCollectionView } from '../document-management.view-model.js';
+import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+import type { EnrichedDocumentRequest } from './enriched-document-request.view.js';
+import type { EnrichedDocument } from './enriched-document.view.js';
+import { type RequestsStats } from './enriched.js';
+export declare class EnrichedDocumentCollection implements TypedOmit<DocumentCollectionView, 'parentId' | 'metadata'> {
+    #private;
+    readonly id: string;
+    readonly name: string;
+    readonly group: string | null;
+    readonly parent: EnrichedDocumentCollection | null;
+    get children(): EnrichedDocumentCollection[];
+    get childrenDeep(): EnrichedDocumentCollection[];
+    get documents(): EnrichedDocument[];
+    get documentsDeep(): EnrichedDocument[];
+    get requests(): EnrichedDocumentRequest[];
+    get requestsDeep(): EnrichedDocumentRequest[];
+    get requestsStats(): RequestsStats;
+    get requestsStatsDeep(): RequestsStats;
+    constructor(data: EnrichedDocumentManagementData, collectionView: DocumentCollectionView, parent: EnrichedDocumentCollection | null);
+}

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

@@ -0,0 +1,89 @@
+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 { Memoize } from '../../../../utils/function/memoize.js';
+import { calculateRequestsStats, mergeRequestsStats } from './enriched.js';
+export class EnrichedDocumentCollection {
+    #data;
+    id;
+    name;
+    group;
+    parent;
+    get children() {
+        return this.#data.collections.filter((collection) => collection.parent?.id == this.id);
+    }
+    get childrenDeep() {
+        return this.children.flatMap((child) => [child, ...child.childrenDeep]);
+    }
+    get documents() {
+        return this.#data.documents.filter((document) => document.assignments.some((assignment) => assignment.collection.id == this.id));
+    }
+    get documentsDeep() {
+        return [...this.documents, ...this.children.flatMap((child) => child.documentsDeep)];
+    }
+    get requests() {
+        return this.#data.requests.filter((request) => request.collections.some((collection) => collection.id == this.id));
+    }
+    get requestsDeep() {
+        return [...this.requests, ...this.children.flatMap((child) => child.requestsDeep)];
+    }
+    get requestsStats() {
+        return calculateRequestsStats(this.requests);
+    }
+    get requestsStatsDeep() {
+        return mergeRequestsStats(this.children.map((child) => child.requestsStatsDeep));
+    }
+    constructor(data, collectionView, parent) {
+        this.#data = data;
+        this.id = collectionView.id;
+        this.name = collectionView.name;
+        this.group = collectionView.group;
+        this.parent = parent;
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCollection.prototype, "children", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCollection.prototype, "childrenDeep", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCollection.prototype, "documents", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCollection.prototype, "documentsDeep", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCollection.prototype, "requests", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCollection.prototype, "requestsDeep", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCollection.prototype, "requestsStats", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentCollection.prototype, "requestsStatsDeep", null);

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

@@ -0,0 +1,12 @@
+import type { TypedOmit } from '../../../../types.js';
+import type { DocumentFile } from '../../document-file.model.js';
+import type { EnrichedDocument } from './enriched-document.view.js';
+export declare class EnrichedDocumentFile implements TypedOmit<DocumentFile, 'metadata'> {
+    readonly id: string;
+    readonly originalFileName: string | null;
+    readonly mimeType: string;
+    readonly hash: string;
+    readonly size: number;
+    readonly document: EnrichedDocument;
+    constructor(file: DocumentFile, document: EnrichedDocument);
+}

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

@@ -0,0 +1,16 @@
+export class EnrichedDocumentFile {
+    id;
+    originalFileName;
+    mimeType;
+    hash;
+    size;
+    document;
+    constructor(file, document) {
+        this.id = file.id;
+        this.originalFileName = file.originalFileName;
+        this.mimeType = file.mimeType;
+        this.hash = file.hash;
+        this.size = file.size;
+        this.document = document;
+    }
+}

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

@@ -0,0 +1,41 @@
+import type { DocumentManagementData } from '../document-management.view-model.js';
+import { EnrichedDocumentCategory } from './enriched-document-category.view.js';
+import { EnrichedDocumentCollection } from './enriched-document-collection.view.js';
+import { EnrichedDocumentRequest } from './enriched-document-request.view.js';
+import type { EnrichedDocumentType } from './enriched-document-type.view.js';
+import { EnrichedDocument } from './enriched-document.view.js';
+import { type RequestsStats } from './enriched.js';
+export declare class EnrichedCollectionsGroup {
+    readonly group: string | null;
+    readonly collections: EnrichedDocumentCollection[];
+    get requestsStats(): RequestsStats;
+    constructor(group: string | null, collections: EnrichedDocumentCollection[]);
+}
+export declare class EnrichedDocumentManagementData {
+    readonly rawData: DocumentManagementData;
+    readonly rawDataMaps: {
+        collections: Map<string, import("../document-management.view-model.js").DocumentCollectionView>;
+        documents: Map<string, import("../document-management.view-model.js").DocumentView>;
+        requests: Map<string, import("../document-management.view-model.js").DocumentRequestView>;
+        files: Map<string, import("../../document-file.model.js").DocumentFile>;
+        categories: Map<string, import("../../document-category.model.js").DocumentCategory>;
+        types: Map<string, import("../../document-type.model.js").DocumentType>;
+    };
+    readonly maps: {
+        collections: Map<string, EnrichedDocumentCollection>;
+        documents: Map<string, EnrichedDocument>;
+        requests: Map<string, EnrichedDocumentRequest>;
+        categories: Map<string, EnrichedDocumentCategory>;
+        types: Map<string, EnrichedDocumentType>;
+    };
+    get rootCollections(): EnrichedDocumentCollection[];
+    get collections(): EnrichedDocumentCollection[];
+    get groupedCollections(): EnrichedCollectionsGroup[];
+    get documents(): EnrichedDocument[];
+    get requests(): EnrichedDocumentRequest[];
+    get rootCategories(): EnrichedDocumentCategory[];
+    get categories(): EnrichedDocumentCategory[];
+    get types(): EnrichedDocumentType[];
+    get requestsStats(): RequestsStats;
+    constructor(data: DocumentManagementData);
+}

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

@@ -0,0 +1,130 @@
+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 { getEntityMap } from '../../../../orm/utils.js';
+import { Memoize } from '../../../../utils/function/memoize.js';
+import { group } from '../../../../utils/iterable-helpers/group.js';
+import { lazyObject } from '../../../../utils/object/lazy-property.js';
+import { isNull } from '../../../../utils/type-guards.js';
+import { EnrichedDocumentCategory } from './enriched-document-category.view.js';
+import { EnrichedDocumentCollection } from './enriched-document-collection.view.js';
+import { EnrichedDocumentRequest } from './enriched-document-request.view.js';
+import { EnrichedDocument } from './enriched-document.view.js';
+import { calculateRequestsStats, mergeRequestsStats } from './enriched.js';
+export class EnrichedCollectionsGroup {
+    group;
+    collections;
+    get requestsStats() {
+        return mergeRequestsStats(this.collections.map((collection) => collection.requestsStats));
+    }
+    constructor(group, collections) {
+        this.group = group;
+        this.collections = collections;
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EnrichedCollectionsGroup.prototype, "requestsStats", null);
+;
+export class EnrichedDocumentManagementData {
+    rawData;
+    rawDataMaps = lazyObject({
+        collections: () => getEntityMap(this.rawData.collections),
+        documents: () => getEntityMap(this.rawData.documents),
+        requests: () => getEntityMap(this.rawData.requests),
+        files: () => getEntityMap(this.rawData.files),
+        categories: () => getEntityMap(this.rawData.categories),
+        types: () => getEntityMap(this.rawData.types),
+    });
+    maps = lazyObject({
+        collections: () => getEntityMap(this.collections),
+        documents: () => getEntityMap(this.documents),
+        requests: () => getEntityMap(this.requests),
+        categories: () => getEntityMap(this.categories),
+        types: () => getEntityMap(this.types),
+    });
+    get rootCollections() {
+        return this.rawData.collections.filter((collection) => isNull(collection.parentId)).map((collection) => new EnrichedDocumentCollection(this, collection, null));
+    }
+    get collections() {
+        return this.rootCollections.flatMap((collection) => [collection, ...collection.childrenDeep]);
+    }
+    get groupedCollections() {
+        const groups = [...group(this.collections, (collection) => collection.group)];
+        return groups.map(([group, collections]) => new EnrichedCollectionsGroup(group, collections));
+    }
+    get documents() {
+        return this.rawData.documents.map((document) => new EnrichedDocument(this, document));
+    }
+    get requests() {
+        return this.rawData.requests.map((request) => new EnrichedDocumentRequest(this, request));
+    }
+    get rootCategories() {
+        return this.rawData.categories.filter((category) => isNull(category.parentId)).map((category) => new EnrichedDocumentCategory(this, category, null));
+    }
+    get categories() {
+        return this.rootCategories.flatMap((category) => [category, ...category.childrenDeep]);
+    }
+    get types() {
+        return this.categories.flatMap((category) => category.types);
+    }
+    get requestsStats() {
+        return calculateRequestsStats(this.requests);
+    }
+    constructor(data) {
+        this.rawData = data;
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentManagementData.prototype, "rootCollections", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentManagementData.prototype, "collections", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentManagementData.prototype, "groupedCollections", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentManagementData.prototype, "documents", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentManagementData.prototype, "requests", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentManagementData.prototype, "rootCategories", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentManagementData.prototype, "categories", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentManagementData.prototype, "types", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentManagementData.prototype, "requestsStats", null);

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

@@ -0,0 +1,17 @@
+import type { TypedOmit } from '../../../../types.js';
+import type { DocumentRequestState } from '../../document-request.model.js';
+import type { DocumentRequestView } from '../document-management.view-model.js';
+import type { EnrichedDocumentCollection } from './enriched-document-collection.view.js';
+import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+import type { EnrichedDocumentType } from './enriched-document-type.view.js';
+import type { EnrichedDocument } from './enriched-document.view.js';
+export declare class EnrichedDocumentRequest implements TypedOmit<DocumentRequestView, 'typeId' | 'documentId' | 'document' | 'collectionIds' | 'metadata'> {
+    #private;
+    readonly id: string;
+    readonly comment: string | null;
+    readonly state: DocumentRequestState;
+    get type(): EnrichedDocumentType;
+    get document(): EnrichedDocument | null;
+    get collections(): EnrichedDocumentCollection[];
+    constructor(data: EnrichedDocumentManagementData, request: DocumentRequestView);
+}

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

@@ -0,0 +1,52 @@
+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 { Memoize } from '../../../../utils/function/memoize.js';
+import { assertDefinedPass } from '../../../../utils/type-guards.js';
+export class EnrichedDocumentRequest {
+    #data;
+    #documentRequestView;
+    id;
+    comment;
+    state;
+    get type() {
+        return assertDefinedPass(this.#data.types.find((type) => type.id == this.#documentRequestView.typeId));
+    }
+    get document() {
+        if (this.#documentRequestView.documentId == null) {
+            return null;
+        }
+        return assertDefinedPass(this.#data.documents.find((document) => document.id == this.#documentRequestView.documentId));
+    }
+    get collections() {
+        return this.#documentRequestView.collectionIds.map((collectionId) => assertDefinedPass(this.#data.collections.find((collection) => collection.id == collectionId)));
+    }
+    constructor(data, request) {
+        this.#data = data;
+        this.#documentRequestView = request;
+        this.id = request.id;
+        this.comment = request.comment;
+        this.state = request.state;
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentRequest.prototype, "type", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentRequest.prototype, "document", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocumentRequest.prototype, "collections", null);

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

@@ -0,0 +1,9 @@
+import type { TypedOmit } from '../../../../types.js';
+import type { DocumentType } from '../../document-type.model.js';
+import type { EnrichedDocumentCategory } from './enriched-document-category.view.js';
+export declare class EnrichedDocumentType implements TypedOmit<DocumentType, 'categoryId' | 'metadata'> {
+    readonly id: string;
+    readonly label: string;
+    readonly category: EnrichedDocumentCategory;
+    constructor(type: DocumentType, category: EnrichedDocumentCategory);
+}

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

@@ -0,0 +1,10 @@
+export class EnrichedDocumentType {
+    id;
+    label;
+    category;
+    constructor(type, category) {
+        this.id = type.id;
+        this.label = type.label;
+        this.category = category;
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { TypedOmit } from '../../../../types.js';
+import type { DocumentValidationExecution } from '../../document-validation-execution.model.js';
+import type { DocumentWorkflow } from '../../document-workflow.model.js';
+import type { DocumentApproval } from '../../document.model.js';
+import type { DocumentPropertyValueView, DocumentView } from '../document-management.view-model.js';
+import { EnrichedDocumentAssignment } from './enriched-document-assignment.view.js';
+import { EnrichedDocumentFile } from './enriched-document-file.view.js';
+import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+import type { EnrichedDocumentType } from './enriched-document-type.view.js';
+export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId' | 'fileId' | 'collectionAssignments' | 'createUserId' | 'metadata'> {
+    #private;
+    readonly id: string;
+    readonly title: string | null;
+    readonly subtitle: string | null;
+    readonly pages: number | null;
+    readonly date: number | null;
+    readonly summary: string | null;
+    readonly tags: string[] | null;
+    readonly approval: DocumentApproval;
+    readonly comment: string | null;
+    readonly properties: DocumentPropertyValueView[];
+    readonly currentWorkflow: DocumentWorkflow | null;
+    readonly validations: DocumentValidationExecution[] | null;
+    get type(): EnrichedDocumentType | null;
+    get file(): EnrichedDocumentFile;
+    get assignments(): EnrichedDocumentAssignment[];
+    constructor(data: EnrichedDocumentManagementData, document: DocumentView);
+}