@tstdl/base 0.93.95 → 0.93.97

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.95",
+  "version": "0.93.97",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -146,7 +146,7 @@
     "type-fest": "^5.4"
   },
   "peerDependencies": {
-    "@genkit-ai/google-genai": "^1.27",
+    "@genkit-ai/google-genai": "^1.28",
     "@google-cloud/storage": "^7.18",
     "@google/genai": "^1.38",
     "@toon-format/toon": "^2.1.0",
@@ -157,13 +157,13 @@
     "@zxcvbn-ts/language-en": "^3.0",
     "drizzle-orm": "^0.45",
     "file-type": "^21.3",
-    "genkit": "^1.27",
+    "genkit": "^1.28",
     "handlebars": "^4.7",
     "minio": "^8.0",
     "mjml": "^4.18",
     "nodemailer": "^7.0",
     "pg": "^8.17",
-    "playwright": "^1.57",
+    "playwright": "^1.58",
     "preact": "^10.28",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
@@ -189,7 +189,7 @@
     "concurrently": "9.2",
     "drizzle-kit": "0.31",
     "eslint": "9.39",
-    "globals": "17.0",
+    "globals": "17.1",
     "tsc-alias": "1.8",
     "typedoc-github-wiki-theme": "2.1",
     "typedoc-plugin-markdown": "4.9",