@tstdl/base 0.93.182 → 0.93.183

package/document-management/tests/enum-helpers.test.js

@@ -1,452 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
-import { GenkitModuleOptions } from '../../ai/genkit/module.js';
-import { NotFoundError } from '../../errors/not-found.error.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 { DocumentPropertyDataType } from '../models/document-property.model.js';
-import { configureDocumentManagement } from '../server/configure.js';
-import { DocumentCategoryTypeService } from '../server/services/document-category-type.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 { TestDocumentManagementAncillaryService, TestDocumentManagementAuthorizationService } from './helper.js';
-describe('Document Management Extended Suite', () => {
-    let injector;
-    let database;
-    let documentManagementService;
-    let categoryTypeService;
-    let propertyService;
-    const schema = 'document_management';
-    const tenantId = crypto.randomUUID();
-    const otherTenantId = 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,
-        });
-        documentManagementService = await injector.resolveAsync(DocumentManagementService);
-        categoryTypeService = await injector.resolveAsync(DocumentCategoryTypeService);
-        propertyService = await injector.resolveAsync(DocumentPropertyService);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    beforeEach(async () => {
-        await clearTenantData(database, schema, ['type_property', 'property', 'type', 'category'], tenantId);
-        await clearTenantData(database, schema, ['type_property', 'property', 'type', 'category'], otherTenantId);
-        categoryTypeService.invalidateCache(tenantId);
-        propertyService.invalidateCache(tenantId);
-        categoryTypeService.invalidateCache(otherTenantId);
-        propertyService.invalidateCache(otherTenantId);
-    });
-    // --- 1. Category Management ---
-    test('1. Create category with key', async () => {
-        await runInInjectionContext(injector, async () => {
-            const category = await categoryTypeService.createCategory({ tenantId, label: 'Cat Key', parentId: null, key: 'cat-key' });
-            expect(category.key).toBe('cat-key');
-            expect(await categoryTypeService.getCategoryId(tenantId, 'cat-key')).toBe(category.id);
-        });
-    });
-    test('2. Create category without key', async () => {
-        await runInInjectionContext(injector, async () => {
-            const category = await categoryTypeService.createCategory({ tenantId, label: 'Cat No Key', parentId: null });
-            expect(category.key).toBeNull();
-            await expect(categoryTypeService.getCategoryId(tenantId, 'cat-no-key')).rejects.toThrow(NotFoundError);
-        });
-    });
-    test('3. Category Hierarchy with keys', async () => {
-        await runInInjectionContext(injector, async () => {
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { root: 'Root', child: 'Child' },
-                categoryParents: { root: null, child: 'root' },
-                typeLabels: {}, typeCategories: {}, propertyConfigurations: {}, typeProperties: {},
-            });
-            const rootId = await categoryTypeService.getCategoryId(tenantId, 'root');
-            const childId = await categoryTypeService.getCategoryId(tenantId, 'child');
-            const child = await categoryTypeService.loadCategory(tenantId, childId);
-            expect(child.parentId).toBe(rootId);
-        });
-    });
-    test('4. Update category label via initialize', async () => {
-        await runInInjectionContext(injector, async () => {
-            await categoryTypeService.createCategory({ tenantId, label: 'Old Label', parentId: null, key: 'cat-update' });
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { 'cat-update': 'New Label' },
-                categoryParents: { 'cat-update': null },
-                typeLabels: {}, typeCategories: {}, propertyConfigurations: {}, typeProperties: {},
-            });
-            const id = await categoryTypeService.getCategoryId(tenantId, 'cat-update');
-            const category = await categoryTypeService.loadCategory(tenantId, id);
-            expect(category.label).toBe('New Label');
-        });
-    });
-    test('5. Update category parent via initialize', async () => {
-        await runInInjectionContext(injector, async () => {
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { 'root': 'Root', 'child': 'Child', 'new-root': 'New Root' },
-                categoryParents: { 'root': null, 'child': 'root', 'new-root': null },
-                typeLabels: {}, typeCategories: {}, propertyConfigurations: {}, typeProperties: {},
-            });
-            // Move child to new-root
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { 'root': 'Root', 'child': 'Child', 'new-root': 'New Root' },
-                categoryParents: { 'root': null, 'child': 'new-root', 'new-root': null },
-                typeLabels: {}, typeCategories: {}, propertyConfigurations: {}, typeProperties: {},
-            });
-            const childId = await categoryTypeService.getCategoryId(tenantId, 'child');
-            const newRootId = await categoryTypeService.getCategoryId(tenantId, 'new-root');
-            const child = await categoryTypeService.loadCategory(tenantId, childId);
-            expect(child.parentId).toBe(newRootId);
-        });
-    });
-    // --- 2. Type Management ---
-    test('6. Create type with key', async () => {
-        await runInInjectionContext(injector, async () => {
-            const category = await categoryTypeService.createCategory({ tenantId, label: 'Cat', parentId: null });
-            const type = await categoryTypeService.createType({ tenantId, label: 'Type Key', categoryId: category.id, key: 'type-key' });
-            expect(type.key).toBe('type-key');
-            expect(await categoryTypeService.getTypeId(tenantId, 'type-key')).toBe(type.id);
-        });
-    });
-    test('7. Create type without key', async () => {
-        await runInInjectionContext(injector, async () => {
-            const category = await categoryTypeService.createCategory({ tenantId, label: 'Cat', parentId: null });
-            const type = await categoryTypeService.createType({ tenantId, label: 'Type No Key', categoryId: category.id });
-            expect(type.key).toBeNull();
-        });
-    });
-    test('8. Assign type to category via initialize', async () => {
-        await runInInjectionContext(injector, async () => {
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { cat: 'Category' },
-                categoryParents: { cat: null },
-                typeLabels: { type: 'Type' },
-                typeCategories: { type: 'cat' },
-                propertyConfigurations: {}, typeProperties: { type: [] },
-            });
-            const catId = await categoryTypeService.getCategoryId(tenantId, 'cat');
-            const typeId = await categoryTypeService.getTypeId(tenantId, 'type');
-            const type = await categoryTypeService.loadType(tenantId, typeId);
-            expect(type.categoryId).toBe(catId);
-        });
-    });
-    test('9. Update type label via initialize', async () => {
-        await runInInjectionContext(injector, async () => {
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { cat: 'Category' },
-                categoryParents: { cat: null },
-                typeLabels: { type: 'Old Type Label' },
-                typeCategories: { type: 'cat' },
-                propertyConfigurations: {}, typeProperties: { type: [] },
-            });
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { cat: 'Category' },
-                categoryParents: { cat: null },
-                typeLabels: { type: 'New Type Label' },
-                typeCategories: { type: 'cat' },
-                propertyConfigurations: {}, typeProperties: { type: [] },
-            });
-            const typeId = await categoryTypeService.getTypeId(tenantId, 'type');
-            const type = await categoryTypeService.loadType(tenantId, typeId);
-            expect(type.label).toBe('New Type Label');
-        });
-    });
-    test('10. Update type category assignment', async () => {
-        await runInInjectionContext(injector, async () => {
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { cat1: 'Cat 1', cat2: 'Cat 2' },
-                categoryParents: { cat1: null, cat2: null },
-                typeLabels: { type: 'Type' },
-                typeCategories: { type: 'cat1' },
-                propertyConfigurations: {}, typeProperties: { type: [] },
-            });
-            const cat2Id = await categoryTypeService.getCategoryId(tenantId, 'cat2');
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { cat1: 'Cat 1', cat2: 'Cat 2' },
-                categoryParents: { cat1: null, cat2: null },
-                typeLabels: { type: 'Type' },
-                typeCategories: { type: 'cat2' }, // Move to cat2
-                propertyConfigurations: {}, typeProperties: { type: [] },
-            });
-            const typeId = await categoryTypeService.getTypeId(tenantId, 'type');
-            const type = await categoryTypeService.loadType(tenantId, typeId);
-            expect(type.categoryId).toBe(cat2Id);
-        });
-    });
-    // --- 3. Property Management ---
-    test('11. Create property with key (Text)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const prop = await propertyService.createProperty({ tenantId, label: 'Text Prop', dataType: DocumentPropertyDataType.Text, key: 'prop-text' });
-            expect(prop.dataType).toBe(DocumentPropertyDataType.Text);
-            expect(await propertyService.getPropertyId(tenantId, 'prop-text')).toBe(prop.id);
-        });
-    });
-    test('12. Create property with key (Number)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const prop = await propertyService.createProperty({ tenantId, label: 'Num Prop', dataType: DocumentPropertyDataType.Integer, key: 'prop-num' });
-            expect(prop.dataType).toBe(DocumentPropertyDataType.Integer);
-        });
-    });
-    test('13. Update property label', async () => {
-        await runInInjectionContext(injector, async () => {
-            await propertyService.createProperty({ tenantId, label: 'Old', dataType: DocumentPropertyDataType.Text, key: 'prop' });
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: {}, categoryParents: {}, typeLabels: {}, typeCategories: {},
-                propertyConfigurations: { prop: [DocumentPropertyDataType.Text, 'New'] },
-                typeProperties: {},
-            });
-            const id = await propertyService.getPropertyId(tenantId, 'prop');
-            const prop = (await propertyService.loadViews(tenantId)).find(p => p.id === id);
-            expect(prop?.label).toBe('New');
-        });
-    });
-    test('14. Update property data type', async () => {
-        await runInInjectionContext(injector, async () => {
-            await propertyService.createProperty({ tenantId, label: 'Prop', dataType: DocumentPropertyDataType.Text, key: 'prop' });
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: {}, categoryParents: {}, typeLabels: {}, typeCategories: {},
-                propertyConfigurations: { prop: [DocumentPropertyDataType.Integer, 'Prop'] },
-                typeProperties: {},
-            });
-            const id = await propertyService.getPropertyId(tenantId, 'prop');
-            const prop = (await propertyService.loadViews(tenantId)).find(p => p.id === id);
-            expect(prop?.dataType).toBe(DocumentPropertyDataType.Integer);
-        });
-    });
-    test('15. Assign properties to types', async () => {
-        await runInInjectionContext(injector, async () => {
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { cat: 'Cat' }, categoryParents: { cat: null },
-                typeLabels: { type: 'Type' }, typeCategories: { type: 'cat' },
-                propertyConfigurations: { prop1: [DocumentPropertyDataType.Text, 'P1'], prop2: [DocumentPropertyDataType.Integer, 'P2'] },
-                typeProperties: { type: ['prop1', 'prop2'] },
-            });
-            const typeId = await categoryTypeService.getTypeId(tenantId, 'type');
-            const prop1Id = await propertyService.getPropertyId(tenantId, 'prop1');
-            const prop2Id = await propertyService.getPropertyId(tenantId, 'prop2');
-            const props = await propertyService.loadViews(tenantId);
-            const p1 = props.find(p => p.id === prop1Id);
-            const p2 = props.find(p => p.id === prop2Id);
-            expect(p1?.typeIds).toContain(typeId);
-            expect(p2?.typeIds).toContain(typeId);
-        });
-    });
-    // --- 4. Cache Behavior ---
-    test('16. Verify cache hit', async () => {
-        await runInInjectionContext(injector, async () => {
-            const category = await categoryTypeService.createCategory({ tenantId, label: 'Cache Test', parentId: null, key: 'cache-hit' });
-            // Load once to populate cache
-            await categoryTypeService.getCategoryId(tenantId, 'cache-hit');
-            // Delete from DB manually
-            await categoryTypeService.categoryRepository.hardDeleteByQuery({ tenantId, id: category.id });
-            // Should still find it in cache
-            expect(await categoryTypeService.getCategoryId(tenantId, 'cache-hit')).toBe(category.id);
-        });
-    });
-    test('17. Verify cache miss throws NotFound', async () => {
-        await runInInjectionContext(injector, async () => {
-            await expect(categoryTypeService.getCategoryId(tenantId, 'missing')).rejects.toThrow(NotFoundError);
-        });
-    });
-    test('18. Manual cache invalidation', async () => {
-        await runInInjectionContext(injector, async () => {
-            const category = await categoryTypeService.createCategory({ tenantId, label: 'Invalidate', parentId: null, key: 'inv' });
-            await categoryTypeService.getCategoryId(tenantId, 'inv'); // cache it
-            categoryTypeService.invalidateCache(tenantId);
-            await categoryTypeService.categoryRepository.hardDeleteByQuery({ tenantId, id: category.id });
-            // Should fail now as cache is cleared and DB is empty
-            await expect(categoryTypeService.getCategoryId(tenantId, 'inv')).rejects.toThrow(NotFoundError);
-        });
-    });
-    test('19. Automatic invalidation after initialize', async () => {
-        await runInInjectionContext(injector, async () => {
-            await categoryTypeService.createCategory({ tenantId, label: 'Auto', parentId: null, key: 'auto' });
-            await categoryTypeService.getCategoryId(tenantId, 'auto'); // cache it
-            // Run initialize (should invalidate)
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { auto: 'Auto Updated' },
-                categoryParents: { auto: null },
-                typeLabels: {}, typeCategories: {}, propertyConfigurations: {}, typeProperties: {},
-            });
-            // If we query DB directly, we see the update
-            const id = await categoryTypeService.getCategoryId(tenantId, 'auto');
-            const cat = await categoryTypeService.loadCategory(tenantId, id);
-            expect(cat.label).toBe('Auto Updated');
-        });
-    });
-    test('20. Multi-tenant isolation', async () => {
-        await runInInjectionContext(injector, async () => {
-            await categoryTypeService.createCategory({ tenantId, label: 'T1', parentId: null, key: 'shared' });
-            await categoryTypeService.createCategory({ tenantId: otherTenantId, label: 'T2', parentId: null, key: 'shared' });
-            const id1 = await categoryTypeService.getCategoryId(tenantId, 'shared');
-            const id2 = await categoryTypeService.getCategoryId(otherTenantId, 'shared');
-            expect(id1).not.toBe(id2);
-        });
-    });
-    // --- 5. Initialization Logic ---
-    test('21. Initialize from scratch', async () => {
-        await runInInjectionContext(injector, async () => {
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { c: 'C' }, categoryParents: { c: null },
-                typeLabels: { t: 'T' }, typeCategories: { t: 'c' },
-                propertyConfigurations: { p: [DocumentPropertyDataType.Text, 'P'] },
-                typeProperties: { t: ['p'] },
-            });
-            expect(await categoryTypeService.getCategoryId(tenantId, 'c')).toBeDefined();
-            expect(await categoryTypeService.getTypeId(tenantId, 't')).toBeDefined();
-            expect(await propertyService.getPropertyId(tenantId, 'p')).toBeDefined();
-        });
-    });
-    test('22. Idempotent initialization', async () => {
-        await runInInjectionContext(injector, async () => {
-            const config = {
-                categoryLabels: { c: 'C' }, categoryParents: { c: null },
-                typeLabels: {}, typeCategories: {}, propertyConfigurations: {}, typeProperties: {},
-            };
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, config);
-            const id1 = await categoryTypeService.getCategoryId(tenantId, 'c');
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, config);
-            const id2 = await categoryTypeService.getCategoryId(tenantId, 'c');
-            expect(id1).toBe(id2);
-        });
-    });
-    test('23. Partial update (add newly defined entity)', async () => {
-        await runInInjectionContext(injector, async () => {
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { c1: 'C1' }, categoryParents: { c1: null },
-                typeLabels: {}, typeCategories: {}, propertyConfigurations: {}, typeProperties: {},
-            });
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { c1: 'C1', c2: 'C2' },
-                categoryParents: { c1: null, c2: null },
-                typeLabels: {}, typeCategories: {}, propertyConfigurations: {}, typeProperties: {},
-            });
-            expect(await categoryTypeService.getCategoryId(tenantId, 'c1')).toBeDefined();
-            expect(await categoryTypeService.getCategoryId(tenantId, 'c2')).toBeDefined();
-        });
-    });
-    test('24. Initialize with invalid parent key throws', async () => {
-        await runInInjectionContext(injector, async () => {
-            await expect(documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { child: 'Child' },
-                // @ts-expect-error - Intentional invalid parent key
-                categoryParents: { child: 'missing-parent' },
-                typeLabels: {}, typeCategories: {}, propertyConfigurations: {}, typeProperties: {},
-            })).rejects.toThrow();
-        });
-    });
-    test('25. Initialize with invalid type category throws', async () => {
-        await runInInjectionContext(injector, async () => {
-            await expect(documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: {}, categoryParents: {},
-                typeLabels: { type: 'Type' },
-                // @ts-expect-error - Intentional invalid type category
-                typeCategories: { type: 'missing-cat' },
-                propertyConfigurations: {}, typeProperties: { type: [] },
-            })).rejects.toThrow();
-        });
-    });
-    // --- 6. Edge Cases ---
-    test('26. Duplicate keys prevented by DB constraint', async () => {
-        // This tests the DB constraint we added
-        await runInInjectionContext(injector, async () => {
-            await categoryTypeService.createCategory({ tenantId, label: 'C1', parentId: null, key: 'dup' });
-            await expect(categoryTypeService.createCategory({ tenantId, label: 'C2', parentId: null, key: 'dup' }))
-                .rejects.toThrow();
-        });
-    });
-    test('27. Null key allows duplicates', async () => {
-        // This confirms that nulls are not unique
-        await runInInjectionContext(injector, async () => {
-            await categoryTypeService.createCategory({ tenantId, label: 'C1', parentId: null }); // key is null
-            await expect(categoryTypeService.createCategory({ tenantId, label: 'C2', parentId: null }))
-                .resolves.toBeDefined();
-        });
-    });
-    test('28. Initialize with multiple properties for a type', async () => {
-        await runInInjectionContext(injector, async () => {
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: { cat: 'Cat' }, categoryParents: { cat: null },
-                typeLabels: { type: 'Type' }, typeCategories: { type: 'cat' },
-                propertyConfigurations: {
-                    p1: [DocumentPropertyDataType.Text, 'P1'],
-                    p2: [DocumentPropertyDataType.Integer, 'P2'],
-                    p3: [DocumentPropertyDataType.Boolean, 'P3'],
-                },
-                typeProperties: { type: ['p1', 'p2', 'p3'] },
-            });
-            const typeId = await categoryTypeService.getTypeId(tenantId, 'type');
-            const p1Id = await propertyService.getPropertyId(tenantId, 'p1');
-            const p3Id = await propertyService.getPropertyId(tenantId, 'p3');
-            const props = await propertyService.loadViews(tenantId);
-            const p1 = props.find(p => p.id === p1Id);
-            const p3 = props.find(p => p.id === p3Id);
-            expect(p1?.typeIds).toContain(typeId);
-            expect(p3?.typeIds).toContain(typeId);
-        });
-    });
-    test('29. Large number of entities', async () => {
-        await runInInjectionContext(injector, async () => {
-            const count = 50;
-            const categoryLabels = {};
-            const categoryParents = {};
-            for (let i = 0; i < count; i++) {
-                categoryLabels[`cat-${i}`] = `Category ${i}`;
-                categoryParents[`cat-${i}`] = null;
-            }
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels, categoryParents,
-                typeLabels: {}, typeCategories: {}, propertyConfigurations: {}, typeProperties: {},
-            });
-            const id = await categoryTypeService.getCategoryId(tenantId, `cat-${count - 1}`);
-            expect(id).toBeDefined();
-        });
-    });
-    test('Missing key throws NotFoundError', async () => {
-        await runInInjectionContext(injector, async () => {
-            await expect(categoryTypeService.getCategoryId(tenantId, 'non-existent')).rejects.toThrow(NotFoundError);
-        });
-    });
-    test('loadCategoriesAndTypes returns properties', async () => {
-        await runInInjectionContext(injector, async () => {
-            await documentManagementService.initializeCategoriesAndTypes(tenantId, {
-                categoryLabels: {}, categoryParents: {}, typeLabels: {}, typeCategories: {},
-                propertyConfigurations: { p1: [DocumentPropertyDataType.Text, 'P1'] },
-                typeProperties: {},
-            });
-            const result = await categoryTypeService.loadCategoriesAndTypes(tenantId);
-            expect(result.properties).toBeDefined();
-            expect(result.properties).toHaveLength(1);
-            expect(result.properties[0]?.label).toBe('P1');
-        });
-    });
-});

