@tstdl/base 0.93.182 → 0.93.183

package/cryptography/tests/totp.test.js

@@ -1,108 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { importKey } from '../cryptography.js';
-import { encodeTotpSecret, generateTotpRecoveryCodes, generateTotpSecret, generateTotpToken, generateTotpUri, hashTotpRecoveryCode, verifyTotpRecoveryCode, verifyTotpToken } from '../totp.js';
-const totpOptions = {
-    codeHashAlgorithm: 'SHA-1',
-    recoveryCodeHashOptions: {
-        algorithm: { name: 'PBKDF2', hash: 'SHA-256', salt: new Uint8Array(16), iterations: 10 },
-        length: 64,
-    },
-};
-describe('TOTP Utilities', () => {
-    test('should generate a secret of appropriate length', () => {
-        expect(generateTotpSecret('SHA-1').byteLength).toBe(20);
-        expect(generateTotpSecret('SHA-256').byteLength).toBe(32);
-        expect(generateTotpSecret('SHA-512').byteLength).toBe(64);
-    });
-    test('should generate a valid TOTP token', async () => {
-        const secretData = new Uint8Array(new ArrayBuffer(20));
-        secretData.fill(1);
-        const secret = await importKey('raw-secret', secretData, { name: 'HMAC', hash: 'SHA-1' }, false, ['sign']);
-        const token = await generateTotpToken(secret, { ...totpOptions, timestamp: 1000000000 });
-        expect(token).toMatch(/^\d{6}$/);
-    });
-    test('should verify a valid TOTP token', async () => {
-        const secretData = new Uint8Array(new ArrayBuffer(20));
-        secretData.fill(1);
-        const secret = await importKey('raw-secret', secretData, { name: 'HMAC', hash: 'SHA-1' }, false, ['sign']);
-        const timestamp = 1000000000;
-        const token = await generateTotpToken(secret, { ...totpOptions, timestamp });
-        const isValid = await verifyTotpToken(secret, token, { ...totpOptions, timestamp });
-        expect(isValid).toBe(true);
-    });
-    test('should fail to verify an invalid TOTP token', async () => {
-        const secretData = new Uint8Array(new ArrayBuffer(20));
-        secretData.fill(1);
-        const secret = await importKey('raw-secret', secretData, { name: 'HMAC', hash: 'SHA-1' }, false, ['sign']);
-        const isValid = await verifyTotpToken(secret, '000000', { ...totpOptions, timestamp: 1000000000 });
-        expect(isValid).toBe(false);
-    });
-    test('should generate a valid otpauth URI', () => {
-        const secret = new Uint8Array(new ArrayBuffer(20));
-        secret.fill(1);
-        const encodedSecret = encodeTotpSecret(secret);
-        const uri = generateTotpUri(encodedSecret, 'user@example.com', 'MyApp', totpOptions);
-        expect(uri).toBe('otpauth://totp/MyApp:user%40example.com?secret=AEAQCAIBAEAQCAIBAEAQCAIBAEAQCAIB&issuer=MyApp&algorithm=SHA1&digits=6&period=30');
-    });
-    test('should generate a valid otpauth URI with SHA-256', () => {
-        const secret = new Uint8Array(new ArrayBuffer(32));
-        secret.fill(1);
-        const encodedSecret = encodeTotpSecret(secret);
-        const uri = generateTotpUri(encodedSecret, 'user@example.com', 'MyApp', { ...totpOptions, codeHashAlgorithm: 'SHA-256' });
-        expect(uri).toBe('otpauth://totp/MyApp:user%40example.com?secret=AEAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQ&issuer=MyApp&algorithm=SHA256&digits=6&period=30');
-    });
-    test('should verify a valid TOTP token with SHA-256', async () => {
-        const secretData = new Uint8Array(new ArrayBuffer(32));
-        secretData.fill(1);
-        const secret = await importKey('raw-secret', secretData, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
-        const timestamp = 1000000000;
-        const options = { ...totpOptions, timestamp, codeHashAlgorithm: 'SHA-256' };
-        const token = await generateTotpToken(secret, options);
-        const isValid = await verifyTotpToken(secret, token, options);
-        expect(isValid).toBe(true);
-    });
-    test('should verify a valid TOTP token with SHA-512', async () => {
-        const secretData = new Uint8Array(new ArrayBuffer(64));
-        secretData.fill(1);
-        const secret = await importKey('raw-secret', secretData, { name: 'HMAC', hash: 'SHA-512' }, false, ['sign']);
-        const timestamp = 1000000000;
-        const options = { ...totpOptions, timestamp, codeHashAlgorithm: 'SHA-512' };
-        const token = await generateTotpToken(secret, options);
-        const isValid = await verifyTotpToken(secret, token, options);
-        expect(isValid).toBe(true);
-    });
-    test('should generate recovery codes', () => {
-        const codes = generateTotpRecoveryCodes(10, 8);
-        expect(codes.length).toBe(10);
-        for (const code of codes) {
-            expect(code).toMatch(/^[A-Z2-7]{8}$/);
-        }
-    });
-    test('should hash and verify a recovery code', async () => {
-        const code = 'ABCDEFGH';
-        const salt = new Uint8Array(new ArrayBuffer(16));
-        salt.fill(1);
-        const options = { algorithm: { name: 'PBKDF2', hash: 'SHA-256', salt, iterations: 10 }, length: 64 };
-        const hash = await hashTotpRecoveryCode(code, options);
-        const isValid = await verifyTotpRecoveryCode(code, hash, options);
-        expect(isValid).toBe(true);
-    });
-    test('should fail to verify an invalid recovery code', async () => {
-        const code = 'ABCDEFGH';
-        const salt = new Uint8Array(new ArrayBuffer(16));
-        salt.fill(1);
-        const options = { algorithm: { name: 'PBKDF2', hash: 'SHA-256', salt, iterations: 10 }, length: 64 };
-        const hash = await hashTotpRecoveryCode(code, options);
-        const isValid = await verifyTotpRecoveryCode('WRONGONE', hash, options);
-        expect(isValid).toBe(false);
-    });
-    test('should hash and verify a recovery code with Argon2id', async () => {
-        const code = 'ABCDEFGH';
-        const salt = new Uint8Array(new ArrayBuffer(16));
-        salt.fill(1);
-        const options = { algorithm: { name: 'Argon2id', parallelism: 1, memory: 1024, passes: 1, nonce: salt }, length: 64 };
-        const hash = await hashTotpRecoveryCode(code, options);
-        const isValid = await verifyTotpRecoveryCode(code, hash, options);
-        expect(isValid).toBe(true);
-    });
-});

package/document-management/tests/ai-config-hierarchy.test.d.ts

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

package/document-management/tests/ai-config-hierarchy.test.js

@@ -1,59 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest';
-import { injectModel } from '../../ai/genkit/index.js';
-import { runInInjectionContext } from '../../injector/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { DocumentManagementAiService } from '../server/services/document-management-ai.service.js';
-import { DocumentCategoryTypeService, DocumentManagementAiProviderService, DocumentManagementAncillaryService } from '../server/services/index.js';
-import { TestDocumentManagementAncillaryService } from './helper.js';
-describe('DocumentManagementAiService Hierarchy', () => {
-    let injector;
-    let aiService;
-    const tenantId = crypto.randomUUID();
-    const mockAiProvider = {
-        getGlobalConfiguration: vi.fn(),
-        getClassificationConfiguration: vi.fn(),
-        getDataExtractionConfiguration: vi.fn(),
-        getAssignmentConfiguration: vi.fn(),
-        getValidationConfiguration: vi.fn(),
-        getContentExtractionConfiguration: vi.fn(),
-    };
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({
-            modules: { messageBus: true, signals: true, objectStorage: true, documentManagement: true },
-        }));
-        injector.register(DocumentManagementAiProviderService, { useValue: mockAiProvider });
-        // Ancillary and configuration are already registered by setupIntegrationTest, but we can override if needed
-        injector.register(DocumentManagementAncillaryService, { useToken: TestDocumentManagementAncillaryService });
-        aiService = await injector.resolveAsync(DocumentManagementAiService);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    test('resolveAiConfiguration should implement Type > Category > Global Step > Global Defaults hierarchy', async () => {
-        const categoryTypeService = await injector.resolveAsync(DocumentCategoryTypeService);
-        const category = await categoryTypeService.createCategory({ tenantId, label: 'Finance', key: 'finance-cat', parentId: null });
-        const type = await categoryTypeService.createType({ tenantId, categoryId: category.id, label: 'Invoice', key: 'invoice-type' });
-        mockAiProvider.getGlobalConfiguration.mockResolvedValue({
-            defaults: { language: 'de', classification: 'Global Default Classify' },
-            steps: {
-                'data-extraction': { language: 'en', extraction: { title: 'Global Step Title' } }
-            },
-            categories: {
-                'finance-cat': { extraction: { title: 'Category Title', subtitle: 'Category Subtitle' } }
-            },
-            documentTypes: {
-                'invoice-type': { extraction: { title: 'Type Title' } }
-            }
-        });
-        mockAiProvider.getDataExtractionConfiguration.mockResolvedValue({
-            extraction: { subtitle: 'Provider Subtitle' }
-        });
-        await runInInjectionContext(injector, async () => {
-            const config = await aiService.resolveAiConfiguration(tenantId, 'data-extraction', { type });
-            expect(config.language).toBe('en'); // Step > Defaults
-            expect(config.classification).toBe('Global Default Classify'); // Fallback to defaults
-            expect(config.extraction.title).toBe('Type Title'); // Type > Category > Step
-            expect(config.extraction.subtitle).toBe('Provider Subtitle'); // Provider > Category
-        });
-    });
-});

