@tstdl/base 0.93.95 → 0.93.97

package/document-management/tests/document-management-core.test.js

@@ -0,0 +1,162 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
+import { AiService } from '../../ai/ai.service.js';
+import { AiModuleOptions } from '../../ai/module.js';
+import { runInInjectionContext } from '../../injector/index.js';
+import { ObjectStorage } from '../../object-storage/index.js';
+import { TaskQueue } from '../../task-queue/index.js';
+import { setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
+import { configureDocumentManagement } from '../server/configure.js';
+import { migrateDocumentManagementSchema } from '../server/module.js';
+import { DocumentCategoryTypeService } from '../server/services/document-category-type.service.js';
+import { DocumentCollectionService } from '../server/services/document-collection.service.js';
+import { DocumentManagementService } from '../server/services/document-management.service.js';
+import { DocumentPropertyService } from '../server/services/document-property.service.js';
+import { DocumentRequestService } from '../server/services/document-request.service.js';
+import { DocumentWorkflowService } from '../server/services/document-workflow.service.js';
+import { DocumentService } from '../server/services/document.service.js';
+import { TestDocumentManagementAncillaryService, TestDocumentManagementAuthorizationService } from './helper.js';
+describe('Document Management Core', () => {
+    let injector;
+    let database;
+    let documentService;
+    let collectionService;
+    let requestService;
+    let managementService;
+    let workflowService;
+    let categoryTypeService;
+    let propertyService;
+    const schema = 'document_management';
+    const tenantId = crypto.randomUUID();
+    beforeAll(async () => {
+        ({ injector, database } = await setupIntegrationTest({
+            modules: { taskQueue: false, messageBus: true }, // Disabled TaskQueue to avoid background noise
+            orm: { schema },
+        }));
+        injector.register(AiModuleOptions, { useValue: {} });
+        injector.register(AiService, { useValue: { processFile: vi.fn() } });
+        injector.register(ObjectStorage, {
+            useValue: {
+                uploadObject: vi.fn(),
+                getDownloadUrl: vi.fn(),
+                getContent: vi.fn(),
+                getContentStream: vi.fn(),
+                getObject: vi.fn(),
+                exists: vi.fn(),
+            },
+        });
+        // Mock TaskQueue
+        injector.register(TaskQueue, {
+            useValue: {
+                enqueue: vi.fn(),
+                enqueueMany: vi.fn(),
+                process: vi.fn(),
+            },
+        });
+        configureDocumentManagement({
+            ancillaryService: TestDocumentManagementAncillaryService,
+            authorizationService: TestDocumentManagementAuthorizationService,
+            fileObjectStorageModule: 'documents',
+            fileUploadObjectStorageModule: 'document-uploads',
+            filePreviewObjectStorageModule: 'document-previews',
+        });
+        await runInInjectionContext(injector, migrateDocumentManagementSchema);
+        documentService = await injector.resolveAsync(DocumentService);
+        collectionService = await injector.resolveAsync(DocumentCollectionService);
+        requestService = await injector.resolveAsync(DocumentRequestService);
+        managementService = await injector.resolveAsync(DocumentManagementService);
+        workflowService = await injector.resolveAsync(DocumentWorkflowService);
+        categoryTypeService = await injector.resolveAsync(DocumentCategoryTypeService);
+        propertyService = await injector.resolveAsync(DocumentPropertyService);
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    beforeEach(async () => {
+        await truncateTables(database, schema, ['request_collection_assignment', 'collection_assignment', 'workflow', 'request', 'document', 'collection', 'type', 'category']);
+    });
+    // --- Collection Management ---
+    test('Create and load collection', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            expect(collection.id).toBeDefined();
+            const loaded = await collectionService.repository.loadByQuery({ tenantId, id: collection.id });
+            expect(loaded.id).toBe(collection.id);
+        });
+    });
+    test('Load collection view resolves metadata', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const data = await managementService.loadData(tenantId, [collection.id]);
+            const view = data.collections.find((c) => c.id === collection.id);
+            expect(view).toBeDefined();
+            // Metadata comes from TestDocumentManagementAncillaryService in helper.ts
+            expect(view?.name).toBe(`Collection ${collection.id}`);
+            expect(view?.group).toBe('Test');
+        });
+    });
+    // --- Document Assignments ---
+    test('Assign document to collection', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const doc = await documentService.create(tenantId, {
+                originalFileName: 'test.pdf',
+                assignment: { collections: [] },
+                skipAi: true,
+            }, new Uint8Array([]));
+            await documentService.update(tenantId, doc.id, { collections: { assign: [collection.id] } });
+            const assignedCollections = await managementService.getRelevantDocumentCollectionIds(tenantId, doc.id);
+            expect(assignedCollections).toContain(collection.id);
+        });
+    });
+    test('Unassign document from collection', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const doc = await documentService.create(tenantId, {
+                originalFileName: 'test.pdf',
+                assignment: { collections: [collection.id] },
+                skipAi: true,
+            }, new Uint8Array([]));
+            // Archive assignment to unassign
+            await documentService.update(tenantId, doc.id, { collections: { archive: [collection.id] } });
+            // getRelevantDocumentCollectionIds includes all assignments (even archived ones maybe?).
+            // Let's check the loadData response for active assignments.
+            const data = await managementService.loadData(tenantId, [collection.id]);
+            const docView = data.documents.find((d) => d.id === doc.id);
+            // The assignment should be filtered out or marked archived in the view?
+            // loadData: documentCollectionAssignments.filter((collectionDocument) => collectionDocument.documentId == document.id)
+            // The query in loadData loads ALL assignments for the collection.
+            // But typically "active" documents are what we care about.
+            // If archived, it might still show up. Let's check the 'archiveTimestamp' in the assignment view.
+            const assignment = docView?.assignment.collections.find((a) => a.collectionId === collection.id);
+            expect(assignment?.archiveTimestamp).not.toBeNull();
+        });
+    });
+    // --- Requests ---
+    test('Create and load document request', async () => {
+        await runInInjectionContext(injector, async () => {
+            // Create a dummy type first
+            const category = await categoryTypeService.createCategory({ tenantId, label: 'ReqCat', parentId: null });
+            const type = await categoryTypeService.createType({ tenantId, label: 'ReqType', categoryId: category.id });
+            const collection = await collectionService.createCollection(tenantId, null);
+            const request = await requestService.createRequest(tenantId, type.id, [collection.id], 'New Request');
+            expect(request.comment).toBe('New Request');
+            // Verify via loadData (indirectly verifies persistence)
+            const data = await managementService.loadData(tenantId, [collection.id]);
+            const loaded = data.requests.find((r) => r.id === request.id);
+            expect(loaded).toBeDefined();
+            expect(loaded?.comment).toBe('New Request');
+        });
+    });
+    test('Request with collection assignment', async () => {
+        await runInInjectionContext(injector, async () => {
+            const category = await categoryTypeService.createCategory({ tenantId, label: 'Cat2', parentId: null });
+            const type = await categoryTypeService.createType({ tenantId, label: 'Type2', categoryId: category.id });
+            const collection = await collectionService.createCollection(tenantId, null);
+            const request = await requestService.createRequest(tenantId, type.id, [collection.id], 'Assignment Request');
+            const data = await managementService.loadData(tenantId, [collection.id]);
+            const reqView = data.requests.find((r) => r.id === request.id);
+            expect(reqView).toBeDefined();
+            expect(reqView?.collectionIds).toContain(collection.id);
+        });
+    });
+});

