@tstdl/base 0.93.97 → 0.93.99

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

@@ -0,0 +1,495 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
+import { AiService } from '../../ai/ai.service.js';
+import { AiModuleOptions } from '../../ai/module.js';
+import { runInInjectionContext } from '../../injector/index.js';
+import { ObjectStorage } from '../../object-storage/index.js';
+import { getRepository } from '../../orm/server/index.js';
+import { clearTenantData, setupIntegrationTest } from '../../unit-test/index.js';
+import { DocumentValidationDefinition } from '../models/document-validation-definition.model.js';
+import { DocumentValidationExecution, DocumentValidationExecutionState, DocumentValidationResultStatus } from '../models/document-validation-execution.model.js';
+import { DocumentWorkflow, DocumentWorkflowState, DocumentWorkflowStep } from '../models/document-workflow.model.js';
+import { DocumentApproval } from '../models/document.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 { DocumentCollectionService } from '../server/services/document-collection.service.js';
+import { DocumentStatisticsService } from '../server/services/document-statistics.service.js';
+import { DocumentTagService } from '../server/services/document-tag.service.js';
+import { DocumentService } from '../server/services/document.service.js';
+import { TestDocumentManagementAncillaryService, TestDocumentManagementAuthorizationService } from './helper.js';
+describe('DocumentStatisticsService', () => {
+    let injector;
+    let database;
+    let documentService;
+    let statsService;
+    let collectionService;
+    let tagService;
+    let categoryTypeService;
+    const schema = 'document_management';
+    const tenantId = crypto.randomUUID();
+    beforeAll(async () => {
+        ({ injector, database } = await setupIntegrationTest({
+            modules: { taskQueue: true },
+            orm: { schema },
+        }));
+        const mockObjectStorage = {
+            uploadObject: vi.fn(),
+            getDownloadUrl: vi.fn(),
+            getContent: vi.fn(),
+            getContentStream: vi.fn(),
+            getObject: vi.fn(),
+            exists: vi.fn(),
+        };
+        const mockAiService = {
+            processFile: vi.fn(),
+        };
+        injector.register(ObjectStorage, { useFactory: () => mockObjectStorage });
+        injector.register(AiModuleOptions, { useValue: {} });
+        injector.register(AiService, { useValue: mockAiService });
+        configureDocumentManagement({
+            ancillaryService: TestDocumentManagementAncillaryService,
+            authorizationService: TestDocumentManagementAuthorizationService,
+            fileObjectStorageModule: 'documents',
+            fileUploadObjectStorageModule: 'document-uploads',
+            filePreviewObjectStorageModule: 'document-previews',
+        });
+        await runInInjectionContext(injector, migrateDocumentManagementSchema);
+        documentService = await injector.resolveAsync(DocumentService);
+        statsService = await injector.resolveAsync(DocumentStatisticsService);
+        collectionService = await injector.resolveAsync(DocumentCollectionService);
+        tagService = await injector.resolveAsync(DocumentTagService);
+        categoryTypeService = await injector.resolveAsync(DocumentCategoryTypeService);
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    beforeEach(async () => {
+        await clearTenantData(database, schema, ['validation_execution', 'validation_definition', 'tag_assignment', 'collection_assignment', 'workflow', 'document', 'collection', 'tag', 'type', 'category'], tenantId);
+    });
+    test('getStatistics should return total count', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            await documentService.create(tenantId, {
+                title: 'Doc 1',
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            await documentService.create(tenantId, {
+                title: 'Doc 2',
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1, 2]));
+            const stats = await statsService.getStatistics(tenantId, { includeTotalCount: true, collectionIds: [collection.id] });
+            expect(stats.totalCount).toBe(2);
+        });
+    });
+    test('getStatistics should return approval breakdown', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            await documentService.create(tenantId, {
+                approval: DocumentApproval.Approved,
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            await documentService.create(tenantId, {
+                approval: DocumentApproval.Pending,
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            await documentService.create(tenantId, {
+                approval: DocumentApproval.Rejected,
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const stats = await statsService.getStatistics(tenantId, { includeApprovalBreakdown: true, collectionIds: [collection.id] });
+            expect(stats.approvalBreakdown?.approved).toBe(1);
+            expect(stats.approvalBreakdown?.pending).toBe(1);
+            expect(stats.approvalBreakdown?.rejected).toBe(1);
+        });
+    });
+    test('getStatistics should filter by collection', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection1 = await collectionService.createCollection(tenantId, null);
+            const collection2 = await collectionService.createCollection(tenantId, null);
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection1.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection2.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const stats = await statsService.getStatistics(tenantId, { includeTotalCount: true, collectionIds: [collection1.id] });
+            expect(stats.totalCount).toBe(1);
+        });
+    });
+    test('getStatistics should return storage usage and total pages', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const doc = await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1, 2, 3])); // Size 3
+            // Manually set pages since our mock doesn't handle PDF page count
+            await documentService.repository.update(doc.id, { pages: 5 });
+            const stats = await statsService.getStatistics(tenantId, { includeStorageUsage: true, includeTotalPages: true, collectionIds: [collection.id] });
+            expect(stats.storageUsage).toBe(3);
+            expect(stats.totalPages).toBe(5);
+        });
+    });
+    test('getStatistics should return data quality metrics', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            // Missing nothing (except type, which is checked separately)
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+                title: 'Title',
+                date: 20230101,
+            }, new Uint8Array([1]));
+            // Missing title and date
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const stats = await statsService.getStatistics(tenantId, { includeDataQuality: true, collectionIds: [collection.id] });
+            expect(stats.dataQuality?.missingTitle).toBe(1);
+            expect(stats.dataQuality?.missingDate).toBe(1);
+            expect(stats.dataQuality?.missingType).toBe(2);
+        });
+    });
+    test('getStatistics should return created last 30 days', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const stats = await statsService.getStatistics(tenantId, { includeCreatedLast30Days: true, collectionIds: [collection.id] });
+            expect(stats.createdLast30Days).toBe(1);
+        });
+    });
+    test('getStatistics should return tag usage', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+                tags: ['Tag1'],
+            }, new Uint8Array([1]));
+            const [tag] = await tagService.loadOrCreate(tenantId, ['Tag1']);
+            const stats = await statsService.getStatistics(tenantId, { includeTagUsage: true, collectionIds: [collection.id] });
+            expect(stats.tagUsage?.[tag.id]).toBe(1);
+        });
+    });
+    test('getStatistics should return mime type distribution', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const stats = await statsService.getStatistics(tenantId, { includeMimeTypeDistribution: true, collectionIds: [collection.id] });
+            expect(Object.keys(stats.mimeTypeDistribution ?? {}).length).toBeGreaterThan(0);
+        });
+    });
+    test('getStatistics should return type breakdown and filter by category', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const categoryLabel = `Category ${crypto.randomUUID()}`;
+            const category = await categoryTypeService.createCategory({ tenantId, label: categoryLabel, parentId: null });
+            const type = await categoryTypeService.createType({ tenantId, label: 'Type 1', categoryId: category.id });
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+                typeId: type.id,
+            }, new Uint8Array([1]));
+            const stats = await statsService.getStatistics(tenantId, { includeTypeBreakdown: true, collectionIds: [collection.id], categoryIds: [category.id] });
+            expect(stats.typeBreakdown?.[type.id]).toBe(1);
+        });
+    });
+    test('getStatistics should return validation failures', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const doc = await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const workflowRepo = await injector.resolveAsync(getRepository(DocumentWorkflow));
+            const validationRepo = await injector.resolveAsync(getRepository(DocumentValidationExecution));
+            const definitionRepo = await injector.resolveAsync(getRepository(DocumentValidationDefinition));
+            const definition = await definitionRepo.insert({
+                tenantId,
+                identifier: 'test-val',
+                label: 'Test Validation',
+                description: null,
+                configuration: {},
+            });
+            const workflow = await workflowRepo.insert({
+                tenantId,
+                documentId: doc.id,
+                step: DocumentWorkflowStep.Validation,
+                state: DocumentWorkflowState.Pending,
+                skipAi: true,
+                completeTimestamp: null,
+                failReason: null,
+                completeUserId: null,
+            });
+            await validationRepo.insert({
+                tenantId,
+                workflowId: workflow.id,
+                definitionId: definition.id,
+                state: DocumentValidationExecutionState.Completed,
+                resultStatus: DocumentValidationResultStatus.Failed,
+                resultMessage: null,
+                startedAt: null,
+                completedAt: null,
+            });
+            const stats = await statsService.getStatistics(tenantId, { includeValidationFailures: true, collectionIds: [collection.id] });
+            expect(stats.validationFailures).toBe(1);
+        });
+    });
+    test('getStatistics should return nothing when no options selected', async () => {
+        await runInInjectionContext(injector, async () => {
+            const stats = await statsService.getStatistics(tenantId, { collectionIds: [] });
+            expect(Object.keys(stats).length).toBe(0);
+        });
+    });
+    test('getStatistics should support combined filters', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection1 = await collectionService.createCollection(tenantId, null);
+            const collection2 = await collectionService.createCollection(tenantId, null);
+            const category1 = await categoryTypeService.createCategory({ tenantId, label: `Cat 1 ${crypto.randomUUID()}`, parentId: null });
+            const category2 = await categoryTypeService.createCategory({ tenantId, label: `Cat 2 ${crypto.randomUUID()}`, parentId: null });
+            const type1 = await categoryTypeService.createType({ tenantId, label: 'Type 1', categoryId: category1.id });
+            const type2 = await categoryTypeService.createType({ tenantId, label: 'Type 2', categoryId: category2.id });
+            // Doc 1: Coll 1, Type 1 (Cat 1)
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection1.id] },
+                typeId: type1.id,
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            // Doc 2: Coll 1, Type 2 (Cat 2)
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection1.id] },
+                typeId: type2.id,
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            // Doc 3: Coll 2, Type 1 (Cat 1)
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection2.id] },
+                typeId: type1.id,
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const stats = await statsService.getStatistics(tenantId, {
+                includeTotalCount: true,
+                collectionIds: [collection1.id],
+                categoryIds: [category1.id]
+            });
+            expect(stats.totalCount).toBe(1); // Only Doc 1 matches both
+        });
+    });
+    test('getStatistics should return multiple stats without category filters', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const category = await categoryTypeService.createCategory({ tenantId, label: `Cat ${crypto.randomUUID()}`, parentId: null });
+            const type = await categoryTypeService.createType({ tenantId, label: 'Type', categoryId: category.id });
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                typeId: type.id,
+                skipWorkflow: true,
+                title: 'Title',
+            }, new Uint8Array([1, 2, 3]));
+            const stats = await statsService.getStatistics(tenantId, {
+                includeTotalCount: true,
+                includeTypeBreakdown: true,
+                includeMimeTypeDistribution: true,
+                includeStorageUsage: true,
+                includeDataQuality: true,
+                collectionIds: [collection.id]
+            });
+            expect(stats.totalCount).toBe(1);
+            expect(stats.typeBreakdown?.[type.id]).toBe(1);
+            expect(stats.storageUsage).toBe(3);
+            expect(stats.dataQuality?.missingTitle).toBe(0);
+        });
+    });
+    test('getStatistics should return stats with only collection filter', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const stats = await statsService.getStatistics(tenantId, {
+                includeTotalCount: true,
+                includeMimeTypeDistribution: true,
+                collectionIds: [collection.id]
+            });
+            expect(stats.totalCount).toBe(1);
+        });
+    });
+    test('getStatistics should return mime type distribution with category filter', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const category = await categoryTypeService.createCategory({ tenantId, label: `Cat ${crypto.randomUUID()}`, parentId: null });
+            const type = await categoryTypeService.createType({ tenantId, label: 'Type', categoryId: category.id });
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                typeId: type.id,
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const stats = await statsService.getStatistics(tenantId, {
+                includeMimeTypeDistribution: true,
+                collectionIds: [collection.id],
+                categoryIds: [category.id]
+            });
+            expect(Object.keys(stats.mimeTypeDistribution ?? {}).length).toBeGreaterThan(0);
+        });
+    });
+    test('getStatistics should return tag usage with filters', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const category = await categoryTypeService.createCategory({ tenantId, label: `Cat ${crypto.randomUUID()}`, parentId: null });
+            const type = await categoryTypeService.createType({ tenantId, label: 'Type', categoryId: category.id });
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                typeId: type.id,
+                skipWorkflow: true,
+                tags: ['Tag1'],
+            }, new Uint8Array([1]));
+            const [tag] = await tagService.loadOrCreate(tenantId, ['Tag1']);
+            const stats = await statsService.getStatistics(tenantId, {
+                includeTagUsage: true,
+                collectionIds: [collection.id],
+                categoryIds: [category.id]
+            });
+            expect(stats.tagUsage?.[tag.id]).toBe(1);
+        });
+    });
+    test('getStatistics should return validation failures with collection filter', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const doc = await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const workflowRepo = await injector.resolveAsync(getRepository(DocumentWorkflow));
+            const validationRepo = await injector.resolveAsync(getRepository(DocumentValidationExecution));
+            const definitionRepo = await injector.resolveAsync(getRepository(DocumentValidationDefinition));
+            const definition = await definitionRepo.insert({
+                tenantId,
+                identifier: 'test-val-2',
+                label: 'Test Validation',
+                description: null,
+                configuration: {},
+            });
+            const workflow = await workflowRepo.insert({
+                tenantId,
+                documentId: doc.id,
+                step: DocumentWorkflowStep.Validation,
+                state: DocumentWorkflowState.Pending,
+                skipAi: true,
+                completeTimestamp: null,
+                failReason: null,
+                completeUserId: null,
+            });
+            await validationRepo.insert({
+                tenantId,
+                workflowId: workflow.id,
+                definitionId: definition.id,
+                state: DocumentValidationExecutionState.Completed,
+                resultStatus: DocumentValidationResultStatus.Failed,
+                resultMessage: null,
+                startedAt: null,
+                completedAt: null,
+            });
+            const stats = await statsService.getStatistics(tenantId, {
+                includeValidationFailures: true,
+                collectionIds: [collection.id]
+            });
+            expect(stats.validationFailures).toBe(1);
+        });
+    });
+    test('getStatistics should return validation failures with category filter', async () => {
+        await runInInjectionContext(injector, async () => {
+            const categoryLabel = `Cat val ${crypto.randomUUID()}`;
+            const category = await categoryTypeService.createCategory({ tenantId, label: categoryLabel, parentId: null });
+            const type = await categoryTypeService.createType({ tenantId, label: 'Type val', categoryId: category.id });
+            const collection = await collectionService.createCollection(tenantId, null);
+            const doc = await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                typeId: type.id,
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const workflowRepo = await injector.resolveAsync(getRepository(DocumentWorkflow));
+            const validationRepo = await injector.resolveAsync(getRepository(DocumentValidationExecution));
+            const definitionRepo = await injector.resolveAsync(getRepository(DocumentValidationDefinition));
+            const definition = await definitionRepo.insert({
+                tenantId,
+                identifier: 'test-val-3',
+                label: 'Test Validation',
+                description: null,
+                configuration: {},
+            });
+            const workflow = await workflowRepo.insert({
+                tenantId,
+                documentId: doc.id,
+                step: DocumentWorkflowStep.Validation,
+                state: DocumentWorkflowState.Pending,
+                skipAi: true,
+                completeTimestamp: null,
+                failReason: null,
+                completeUserId: null,
+            });
+            await validationRepo.insert({
+                tenantId,
+                workflowId: workflow.id,
+                definitionId: definition.id,
+                state: DocumentValidationExecutionState.Completed,
+                resultStatus: DocumentValidationResultStatus.Failed,
+                resultMessage: null,
+                startedAt: null,
+                completedAt: null,
+            });
+            const stats = await statsService.getStatistics(tenantId, {
+                includeValidationFailures: true,
+                collectionIds: [collection.id],
+                categoryIds: [category.id]
+            });
+            expect(stats.validationFailures).toBe(1);
+        });
+    });
+    test('getStatistics should return type breakdown with collection filter', async () => {
+        await runInInjectionContext(injector, async () => {
+            const collection = await collectionService.createCollection(tenantId, null);
+            const category = await categoryTypeService.createCategory({ tenantId, label: `Cat ${crypto.randomUUID()}`, parentId: null });
+            const type = await categoryTypeService.createType({ tenantId, label: 'Type', categoryId: category.id });
+            await documentService.create(tenantId, {
+                assignment: { collections: [collection.id] },
+                typeId: type.id,
+                skipWorkflow: true,
+            }, new Uint8Array([1]));
+            const stats = await statsService.getStatistics(tenantId, {
+                includeTypeBreakdown: true,
+                collectionIds: [collection.id]
+            });
+            expect(stats.typeBreakdown?.[type.id]).toBe(1);
+        });
+    });
+    test('getStatistics should return zeroed stats for empty tenant', async () => {
+        await runInInjectionContext(injector, async () => {
+            const stats = await statsService.getStatistics(tenantId, {
+                includeTotalCount: true,
+                includeStorageUsage: true,
+                includeTotalPages: true,
+                includeValidationFailures: true,
+                collectionIds: []
+            });
+            expect(stats.totalCount).toBe(0);
+            expect(stats.storageUsage).toBe(0);
+            expect(stats.totalPages).toBe(0);
+            expect(stats.validationFailures).toBe(0);
+        });
+    });
+});

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