package/document-management/tests/ai-config-integration.test.d.ts

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

package/document-management/tests/ai-config-integration.test.js

@@ -1,125 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest';
-const mockGenerate = vi.fn();
-vi.mock('genkit', async () => {
-    const original = await vi.importActual('genkit');
-    return {
-        ...original,
-        genkit: () => ({
-            generate: mockGenerate,
-        }),
-    };
-});
-import { injectModel } from '../../ai/genkit/index.js';
-import { runInInjectionContext } from '../../injector/index.js';
-import { ObjectStorage } from '../../object-storage/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { DocumentCategoryTypeService } from '../server/services/document-category-type.service.js';
-import { DocumentManagementAiService } from '../server/services/document-management-ai.service.js';
-import { DocumentService } from '../server/services/document.service.js';
-import { DocumentManagementAiProviderService, DocumentManagementAncillaryService } from '../server/services/index.js';
-import { TestDocumentManagementAncillaryService } from './helper.js';
-describe('DocumentManagementAiService Integration', () => {
-    let injector;
-    let aiService;
-    let flashModel;
-    const tenantId = crypto.randomUUID();
-    const mockAiProvider = {
-        getGlobalConfiguration: vi.fn(),
-        getClassificationConfiguration: vi.fn(),
-        getDataExtractionConfiguration: vi.fn(),
-        getAssignmentConfiguration: vi.fn(),
-        getValidationConfiguration: vi.fn(),
-        getContentExtractionConfiguration: vi.fn(),
-    };
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({
-            modules: { messageBus: true, signals: true, objectStorage: true, documentManagement: true, taskQueue: true },
-        }));
-        const mockObjectStorage = {
-            store: vi.fn().mockResolvedValue({ mimeType: 'application/pdf', hash: 'hash', size: 100 }),
-            uploadObject: vi.fn(),
-            getDownloadUrl: vi.fn(),
-            getContent: vi.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
-            getContentStream: vi.fn(),
-            getObject: vi.fn(),
-            exists: vi.fn(),
-        };
-        runInInjectionContext(injector, () => {
-            flashModel = injectModel('gemini-2.5-flash');
-        });
-        injector.register(DocumentManagementAiProviderService, { useValue: mockAiProvider });
-        injector.register(DocumentManagementAncillaryService, { useToken: TestDocumentManagementAncillaryService });
-        injector.register(ObjectStorage, { useValue: mockObjectStorage });
-        aiService = await injector.resolveAsync(DocumentManagementAiService);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    test('extractData should include granular instructions in prompt', async () => {
-        const categoryTypeService = await injector.resolveAsync(DocumentCategoryTypeService);
-        const documentService = await injector.resolveAsync(DocumentService);
-        const category = await categoryTypeService.createCategory({ tenantId, label: 'Finance', key: 'finance', parentId: null });
-        const type = await categoryTypeService.createType({ tenantId, categoryId: category.id, label: 'Invoice', key: 'invoice' });
-        const document = await documentService.create(tenantId, {
-            typeId: type.id,
-            originalFileName: 'test.pdf',
-            skipWorkflow: true,
-            assignment: { collections: [] }
-        }, new Uint8Array([1, 2, 3]));
-        mockAiProvider.getGlobalConfiguration.mockResolvedValue({
-            documentTypes: {
-                'invoice': {
-                    extraction: {
-                        title: { format: 'INV-{{Date}}' },
-                        summary: { content: 'Focus on items.', strategy: 'append' }
-                    }
-                }
-            }
-        });
-        mockAiProvider.getDataExtractionConfiguration.mockResolvedValue(undefined);
-        // Mock Genkit output
-        mockGenerate.mockResolvedValue({
-            output: {
-                documentTitle: 'INV-2024',
-                documentSubtitle: null,
-                documentSummary: 'Summary',
-                documentTags: [],
-                documentDate: null
-            }
-        });
-        await runInInjectionContext(injector, async () => {
-            await aiService.extractData(tenantId, document.id);
-            const lastCall = mockGenerate.mock.calls[0][0];
-            const userPrompt = lastCall.prompt;
-            const userPromptText = userPrompt.map((p) => p.text).join('\n');
-            expect(userPromptText).toContain('Format the title of the document exactly as follows: INV-{{Date}}');
-            expect(userPromptText).toContain('Focus on items.');
-        });
-    });
-    test('classifyDocumentType should include granular instructions in prompt', async () => {
-        const documentService = await injector.resolveAsync(DocumentService);
-        const document = await documentService.create(tenantId, {
-            originalFileName: 'test.pdf',
-            skipWorkflow: true,
-            assignment: { collections: [] }
-        }, new Uint8Array([1, 2, 3]));
-        mockAiProvider.getGlobalConfiguration.mockResolvedValue({
-            defaults: {
-                classification: { content: 'Prefer Finance types.', strategy: 'append' }
-            }
-        });
-        mockAiProvider.getClassificationConfiguration.mockResolvedValue(undefined);
-        mockGenerate.mockResolvedValue({
-            output: {
-                documentType: 'Category: Finance | Type: Invoice'
-            }
-        });
-        await runInInjectionContext(injector, async () => {
-            await aiService.classifyDocumentType(tenantId, document.id);
-            const lastCall = mockGenerate.mock.calls[1][0];
-            const systemPrompt = lastCall.system;
-            const systemPromptText = systemPrompt.map((p) => p.text).join('\n');
-            expect(systemPromptText).toContain('Prefer Finance types.');
-        });
-    });
-});