package/document-management/tests/helper.d.ts

@@ -1,24 +0,0 @@
-import { DocumentManagementAuthorizationService } from '../authorization/document-management-authorization.service.js';
-import type { DocumentCollection } from '../models/document-collection.model.js';
-import { DocumentManagementAncillaryService } from '../server/services/document-management-ancillary.service.js';
-import type { DocumentCollectionMetadata } from '../service-models/document-collection-metadata.service-model.js';
-export declare class TestDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
-    resolveMetadata(_tenantId: string, collections: DocumentCollection[]): DocumentCollectionMetadata[];
-}
-export declare class TestDocumentManagementAuthorizationService extends DocumentManagementAuthorizationService {
-    getTenantId(): string;
-    getSubject(): string;
-    canReadCollection(): boolean;
-    canCreateDocuments(): boolean;
-    canDeleteDocuments(): boolean;
-    canAssignDocuments(): boolean;
-    canUpdateDocument(): boolean;
-    canApproveDocument(): boolean;
-    canRejectDocument(): boolean;
-    canManageRequests(): boolean;
-    canManageCategoriesAndTypes(): boolean;
-    canReadDocumentRequestsTemplates(): boolean;
-    canManageDocumentRequestsTemplates(): boolean;
-    canManageValidationDefinitions(): boolean;
-    canProgressDocumentWorkflow(): boolean;
-}

