@tstdl/base 0.92.123 → 0.92.125

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

@@ -0,0 +1,77 @@
+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, isNull } from '../../../../utils/type-guards.js';
+import { EnrichedDocumentAssignment } from './enriched-document-assignment.view.js';
+import { EnrichedDocumentFile } from './enriched-document-file.view.js';
+export class EnrichedDocument {
+    #data;
+    #documentView;
+    id;
+    title;
+    subtitle;
+    pages;
+    date;
+    summary;
+    tags;
+    approval;
+    comment;
+    properties;
+    currentWorkflow;
+    validations;
+    get type() {
+        if (isNull(this.#documentView.typeId)) {
+            return null;
+        }
+        return assertDefinedPass(this.#data.maps.types.get(this.#documentView.typeId));
+    }
+    get file() {
+        const file = assertDefinedPass(this.#data.rawDataMaps.files.get(this.#documentView.fileId));
+        return new EnrichedDocumentFile(file, this);
+    }
+    get assignments() {
+        return this.#documentView.collectionAssignments
+            .map((assignment) => {
+            const collection = assertDefinedPass(this.#data.collections.find((collection) => collection.id == assignment.collectionId));
+            return new EnrichedDocumentAssignment(assignment.id, collection, assertDefinedPass(this.#data.documents.find((document) => document.id == this.#documentView.id)), assignment.archiveTimestamp);
+        });
+    }
+    constructor(data, document) {
+        this.#data = data;
+        this.#documentView = document;
+        this.id = document.id;
+        this.title = document.title;
+        this.subtitle = document.subtitle;
+        this.pages = document.pages;
+        this.date = document.date;
+        this.summary = document.summary;
+        this.tags = document.tags;
+        this.approval = document.approval;
+        this.comment = document.comment;
+        this.properties = document.properties;
+        this.currentWorkflow = document.currentWorkflow;
+        this.validations = document.validations;
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EnrichedDocument.prototype, "type", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", EnrichedDocumentFile),
+    __metadata("design:paramtypes", [])
+], EnrichedDocument.prototype, "file", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], EnrichedDocument.prototype, "assignments", null);

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

@@ -0,0 +1,18 @@
+import type { DocumentManagementData, DocumentRequestView } from '../document-management.view-model.js';
+import { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+import type { EnrichedDocumentRequest } from './enriched-document-request.view.js';
+export type RequestsStats = {
+    /** Open without document */
+    open: number;
+    /** Open with pending approval */
+    pending: number;
+    /** Closed without document */
+    closed: number;
+    /** Closed with rejected document */
+    rejected: number;
+    /** Fulfilled with approved document */
+    fulfilled: number;
+};
+export declare function toEnrichedDocumentManagementData(data: DocumentManagementData): EnrichedDocumentManagementData;
+export declare function calculateRequestsStats(requests: Iterable<DocumentRequestView | EnrichedDocumentRequest>): RequestsStats;
+export declare function mergeRequestsStats(stats: Iterable<RequestsStats>): RequestsStats;

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

@@ -0,0 +1,39 @@
+import { match, P } from 'ts-pattern';
+import { reduce } from '../../../../utils/iterable-helpers/index.js';
+import { _throw } from '../../../../utils/throw.js';
+import { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+export function toEnrichedDocumentManagementData(data) {
+    return new EnrichedDocumentManagementData(data);
+}
+export function calculateRequestsStats(requests) {
+    let open = 0;
+    let pending = 0;
+    let closed = 0;
+    let rejected = 0;
+    let fulfilled = 0;
+    for (const request of requests) {
+        match(request)
+            .with({ state: 'open', document: null }, () => open++)
+            .with({ state: 'open', document: P.nonNullable }, () => pending++)
+            .with({ state: 'closed', document: null }, () => closed++)
+            .with({ state: 'closed', document: { approval: 'rejected' } }, () => rejected++)
+            .with({ state: 'fulfilled', document: { approval: 'approved' } }, () => fulfilled++)
+            .otherwise(() => _throw('Invalid request state'));
+    }
+    return {
+        open,
+        pending,
+        closed,
+        rejected,
+        fulfilled,
+    };
+}
+export function mergeRequestsStats(stats) {
+    return {
+        open: reduce(stats, (a, b) => a + b.open, 0),
+        pending: reduce(stats, (a, b) => a + b.pending, 0),
+        closed: reduce(stats, (a, b) => a + b.closed, 0),
+        rejected: reduce(stats, (a, b) => a + b.rejected, 0),
+        fulfilled: reduce(stats, (a, b) => a + b.fulfilled, 0),
+    };
+}

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

@@ -0,0 +1,9 @@
+export * from './enriched-document-assignment.view.js';
+export * from './enriched-document-category.view.js';
+export * from './enriched-document-collection.view.js';
+export * from './enriched-document-file.view.js';
+export * from './enriched-document-management-data.view.js';
+export * from './enriched-document-request.view.js';
+export * from './enriched-document-type.view.js';
+export * from './enriched-document.view.js';
+export * from './enriched.js';

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

@@ -0,0 +1,9 @@
+export * from './enriched-document-assignment.view.js';
+export * from './enriched-document-category.view.js';
+export * from './enriched-document-collection.view.js';
+export * from './enriched-document-file.view.js';
+export * from './enriched-document-management-data.view.js';
+export * from './enriched-document-request.view.js';
+export * from './enriched-document-type.view.js';
+export * from './enriched-document.view.js';
+export * from './enriched.js';

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

@@ -2,7 +2,7 @@ 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 './document-management.view-model.js';
+export * from './enriched/index.js';
 export * from './normalized-requests-template-data.model.js';
 export * from './stats.view-model.js';

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

@@ -2,7 +2,7 @@ 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 './document-management.view-model.js';
+export * from './enriched/index.js';
 export * from './normalized-requests-template-data.model.js';
 export * from './stats.view-model.js';

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

@@ -1,16 +1,18 @@
 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[];
+import type { EnrichedDocumentCategory } from './enriched/enriched-document-category.view.js';
+import type { EnrichedDocumentManagementData } from './enriched/enriched-document-management-data.view.js';
+import type { EnrichedDocumentType } from './enriched/enriched-document-type.view.js';
+export type EnrichedDocumentRequestsTemplateData = TypedOmit<DocumentRequestsTemplateData, 'templates'> & {
+    templates: EnrichedDocumentRequestsTemplateView[];
+    categories: EnrichedDocumentCategory[];
+    types: EnrichedDocumentType[];
 };
-export type NormalizedDocumentRequestsTemplateView = TypedOmit<DocumentRequestsTemplateView, 'requestTemplates'> & {
-    requestTemplates: NormalizedDocumentRequestTemplate[];
+export type EnrichedDocumentRequestsTemplateView = TypedOmit<DocumentRequestsTemplateView, 'requestTemplates'> & {
+    requestTemplates: EnrichedDocumentRequestTemplate[];
 };
-export type NormalizedDocumentRequestTemplate = TypedOmit<DocumentRequestTemplate, 'typeId'> & {
-    type: NormalizedDocumentType | null;
+export type EnrichedDocumentRequestTemplate = TypedOmit<DocumentRequestTemplate, 'typeId'> & {
+    type: EnrichedDocumentType;
 };
-export declare function toNormalizedDocumentRequestsTemplateData(templateData: DocumentRequestsTemplateData, documentManagementData: NormalizedDocumentManagementData): NormalizedDocumentRequestsTemplateData;
+export declare function toEnrichedDocumentRequestsTemplateData(templateData: DocumentRequestsTemplateData, documentManagementData: EnrichedDocumentManagementData): EnrichedDocumentRequestsTemplateData;

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

@@ -1,13 +1,14 @@
-export function toNormalizedDocumentRequestsTemplateData(templateData, documentManagementData) {
+import { assertDefinedPass } from '../../../utils/type-guards.js';
+export function toEnrichedDocumentRequestsTemplateData(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
-            }))
+                type: assertDefinedPass(documentManagementData.maps.types.get(requestTemplate.typeId)),
+            })),
         })),
         categories: documentManagementData.categories,
-        types: documentManagementData.types
+        types: documentManagementData.types,
     };
 }

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