package/document-management/tests/ai-config-merge.test.d.ts

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

package/document-management/tests/ai-config-merge.test.js

@@ -1,46 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { mergeInstructions } from '../server/services/document-management-ai.service.js';
-describe('AI Instruction Merging', () => {
-    test('should return base when no overrides are provided', () => {
-        const base = 'Default instruction';
-        expect(mergeInstructions(base, [])).toBe(base);
-    });
-    test('should replace with string override', () => {
-        const base = 'Default instruction';
-        const overrides = ['Custom instruction'];
-        expect(mergeInstructions(base, overrides)).toBe('Custom instruction');
-    });
-    test('should append with append strategy', () => {
-        const base = 'Default instruction';
-        const overrides = [{ content: 'Added instruction', strategy: 'append' }];
-        expect(mergeInstructions(base, overrides)).toBe('Default instruction\n\nAdded instruction');
-    });
-    test('should replace with replace strategy', () => {
-        const base = 'Default instruction';
-        const overrides = [{ content: 'New instruction', strategy: 'replace' }];
-        expect(mergeInstructions(base, overrides)).toBe('New instruction');
-    });
-    test('should handle multiple overrides in order', () => {
-        const base = 'Base';
-        const overrides = [
-            { content: 'Global', strategy: 'append' },
-            { content: 'Category', strategy: 'append' },
-            { content: 'Type', strategy: 'replace' }
-        ];
-        expect(mergeInstructions(base, overrides)).toBe('Type');
-    });
-    test('should handle format simple override', () => {
-        const base = 'Create a title.';
-        const overrides = [{ format: '[ID] - [Name]' }];
-        const result = mergeInstructions(base, overrides);
-        expect(result).toContain('[ID] - [Name]');
-    });
-    test('should handle Instructions in content', () => {
-        const base = 'Base';
-        const overrides = [{ content: { Detail: 'More info' }, strategy: 'append' }];
-        const result = mergeInstructions(base, overrides);
-        expect(result).toContain('Base');
-        expect(result).toContain('# Detail');
-        expect(result).toContain('More info');
-    });
-});

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

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

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

