@tstdl/base 0.93.182 → 0.93.183

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

@@ -1,101 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
-import { GenkitModuleOptions } from '../../ai/genkit/module.js';
-import { runInInjectionContext } from '../../injector/index.js';
-import { ObjectStorage } from '../../object-storage/index.js';
-import { TaskQueue } from '../../task-queue/index.js';
-import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
-import { DocumentManagementAuthorizationService } from '../authorization/document-management-authorization.service.js';
-import { DocumentManagementApiController } from '../server/api/document-management.api.js';
-import { configureDocumentManagement } from '../server/configure.js';
-import { DocumentCollectionService } from '../server/services/document-collection.service.js';
-import { DocumentManagementAiService } from '../server/services/document-management-ai.service.js';
-import { DocumentService } from '../server/services/document.service.js';
-import { TestDocumentManagementAncillaryService, TestDocumentManagementAuthorizationService } from './helper.js';
-describe('DocumentManagementApi Stats', () => {
-    let injector;
-    let database;
-    let controller;
-    let documentService;
-    let collectionService;
-    const schema = 'document_management';
-    const tenantId = crypto.randomUUID();
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({
-            modules: { taskQueue: false, messageBus: true, documentManagement: true },
-            orm: { schema },
-        }));
-        injector.register(GenkitModuleOptions, { useValue: {} });
-        injector.register(DocumentManagementAiService, { useValue: { extractContent: vi.fn(), classifyDocumentType: vi.fn(), extractData: vi.fn(), findSuitableCollectionsForDocument: vi.fn(), findSuitableRequestForDocument: vi.fn() } });
-        injector.register(ObjectStorage, {
-            useValue: {
-                uploadObject: vi.fn(),
-                getDownloadUrl: vi.fn(),
-                getContent: vi.fn(),
-                getContentStream: vi.fn(),
-                getObject: vi.fn(),
-                exists: vi.fn(),
-            },
-        });
-        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',
-            injector,
-        });
-        controller = await injector.resolveAsync(DocumentManagementApiController);
-        documentService = await injector.resolveAsync(DocumentService);
-        collectionService = await injector.resolveAsync(DocumentCollectionService);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    beforeEach(async () => {
-        await clearTenantData(database, schema, ['collection_assignment', 'workflow', 'document', 'collection', 'tag', 'type', 'category'], tenantId);
-    });
-    test('getStatistics API endpoint', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            const authService = injector.resolve(DocumentManagementAuthorizationService);
-            vi.spyOn(authService, 'getTenantId').mockResolvedValue(tenantId);
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1, 2, 3]));
-            const mockContext = {
-                getToken: async () => ({ payload: { tenantId } }),
-                parameters: {
-                    includeTotalCount: true,
-                    includeStorageUsage: true,
-                    collectionIds: [collection.id],
-                },
-            };
-            const stats = await controller.getStatistics(mockContext);
-            expect(stats.totalCount).toBe(1);
-            expect(stats.storageUsage).toBe(3);
-        });
-    });
-    test('getStatistics API endpoint should deny access if collection is restricted', async () => {
-        await runInInjectionContext(injector, async () => {
-            const authService = injector.resolve(DocumentManagementAuthorizationService);
-            vi.spyOn(authService, 'getTenantId').mockResolvedValue(tenantId);
-            vi.spyOn(authService, 'canReadCollection').mockResolvedValue(false);
-            const mockContext = {
-                getToken: async () => ({ payload: { tenantId } }),
-                parameters: {
-                    includeTotalCount: true,
-                    collectionIds: ['some-collection-id'],
-                },
-            };
-            await expect(controller.getStatistics(mockContext)).rejects.toThrow('You are not allowed to read collection some-collection-id');
-        });
-    });
-});

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

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

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