@@ -5,7 +5,7 @@ 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 { clearTenantData, setupIntegrationTest } 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';
@@ -62,7 +62,8 @@ describe('Document Management Extended Suite', () => {
         await injector?.dispose();
     });
     beforeEach(async () => {
-        await truncateTables(database, schema, ['type_property', 'property', 'type', 'category']);
+        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);

package/enumeration/enumeration.d.ts

@@ -1,5 +1,29 @@
 import type { EnumerationObject } from '../types/index.js';
+/**
+ * Utility type to extract a union of values from an {@link EnumerationObject}.
+ * @template T The type of the enumeration object.
+ */
 export type EnumType<T extends EnumerationObject> = T[keyof T];
+/**
+ * Defines a new enumeration by registering a name for an enumeration object.
+ * This name can be retrieved at runtime for introspection purposes.
+ * @template T The type of the enumeration object.
+ * @param name A unique name for the enumeration.
+ * @param enumObject The object containing the enumeration values.
+ * @returns The original `enumObject`.
+ */
 export declare function defineEnum<const T extends EnumerationObject>(name: string, enumObject: T): T;
+/**
+ * Safely attempts to retrieve the registered name of an enumeration object.
+ * @param enumeration The enumeration object to look up.
+ * @returns The registered name, or `undefined` if not found.
+ */
 export declare function tryGetEnumName(enumeration: EnumerationObject): string | undefined;
+/**
+ * Retrieves the registered name of an enumeration object.
+ * Throws an error if the enumeration is not registered.
+ * @param enumeration The enumeration object to look up.
+ * @returns The registered name.
+ * @throws Error if the enumeration is not registered.
+ */
 export declare function getEnumName(enumeration: EnumerationObject): string;

package/enumeration/enumeration.js

@@ -1,12 +1,32 @@
 import { isUndefined } from '../utils/type-guards.js';
 const registry = new WeakMap();
+/**
+ * Defines a new enumeration by registering a name for an enumeration object.
+ * This name can be retrieved at runtime for introspection purposes.
+ * @template T The type of the enumeration object.
+ * @param name A unique name for the enumeration.
+ * @param enumObject The object containing the enumeration values.
+ * @returns The original `enumObject`.
+ */
 export function defineEnum(name, enumObject) {
     registry.set(enumObject, name);
     return enumObject;
 }
+/**
+ * Safely attempts to retrieve the registered name of an enumeration object.
+ * @param enumeration The enumeration object to look up.
+ * @returns The registered name, or `undefined` if not found.
+ */
 export function tryGetEnumName(enumeration) {
     return registry.get(enumeration);
 }
+/**
+ * Retrieves the registered name of an enumeration object.
+ * Throws an error if the enumeration is not registered.
+ * @param enumeration The enumeration object to look up.
+ * @returns The registered name.
+ * @throws Error if the enumeration is not registered.
+ */
 export function getEnumName(enumeration) {
     const name = tryGetEnumName(enumeration);
     if (isUndefined(name)) {

package/examples/document-management/main.js

@@ -23,7 +23,7 @@ import { inject, injectManyAsync, runInInjectionContext } from '../../injector/i
 import { PrettyPrintLogFormatter, provideConsoleLogTransport } from '../../logger/index.js';
 import { configureLocalMessageBus } from '../../message-bus/index.js';
 import { WebServerModule } from '../../module/index.js';
-import { configureS3ObjectStorage } from '../../object-storage/index.js';
+import { configureS3ObjectStorage } from '../../object-storage/s3/index.js';
 import { configureOrm } from '../../orm/server/index.js';
 import { configureDefaultSignalsImplementation } from '../../signals/implementation/configure.js';
 import { configurePostgresTaskQueue, migratePostgresTaskQueueSchema } from '../../task-queue/postgres/index.js';

package/intl/number-parser.d.ts

@@ -1,18 +1,25 @@
 export declare class NumberParser {
-    private readonly group;
-    private readonly decimal;
-    private readonly numeral;
-    private readonly loosePattern;
-    private readonly numeralIndex;
-    private readonly numeralReplacer;
+    #private;
     readonly locale: string;
     constructor(locale: string);
     /**
-     * Parse a string
-     * @param value Value to parse
-     * @param loose Try to parse an invalid string by removing unsupported characters. Might produce incorrect results, depending on input
+     * Parse a string.
+     * @param value Value to parse.
+     * @param loose Try to parse an invalid string by removing unsupported characters. Might produce incorrect results, depending on input.
      */
     parse(value: string, loose?: boolean): number;
 }
+/**
+ * Get a memoized {@link NumberParser} instance for a given locale.
+ * @param locale The locale to get the parser for.
+ * @returns A {@link NumberParser} instance.
+ */
 export declare const getNumberParser: (locale: string) => NumberParser;
+/**
+ * Parses a localized number string into a standard JavaScript number.
+ * @param locale The locale of the number string.
+ * @param value The string to parse.
+ * @param loose Whether to use loose parsing (stripping non-numeric characters).
+ * @returns The parsed number, or `NaN` if parsing fails.
+ */
 export declare function parseNumber(locale: string, value: string, loose?: boolean): number;