@@ -1,6 +1,8 @@
-export declare class RequestFilesStats {
-    requiredFilesCount: number;
-    requiredFilesLeft: number;
-    pendingFilesCount: number;
-    approvedFilesCount: number;
+export declare class RequestStats {
+    total: number;
+    documentPending: number;
+    approvalPending: number;
+    approvals: number;
+    rejections: number;
+    closedWithoutDocument: number;
 }

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

@@ -8,25 +8,35 @@ 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;
+export class RequestStats {
+    total;
+    documentPending;
+    approvalPending;
+    approvals;
+    rejections;
+    closedWithoutDocument;
 }
 __decorate([
     NumberProperty(),
     __metadata("design:type", Number)
-], RequestFilesStats.prototype, "requiredFilesCount", void 0);
+], RequestStats.prototype, "total", void 0);
 __decorate([
     NumberProperty(),
     __metadata("design:type", Number)
-], RequestFilesStats.prototype, "requiredFilesLeft", void 0);
+], RequestStats.prototype, "documentPending", void 0);
 __decorate([
     NumberProperty(),
     __metadata("design:type", Number)
-], RequestFilesStats.prototype, "pendingFilesCount", void 0);
+], RequestStats.prototype, "approvalPending", void 0);
 __decorate([
     NumberProperty(),
     __metadata("design:type", Number)
-], RequestFilesStats.prototype, "approvedFilesCount", void 0);
+], RequestStats.prototype, "approvals", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestStats.prototype, "rejections", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestStats.prototype, "closedWithoutDocument", void 0);