@@ -1,63 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest';
-import { injectModel } from '../../ai/genkit/index.js';
-import { runInInjectionContext } from '../../injector/index.js';
-import { ObjectStorage } from '../../object-storage/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { DocumentManagementConfiguration } from '../server/module.js';
-import { DocumentManagementAiService } from '../server/services/document-management-ai.service.js';
-import { DocumentCategoryTypeService, DocumentManagementAiProviderService, DocumentManagementAncillaryService } from '../server/services/index.js';
-import { TestDocumentManagementAncillaryService } from './helper.js';
-describe('DocumentManagementAiService Overrides', () => {
-    let injector;
-    let aiService;
-    let flashModel;
-    let proModel;
-    const tenantId = crypto.randomUUID();
-    const mockAiProvider = {
-        getGlobalConfiguration: vi.fn(),
-        getClassificationConfiguration: vi.fn(),
-        getDataExtractionConfiguration: vi.fn(),
-        getAssignmentConfiguration: 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' } });
-        aiService = await injector.resolveAsync(DocumentManagementAiService);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    test('resolveAiConfiguration should merge configurations correctly', async () => {
-        const categoryTypeService = await injector.resolveAsync(DocumentCategoryTypeService);
-        const category = await categoryTypeService.createCategory({ tenantId, label: 'Finance', key: 'finance-cat', parentId: null });
-        const type = await categoryTypeService.createType({ tenantId, categoryId: category.id, label: 'Invoice', key: 'invoice-key' });
-        mockAiProvider.getGlobalConfiguration.mockResolvedValue({
-            defaults: {
-                language: 'en',
-                model: flashModel,
-                prompt: { systemAddition: 'Global System' },
-            },
-        });
-        mockAiProvider.getDataExtractionConfiguration.mockResolvedValue({
-            model: proModel,
-            prompt: { systemAddition: 'Extraction System', systemOverride: (base) => `OVERRIDDEN: ${base}` },
-        });
-        await runInInjectionContext(injector, async () => {
-            // Accessing private method for testing purposes
-            const config = await aiService.resolveAiConfiguration(tenantId, 'data-extraction', { type });
-            expect(config.language).toBe('en');
-            expect(config.model).toBe(proModel);
-            expect(config.prompt.systemAddition).toEqual(['Global System', 'Extraction System']);
-            expect(config.prompt.systemOverride('Base')).toBe('OVERRIDDEN: Base');
-        });
-    });
-});

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

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

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

@@ -1,157 +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 { 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 { 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 categoryTypeService;
-    const schema = 'document_management';
-    const tenantId = crypto.randomUUID();
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({
-            modules: { taskQueue: false, messageBus: true, documentManagement: true }, // Disabled TaskQueue to avoid background noise
-            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(),
-            },
-        });
-        // 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',
-            injector,
-        });
-        documentService = await injector.resolveAsync(DocumentService);
-        collectionService = await injector.resolveAsync(DocumentCollectionService);
-        requestService = await injector.resolveAsync(DocumentRequestService);
-        managementService = await injector.resolveAsync(DocumentManagementService);
-        categoryTypeService = await injector.resolveAsync(DocumentCategoryTypeService);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    beforeEach(async () => {
-        await clearTenantData(database, schema, ['request_collection_assignment', 'collection_assignment', 'workflow', 'request', 'document', 'collection', 'type', 'category'], tenantId);
-    });
-    // --- 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-management.api.test.d.ts

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