@tstdl/base 0.93.182 → 0.93.184

package/document-management/tests/document-validation-ai-overrides.test.js

@@ -1,87 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest';
-import { injectModel } from '../../ai/genkit/index.js';
-import { formatInstructions } from '../../ai/prompts/index.js';
-import { runInInjectionContext } from '../../injector/index.js';
-import { object, string } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { isString } from '../../utils/type-guards.js';
-import { DocumentManagementConfiguration } from '../server/module.js';
-import { DocumentFileService } from '../server/services/document-file.service.js';
-import { DocumentManagementAiProviderService, DocumentManagementAncillaryService } from '../server/services/index.js';
-import { AiValidationExecutor } from '../server/validators/ai-validation-executor.js';
-import { TestDocumentManagementAncillaryService } from './helper.js';
-class TestAiValidationExecutor extends AiValidationExecutor {
-    identifier = 'test-validation';
-    schema = object({ valid: string() });
-    async getValidationInstructions() { return 'Test Prompt'; }
-    async getResult() { return { status: 'passed' }; }
-    executorConfig = {};
-    getAiConfiguration() { return this.executorConfig; }
-    // Expose protected method for testing
-    async publicExecute(context) {
-        return this.execute(context);
-    }
-}
-describe('AiValidationExecutor Overrides', () => {
-    let injector;
-    let flashModel;
-    let proModel;
-    const tenantId = crypto.randomUUID();
-    const mockAiProvider = {
-        getGlobalConfiguration: vi.fn(),
-        getValidationConfiguration: vi.fn(),
-    };
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({
-            modules: { messageBus: true, signals: true, objectStorage: true },
-        }));
-        runInInjectionContext(injector, () => {
-            flashModel = injectModel('gemini-2.5-flash');
-            proModel = injectModel('gemini-2.5-pro');
-        });
-        injector.register(DocumentManagementAiProviderService, { useValue: mockAiProvider });
-        injector.register(DocumentManagementAncillaryService, { useToken: TestDocumentManagementAncillaryService });
-        injector.register(DocumentManagementConfiguration, { useValue: { fileObjectStorageModule: 'docs', fileUploadObjectStorageModule: 'uploads', filePreviewObjectStorageModule: 'previews' } });
-        injector.register(DocumentFileService, { useValue: { getContent: vi.fn().mockResolvedValue(new Uint8Array([1, 2, 3])) } });
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    test('AiValidationExecutor should merge configurations correctly', async () => {
-        mockAiProvider.getGlobalConfiguration.mockResolvedValue({
-            defaults: {
-                language: 'en',
-                model: flashModel,
-                prompt: { systemAddition: 'Global System', userAddition: 'Global User' },
-            },
-        });
-        mockAiProvider.getValidationConfiguration.mockResolvedValue({
-            model: proModel,
-            prompt: { systemAddition: 'Validation System', systemOverride: (base) => `OVERRIDDEN: ${isString(base) ? base : formatInstructions(base)}` },
-        });
-        await runInInjectionContext(injector, async () => {
-            const executor = new TestAiValidationExecutor();
-            executor.executorConfig = {
-                prompt: { systemAddition: 'Executor System', userAddition: 'Executor User' },
-            };
-            const generateSpy = vi.spyOn(executor.genkit, 'generate').mockResolvedValue({ output: { valid: 'yes' } });
-            const context = {
-                execution: { tenantId },
-                definition: { identifier: 'test-validation' },
-                document: { id: 'test-doc', mimeType: 'application/pdf' },
-            };
-            await executor.publicExecute(context);
-            const call = generateSpy.mock.calls[0][0];
-            const systemText = call.system.map((p) => p.text).join('\n');
-            const userText = call.prompt.map((p) => p.text).join('\n');
-            expect(call.model.name).toBe(proModel.name);
-            expect(systemText).toContain('Global System');
-            expect(systemText).toContain('Executor System');
-            expect(systemText).toContain('Validation System');
-            expect(systemText).toContain('OVERRIDDEN:');
-            expect(userText).toContain('Global User');
-            expect(userText).toContain('Executor User');
-            expect(userText).toContain('IMPORTANT: All generated text content MUST be in en.');
-        });
-    });
-});

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

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

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

@@ -1,143 +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 { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
-import { DocumentWorkflowState, DocumentWorkflowStep } from '../models/document-workflow.model.js';
-import { DocumentApproval } from '../models/document.model.js';
-import { configureDocumentManagement } from '../server/configure.js';
-import { DocumentManagementConfiguration } from '../server/module.js';
-import { DocumentCollectionService } from '../server/services/document-collection.service.js';
-import { DocumentManagementAiService } from '../server/services/document-management-ai.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, 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);
-        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 == DocumentWorkflowStep.Classification)?.state).toBe('completed');
-            expect(workflows.find((w) => w.step == DocumentWorkflowStep.DataExtraction)?.state).toBe('pending');
-            expect(workflows.find((w) => w.step == DocumentWorkflowStep.DataExtraction)?.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(), DocumentWorkflowState.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

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