package/document-management/tests/helper.js

@@ -1,39 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Singleton } from '../../injector/index.js';
-import { DocumentManagementAuthorizationService } from '../authorization/document-management-authorization.service.js';
-import { DocumentManagementAncillaryService } from '../server/services/document-management-ancillary.service.js';
-let TestDocumentManagementAncillaryService = class TestDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
-    resolveMetadata(_tenantId, collections) {
-        return collections.map((c) => ({ id: c.id, name: `Collection ${c.id}`, group: 'Test' }));
-    }
-};
-TestDocumentManagementAncillaryService = __decorate([
-    Singleton()
-], TestDocumentManagementAncillaryService);
-export { TestDocumentManagementAncillaryService };
-let TestDocumentManagementAuthorizationService = class TestDocumentManagementAuthorizationService extends DocumentManagementAuthorizationService {
-    getTenantId() { return 'test-tenant'; }
-    getSubject() { return 'test-user'; }
-    canReadCollection() { return true; }
-    canCreateDocuments() { return true; }
-    canDeleteDocuments() { return true; }
-    canAssignDocuments() { return true; }
-    canUpdateDocument() { return true; }
-    canApproveDocument() { return true; }
-    canRejectDocument() { return true; }
-    canManageRequests() { return true; }
-    canManageCategoriesAndTypes() { return true; }
-    canReadDocumentRequestsTemplates() { return true; }
-    canManageDocumentRequestsTemplates() { return true; }
-    canManageValidationDefinitions() { return true; }
-    canProgressDocumentWorkflow() { return true; }
-};
-TestDocumentManagementAuthorizationService = __decorate([
-    Singleton()
-], TestDocumentManagementAuthorizationService);
-export { TestDocumentManagementAuthorizationService };

