@tstdl/base 0.93.94 → 0.93.96

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

@@ -0,0 +1,452 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
+import { AiService } from '../../ai/ai.service.js';
+import { AiModuleOptions } from '../../ai/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 { setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
+import { DocumentPropertyDataType } from '../models/document-property.model.js';
+import { configureDocumentManagement } from '../server/configure.js';
+import { migrateDocumentManagementSchema } from '../server/module.js';
+import { DocumentCategoryTypeService } from '../server/services/document-category-type.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 },
+            orm: { schema },
+        }));
+        injector.register(AiModuleOptions, { useValue: {} });
+        injector.register(AiService, { useValue: { processFile: vi.fn() } });
+        injector.register(ObjectStorage, {
+            useValue: {
+                uploadObject: vi.fn(),
+                getDownloadUrl: vi.fn(),
+                getContent: vi.fn(),
+                getContentStream: vi.fn(),
+                getObject: vi.fn(),
+                exists: vi.fn(),
+            },
+        });
+        injector.register(TaskQueue, {
+            useValue: {
+                enqueue: vi.fn(),
+                enqueueMany: vi.fn(),
+                process: vi.fn(),
+            },
+        });
+        configureDocumentManagement({
+            ancillaryService: TestDocumentManagementAncillaryService,
+            authorizationService: TestDocumentManagementAuthorizationService,
+            fileObjectStorageModule: 'documents',
+            fileUploadObjectStorageModule: 'document-uploads',
+            filePreviewObjectStorageModule: 'document-previews',
+        });
+        await runInInjectionContext(injector, migrateDocumentManagementSchema);
+        documentManagementService = await injector.resolveAsync(DocumentManagementService);
+        categoryTypeService = await injector.resolveAsync(DocumentCategoryTypeService);
+        propertyService = await injector.resolveAsync(DocumentPropertyService);
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    beforeEach(async () => {
+        await truncateTables(database, schema, ['type_property', 'property', 'type', 'category']);
+        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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,39 @@
+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/{utils/format-error.js → errors/format.js}

@@ -1,8 +1,7 @@
-import { unwrapError } from '../errors/utils.js';
-import { decycle } from './object/decycle.js';
-import { objectKeys } from './object/object.js';
-import { tryChain } from './try-chain.js';
-import { isArray, isDefined, isFunction, isObject, isString, isUndefined } from './type-guards.js';
+import { decycle, objectKeys } from '../utils/object/index.js';
+import { tryChain } from '../utils/try-chain.js';
+import { isArray, isDefined, isFunction, isObject, isString, isUndefined } from '../utils/type-guards.js';
+import { unwrapError } from './utils.js';
 export function serializeError(error, options = {}) {
     const { includeName = true, includeRest = 'if-no-extra-info', includeExtraInfo = true, includeStack = true, depth = 5, } = options;
     if (depth <= 0) {
@@ -97,39 +96,46 @@ function formatSerializedError(serialized, options) {
     const { includeName = true, includeStack = true, depth = 5 } = options;
     // 1. Header (Name: Message)
     const prefix = includeName && name ? `${name}: ` : '';
-    const header = `${prefix}${message}`;
+    const messageString = String(message);
+    const header = `${prefix}${messageString}`;
+    const alignedHeader = (prefix.length > 0 && messageString.includes('\n'))
+        ? `${prefix}${messageString.replace(/\n/g, `\n${' '.repeat(prefix.length)}`)}`
+        : header;
+    let formatted = alignedHeader;
     // 2. Body (Rest / Extra Info)
-    let body = '';
-    if (rest) {
-        body += `\n${JSON.stringify(rest, null, 2)}`;
+    if (isDefined(rest)) {
+        formatted += `\n${indent(JSON.stringify(rest, null, 2), 4)}`;
     }
-    if (extraInfo) {
-        body += `\n${JSON.stringify(extraInfo, null, 2)}`;
+    if (isDefined(extraInfo)) {
+        formatted += `\n${indent(JSON.stringify(extraInfo, null, 2), 4)}`;
     }
     // 3. Stack Trace
-    let stackString = '';
-    if (includeStack && stack) {
+    if (includeStack && isDefined(stack)) {
         // Deduplicate header if stack already starts with it (standard Node.js behavior)
         if (stack.startsWith(header)) {
-            stackString = stack.slice(header.length);
+            formatted += stack.slice(header.length);
         }
         else {
-            stackString = `\n${stack}`;
+            formatted += `\n${stack}`;
         }
     }
     // 4. Recursion (Causes and Aggregate Errors)
     const nextOptions = { ...options, depth: depth - 1 };
-    const causeString = (includeStack && cause)
-        ? formatNestedError('Caused by:', cause, nextOptions)
-        : '';
-    const aggregateErrorsString = aggregateErrors
-        ? aggregateErrors
-            .map((err, i) => formatNestedError(`Sub-error #${i + 1}:`, err, nextOptions))
-            .join('')
-        : '';
-    return `${header}${body}${stackString}${causeString}${aggregateErrorsString}`;
+    if (includeStack && isDefined(cause)) {
+        formatted += formatNestedError('Caused by:', cause, nextOptions);
+    }
+    if (isArray(aggregateErrors)) {
+        for (const [index, err] of aggregateErrors.entries()) {
+            formatted += formatNestedError(`Sub-error #${index + 1}:`, err, nextOptions);
+        }
+    }
+    return formatted;
 }
 function formatNestedError(prefix, serializedError, options) {
-    const formatted = formatSerializedError(serializedError, options).replace(/\n/g, '\n  ');
-    return `\n\n${prefix}\n  ${formatted}`;
+    const formatted = formatSerializedError(serializedError, options);
+    return `\n${prefix}\n${indent(formatted, 2)}`;
+}
+function indent(text, spaces) {
+    const indentation = ' '.repeat(spaces);
+    return text.split('\n').map((line) => (line.length > 0 ? `${indentation}${line}` : line)).join('\n');
 }

package/errors/index.d.ts

@@ -10,6 +10,7 @@ export * from './custom.error.js';
 export * from './details.error.js';
 export * from './errors.localization.js';
 export * from './forbidden.error.js';
+export * from './format.js';
 export * from './invalid-credentials.error.js';
 export * from './invalid-token.error.js';
 export * from './max-bytes-exceeded.error.js';

package/errors/index.js

@@ -10,6 +10,7 @@ export * from './custom.error.js';
 export * from './details.error.js';
 export * from './errors.localization.js';
 export * from './forbidden.error.js';
+export * from './format.js';
 export * from './invalid-credentials.error.js';
 export * from './invalid-token.error.js';
 export * from './max-bytes-exceeded.error.js';

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

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