@@ -1,498 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
-import { GenkitModuleOptions } from '../../ai/genkit/module.js';
-import { runInInjectionContext } from '../../injector/index.js';
-import { ObjectStorage } from '../../object-storage/index.js';
-import { getRepository } from '../../orm/server/index.js';
-import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
-import { DocumentValidationDefinition } from '../models/document-validation-definition.model.js';
-import { DocumentValidationExecution, DocumentValidationExecutionState, DocumentValidationResultStatus } from '../models/document-validation-execution.model.js';
-import { DocumentWorkflow, DocumentWorkflowState, DocumentWorkflowStep } from '../models/document-workflow.model.js';
-import { DocumentApproval } from '../models/document.model.js';
-import { configureDocumentManagement } from '../server/configure.js';
-import { DocumentCategoryTypeService } from '../server/services/document-category-type.service.js';
-import { DocumentCollectionService } from '../server/services/document-collection.service.js';
-import { DocumentManagementAiService } from '../server/services/document-management-ai.service.js';
-import { DocumentStatisticsService } from '../server/services/document-statistics.service.js';
-import { DocumentTagService } from '../server/services/document-tag.service.js';
-import { DocumentService } from '../server/services/document.service.js';
-import { TestDocumentManagementAncillaryService, TestDocumentManagementAuthorizationService } from './helper.js';
-describe('DocumentStatisticsService', () => {
-    let injector;
-    let database;
-    let documentService;
-    let statsService;
-    let collectionService;
-    let tagService;
-    let categoryTypeService;
-    const schema = 'document_management';
-    const tenantId = crypto.randomUUID();
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({
-            modules: { taskQueue: true, documentManagement: 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 = {
-            extractContent: vi.fn(),
-            classifyDocumentType: vi.fn(),
-            extractData: vi.fn(),
-            findSuitableCollectionsForDocument: vi.fn(),
-            findSuitableRequestForDocument: vi.fn(),
-        };
-        injector.register(ObjectStorage, { useFactory: () => mockObjectStorage });
-        injector.register(GenkitModuleOptions, { useValue: {} });
-        injector.register(DocumentManagementAiService, { useValue: mockAiService });
-        configureDocumentManagement({
-            ancillaryService: TestDocumentManagementAncillaryService,
-            authorizationService: TestDocumentManagementAuthorizationService,
-            fileObjectStorageModule: 'documents',
-            fileUploadObjectStorageModule: 'document-uploads',
-            filePreviewObjectStorageModule: 'document-previews',
-            injector,
-        });
-        documentService = await injector.resolveAsync(DocumentService);
-        statsService = await injector.resolveAsync(DocumentStatisticsService);
-        collectionService = await injector.resolveAsync(DocumentCollectionService);
-        tagService = await injector.resolveAsync(DocumentTagService);
-        categoryTypeService = await injector.resolveAsync(DocumentCategoryTypeService);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    beforeEach(async () => {
-        await clearTenantData(database, schema, ['validation_execution', 'validation_definition', 'tag_assignment', 'collection_assignment', 'workflow', 'document', 'collection', 'tag', 'type', 'category'], tenantId);
-    });
-    test('getStatistics should return total count', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            await documentService.create(tenantId, {
-                title: 'Doc 1',
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            await documentService.create(tenantId, {
-                title: 'Doc 2',
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1, 2]));
-            const stats = await statsService.getStatistics(tenantId, { includeTotalCount: true, collectionIds: [collection.id] });
-            expect(stats.totalCount).toBe(2);
-        });
-    });
-    test('getStatistics should return approval breakdown', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            await documentService.create(tenantId, {
-                approval: DocumentApproval.Approved,
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            await documentService.create(tenantId, {
-                approval: DocumentApproval.Pending,
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            await documentService.create(tenantId, {
-                approval: DocumentApproval.Rejected,
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const stats = await statsService.getStatistics(tenantId, { includeApprovalBreakdown: true, collectionIds: [collection.id] });
-            expect(stats.approvalBreakdown?.approved).toBe(1);
-            expect(stats.approvalBreakdown?.pending).toBe(1);
-            expect(stats.approvalBreakdown?.rejected).toBe(1);
-        });
-    });
-    test('getStatistics should filter by collection', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection1 = await collectionService.createCollection(tenantId, null);
-            const collection2 = await collectionService.createCollection(tenantId, null);
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection1.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection2.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const stats = await statsService.getStatistics(tenantId, { includeTotalCount: true, collectionIds: [collection1.id] });
-            expect(stats.totalCount).toBe(1);
-        });
-    });
-    test('getStatistics should return storage usage and total pages', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            const doc = await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1, 2, 3])); // Size 3
-            // Manually set pages since our mock doesn't handle PDF page count
-            await documentService.repository.update(doc.id, { pages: 5 });
-            const stats = await statsService.getStatistics(tenantId, { includeStorageUsage: true, includeTotalPages: true, collectionIds: [collection.id] });
-            expect(stats.storageUsage).toBe(3);
-            expect(stats.totalPages).toBe(5);
-        });
-    });
-    test('getStatistics should return data quality metrics', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            // Missing nothing (except type, which is checked separately)
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-                title: 'Title',
-                date: 20230101,
-            }, new Uint8Array([1]));
-            // Missing title and date
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const stats = await statsService.getStatistics(tenantId, { includeDataQuality: true, collectionIds: [collection.id] });
-            expect(stats.dataQuality?.missingTitle).toBe(1);
-            expect(stats.dataQuality?.missingDate).toBe(1);
-            expect(stats.dataQuality?.missingType).toBe(2);
-        });
-    });
-    test('getStatistics should return created last 30 days', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const stats = await statsService.getStatistics(tenantId, { includeCreatedLast30Days: true, collectionIds: [collection.id] });
-            expect(stats.createdLast30Days).toBe(1);
-        });
-    });
-    test('getStatistics should return tag usage', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-                tags: ['Tag1'],
-            }, new Uint8Array([1]));
-            const [tag] = await tagService.loadOrCreate(tenantId, ['Tag1']);
-            const stats = await statsService.getStatistics(tenantId, { includeTagUsage: true, collectionIds: [collection.id] });
-            expect(stats.tagUsage?.[tag.id]).toBe(1);
-        });
-    });
-    test('getStatistics should return mime type distribution', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const stats = await statsService.getStatistics(tenantId, { includeMimeTypeDistribution: true, collectionIds: [collection.id] });
-            expect(Object.keys(stats.mimeTypeDistribution ?? {}).length).toBeGreaterThan(0);
-        });
-    });
-    test('getStatistics should return type breakdown and filter by category', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            const categoryLabel = `Category ${crypto.randomUUID()}`;
-            const category = await categoryTypeService.createCategory({ tenantId, label: categoryLabel, parentId: null });
-            const type = await categoryTypeService.createType({ tenantId, label: 'Type 1', categoryId: category.id });
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-                typeId: type.id,
-            }, new Uint8Array([1]));
-            const stats = await statsService.getStatistics(tenantId, { includeTypeBreakdown: true, collectionIds: [collection.id], categoryIds: [category.id] });
-            expect(stats.typeBreakdown?.[type.id]).toBe(1);
-        });
-    });
-    test('getStatistics should return validation failures', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            const doc = await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const workflowRepo = await injector.resolveAsync(getRepository(DocumentWorkflow));
-            const validationRepo = await injector.resolveAsync(getRepository(DocumentValidationExecution));
-            const definitionRepo = await injector.resolveAsync(getRepository(DocumentValidationDefinition));
-            const definition = await definitionRepo.insert({
-                tenantId,
-                identifier: 'test-val',
-                label: 'Test Validation',
-                description: null,
-                configuration: {},
-            });
-            const workflow = await workflowRepo.insert({
-                tenantId,
-                documentId: doc.id,
-                step: DocumentWorkflowStep.Validation,
-                state: DocumentWorkflowState.Pending,
-                skipAi: true,
-                completeTimestamp: null,
-                failReason: null,
-                completeUserId: null,
-            });
-            await validationRepo.insert({
-                tenantId,
-                workflowId: workflow.id,
-                definitionId: definition.id,
-                state: DocumentValidationExecutionState.Completed,
-                resultStatus: DocumentValidationResultStatus.Failed,
-                resultMessage: null,
-                startedAt: null,
-                completedAt: null,
-            });
-            const stats = await statsService.getStatistics(tenantId, { includeValidationFailures: true, collectionIds: [collection.id] });
-            expect(stats.validationFailures).toBe(1);
-        });
-    });
-    test('getStatistics should return nothing when no options selected', async () => {
-        await runInInjectionContext(injector, async () => {
-            const stats = await statsService.getStatistics(tenantId, { collectionIds: [] });
-            expect(Object.keys(stats).length).toBe(0);
-        });
-    });
-    test('getStatistics should support combined filters', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection1 = await collectionService.createCollection(tenantId, null);
-            const collection2 = await collectionService.createCollection(tenantId, null);
-            const category1 = await categoryTypeService.createCategory({ tenantId, label: `Cat 1 ${crypto.randomUUID()}`, parentId: null });
-            const category2 = await categoryTypeService.createCategory({ tenantId, label: `Cat 2 ${crypto.randomUUID()}`, parentId: null });
-            const type1 = await categoryTypeService.createType({ tenantId, label: 'Type 1', categoryId: category1.id });
-            const type2 = await categoryTypeService.createType({ tenantId, label: 'Type 2', categoryId: category2.id });
-            // Doc 1: Coll 1, Type 1 (Cat 1)
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection1.id] },
-                typeId: type1.id,
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            // Doc 2: Coll 1, Type 2 (Cat 2)
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection1.id] },
-                typeId: type2.id,
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            // Doc 3: Coll 2, Type 1 (Cat 1)
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection2.id] },
-                typeId: type1.id,
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const stats = await statsService.getStatistics(tenantId, {
-                includeTotalCount: true,
-                collectionIds: [collection1.id],
-                categoryIds: [category1.id],
-            });
-            expect(stats.totalCount).toBe(1); // Only Doc 1 matches both
-        });
-    });
-    test('getStatistics should return multiple stats without category filters', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            const category = await categoryTypeService.createCategory({ tenantId, label: `Cat ${crypto.randomUUID()}`, parentId: null });
-            const type = await categoryTypeService.createType({ tenantId, label: 'Type', categoryId: category.id });
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                typeId: type.id,
-                skipWorkflow: true,
-                title: 'Title',
-            }, new Uint8Array([1, 2, 3]));
-            const stats = await statsService.getStatistics(tenantId, {
-                includeTotalCount: true,
-                includeTypeBreakdown: true,
-                includeMimeTypeDistribution: true,
-                includeStorageUsage: true,
-                includeDataQuality: true,
-                collectionIds: [collection.id],
-            });
-            expect(stats.totalCount).toBe(1);
-            expect(stats.typeBreakdown?.[type.id]).toBe(1);
-            expect(stats.storageUsage).toBe(3);
-            expect(stats.dataQuality?.missingTitle).toBe(0);
-        });
-    });
-    test('getStatistics should return stats with only collection filter', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const stats = await statsService.getStatistics(tenantId, {
-                includeTotalCount: true,
-                includeMimeTypeDistribution: true,
-                collectionIds: [collection.id],
-            });
-            expect(stats.totalCount).toBe(1);
-        });
-    });
-    test('getStatistics should return mime type distribution with category filter', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            const category = await categoryTypeService.createCategory({ tenantId, label: `Cat ${crypto.randomUUID()}`, parentId: null });
-            const type = await categoryTypeService.createType({ tenantId, label: 'Type', categoryId: category.id });
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                typeId: type.id,
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const stats = await statsService.getStatistics(tenantId, {
-                includeMimeTypeDistribution: true,
-                collectionIds: [collection.id],
-                categoryIds: [category.id],
-            });
-            expect(Object.keys(stats.mimeTypeDistribution ?? {}).length).toBeGreaterThan(0);
-        });
-    });
-    test('getStatistics should return tag usage with filters', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            const category = await categoryTypeService.createCategory({ tenantId, label: `Cat ${crypto.randomUUID()}`, parentId: null });
-            const type = await categoryTypeService.createType({ tenantId, label: 'Type', categoryId: category.id });
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                typeId: type.id,
-                skipWorkflow: true,
-                tags: ['Tag1'],
-            }, new Uint8Array([1]));
-            const [tag] = await tagService.loadOrCreate(tenantId, ['Tag1']);
-            const stats = await statsService.getStatistics(tenantId, {
-                includeTagUsage: true,
-                collectionIds: [collection.id],
-                categoryIds: [category.id],
-            });
-            expect(stats.tagUsage?.[tag.id]).toBe(1);
-        });
-    });
-    test('getStatistics should return validation failures with collection filter', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            const doc = await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const workflowRepo = await injector.resolveAsync(getRepository(DocumentWorkflow));
-            const validationRepo = await injector.resolveAsync(getRepository(DocumentValidationExecution));
-            const definitionRepo = await injector.resolveAsync(getRepository(DocumentValidationDefinition));
-            const definition = await definitionRepo.insert({
-                tenantId,
-                identifier: 'test-val-2',
-                label: 'Test Validation',
-                description: null,
-                configuration: {},
-            });
-            const workflow = await workflowRepo.insert({
-                tenantId,
-                documentId: doc.id,
-                step: DocumentWorkflowStep.Validation,
-                state: DocumentWorkflowState.Pending,
-                skipAi: true,
-                completeTimestamp: null,
-                failReason: null,
-                completeUserId: null,
-            });
-            await validationRepo.insert({
-                tenantId,
-                workflowId: workflow.id,
-                definitionId: definition.id,
-                state: DocumentValidationExecutionState.Completed,
-                resultStatus: DocumentValidationResultStatus.Failed,
-                resultMessage: null,
-                startedAt: null,
-                completedAt: null,
-            });
-            const stats = await statsService.getStatistics(tenantId, {
-                includeValidationFailures: true,
-                collectionIds: [collection.id],
-            });
-            expect(stats.validationFailures).toBe(1);
-        });
-    });
-    test('getStatistics should return validation failures with category filter', async () => {
-        await runInInjectionContext(injector, async () => {
-            const categoryLabel = `Cat val ${crypto.randomUUID()}`;
-            const category = await categoryTypeService.createCategory({ tenantId, label: categoryLabel, parentId: null });
-            const type = await categoryTypeService.createType({ tenantId, label: 'Type val', categoryId: category.id });
-            const collection = await collectionService.createCollection(tenantId, null);
-            const doc = await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                typeId: type.id,
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const workflowRepo = await injector.resolveAsync(getRepository(DocumentWorkflow));
-            const validationRepo = await injector.resolveAsync(getRepository(DocumentValidationExecution));
-            const definitionRepo = await injector.resolveAsync(getRepository(DocumentValidationDefinition));
-            const definition = await definitionRepo.insert({
-                tenantId,
-                identifier: 'test-val-3',
-                label: 'Test Validation',
-                description: null,
-                configuration: {},
-            });
-            const workflow = await workflowRepo.insert({
-                tenantId,
-                documentId: doc.id,
-                step: DocumentWorkflowStep.Validation,
-                state: DocumentWorkflowState.Pending,
-                skipAi: true,
-                completeTimestamp: null,
-                failReason: null,
-                completeUserId: null,
-            });
-            await validationRepo.insert({
-                tenantId,
-                workflowId: workflow.id,
-                definitionId: definition.id,
-                state: DocumentValidationExecutionState.Completed,
-                resultStatus: DocumentValidationResultStatus.Failed,
-                resultMessage: null,
-                startedAt: null,
-                completedAt: null,
-            });
-            const stats = await statsService.getStatistics(tenantId, {
-                includeValidationFailures: true,
-                collectionIds: [collection.id],
-                categoryIds: [category.id],
-            });
-            expect(stats.validationFailures).toBe(1);
-        });
-    });
-    test('getStatistics should return type breakdown with collection filter', async () => {
-        await runInInjectionContext(injector, async () => {
-            const collection = await collectionService.createCollection(tenantId, null);
-            const category = await categoryTypeService.createCategory({ tenantId, label: `Cat ${crypto.randomUUID()}`, parentId: null });
-            const type = await categoryTypeService.createType({ tenantId, label: 'Type', categoryId: category.id });
-            await documentService.create(tenantId, {
-                assignment: { collections: [collection.id] },
-                typeId: type.id,
-                skipWorkflow: true,
-            }, new Uint8Array([1]));
-            const stats = await statsService.getStatistics(tenantId, {
-                includeTypeBreakdown: true,
-                collectionIds: [collection.id],
-            });
-            expect(stats.typeBreakdown?.[type.id]).toBe(1);
-        });
-    });
-    test('getStatistics should return zeroed stats for empty tenant', async () => {
-        await runInInjectionContext(injector, async () => {
-            const stats = await statsService.getStatistics(tenantId, {
-                includeTotalCount: true,
-                includeStorageUsage: true,
-                includeTotalPages: true,
-                includeValidationFailures: true,
-                collectionIds: [],
-            });
-            expect(stats.totalCount).toBe(0);
-            expect(stats.storageUsage).toBe(0);
-            expect(stats.totalPages).toBe(0);
-            expect(stats.validationFailures).toBe(0);
-        });
-    });
-});

package/document-management/tests/document-validation-ai-overrides.test.d.ts

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