package/errors/tests/format.test.d.ts

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

package/errors/tests/format.test.js

@@ -1,84 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { formatError } from '../format.js';
-describe('formatError', () => {
-    it('should format a simple error', () => {
-        const error = new Error('test message');
-        const formatted = formatError(error, { includeStack: false });
-        expect(formatted).toBe('Error: test message');
-    });
-    it('should align multi-line messages', () => {
-        const error = new Error('line 1\nline 2');
-        const formatted = formatError(error, { includeStack: false });
-        expect(formatted).toBe('Error: line 1\n       line 2');
-    });
-    it('should format nested errors with causes', () => {
-        const cause = new Error('cause message');
-        const error = new Error('top message', { cause });
-        const formatted = formatError(error, { includeStack: true });
-        expect(formatted).toContain('Error: top message');
-        expect(formatted).toContain('Caused by:');
-        expect(formatted).toContain('Error: cause message');
-    });
-    it('should deduplicate stack header', () => {
-        const error = new Error('test message');
-        const formatted = formatError(error, { includeStack: true });
-        const lines = formatted.split('\n');
-        expect(lines[0]).toBe('Error: test message');
-        expect(lines[1].trim()).toMatch(/^at /);
-    });
-    it('should handle multi-line message alignment with stack deduplication', () => {
-        const error = new Error('multi\nline');
-        const formatted = formatError(error, { includeStack: true });
-        expect(formatted).toContain('Error: multi\n       line');
-        const lines = formatted.split('\n');
-        expect(lines[0]).toBe('Error: multi');
-        expect(lines[1]).toBe('       line');
-        expect(lines[2].trim()).toMatch(/^at /);
-    });
-    it('should format rest properties', () => {
-        const error = new Error('message');
-        error.code = 'ERR_CODE';
-        error.details = { foo: 'bar' };
-        const formatted = formatError(error, { includeStack: false, includeRest: true });
-        expect(formatted).toContain('Error: message');
-        expect(formatted).toContain('"code": "ERR_CODE"');
-        expect(formatted).toContain('"foo": "bar"');
-    });
-    it('should format AggregateError', () => {
-        const error1 = new Error('sub error 1');
-        const error2 = new Error('sub error 2');
-        const aggregateError = new AggregateError([error1, error2], 'aggregate message');
-        const formatted = formatError(aggregateError, { includeStack: false });
-        expect(formatted).toContain('AggregateError: aggregate message');
-        expect(formatted).toContain('Sub-error #1:');
-        expect(formatted).toContain('Error: sub error 1');
-        expect(formatted).toContain('Sub-error #2:');
-        expect(formatted).toContain('Error: sub error 2');
-    });
-    it('should handle deep cause chains', () => {
-        const cause2 = new Error('bottom');
-        const cause1 = new Error('middle', { cause: cause2 });
-        const error = new Error('top', { cause: cause1 });
-        const formatted = formatError(error, { includeStack: true });
-        expect(formatted).toContain('Error: top');
-        expect(formatted).toContain('Caused by:\n  Error: middle');
-        expect(formatted).toContain('\n  Caused by:\n    Error: bottom');
-    });
-    it('should handle non-error objects', () => {
-        const obj = { foo: 'bar', baz: 123 };
-        const formatted = formatError(obj);
-        expect(formatted).toContain('"foo": "bar"');
-        expect(formatted).toContain('"baz": 123');
-    });
-    it('should handle errors with empty messages', () => {
-        const error = new Error('');
-        error.name = 'CustomError';
-        const formatted = formatError(error, { includeStack: false });
-        expect(formatted).toBe('CustomError: ');
-    });
-    it('should handle null or undefined', () => {
-        // Current behavior defaults name to 'Error' for non-raw-object fallback
-        expect(formatError(null)).toBe('Error: null');
-        expect(formatError(undefined)).toBe('Error: undefined');
-    });
-});