package/document-management/tests/document.service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/document-management/tests/document.service.test.js

@@ -0,0 +1,139 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
+import { AiService } from '../../ai/ai.service.js';
+import { AiModuleOptions } from '../../ai/module.js';
+import { runInInjectionContext } from '../../injector/index.js';
+import { ObjectStorage } from '../../object-storage/index.js';
+import { clearTenantData, setupIntegrationTest } from '../../unit-test/index.js';
+import { DocumentWorkflowState } from '../models/document-workflow.model.js';
+import { DocumentApproval } from '../models/document.model.js';
+import { configureDocumentManagement } from '../server/configure.js';
+import { DocumentManagementConfiguration, migrateDocumentManagementSchema } from '../server/module.js';
+import { DocumentCollectionService } from '../server/services/document-collection.service.js';
+import { DocumentWorkflowService } from '../server/services/document-workflow.service.js';
+import { DocumentService } from '../server/services/document.service.js';
+import { TestDocumentManagementAncillaryService, TestDocumentManagementAuthorizationService } from './helper.js';
+describe('DocumentService', () => {
+    let injector;
+    let database;
+    let documentService;
+    let workflowService;
+    let collectionService;
+    const schema = 'document_management';
+    const tenantId = crypto.randomUUID();
+    beforeAll(async () => {
+        ({ injector, database } = await setupIntegrationTest({
+            modules: { taskQueue: true },
+            orm: { schema },
+        }));
+        const mockObjectStorage = {
+            uploadObject: vi.fn(),
+            getDownloadUrl: vi.fn(),
+            getContent: vi.fn(),
+            getContentStream: vi.fn(),
+            getObject: vi.fn(),
+            exists: vi.fn(),
+        };
+        const mockAiService = {
+            processFile: vi.fn(),
+        };
+        injector.register(ObjectStorage, { useFactory: () => mockObjectStorage });
+        injector.register(AiModuleOptions, { useValue: {} });
+        injector.register(AiService, { useValue: mockAiService });
+        configureDocumentManagement({
+            ancillaryService: TestDocumentManagementAncillaryService,
+            authorizationService: TestDocumentManagementAuthorizationService,
+            fileObjectStorageModule: 'documents',
+            fileUploadObjectStorageModule: 'document-uploads',
+            filePreviewObjectStorageModule: 'document-previews',
+        });
+        await runInInjectionContext(injector, migrateDocumentManagementSchema);
+        documentService = await injector.resolveAsync(DocumentService);
+        workflowService = await injector.resolveAsync(DocumentWorkflowService);
+        collectionService = await injector.resolveAsync(DocumentCollectionService);
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    beforeEach(async () => {
+        await clearTenantData(database, schema, ['collection_assignment', 'workflow', 'document', 'collection'], tenantId);
+    });
+    test('create with skipWorkflow: true should not initiate workflow and set approval', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const doc = await documentService.create(tenantId, {
+                originalFileName: 'test.pdf',
+                approval: DocumentApproval.Approved,
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1, 2, 3]));
+            expect(doc.approval).toBe(DocumentApproval.Approved);
+            const workflows = await workflowService.loadWorkflows(tenantId, doc.id);
+            expect(workflows).toHaveLength(0);
+        });
+    });
+    test('create with skipAi: true should initiate workflow with skipAi flag', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const doc = await documentService.create(tenantId, {
+                originalFileName: 'test.pdf',
+                assignment: { collections: [collection.id] },
+                skipAi: true,
+            }, new Uint8Array([1, 2, 3]));
+            const workflows = await workflowService.loadWorkflows(tenantId, doc.id);
+            expect(workflows).toHaveLength(1);
+            expect(workflows[0].skipAi).toBe(true);
+        });
+    });
+    test('proceedWorkflow with skipAi: true should allow manual progression from Pending', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const doc = await documentService.create(tenantId, {
+                originalFileName: 'test.pdf',
+                assignment: { collections: [collection.id] },
+                skipAi: true,
+            }, new Uint8Array([1, 2, 3]));
+            let workflows = await workflowService.loadWorkflows(tenantId, doc.id);
+            expect(workflows).toHaveLength(1);
+            expect(workflows[0].step).toBe('classification');
+            expect(workflows[0].state).toBe('pending');
+            await workflowService.proceedWorkflow(tenantId, doc.id, crypto.randomUUID(), DocumentWorkflowState.Completed);
+            workflows = await workflowService.loadWorkflows(tenantId, doc.id);
+            expect(workflows).toHaveLength(2);
+            expect(workflows.find((w) => w.step == 'classification')?.state).toBe('completed');
+            expect(workflows.find((w) => w.step == 'extraction')?.state).toBe('pending');
+            expect(workflows.find((w) => w.step == 'extraction')?.skipAi).toBe(true);
+        });
+    });
+    test('proceedWorkflow with skipAi: true should allow progression to Review', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const doc = await documentService.create(tenantId, {
+                originalFileName: 'test.pdf',
+                assignment: { collections: [collection.id] },
+                skipAi: true,
+            }, new Uint8Array([1, 2, 3]));
+            await workflowService.proceedWorkflow(tenantId, doc.id, crypto.randomUUID(), 'review');
+            const workflows = await workflowService.loadWorkflows(tenantId, doc.id);
+            expect(workflows).toHaveLength(1);
+            expect(workflows[0].step).toBe('classification');
+            expect(workflows[0].state).toBe('review');
+        });
+    });
+    test('global skipAi: true should override per-document setting', async () => {
+        await runInInjectionContext(injector, async () => {
+            // Mock configuration override
+            const config = injector.resolve(DocumentManagementConfiguration);
+            config.skipAi = true;
+            const collection = await collectionService.createCollection(tenantId, null);
+            const doc = await documentService.create(tenantId, {
+                originalFileName: 'test.pdf',
+                assignment: { collections: [collection.id] },
+                skipAi: false, // Per-document false, but global true
+            }, new Uint8Array([1, 2, 3]));
+            const workflows = await workflowService.loadWorkflows(tenantId, doc.id);
+            expect(workflows).toHaveLength(1);
+            expect(workflows[0].skipAi).toBe(true); // Global override
+            config.skipAi = false; // Reset for other tests
+        });
+    });
+});

package/document-management/tests/enum-helpers.test.d.ts

@@ -0,0 +1 @@
+export {};