package/document-management/server/module.d.ts

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

package/document-management/server/module.js

@@ -1,21 +1,17 @@
 import './schemas.js';
 import { inject, Injector } from '../../injector/index.js';
 import { Database, migrate } from '../../orm/server/database.js';
-import { isDefined } from '../../utils/type-guards.js';
-import { DocumentManagementAncillaryService, DocumentManagementService } from './services/index.js';
+import { DocumentManagementAncillaryService } from './services/document-management-ancillary.service.js';
 export class DocumentManagementConfig {
     ancillaryService;
     fileObjectStorageModule;
+    filePreviewObjectStorageModule;
     database;
-    customService;
 }
 ;
 export function configureDocumentManagement(config) {
     Injector.register(DocumentManagementConfig, { useValue: config });
     Injector.register(DocumentManagementAncillaryService, { useToken: config.ancillaryService });
-    if (isDefined(config.customService)) {
-        Injector.register(DocumentManagementService, { useToken: config.customService });
-    }
 }
 export async function migrateDocumentManagementSchema() {
     const connection = inject(DocumentManagementConfig, undefined, { optional: true })?.database?.connection;
@@ -23,6 +19,6 @@ export async function migrateDocumentManagementSchema() {
     await migrate(database, {
         migrationsSchema: 'document_management',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', '')
+        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
     });
 }

package/document-management/server/schemas.d.ts

@@ -1,36 +1,31 @@
-import { DocumentCategory } from '../models/document-category.model.js';
-import { DocumentCollectionDocument } from '../models/document-collection-document.model.js';
-import { DocumentCollection } from '../models/document-collection.model.js';
-import { DocumentFile } from '../models/document-file.model.js';
-import { DocumentPropertyValue, DocumentRequestAssignmentTaskPropertyValue, DocumentRequestFilePropertyValue } from '../models/document-property-value.model.js';
-import { DocumentProperty } from '../models/document-property.model.js';
-import { DocumentRequestAssignmentTaskCollection } from '../models/document-request-assignment-task-collection.model.js';
-import { DocumentRequestAssignmentTask } from '../models/document-request-assignment-task.model.js';
-import { DocumentRequestCollection } from '../models/document-request-collection.model.js';
-import { DocumentRequestFile } from '../models/document-request-file.model.js';
-import { DocumentRequestTemplate } from '../models/document-request-template.js';
-import { DocumentRequest } from '../models/document-request.model.js';
-import { DocumentRequestsTemplate } from '../models/document-requests-template.js';
-import { DocumentTypeProperty } from '../models/document-type-property.model.js';
-import { DocumentType } from '../models/document-type.model.js';
-import { Document } from '../models/document.model.js';
+import { Document, DocumentAssignmentScope, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentProperty, DocumentPropertyValue, DocumentRequest, DocumentRequestCollection, DocumentRequestsTemplate, DocumentRequestSubmission, DocumentRequestTemplate, DocumentType, DocumentTypeProperty, DocumentTypeValidation, DocumentValidationDefinition, DocumentValidationExecution, DocumentValidationExecutionRelatedDocument, DocumentWorkflow } from '../models/index.js';
 export declare const documentManagementSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"document_management">;
-export declare const dataType: import("drizzle-orm/pg-core").PgEnum<["boolean", "date", "decimal", "text", "integer"]>;
+export declare const aocumentApproval: import("drizzle-orm/pg-core").PgEnum<["pending", "approved", "rejected"]>;
+export declare const documentAssignmentCollectionTarget: import("drizzle-orm/pg-core").PgEnum<["request", "collection"]>;
+export declare const documentPropertyDataType: import("drizzle-orm/pg-core").PgEnum<["boolean", "date", "decimal", "text", "integer"]>;
+export declare const documentRequestState: import("drizzle-orm/pg-core").PgEnum<["open", "closed", "fulfilled"]>;
+export declare const documentValidationExecutionState: import("drizzle-orm/pg-core").PgEnum<["pending", "error", "running", "completed"]>;
+export declare const documentValidationResultStatus: import("drizzle-orm/pg-core").PgEnum<["warning", "failed", "passed"]>;
+export declare const documentWorkflowState: import("drizzle-orm/pg-core").PgEnum<["pending", "error", "running", "completed", "failed"]>;
+export declare const documentWorkflowStep: import("drizzle-orm/pg-core").PgEnum<["classification", "extraction", "assignment", "validation"]>;
 export declare const document: import("../../orm/server/types.js").PgTableFromType<typeof Document, "document_management">;
+export declare const documentAssignmentScope: import("../../orm/server/types.js").PgTableFromType<typeof DocumentAssignmentScope, "document_management">;
+export declare const documentAssignmentTask: import("../../orm/server/types.js").PgTableFromType<typeof DocumentAssignmentTask, "document_management">;
 export declare const documentCategory: import("../../orm/server/types.js").PgTableFromType<typeof DocumentCategory, "document_management">;
 export declare const documentCollection: import("../../orm/server/types.js").PgTableFromType<typeof DocumentCollection, "document_management">;
-export declare const documentCollectionDocument: import("../../orm/server/types.js").PgTableFromType<typeof DocumentCollectionDocument, "document_management">;
+export declare const documentCollectionAssignment: import("../../orm/server/types.js").PgTableFromType<typeof DocumentCollectionAssignment, "document_management">;
 export declare const documentFile: import("../../orm/server/types.js").PgTableFromType<typeof DocumentFile, "document_management">;
 export declare const documentProperty: import("../../orm/server/types.js").PgTableFromType<typeof DocumentProperty, "document_management">;
 export declare const documentPropertyValue: import("../../orm/server/types.js").PgTableFromType<typeof DocumentPropertyValue, "document_management">;
 export declare const documentRequest: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequest, "document_management">;
-export declare const documentRequestAssignmentTask: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestAssignmentTask, "document_management">;
-export declare const documentRequestAssignmentTaskCollection: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestAssignmentTaskCollection, "document_management">;
-export declare const documentRequestAssignmentTaskPropertyValue: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestAssignmentTaskPropertyValue, "document_management">;
 export declare const documentRequestCollection: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestCollection, "document_management">;
-export declare const documentRequestFile: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestFile, "document_management">;
-export declare const documentRequestFilePropertyValue: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestFilePropertyValue, "document_management">;
 export declare const documentRequestsTemplate: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestsTemplate, "document_management">;
+export declare const documentRequestSubmission: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestSubmission, "document_management">;
 export declare const documentRequestTemplate: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestTemplate, "document_management">;
 export declare const documentType: import("../../orm/server/types.js").PgTableFromType<typeof DocumentType, "document_management">;
 export declare const documentTypeProperty: import("../../orm/server/types.js").PgTableFromType<typeof DocumentTypeProperty, "document_management">;
+export declare const documentTypeValidation: import("../../orm/server/types.js").PgTableFromType<typeof DocumentTypeValidation, "document_management">;
+export declare const documentValidationDefinition: import("../../orm/server/types.js").PgTableFromType<typeof DocumentValidationDefinition, "document_management">;
+export declare const documentValidationExecution: import("../../orm/server/types.js").PgTableFromType<typeof DocumentValidationExecution, "document_management">;
+export declare const documentValidationExecutionRelatedDocument: import("../../orm/server/types.js").PgTableFromType<typeof DocumentValidationExecutionRelatedDocument, "document_management">;
+export declare const documentWorkflow: import("../../orm/server/types.js").PgTableFromType<typeof DocumentWorkflow, "document_management">;

package/document-management/server/schemas.js

@@ -1,37 +1,32 @@
 import { databaseSchema } from '../../orm/server/database-schema.js';
-import { DocumentCategory } from '../models/document-category.model.js';
-import { DocumentCollectionDocument } from '../models/document-collection-document.model.js';
-import { DocumentCollection } from '../models/document-collection.model.js';
-import { DocumentFile } from '../models/document-file.model.js';
-import { DocumentPropertyValue, DocumentRequestAssignmentTaskPropertyValue, DocumentRequestFilePropertyValue } from '../models/document-property-value.model.js';
-import { DocumentProperty, DocumentPropertyDataType } from '../models/document-property.model.js';
-import { DocumentRequestAssignmentTaskCollection } from '../models/document-request-assignment-task-collection.model.js';
-import { DocumentRequestAssignmentTask } from '../models/document-request-assignment-task.model.js';
-import { DocumentRequestCollection } from '../models/document-request-collection.model.js';
-import { DocumentRequestFile } from '../models/document-request-file.model.js';
-import { DocumentRequestTemplate } from '../models/document-request-template.js';
-import { DocumentRequest } from '../models/document-request.model.js';
-import { DocumentRequestsTemplate } from '../models/document-requests-template.js';
-import { DocumentTypeProperty } from '../models/document-type-property.model.js';
-import { DocumentType } from '../models/document-type.model.js';
-import { Document } from '../models/document.model.js';
+import { Document, DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTarget, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentRequest, DocumentRequestCollection, DocumentRequestState, DocumentRequestsTemplate, DocumentRequestSubmission, DocumentRequestTemplate, DocumentType, DocumentTypeProperty, DocumentTypeValidation, DocumentValidationDefinition, DocumentValidationExecution, DocumentValidationExecutionRelatedDocument, DocumentValidationExecutionState, DocumentValidationResultStatus, DocumentWorkflow, DocumentWorkflowState, DocumentWorkflowStep } from '../models/index.js';
 export const documentManagementSchema = databaseSchema('document_management');
-export const dataType = documentManagementSchema.getEnum(DocumentPropertyDataType, 'DocumentPropertyDataType');
+export const aocumentApproval = documentManagementSchema.getEnum(DocumentApproval);
+export const documentAssignmentCollectionTarget = documentManagementSchema.getEnum(DocumentAssignmentTarget);
+export const documentPropertyDataType = documentManagementSchema.getEnum(DocumentPropertyDataType);
+export const documentRequestState = documentManagementSchema.getEnum(DocumentRequestState);
+export const documentValidationExecutionState = documentManagementSchema.getEnum(DocumentValidationExecutionState);
+export const documentValidationResultStatus = documentManagementSchema.getEnum(DocumentValidationResultStatus);
+export const documentWorkflowState = documentManagementSchema.getEnum(DocumentWorkflowState);
+export const documentWorkflowStep = documentManagementSchema.getEnum(DocumentWorkflowStep);
 export const document = documentManagementSchema.getTable(Document);
+export const documentAssignmentScope = documentManagementSchema.getTable(DocumentAssignmentScope);
+export const documentAssignmentTask = documentManagementSchema.getTable(DocumentAssignmentTask);
 export const documentCategory = documentManagementSchema.getTable(DocumentCategory);
 export const documentCollection = documentManagementSchema.getTable(DocumentCollection);
-export const documentCollectionDocument = documentManagementSchema.getTable(DocumentCollectionDocument);
+export const documentCollectionAssignment = documentManagementSchema.getTable(DocumentCollectionAssignment);
 export const documentFile = documentManagementSchema.getTable(DocumentFile);
 export const documentProperty = documentManagementSchema.getTable(DocumentProperty);
 export const documentPropertyValue = documentManagementSchema.getTable(DocumentPropertyValue);
 export const documentRequest = documentManagementSchema.getTable(DocumentRequest);
-export const documentRequestAssignmentTask = documentManagementSchema.getTable(DocumentRequestAssignmentTask);
-export const documentRequestAssignmentTaskCollection = documentManagementSchema.getTable(DocumentRequestAssignmentTaskCollection);
-export const documentRequestAssignmentTaskPropertyValue = documentManagementSchema.getTable(DocumentRequestAssignmentTaskPropertyValue);
 export const documentRequestCollection = documentManagementSchema.getTable(DocumentRequestCollection);
-export const documentRequestFile = documentManagementSchema.getTable(DocumentRequestFile);
-export const documentRequestFilePropertyValue = documentManagementSchema.getTable(DocumentRequestFilePropertyValue);
 export const documentRequestsTemplate = documentManagementSchema.getTable(DocumentRequestsTemplate);
+export const documentRequestSubmission = documentManagementSchema.getTable(DocumentRequestSubmission);
 export const documentRequestTemplate = documentManagementSchema.getTable(DocumentRequestTemplate);
 export const documentType = documentManagementSchema.getTable(DocumentType);
 export const documentTypeProperty = documentManagementSchema.getTable(DocumentTypeProperty);
+export const documentTypeValidation = documentManagementSchema.getTable(DocumentTypeValidation);
+export const documentValidationDefinition = documentManagementSchema.getTable(DocumentValidationDefinition);
+export const documentValidationExecution = documentManagementSchema.getTable(DocumentValidationExecution);
+export const documentValidationExecutionRelatedDocument = documentManagementSchema.getTable(DocumentValidationExecutionRelatedDocument);
+export const documentWorkflow = documentManagementSchema.getTable(DocumentWorkflow);

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

@@ -0,0 +1,25 @@
+import { DocumentCategory, DocumentType } from '../../../document-management/models/index.js';
+import type { DocumentCategoryView } from '../../../document-management/models/service-models/index.js';
+import { Transactional } from '../../../orm/server/index.js';
+export declare const enumTypeKey = "enum-type";
+export declare class DocumentCategoryTypeService extends Transactional {
+    #private;
+    loadCategory(id: string): Promise<DocumentCategory>;
+    loadType(id: string): Promise<DocumentType>;
+    createCategory(label: string, parentId: string | null, enumKey?: string): Promise<DocumentCategory>;
+    createType(label: string, categoryId: string, enumKey?: string): Promise<DocumentType>;
+    updateCategory(id: string, update: {
+        label?: string;
+        parentId?: string | null;
+    }): Promise<DocumentCategory>;
+    updateType(id: string, update: {
+        label?: string;
+        categoryId?: string;
+    }): Promise<DocumentType>;
+    loadCategoryGraph(categoryId: string): Promise<DocumentCategory[]>;
+    loadCategoriesAndTypes(): Promise<{
+        categories: DocumentCategory[];
+        types: DocumentType[];
+    }>;
+    loadCategoryViews(): Promise<DocumentCategoryView[]>;
+}

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

@@ -0,0 +1,66 @@
+var _a;
+import { DocumentCategory, DocumentType } from '../../../document-management/models/index.js';
+import { inject } from '../../../injector/inject.js';
+import { Logger } from '../../../logger/logger.js';
+import { Transactional } from '../../../orm/server/index.js';
+import { injectRepository } from '../../../orm/server/repository.js';
+import { groupToMap } from '../../../utils/iterable-helpers/group-to-map.js';
+import { isUndefined } from '../../../utils/type-guards.js';
+export const enumTypeKey = 'enum-type';
+export class DocumentCategoryTypeService extends Transactional {
+    #documentCategoryRepository = injectRepository(DocumentCategory);
+    #documentTypeRepository = injectRepository(DocumentType);
+    #logger = inject(Logger, _a.name);
+    async loadCategory(id) {
+        return this.#documentCategoryRepository.load(id);
+    }
+    async loadType(id) {
+        return this.#documentTypeRepository.load(id);
+    }
+    async createCategory(label, parentId, enumKey) {
+        return this.#documentCategoryRepository.insert({ label, parentId, metadata: { attributes: { [enumTypeKey]: enumKey } } });
+    }
+    async createType(label, categoryId, enumKey) {
+        return this.#documentTypeRepository.insert({ label, categoryId, metadata: { attributes: { [enumTypeKey]: enumKey } } });
+    }
+    async updateCategory(id, update) {
+        return this.#documentCategoryRepository.update(id, update);
+    }
+    async updateType(id, update) {
+        return this.#documentTypeRepository.update(id, update);
+    }
+    async loadCategoryGraph(categoryId) {
+        const category = await this.#documentCategoryRepository.load(categoryId);
+        if (category.parentId == null) {
+            return [category];
+        }
+        const parents = await this.loadCategoryGraph(category.parentId);
+        return [...parents, category];
+    }
+    async loadCategoriesAndTypes() {
+        const [categories, types] = await Promise.all([
+            this.#documentCategoryRepository.loadManyByQuery({}, { order: 'label' }),
+            this.#documentTypeRepository.loadManyByQuery({}, { order: 'label' }),
+        ]);
+        return { categories, types };
+    }
+    async loadCategoryViews() {
+        const { categories, types } = await this.loadCategoriesAndTypes();
+        const categoryChildrenMap = groupToMap(categories, (category) => category.parentId);
+        const categoryTypesMap = groupToMap(types, (type) => type.categoryId);
+        const rootCategories = categoryChildrenMap.get(null);
+        if (isUndefined(rootCategories)) {
+            return [];
+        }
+        return rootCategories.map((category) => getView(category, categoryChildrenMap, categoryTypesMap));
+    }
+}
+_a = DocumentCategoryTypeService;
+function getView(category, categoryChildrenMap, categoryTypesMap) {
+    const childCategories = categoryChildrenMap.get(category.id) ?? [];
+    return {
+        ...category,
+        children: childCategories.map((c) => getView(c, categoryChildrenMap, categoryTypesMap)),
+        types: categoryTypesMap.get(category.id) ?? [],
+    };
+}

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

@@ -0,0 +1,13 @@
+import { type Query } from '../../../orm/index.js';
+import { Transactional } from '../../../orm/server/index.js';
+import type { OneOrMany } from '../../../types.js';
+import { Document, DocumentCollection } from '../../models/index.js';
+export declare class DocumentCollectionService extends Transactional {
+    #private;
+    readonly repository: import("../../../orm/server/repository.js").EntityRepository<DocumentCollection>;
+    loadCollectionGraph(collectionId: string): Promise<DocumentCollection[]>;
+    createCollection(parentId: string | null): Promise<DocumentCollection>;
+    collectionHasDocumentByFilter(collectionId: string, filter: Query<Document>): Promise<boolean>;
+    assignDocument(documentId: string, collectionIds: OneOrMany<string>): Promise<void>;
+    archiveDocument(documentId: string, collectionIds: OneOrMany<string>): Promise<void>;
+}

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

@@ -0,0 +1,41 @@
+import { and, eq, sql } from 'drizzle-orm';
+import { TRANSACTION_TIMESTAMP } from '../../../orm/index.js';
+import { Transactional } from '../../../orm/server/index.js';
+import { injectRepository } from '../../../orm/server/repository.js';
+import { toArray } from '../../../utils/array/index.js';
+import { Document, DocumentCollection, DocumentCollectionAssignment } from '../../models/index.js';
+import { document, documentCollectionAssignment } from '../schemas.js';
+export class DocumentCollectionService extends Transactional {
+    #documentRepository = injectRepository(Document);
+    #documentCollectionAssignmentRepository = injectRepository(DocumentCollectionAssignment);
+    repository = injectRepository(DocumentCollection);
+    async loadCollectionGraph(collectionId) {
+        const collection = await this.repository.load(collectionId);
+        if (collection.parentId == null) {
+            return [collection];
+        }
+        const parents = await this.loadCollectionGraph(collection.parentId);
+        return [...parents, collection];
+    }
+    async createCollection(parentId) {
+        return this.repository.withSession(this.session).insert({ parentId });
+    }
+    async collectionHasDocumentByFilter(collectionId, filter) {
+        const matchingDocuments = this.session
+            .select()
+            .from(documentCollectionAssignment)
+            .leftJoin(document, eq(document.id, documentCollectionAssignment.documentId))
+            .where(and(eq(documentCollectionAssignment.collectionId, collectionId), this.#documentRepository.convertQuery(filter)));
+        const result = await this.session.execute(sql `SELECT EXISTS(SELECT 1 FROM ${matchingDocuments}))`);
+        console.log(result);
+        throw new Error('verify');
+        // return result[0]!;
+    }
+    async assignDocument(documentId, collectionIds) {
+        const values = toArray(collectionIds).map((collectionId) => ({ collectionId, documentId, archiveTimestamp: null }));
+        await this.#documentCollectionAssignmentRepository.withSession(this.session).upsertMany(['collectionId', 'documentId'], values);
+    }
+    async archiveDocument(documentId, collectionIds) {
+        await this.#documentCollectionAssignmentRepository.withSession(this.session).updateManyByQuery({ collectionId: { $in: toArray(collectionIds) }, documentId, archiveTimestamp: null }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
+    }
+}