@tstdl/base 0.93.139 → 0.93.141

package/document-management/README.md

@@ -0,0 +1,403 @@
+# Document Management Module
+
+The `@tstdl/base/document-management` module provides a comprehensive, AI-enhanced system for managing document lifecycles. It features hierarchical collections, automated classification and data extraction, structured validation workflows, and a robust permission system.
+
+## Table of Contents
+
+- [✨ Features](#-features)
+- [Core Concepts](#core-concepts)
+- [🚀 Basic Usage](#-basic-usage)
+  - [Server Configuration](#server-configuration)
+  - [Client API Interaction](#client-api-interaction)
+- [🔧 Advanced Topics](#-advanced-topics)
+  - [Defining Taxonomy (Categories & Types)](#defining-taxonomy-categories--types)
+  - [Implementing Authorization](#implementing-authorization)
+  - [Context Metadata (Ancillary Service)](#context-metadata-ancillary-service)
+  - [Advanced AI Configuration](#advanced-ai-configuration)
+  - [Document Requests & Templates](#document-requests--templates)
+  - [Retrieving Statistics](#retrieving-statistics)
+  - [Real-time Updates](#real-time-updates)
+- [📚 API](#-api)
+
+## ✨ Features
+
+- **Hierarchical Collections**: Organize documents into logical groups (e.g., by tenant, case, or project) with support for infinitely nested sub-collections.
+- **AI-Powered Workflow**: Asynchronous processing pipeline including:
+  - **Classification**: Automatically determines document type.
+  - **Extraction**: Extracts structured properties (dates, amounts, etc.) and tags.
+  - **Assignment**: Suggests target collections or requests based on content.
+- **Human-in-the-Loop**: Multi-stage verification process. AI results are presented in "Review" states for manual verification and correction before proceeding.
+- **Structured Taxonomy**: Define multi-level Categories, Document Types, and strongly-typed Properties (Text, Number, Date, Boolean).
+- **Document Requests**: Formalize requirements for specific documents, track fulfillment, and use templates for recurring needs (e.g., onboarding packages).
+- **Validation Framework**: Extensible validation logic integrated into the workflow. Support for automated checks and multi-document consistency.
+- **Real-time Synchronization**: Built-in SSE support for live updates of document states, requests, and collection data.
+- **Secure File Handling**: Direct-to-object-storage uploads via signed URLs and on-the-fly preview generation for various file types.
+- **Comprehensive Statistics**: Built-in reporting on document counts, approval states, type distribution, and validation failures.
+
+## Core Concepts
+
+### Collections & Assignments
+
+A **Collection** is the primary container for documents. Documents are not "stored" inside a collection physically but are **assigned** to them. A single document can be assigned to multiple collections.
+
+### Taxonomy
+
+The system relies on a structured definition of data:
+
+1.  **Categories**: High-level grouping (e.g., "Financial", "Legal"). Supports hierarchical nesting (sub-categories).
+2.  **Types**: Specific document kinds (e.g., "Invoice", "Contract") belonging to a category.
+3.  **Properties**: Typed data fields (e.g., "Invoice Amount", "Due Date") attached to specific Document Types.
+
+### The Workflow & Immutability
+
+Every uploaded document goes through a state machine managed by the `DocumentWorkflowService`:
+
+1.  **Classification**: AI determines the `DocumentType`.
+2.  **Extraction**: AI populates `DocumentProperties` and tags.
+3.  **Assignment**: AI suggests collections or requests if not explicitly provided during upload.
+4.  **Validation**: Runs automated checks (e.g., "Is this a valid ID card?").
+
+Between steps, the document may enter a **Review** state (e.g., `Waiting for Review (Analysis)`), requiring a user to confirm or correct the data via the API (`proceedDocumentWorkflow`).
+
+**Immutability**: Once a document is moved to the **Approved** state, it becomes read-only. This ensures data integrity for processed documents. Any errors discovered after approval require the document to be archived and a new version uploaded.
+
+### Assignments & Archiving
+
+Documents are linked to collections via **Assignments**. A document can be assigned to many collections simultaneously. If a document is no longer needed in a specific context, you can **archive** the assignment. This hides the document from that collection's views without deleting the document entity or affecting its assignments in other collections.
+
+## 🚀 Basic Usage
+
+### Server Configuration
+
+To use the module, you must configure it during your application bootstrap. This involves registering the module and providing implementations for authorization and metadata resolution.
+
+```typescript
+import { configureDocumentManagement } from '@tstdl/base/document-management/server';
+import { AppAncillaryService } from './services/app-ancillary.service.js';
+import { AppAuthorizationService } from './services/app-authorization.service.js';
+
+// In your application bootstrap function
+export async function bootstrap() {
+  configureDocumentManagement({
+    // Service to resolve collection names/groups from your app's data
+    ancillaryService: AppAncillaryService,
+
+    // Service to handle permissions
+    authorizationService: AppAuthorizationService,
+
+    // Object Storage module names (must be configured via configureObjectStorage)
+    fileObjectStorageModule: 'documents',
+    fileUploadObjectStorageModule: 'document-uploads',
+    filePreviewObjectStorageModule: 'document-previews',
+
+    // Optional database config override
+    // database: { ... }
+  });
+}
+```
+
+### Client API Interaction
+
+The `DocumentManagementApi` provides a type-safe client for all operations.
+
+#### 1. Uploading a Document
+
+Uploading is a two-step process: get a signed URL, upload the binary, then create the entity.
+
+```typescript
+import { inject } from '@tstdl/base/injector';
+import { DocumentManagementApi } from '@tstdl/base/document-management';
+
+async function uploadInvoice(file: File, collectionId: string) {
+  const api = inject(DocumentManagementApi);
+
+  // 1. Initiate upload to get a secure URL
+  const { uploadId, uploadUrl } = await api.initiateDocumentUpload({
+    contentLength: file.size,
+  });
+
+  // 2. Upload the file content directly to storage
+  await fetch(uploadUrl, { method: 'PUT', body: file });
+
+  // 3. Create the document entity
+  const document = await api.createDocument({
+    uploadId,
+    originalFileName: file.name,
+    assignment: {
+      collections: [collectionId], // Assign to a specific collection
+    },
+    // Optional: Provide initial metadata if known
+    // title: 'My Invoice',
+    // typeId: 'invoice-type-id'
+  });
+
+  console.log('Document created:', document.id);
+}
+```
+
+#### 2. Loading Data
+
+Fetch all documents, requests, and metadata for a set of collections.
+
+```typescript
+import { inject } from '@tstdl/base/injector';
+import { DocumentManagementApi, toEnrichedDocumentManagementData } from '@tstdl/base/document-management';
+
+async function loadDashboard(collectionId: string) {
+  const api = inject(DocumentManagementApi);
+
+  // Load raw data
+  const rawData = await api.loadData({ collectionIds: [collectionId] });
+
+  // Convert to enriched view model for easier consumption (resolves references)
+  const data = toEnrichedDocumentManagementData(rawData);
+
+  for (const doc of data.documents) {
+    console.log(`Document: ${doc.title} (${doc.type?.label})`);
+    console.log(`Status: ${doc.approval}`);
+
+    // Access typed properties easily
+    const amount = doc.properties.find((p) => p.label === 'Amount')?.value;
+  }
+}
+```
+
+## 🔧 Advanced Topics
+
+### Defining Taxonomy (Categories & Types)
+
+You should seed your database with a defined taxonomy. This is typically done in a startup script or migration utility using `DocumentManagementService`.
+
+```typescript
+import { DocumentManagementService } from '@tstdl/base/document-management/server';
+import { DocumentPropertyDataType } from '@tstdl/base/document-management';
+import { defineEnum } from '@tstdl/base/enumeration';
+import { inject } from '@tstdl/base/injector';
+
+// Define Enums for type safety
+const MyCategory = defineEnum('MyCategory', { Finance: 'finance' });
+const MyType = defineEnum('MyType', { Invoice: 'invoice' });
+const MyProp = defineEnum('MyProp', { Amount: 'amount', DueDate: 'due-date' });
+
+async function seedTaxonomy(tenantId: string) {
+  const service = inject(DocumentManagementService);
+
+  await service.initializeCategoriesAndTypes(tenantId, {
+    categoryLabels: { [MyCategory.Finance]: 'Financial Documents' },
+    categoryParents: { [MyCategory.Finance]: null },
+
+    typeLabels: { [MyType.Invoice]: 'Incoming Invoice' },
+    typeCategories: { [MyType.Invoice]: MyCategory.Finance },
+
+    propertyConfigurations: {
+      [MyProp.Amount]: [DocumentPropertyDataType.Decimal, 'Total Amount'],
+      [MyProp.DueDate]: [DocumentPropertyDataType.Date, 'Payment Due Date'],
+    },
+
+    typeProperties: {
+      [MyType.Invoice]: [MyProp.Amount, MyProp.DueDate],
+    },
+  });
+}
+```
+
+### Implementing Authorization
+
+You must implement `DocumentManagementAuthorizationService` to control access. This service is called by the API layer.
+
+```typescript
+import { DocumentManagementAuthorizationService } from '@tstdl/base/document-management';
+import { Singleton } from '@tstdl/base/injector';
+
+// Assuming your app uses a specific token type
+type MyToken = { payload: { userId: string; tenantId: string; roles: string[] } };
+
+@Singleton()
+export class AppAuthorizationService extends DocumentManagementAuthorizationService<MyToken> {
+  getTenantId(token?: MyToken): string {
+    return token?.payload.tenantId ?? '';
+  }
+
+  getSubject(token?: MyToken): string {
+    return token?.payload.userId ?? '';
+  }
+
+  async canReadCollection(collectionId: string, token?: MyToken): Promise<boolean> {
+    // Implement your logic: check if user has access to this collection
+    return true;
+  }
+
+  async canApproveDocument(documentId: string, token?: MyToken): Promise<boolean> {
+    return token?.payload.roles.includes('manager') ?? false;
+  }
+
+  // ... implement other abstract methods (canCreateDocuments, canAssignDocuments, etc.)
+}
+```
+
+### Context Metadata (Ancillary Service)
+
+The `DocumentManagementAncillaryService` allows you to inject application-specific data (like names) into the document management views, as the module itself only knows about Collection IDs.
+
+```typescript
+import { DocumentManagementAncillaryService } from '@tstdl/base/document-management/server';
+import { DocumentCollection, DocumentCollectionMetadata } from '@tstdl/base/document-management';
+import { Singleton, inject } from '@tstdl/base/injector';
+import { UserRepository } from './user.repository.js';
+
+@Singleton()
+export class AppAncillaryService extends DocumentManagementAncillaryService {
+  readonly #userRepo = inject(UserRepository);
+
+  async resolveMetadata(collections: DocumentCollection[]): Promise<DocumentCollectionMetadata[]> {
+    // Example: If collection.id corresponds to a User ID
+    const userIds = collections.map((c) => c.id);
+    const users = await this.#userRepo.loadMany(userIds);
+
+    return collections.map((collection) => {
+      const user = users.find((u) => u.id == collection.id);
+      return {
+        name: user ? `${user.firstName} ${user.lastName}` : 'Unknown Collection',
+        group: 'User Files',
+      };
+    });
+  }
+}
+```
+
+### Advanced AI Configuration
+
+The module allows for fine-grained control over AI behavior during classification and data extraction. Configuration follows a strict hierarchy:
+
+1.  **Document Type**: Config linked to a specific `DocumentType` key.
+2.  **Document Category**: Config linked to a specific `DocumentCategory` key.
+3.  **Step-Specific Global**: Global config for a `DocumentWorkflowStep`.
+4.  **Global Defaults**: Fallback module configuration.
+
+#### Structured Overrides
+
+For each core field (`title`, `subtitle`, `date`, `summary`, `tags`) and dynamic properties, you can provide granular instructions using the `InstructionOverride` type:
+
+-   **Simple Way**: Provide a `format` string (e.g., `INV-{{Date}}`).
+-   **Advanced Way**: Provide custom `content` and a `strategy` (`append` or `replace`).
+
+```typescript
+// Example configuration in your AI Provider
+override getGlobalConfiguration() {
+  return {
+    documentTypes: {
+      'invoice': {
+        extraction: {
+          title: { format: 'Invoice - {{Vendor}} - {{Date}}' },
+          summary: { content: 'Focus on individual line items.', strategy: 'append' }
+        }
+      }
+    },
+    defaults: {
+      classification: { content: 'Always prefer finance categories if an IBAN is found.', strategy: 'append' }
+    }
+  };
+}
+```
+
+### Document Requests & Templates
+
+Create requests to ask users for specific documents.
+
+```typescript
+import { inject } from '@tstdl/base/injector';
+import { DocumentManagementApi } from '@tstdl/base/document-management';
+
+async function requestDocument() {
+  const api = inject(DocumentManagementApi);
+
+  // Create a single request
+  await api.createDocumentRequest({
+    collectionIds: ['target-collection-id'],
+    typeId: 'invoice-type-id',
+    comment: 'Please upload the invoice for March.',
+  });
+
+  // Or apply a pre-defined template
+  await api.applyDocumentRequestsTemplate({
+    id: 'onboarding-template-id',
+    collectionIds: ['new-employee-collection-id'],
+  });
+}
+```
+
+### Retrieving Statistics
+
+The module provides a flexible API to retrieve statistical insights about documents, such as counts, storage usage, and data quality metrics.
+
+```typescript
+import { inject } from '@tstdl/base/injector';
+import { DocumentManagementApi } from '@tstdl/base/document-management';
+
+async function getStats(collectionId: string) {
+  const api = inject(DocumentManagementApi);
+
+  const stats = await api.getStatistics({
+    includeTotalCount: true,
+    includeApprovalBreakdown: true,
+    includeStorageUsage: true,
+    includeDataQuality: true,
+    collectionIds: [collectionId], // Optional: Filter by specific collections
+  });
+
+  console.log(`Total Documents: ${stats.totalCount}`);
+  console.log(`Storage Used: ${stats.storageUsage} bytes`);
+  console.log(`Approved: ${stats.approvalBreakdown?.approved}`);
+  console.log(`Documents missing type: ${stats.dataQuality?.missingType}`);
+}
+```
+
+### Real-time Updates
+
+The module supports Server-Sent Events (SSE) to push updates to the client when documents or collections change.
+
+```typescript
+import { inject } from '@tstdl/base/injector';
+import { DocumentManagementApi } from '@tstdl/base/document-management';
+
+async function watchCollection(collectionId: string) {
+  const api = inject(DocumentManagementApi);
+
+  // Returns an AsyncIterable that yields new data whenever changes occur
+  const stream = api.loadDataStream({ collectionIds: [collectionId] });
+
+  for await (const data of stream) {
+    console.log('Data updated:', data);
+    // Update UI...
+  }
+}
+```
+
+## 📚 API
+
+### Client / Shared
+
+| Export                                   | Description                                                                     |
+| :--------------------------------------- | :------------------------------------------------------------------------------ |
+| `DocumentManagementApi`                  | Main client class for API interaction.                                          |
+| `DocumentManagementData`                 | DTO containing all loaded data (collections, documents, types, etc.).           |
+| `toEnrichedDocumentManagementData`       | Helper to convert raw DTO into an object graph with resolved references.        |
+| `DocumentView`                           | Represents a document with its properties, tags, and workflow status.           |
+| `DocumentRequestView`                    | Represents a request for a document.                                            |
+| `DocumentPropertyDataType`               | Enum defining supported property types (Text, Integer, Decimal, Boolean, Date). |
+| `DocumentManagementAuthorizationService` | Abstract base class for authorization logic.                                    |
+
+### Server
+
+| Export                               | Description                                                    |
+| :----------------------------------- | :------------------------------------------------------------- |
+| `configureDocumentManagement`        | Function to configure the module in the application bootstrap. |
+| `DocumentManagementService`          | Core service for managing data and initializing taxonomy.      |
+| `DocumentService`                    | Service for creating and updating documents.                   |
+| `DocumentFileService`                | Service for handling file uploads, storage, and previews.      |
+| `DocumentRequestService`             | Service for managing document requests and templates.          |
+| `DocumentStatisticsService`          | Service for retrieving document statistics.                   |
+| `DocumentWorkflowService`            | Service for managing the document processing workflow.         |
+| `DocumentManagementAncillaryService` | Abstract base class for resolving collection metadata.         |
+| `DocumentValidationExecutor`         | Abstract base class for implementing custom validation logic.  |
+| `AiValidationExecutor`               | Base class for AI-driven validation executors.                 |

package/document-management/server/configure.js

@@ -1,7 +1,8 @@
 import { Injector } from '../../injector/injector.js';
+import { registerDatabaseMigration } from '../../orm/server/index.js';
 import { isDefined } from '../../utils/type-guards.js';
 import { DocumentManagementAuthorizationService } from '../authorization/document-management-authorization.service.js';
-import { DocumentManagementConfiguration } from './module.js';
+import { DocumentManagementConfiguration, migrateDocumentManagementSchema } from './module.js';
 import { DocumentManagementAiProviderService, DocumentManagementAncillaryService } from './services/index.js';
 export function configureDocumentManagement(configuration) {
     const targetInjector = configuration.injector ?? Injector;
@@ -11,4 +12,7 @@ export function configureDocumentManagement(configuration) {
     if (isDefined(configuration.aiProvider)) {
         targetInjector.register(DocumentManagementAiProviderService, { useToken: configuration.aiProvider });
     }
+    if (configuration.autoMigrate != false) {
+        registerDatabaseMigration('DocumentManagement', migrateDocumentManagementSchema, { injector: configuration.injector });
+    }
 }

package/document-management/server/module.d.ts

@@ -1,4 +1,3 @@
-import './schemas.js';
 import { type InjectionToken } from '../../injector/index.js';
 import { type DatabaseConfig } from '../../orm/server/index.js';
 import type { DocumentManagementAuthorizationService } from '../authorization/document-management-authorization.service.js';
@@ -14,5 +13,6 @@ export declare class DocumentManagementConfiguration {
     database?: DatabaseConfig;
     maxFileSize?: number;
     skipAi?: boolean;
+    autoMigrate?: boolean;
 }
 export declare function migrateDocumentManagementSchema(): Promise<void>;

package/document-management/server/module.js

@@ -1,4 +1,3 @@
-import './schemas.js';
 import { inject } from '../../injector/index.js';
 import { Database, migrate } from '../../orm/server/index.js';
 export class DocumentManagementConfiguration {
@@ -11,6 +10,7 @@ export class DocumentManagementConfiguration {
     database;
     maxFileSize;
     skipAi;
+    autoMigrate;
 }
 ;
 export async function migrateDocumentManagementSchema() {

package/document-management/server/services/document-management-ancillary.service.js

@@ -6,6 +6,6 @@ export class DocumentManagementAncillaryService {
      * @returns The resolved file name for the document, without the file extension.
      */
     getDocumentFilename(document) {
-        return document.title ?? document.originalFileName ?? document.id;
+        return document.title ?? document.originalFileName?.slice(0, document.originalFileName.lastIndexOf('.')) ?? document.id;
     }
 }

package/document-management/server/services/document-management.service.js

@@ -8,18 +8,17 @@ var _a;
 var DocumentManagementService_1;
 import { and, eq } from 'drizzle-orm';
 import { union } from 'drizzle-orm/pg-core';
+import { filter, firstValueFrom, race, share, takeUntil } from 'rxjs';
 import { Enumerable } from '../../../enumerable/index.js';
 import { BadRequestError } from '../../../errors/bad-request.error.js';
 import { inject } from '../../../injector/index.js';
 import { Logger } from '../../../logger/logger.js';
 import { Transactional, injectRepository, injectTransactional } from '../../../orm/server/index.js';
-import { DeferredPromise } from '../../../promise/deferred-promise.js';
 import { distinct } from '../../../utils/array/index.js';
 import { compareByValueSelection } from '../../../utils/comparison.js';
 import { groupToMap, groupToSingleMap } from '../../../utils/iterable-helpers/index.js';
 import { fromEntries, objectEntries } from '../../../utils/object/index.js';
 import { assertDefinedPass, isDefined, isNotNull, isNull, isUndefined } from '../../../utils/type-guards.js';
-import { filter, merge } from 'rxjs';
 import { DocumentAssignmentScope, DocumentAssignmentTask, DocumentCategory, DocumentCollectionAssignment, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentTypeProperty, DocumentValidationExecution, DocumentWorkflowStep } from '../../models/index.js';
 import { documentAssignmentScope, documentAssignmentTask, documentCollectionAssignment, documentRequest, documentRequestCollectionAssignment } from '../schemas.js';
 import { DocumentCategoryTypeService } from './document-category-type.service.js';
@@ -72,14 +71,17 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
         return result.map((row) => row.collectionId);
     }
     async *loadDataStream(tenantId, collectionIds, cancellationSignal) {
-        const continuePromise = new DeferredPromise();
-        const newData$ = this.#observationService.collectionsChangedMessageBus.allMessages$.pipe(filter((changedCollectionIds) => collectionIds.some((id) => changedCollectionIds.includes(id))));
-        const subscription = merge(newData$, cancellationSignal).subscribe(() => continuePromise.resolveIfPending());
+        const collectionIdsSet = new Set(collectionIds);
+        let hasNewData = false;
+        const newData$ = this.#observationService.collectionsChangedMessageBus.allMessages$.pipe(filter((changedCollectionIds) => changedCollectionIds.some((id) => collectionIdsSet.has(id))), takeUntil(cancellationSignal), share());
+        const subscription = newData$.subscribe(() => hasNewData = true);
         try {
             while (cancellationSignal.isUnset) {
+                hasNewData = false;
                 yield await this.loadData(tenantId, collectionIds);
-                await continuePromise;
-                continuePromise.reset();
+                if (!hasNewData && cancellationSignal.isUnset) {
+                    await firstValueFrom(race(cancellationSignal, newData$));
+                }
             }
         }
         finally {

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

@@ -8,7 +8,6 @@ import { TestDocumentManagementAncillaryService } from './helper.js';
 describe('DocumentManagementAiService Hierarchy', () => {
     let injector;
     let aiService;
-    let flashModel;
     const tenantId = crypto.randomUUID();
     const mockAiProvider = {
         getGlobalConfiguration: vi.fn(),
@@ -20,12 +19,8 @@ describe('DocumentManagementAiService Hierarchy', () => {
     };
     beforeAll(async () => {
         ({ injector } = await setupIntegrationTest({
-            orm: { schema: 'document_management' },
             modules: { messageBus: true, signals: true, objectStorage: true, documentManagement: true },
         }));
-        runInInjectionContext(injector, () => {
-            flashModel = injectModel('gemini-2.5-flash');
-        });
         injector.register(DocumentManagementAiProviderService, { useValue: mockAiProvider });
         // Ancillary and configuration are already registered by setupIntegrationTest, but we can override if needed
         injector.register(DocumentManagementAncillaryService, { useToken: TestDocumentManagementAncillaryService });

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

@@ -22,7 +22,6 @@ describe('DocumentManagementAiService Overrides', () => {
     };
     beforeAll(async () => {
         ({ injector } = await setupIntegrationTest({
-            orm: { schema: 'document_management' },
             modules: { messageBus: true, signals: true, objectStorage: true },
         }));
         runInInjectionContext(injector, () => {

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

@@ -5,7 +5,6 @@ import { ObjectStorage } from '../../object-storage/index.js';
 import { TaskQueue } from '../../task-queue/index.js';
 import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
 import { configureDocumentManagement } from '../server/configure.js';
-import { 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 { DocumentManagementAiService } from '../server/services/document-management-ai.service.js';
@@ -23,13 +22,11 @@ describe('Document Management Core', () => {
     let requestService;
     let managementService;
     let categoryTypeService;
-    let workflowService;
-    let propertyService;
     const schema = 'document_management';
     const tenantId = crypto.randomUUID();
     beforeAll(async () => {
         ({ injector, database } = await setupIntegrationTest({
-            modules: { taskQueue: false, messageBus: true }, // Disabled TaskQueue to avoid background noise
+            modules: { taskQueue: false, messageBus: true, documentManagement: true }, // Disabled TaskQueue to avoid background noise
             orm: { schema },
         }));
         injector.register(GenkitModuleOptions, { useValue: {} });
@@ -58,15 +55,13 @@ describe('Document Management Core', () => {
             fileObjectStorageModule: 'documents',
             fileUploadObjectStorageModule: 'document-uploads',
             filePreviewObjectStorageModule: 'document-previews',
+            injector,
         });
-        await runInInjectionContext(injector, migrateDocumentManagementSchema);
         documentService = await injector.resolveAsync(DocumentService);
         collectionService = await injector.resolveAsync(DocumentCollectionService);
         requestService = await injector.resolveAsync(DocumentRequestService);
         managementService = await injector.resolveAsync(DocumentManagementService);
-        workflowService = await injector.resolveAsync(DocumentWorkflowService);
         categoryTypeService = await injector.resolveAsync(DocumentCategoryTypeService);
-        propertyService = await injector.resolveAsync(DocumentPropertyService);
     });
     afterAll(async () => {
         await injector?.dispose();

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

@@ -7,7 +7,6 @@ import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
 import { DocumentManagementAuthorizationService } from '../authorization/document-management-authorization.service.js';
 import { DocumentManagementApiController } from '../server/api/document-management.api.js';
 import { configureDocumentManagement } from '../server/configure.js';
-import { migrateDocumentManagementSchema } from '../server/module.js';
 import { DocumentCollectionService } from '../server/services/document-collection.service.js';
 import { DocumentManagementAiService } from '../server/services/document-management-ai.service.js';
 import { DocumentService } from '../server/services/document.service.js';
@@ -22,7 +21,7 @@ describe('DocumentManagementApi Stats', () => {
     const tenantId = crypto.randomUUID();
     beforeAll(async () => {
         ({ injector, database } = await setupIntegrationTest({
-            modules: { taskQueue: false, messageBus: true },
+            modules: { taskQueue: false, messageBus: true, documentManagement: true },
             orm: { schema },
         }));
         injector.register(GenkitModuleOptions, { useValue: {} });
@@ -50,8 +49,8 @@ describe('DocumentManagementApi Stats', () => {
             fileObjectStorageModule: 'documents',
             fileUploadObjectStorageModule: 'document-uploads',
             filePreviewObjectStorageModule: 'document-previews',
+            injector,
         });
-        await runInInjectionContext(injector, migrateDocumentManagementSchema);
         controller = await injector.resolveAsync(DocumentManagementApiController);
         documentService = await injector.resolveAsync(DocumentService);
         collectionService = await injector.resolveAsync(DocumentCollectionService);
@@ -76,8 +75,8 @@ describe('DocumentManagementApi Stats', () => {
                 parameters: {
                     includeTotalCount: true,
                     includeStorageUsage: true,
-                    collectionIds: [collection.id]
-                }
+                    collectionIds: [collection.id],
+                },
             };
             const stats = await controller.getStatistics(mockContext);
             expect(stats.totalCount).toBe(1);
@@ -93,8 +92,8 @@ describe('DocumentManagementApi Stats', () => {
                 getToken: async () => ({ payload: { tenantId } }),
                 parameters: {
                     includeTotalCount: true,
-                    collectionIds: ['some-collection-id']
-                }
+                    collectionIds: ['some-collection-id'],
+                },
             };
             await expect(controller.getStatistics(mockContext)).rejects.toThrow('You are not allowed to read collection some-collection-id');
         });