package/http/tests/server-timing.test.d.ts

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

package/http/tests/server-timing.test.js

@@ -1,42 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { ServerTiming } from '../server-timing.js';
-describe('ServerTiming', () => {
-    test('should be empty by default', () => {
-        const timing = new ServerTiming();
-        expect(timing.hasMetrics).toBe(false);
-        expect(timing.toString()).toBe('');
-    });
-    test('should add a simple metric', () => {
-        const timing = new ServerTiming();
-        timing.add('db');
-        expect(timing.hasMetrics).toBe(true);
-        expect(timing.toString()).toBe('db');
-    });
-    test('should add a metric with duration', () => {
-        const timing = new ServerTiming();
-        timing.add('db', 53.2);
-        expect(timing.toString()).toBe('db;dur=53.2');
-    });
-    test('should add a metric with duration and description', () => {
-        const timing = new ServerTiming();
-        timing.add('db', 53.2, 'Database Query');
-        expect(timing.toString()).toBe('db;dur=53.2;desc="Database Query"');
-    });
-    test('should add multiple metrics', () => {
-        const timing = new ServerTiming();
-        timing.add('cache', undefined, 'Cache Miss');
-        timing.add('db', 53.2);
-        timing.add('total', 123.45);
-        expect(timing.toString()).toBe('cache;desc="Cache Miss", db;dur=53.2, total;dur=123.45');
-    });
-    test('should use start/stop for metrics', async () => {
-        const timing = new ServerTiming();
-        const stop = timing.start('total');
-        await new Promise((resolve) => setTimeout(resolve, 11));
-        stop();
-        const result = timing.toString();
-        expect(result).toMatch(/total;dur=\d+\.\d+/);
-        const duration = Number.parseFloat(result.split('=')[1]);
-        expect(duration).toBeGreaterThanOrEqual(10);
-    });
-});

package/injector/tests/advanced.test.d.ts

@@ -1 +0,0 @@
-import '../../polyfills.js';