@tstdl/base 0.92.142 → 0.92.143

package/document-management/server/drizzle/meta/_journal.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1748245798363,
-      "tag": "0000_moaning_luckman",
+      "when": 1750098709757,
+      "tag": "0000_parallel_mantis",
       "breakpoints": true
     }
   ]

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

@@ -1,9 +1,9 @@
 import './schemas.js';
 import { type InjectionToken } from '../../injector/index.js';
 import type { DatabaseConfig } from '../../orm/server/module.js';
+import type { DocumentManagementAuthorizationService } from '../authorization/document-management-authorization.service.js';
 import type { DocumentManagementAncillaryService } from './services/document-management-ancillary.service.js';
-import type { DocumentManagementAuthorizationService } from './services/document-management-authorization.service.js';
-export declare class DocumentManagementConfig {
+export declare class DocumentManagementConfiguration {
     ancillaryService: InjectionToken<DocumentManagementAncillaryService>;
     authorizationService: InjectionToken<DocumentManagementAuthorizationService>;
     fileObjectStorageModule: string;

package/document-management/server/module.js

@@ -1,7 +1,7 @@
 import './schemas.js';
 import { inject } from '../../injector/index.js';
 import { Database, migrate } from '../../orm/server/database.js';
-export class DocumentManagementConfig {
+export class DocumentManagementConfiguration {
     ancillaryService;
     authorizationService;
     fileObjectStorageModule;
@@ -12,7 +12,7 @@ export class DocumentManagementConfig {
 }
 ;
 export async function migrateDocumentManagementSchema() {
-    const connection = inject(DocumentManagementConfig, undefined, { optional: true })?.database?.connection;
+    const connection = inject(DocumentManagementConfiguration, undefined, { optional: true })?.database?.connection;
     const database = inject(Database, connection);
     await migrate(database, {
         migrationsSchema: 'document_management',

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

@@ -1,13 +1,13 @@
-import { Document, DocumentAssignmentScope, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentProperty, DocumentPropertyValue, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestsTemplate, DocumentRequestSubmission, DocumentRequestTemplate, DocumentType, DocumentTypeProperty, DocumentTypeValidation, DocumentValidationDefinition, DocumentValidationExecution, DocumentValidationExecutionRelatedDocument, DocumentWorkflow } from '../models/index.js';
+import { Document, DocumentAssignmentScope, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentProperty, DocumentPropertyValue, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestsTemplate, DocumentRequestTemplate, DocumentTag, DocumentTagAssignment, DocumentType, DocumentTypeProperty, DocumentTypeValidation, DocumentValidationDefinition, DocumentValidationExecution, DocumentValidationExecutionRelatedDocument, DocumentWorkflow } from '../models/index.js';
 export declare const documentManagementSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"document_management">;
-export declare const aocumentApproval: import("drizzle-orm/pg-core").PgEnum<["pending", "approved", "rejected"]>;
-export declare const documentAssignmentCollectionTarget: import("drizzle-orm/pg-core").PgEnum<["request", "collection"]>;
+export declare const documentApproval: import("drizzle-orm/pg-core").PgEnum<["pending", "approved", "rejected"]>;
+export declare const documentAssignmentTarget: import("drizzle-orm/pg-core").PgEnum<["request", "collection"]>;
 export declare const documentPropertyDataType: import("drizzle-orm/pg-core").PgEnum<["boolean", "date", "decimal", "text", "integer"]>;
 export declare const documentRequestState: import("drizzle-orm/pg-core").PgEnum<["open", "closed", "fulfilled"]>;
 export declare const documentValidationExecutionState: import("drizzle-orm/pg-core").PgEnum<["pending", "error", "running", "completed"]>;
 export declare const documentValidationResultStatus: import("drizzle-orm/pg-core").PgEnum<["warning", "failed", "passed"]>;
 export declare const documentWorkflowFailReason: import("drizzle-orm/pg-core").PgEnum<["no-suitable-collection", "no-suitable-request"]>;
-export declare const documentWorkflowState: import("drizzle-orm/pg-core").PgEnum<["pending", "error", "running", "completed", "failed"]>;
+export declare const documentWorkflowState: import("drizzle-orm/pg-core").PgEnum<["pending", "error", "running", "completed", "failed", "review"]>;
 export declare const documentWorkflowStep: import("drizzle-orm/pg-core").PgEnum<["classification", "extraction", "assignment", "validation"]>;
 export declare const document: import("../../orm/server/types.js").PgTableFromType<typeof Document, "document_management">;
 export declare const documentAssignmentScope: import("../../orm/server/types.js").PgTableFromType<typeof DocumentAssignmentScope, "document_management">;
@@ -20,8 +20,9 @@ export declare const documentPropertyValue: import("../../orm/server/types.js").
 export declare const documentRequest: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequest, "document_management">;
 export declare const documentRequestCollectionAssignment: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestCollectionAssignment, "document_management">;
 export declare const documentRequestsTemplate: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestsTemplate, "document_management">;
-export declare const documentRequestSubmission: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestSubmission, "document_management">;
 export declare const documentRequestTemplate: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestTemplate, "document_management">;
+export declare const documentTag: import("../../orm/server/types.js").PgTableFromType<typeof DocumentTag, "document_management">;
+export declare const documentTagAssignment: import("../../orm/server/types.js").PgTableFromType<typeof DocumentTagAssignment, "document_management">;
 export declare const documentType: import("../../orm/server/types.js").PgTableFromType<typeof DocumentType, "document_management">;
 export declare const documentTypeProperty: import("../../orm/server/types.js").PgTableFromType<typeof DocumentTypeProperty, "document_management">;
 export declare const documentTypeValidation: import("../../orm/server/types.js").PgTableFromType<typeof DocumentTypeValidation, "document_management">;

package/document-management/server/schemas.js

@@ -1,15 +1,15 @@
 import { databaseSchema } from '../../orm/server/database-schema.js';
-import { Document, DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTarget, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestState, DocumentRequestsTemplate, DocumentRequestSubmission, DocumentRequestTemplate, DocumentType, DocumentTypeProperty, DocumentTypeValidation, DocumentValidationDefinition, DocumentValidationExecution, DocumentValidationExecutionRelatedDocument, DocumentValidationExecutionState, DocumentValidationResultStatus, DocumentWorkflow, DocumentWorkflowFailReason, DocumentWorkflowState, DocumentWorkflowStep } from '../models/index.js';
+import { Document, DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTarget, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestState, DocumentRequestsTemplate, DocumentRequestTemplate, DocumentTag, DocumentTagAssignment, DocumentType, DocumentTypeProperty, DocumentTypeValidation, DocumentValidationDefinition, DocumentValidationExecution, DocumentValidationExecutionRelatedDocument, DocumentValidationExecutionState, DocumentValidationResultStatus, DocumentWorkflow, DocumentWorkflowFailReason, DocumentWorkflowState, DocumentWorkflowStep } from '../models/index.js';
 export const documentManagementSchema = databaseSchema('document_management');
-export const aocumentApproval = documentManagementSchema.getEnum(DocumentApproval);
-export const documentAssignmentCollectionTarget = documentManagementSchema.getEnum(DocumentAssignmentTarget);
-export const documentPropertyDataType = documentManagementSchema.getEnum(DocumentPropertyDataType);
-export const documentRequestState = documentManagementSchema.getEnum(DocumentRequestState);
-export const documentValidationExecutionState = documentManagementSchema.getEnum(DocumentValidationExecutionState);
-export const documentValidationResultStatus = documentManagementSchema.getEnum(DocumentValidationResultStatus);
-export const documentWorkflowFailReason = documentManagementSchema.getEnum(DocumentWorkflowFailReason);
-export const documentWorkflowState = documentManagementSchema.getEnum(DocumentWorkflowState);
-export const documentWorkflowStep = documentManagementSchema.getEnum(DocumentWorkflowStep);
+export const documentApproval = documentManagementSchema.getEnum(DocumentApproval);
+export const documentAssignmentTarget = documentManagementSchema.getEnum(DocumentAssignmentTarget, 'assignment_target');
+export const documentPropertyDataType = documentManagementSchema.getEnum(DocumentPropertyDataType, 'property_data_type');
+export const documentRequestState = documentManagementSchema.getEnum(DocumentRequestState, 'request_state');
+export const documentValidationExecutionState = documentManagementSchema.getEnum(DocumentValidationExecutionState, 'validation_execution_state');
+export const documentValidationResultStatus = documentManagementSchema.getEnum(DocumentValidationResultStatus, 'validation_result_status');
+export const documentWorkflowFailReason = documentManagementSchema.getEnum(DocumentWorkflowFailReason, 'workflow_fail_reason');
+export const documentWorkflowState = documentManagementSchema.getEnum(DocumentWorkflowState, 'workflow_state');
+export const documentWorkflowStep = documentManagementSchema.getEnum(DocumentWorkflowStep, 'workflow_step');
 export const document = documentManagementSchema.getTable(Document);
 export const documentAssignmentScope = documentManagementSchema.getTable(DocumentAssignmentScope);
 export const documentAssignmentTask = documentManagementSchema.getTable(DocumentAssignmentTask);
@@ -21,8 +21,9 @@ export const documentPropertyValue = documentManagementSchema.getTable(DocumentP
 export const documentRequest = documentManagementSchema.getTable(DocumentRequest);
 export const documentRequestCollectionAssignment = documentManagementSchema.getTable(DocumentRequestCollectionAssignment);
 export const documentRequestsTemplate = documentManagementSchema.getTable(DocumentRequestsTemplate);
-export const documentRequestSubmission = documentManagementSchema.getTable(DocumentRequestSubmission);
 export const documentRequestTemplate = documentManagementSchema.getTable(DocumentRequestTemplate);
+export const documentTag = documentManagementSchema.getTable(DocumentTag);
+export const documentTagAssignment = documentManagementSchema.getTable(DocumentTagAssignment);
 export const documentType = documentManagementSchema.getTable(DocumentType);
 export const documentTypeProperty = documentManagementSchema.getTable(DocumentTypeProperty);
 export const documentTypeValidation = documentManagementSchema.getTable(DocumentTypeValidation);

package/document-management/server/services/document-category-type.service.d.ts

@@ -2,25 +2,34 @@ import { Transactional } from '../../../orm/server/index.js';
 import { DocumentCategory, DocumentType } from '../../models/index.js';
 import type { DocumentCategoryView } from '../../service-models/index.js';
 export declare class DocumentCategoryTypeService extends Transactional {
-    #private;
     readonly categoryRepository: import("../../../orm/server/repository.js").EntityRepository<DocumentCategory>;
     readonly typeRepository: import("../../../orm/server/repository.js").EntityRepository<DocumentType>;
-    loadCategory(id: string): Promise<DocumentCategory>;
-    loadType(id: string): Promise<DocumentType>;
-    createCategory(label: string, parentId: string | null, enumKey?: string): Promise<DocumentCategory>;
-    createType(label: string, categoryId: string, enumKey?: string): Promise<DocumentType>;
-    updateCategory(id: string, update: {
+    loadCategory(tenantId: string, id: string): Promise<DocumentCategory>;
+    loadType(tenantId: string, id: string): Promise<DocumentType>;
+    createCategory(data: {
+        tenantId: string | null;
+        label: string;
+        parentId: string | null;
+        enumKey?: string;
+    }): Promise<DocumentCategory>;
+    createType(data: {
+        tenantId: string | null;
+        label: string;
+        categoryId: string;
+        enumKey?: string;
+    }): Promise<DocumentType>;
+    updateCategory(tenantId: string | null, id: string, update: {
         label?: string;
         parentId?: string | null;
     }): Promise<DocumentCategory>;
-    updateType(id: string, update: {
+    updateType(tenantId: string | null, id: string, update: {
         label?: string;
         categoryId?: string;
     }): Promise<DocumentType>;
-    loadCategoryGraph(categoryId: string): Promise<DocumentCategory[]>;
-    loadCategoriesAndTypes(): Promise<{
+    loadCategoryGraph(tenantId: string, categoryId: string): Promise<DocumentCategory[]>;
+    loadCategoriesAndTypes(tenantId: string | null): Promise<{
         categories: DocumentCategory[];
         types: DocumentType[];
     }>;
-    loadCategoryViews(): Promise<DocumentCategoryView[]>;
+    loadCategoryViews(tenantId: string | null): Promise<DocumentCategoryView[]>;
 }

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

@@ -4,10 +4,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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;
 };
-var _a;
-var DocumentCategoryTypeService_1;
-import { inject } from '../../../injector/inject.js';
-import { Logger } from '../../../logger/logger.js';
 import { Transactional } from '../../../orm/server/index.js';
 import { injectRepository } from '../../../orm/server/repository.js';
 import { groupToMap } from '../../../utils/iterable-helpers/group-to-map.js';
@@ -15,45 +11,56 @@ import { isUndefined } from '../../../utils/type-guards.js';
 import { DocumentCategory, DocumentType } from '../../models/index.js';
 import { enumTypeKey } from './enum-type-key.js';
 import { DocumentManagementSingleton } from './singleton.js';
-let DocumentCategoryTypeService = DocumentCategoryTypeService_1 = class DocumentCategoryTypeService extends Transactional {
-    #logger = inject(Logger, DocumentCategoryTypeService_1.name);
+let DocumentCategoryTypeService = class DocumentCategoryTypeService extends Transactional {
     categoryRepository = injectRepository(DocumentCategory);
     typeRepository = injectRepository(DocumentType);
-    async loadCategory(id) {
-        return await this.categoryRepository.load(id);
+    async loadCategory(tenantId, id) {
+        return await this.categoryRepository.loadByQuery({ id, tenantId: { $or: [null, tenantId] } });
     }
-    async loadType(id) {
-        return await this.typeRepository.load(id);
+    async loadType(tenantId, id) {
+        return await this.typeRepository.loadByQuery({ id, tenantId: { $or: [null, tenantId] } });
     }
-    async createCategory(label, parentId, enumKey) {
-        return await this.categoryRepository.insert({ label, parentId, metadata: { attributes: { [enumTypeKey]: enumKey } } });
+    async createCategory(data) {
+        return await this.categoryRepository.insert({
+            tenantId: data.tenantId,
+            label: data.label,
+            parentId: data.parentId,
+            metadata: { attributes: { [enumTypeKey]: data.enumKey } },
+        });
     }
-    async createType(label, categoryId, enumKey) {
-        return await this.typeRepository.insert({ label, categoryId, metadata: { attributes: { [enumTypeKey]: enumKey } } });
+    async createType(data) {
+        // Ensure the category exists for the tenant before creating the type
+        await this.categoryRepository.loadByQuery({ tenantId: { $or: [null, data.tenantId] }, id: data.categoryId });
+        return await this.typeRepository.insert({
+            tenantId: data.tenantId,
+            label: data.label,
+            categoryId: data.categoryId,
+            metadata: { attributes: { [enumTypeKey]: data.enumKey } },
+        });
     }
-    async updateCategory(id, update) {
-        return await this.categoryRepository.update(id, update);
+    async updateCategory(tenantId, id, update) {
+        return await this.categoryRepository.updateByQuery({ tenantId, id }, update);
     }
-    async updateType(id, update) {
-        return await this.typeRepository.update(id, update);
+    async updateType(tenantId, id, update) {
+        return await this.typeRepository.updateByQuery({ tenantId, id }, update);
     }
-    async loadCategoryGraph(categoryId) {
-        const category = await this.categoryRepository.load(categoryId);
+    async loadCategoryGraph(tenantId, categoryId) {
+        const category = await this.categoryRepository.loadByQuery({ tenantId: { $or: [null, tenantId] }, id: categoryId });
         if (category.parentId == null) {
             return [category];
         }
-        const parents = await this.loadCategoryGraph(category.parentId);
+        const parents = await this.loadCategoryGraph(tenantId, category.parentId);
         return [...parents, category];
     }
-    async loadCategoriesAndTypes() {
+    async loadCategoriesAndTypes(tenantId) {
         const [categories, types] = await Promise.all([
-            this.categoryRepository.loadManyByQuery({}, { order: 'label' }),
-            this.typeRepository.loadManyByQuery({}, { order: 'label' }),
+            this.categoryRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } }, { order: 'label' }),
+            this.typeRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } }, { order: 'label' }),
         ]);
         return { categories, types };
     }
-    async loadCategoryViews() {
-        const { categories, types } = await this.loadCategoriesAndTypes();
+    async loadCategoryViews(tenantId) {
+        const { categories, types } = await this.loadCategoriesAndTypes(tenantId);
         const categoryChildrenMap = groupToMap(categories, (category) => category.parentId);
         const categoryTypesMap = groupToMap(types, (type) => type.categoryId);
         const rootCategories = categoryChildrenMap.get(null);
@@ -63,7 +70,7 @@ let DocumentCategoryTypeService = DocumentCategoryTypeService_1 = class Document
         return rootCategories.map((category) => getView(category, categoryChildrenMap, categoryTypesMap));
     }
 };
-DocumentCategoryTypeService = DocumentCategoryTypeService_1 = __decorate([
+DocumentCategoryTypeService = __decorate([
     DocumentManagementSingleton()
 ], DocumentCategoryTypeService);
 export { DocumentCategoryTypeService };

package/document-management/server/services/document-collection.service.d.ts

@@ -1,13 +1,20 @@
-import { type Query } from '../../../orm/index.js';
+import type { DocumentCollectionMetadata } from '../../../document-management/service-models/index.js';
+import { type EntityMetadataInsert, type Query } from '../../../orm/index.js';
 import { Transactional } from '../../../orm/server/index.js';
 import type { OneOrMany } from '../../../types.js';
 import { Document, DocumentCollection } from '../../models/index.js';
 export declare class DocumentCollectionService extends Transactional {
     #private;
     readonly repository: import("../../../orm/server/repository.js").EntityRepository<DocumentCollection>;
-    loadCollectionGraph(collectionId: string): Promise<DocumentCollection[]>;
-    createCollection(parentId: string | null): Promise<DocumentCollection>;
-    collectionHasDocumentByFilter(collectionId: string, filter: Query<Document>): Promise<boolean>;
-    assignDocument(documentId: string, collectionIds: OneOrMany<string>): Promise<void>;
-    archiveDocument(documentId: string, collectionIds: OneOrMany<string>): Promise<void>;
+    resolveMetadata<const T extends (DocumentCollection | string)[]>(tenantId: string, collectionsOrIds: T): Promise<{
+        [K in keyof T]: DocumentCollectionMetadata;
+    }>;
+    resolveMetadataMap(tenantId: string, collectionsOrIds: (DocumentCollection | string)[]): Promise<Record<string, DocumentCollectionMetadata>>;
+    loadCollectionGraph(tenantId: string, collectionId: string): Promise<DocumentCollection[]>;
+    createCollection(tenantId: string, parentId: string | null, options?: {
+        metadata?: EntityMetadataInsert;
+    }): Promise<DocumentCollection>;
+    collectionHasDocumentByFilter(tenantId: string, collectionId: string, filter: Query<Document>): Promise<boolean>;
+    assignDocument(document: Document, collectionIds: OneOrMany<string>): Promise<void>;
+    archiveDocument(document: Document, collectionIds: OneOrMany<string>): Promise<void>;
 }

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

@@ -5,45 +5,69 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { and, eq, sql } from 'drizzle-orm';
+import { inject } from '../../../injector/inject.js';
 import { TRANSACTION_TIMESTAMP } from '../../../orm/index.js';
 import { Transactional } from '../../../orm/server/index.js';
 import { injectRepository } from '../../../orm/server/repository.js';
 import { toArray } from '../../../utils/array/index.js';
+import { fromEntries } from '../../../utils/object/index.js';
+import { assertDefinedPass, isString } from '../../../utils/type-guards.js';
 import { Document, DocumentCollection, DocumentCollectionAssignment } from '../../models/index.js';
 import { document, documentCollectionAssignment } from '../schemas.js';
+import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
 let DocumentCollectionService = class DocumentCollectionService extends Transactional {
+    #ancillaryService = inject(DocumentManagementAncillaryService);
     #documentRepository = injectRepository(Document);
     #documentCollectionAssignmentRepository = injectRepository(DocumentCollectionAssignment);
     repository = injectRepository(DocumentCollection);
-    async loadCollectionGraph(collectionId) {
-        const collection = await this.repository.load(collectionId);
+    async resolveMetadata(tenantId, collectionsOrIds) {
+        if (collectionsOrIds.length == 0) {
+            return [];
+        }
+        const loadIds = collectionsOrIds.filter((collection) => isString(collection));
+        if (loadIds.length == 0) {
+            return this.#ancillaryService.resolveMetadata(collectionsOrIds);
+        }
+        const loadedCollections = await this.repository.loadManyByQuery({ tenantId, id: { $in: loadIds } });
+        const collections = collectionsOrIds.map((collectionOrId) => isString(collectionOrId)
+            ? assertDefinedPass(loadedCollections.find((collection) => collection.id == collectionOrId), `Could not load collection "${collectionOrId}".`)
+            : collectionOrId);
+        return this.#ancillaryService.resolveMetadata(collections);
+    }
+    async resolveMetadataMap(tenantId, collectionsOrIds) {
+        const names = await this.resolveMetadata(tenantId, collectionsOrIds);
+        const entries = collectionsOrIds.map((collectionOrId, index) => [isString(collectionOrId) ? collectionOrId : collectionOrId.id, names[index]]);
+        return fromEntries(entries);
+    }
+    async loadCollectionGraph(tenantId, collectionId) {
+        const collection = await this.repository.loadByQuery({ tenantId, id: collectionId });
         if (collection.parentId == null) {
             return [collection];
         }
-        const parents = await this.loadCollectionGraph(collection.parentId);
+        const parents = await this.loadCollectionGraph(tenantId, collection.parentId);
         return [...parents, collection];
     }
-    async createCollection(parentId) {
-        return this.repository.withSession(this.session).insert({ parentId });
+    async createCollection(tenantId, parentId, options) {
+        return await this.repository.withSession(this.session).insert({ tenantId, parentId, metadata: options?.metadata });
     }
-    async collectionHasDocumentByFilter(collectionId, filter) {
+    async collectionHasDocumentByFilter(tenantId, collectionId, filter) {
         const matchingDocuments = this.session
             .select()
             .from(documentCollectionAssignment)
-            .leftJoin(document, eq(document.id, documentCollectionAssignment.documentId))
-            .where(and(eq(documentCollectionAssignment.collectionId, collectionId), this.#documentRepository.convertQuery(filter)));
+            .leftJoin(document, and(eq(document.tenantId, tenantId), eq(document.id, documentCollectionAssignment.documentId)))
+            .where(and(eq(documentCollectionAssignment.tenantId, tenantId), eq(documentCollectionAssignment.collectionId, collectionId), this.#documentRepository.convertQuery(filter)));
         const result = await this.session.execute(sql `SELECT EXISTS(SELECT 1 FROM ${matchingDocuments}))`);
         console.log(result);
         throw new Error('verify');
         // return result[0]!;
     }
-    async assignDocument(documentId, collectionIds) {
-        const values = toArray(collectionIds).map((collectionId) => ({ collectionId, documentId, archiveTimestamp: null }));
+    async assignDocument(document, collectionIds) {
+        const values = toArray(collectionIds).map((collectionId) => ({ tenantId: document.tenantId, collectionId, documentId: document.id, archiveTimestamp: null }));
         await this.#documentCollectionAssignmentRepository.withSession(this.session).upsertMany(['collectionId', 'documentId'], values);
     }
-    async archiveDocument(documentId, collectionIds) {
-        await this.#documentCollectionAssignmentRepository.withSession(this.session).updateManyByQuery({ collectionId: { $in: toArray(collectionIds) }, documentId, archiveTimestamp: null }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
+    async archiveDocument(document, collectionIds) {
+        await this.#documentCollectionAssignmentRepository.withSession(this.session).updateManyByQuery({ tenantId: document.tenantId, collectionId: { $in: toArray(collectionIds) }, documentId: document.id, archiveTimestamp: null }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
     }
 };
 DocumentCollectionService = __decorate([

package/document-management/server/services/document-file.service.d.ts

@@ -1,5 +1,6 @@
 import type { FileContentPart } from '../../../ai/types.js';
 import { Transactional } from '../../../orm/server/index.js';
+import { Document } from '../../models/index.js';
 export type DocumentFileMetadata = {
     mimeType: string;
     size: number;
@@ -25,13 +26,13 @@ export declare class DocumentFileService extends Transactional {
         uploadId: string;
         uploadKey: string;
     }): Promise<[DocumentFileMetadata, Uint8Array]>;
-    getContent(fileId: string): Promise<Uint8Array>;
-    getContentStream(fileId: string): ReadableStream<Uint8Array>;
-    getContentUrl(documentId: string, title: string | null, download?: boolean): Promise<string>;
-    getPreview(fileId: string, page?: number): Promise<Uint8Array>;
-    getPreviewStream(fileId: string, page?: number): ReadableStream<Uint8Array>;
-    getPreviewUrl(fileId: string, page?: number): Promise<string>;
-    getAiFileContentPart(documentId: string): Promise<FileContentPart>;
+    getContent(document: Document): Promise<Uint8Array>;
+    getContentStream(document: Document): ReadableStream<Uint8Array>;
+    getContentUrl(document: Document, download?: boolean): Promise<string>;
+    getPreview(document: Document, page?: number): Promise<Uint8Array>;
+    getPreviewStream(document: Document, page?: number): ReadableStream<Uint8Array>;
+    getPreviewUrl(document: Document, page?: number): Promise<string>;
+    getAiFileContentPart(document: Document): Promise<FileContentPart>;
     private createPreviewIfNotExists;
     private getDocumentFileContentObjectUrl;
 }

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

@@ -69,7 +69,6 @@ import { inject } from '../../../injector/inject.js';
 import { Logger } from '../../../logger/logger.js';
 import { ObjectStorage } from '../../../object-storage/index.js';
 import { Transactional } from '../../../orm/server/index.js';
-import { injectRepository } from '../../../orm/server/repository.js';
 import { pdfToImage } from '../../../pdf/index.js';
 import { Alphabet } from '../../../utils/alphabet.js';
 import { digest } from '../../../utils/cryptography.js';
@@ -79,15 +78,14 @@ import { readableStreamFromPromise, readBinaryStream } from '../../../utils/stre
 import { isDefined, isNotReadableStream, isNotUint8Array, isUint8Array } from '../../../utils/type-guards.js';
 import { millisecondsPerMinute, secondsPerMinute } from '../../../utils/units.js';
 import { Document } from '../../models/index.js';
-import { DocumentManagementConfig } from '../module.js';
+import { DocumentManagementConfiguration } from '../module.js';
 import { DocumentManagementSingleton } from './singleton.js';
 let DocumentFileService = DocumentFileService_1 = class DocumentFileService extends Transactional {
-    #config = inject(DocumentManagementConfig);
-    #documentRepository = injectRepository(Document);
+    #configuration = inject(DocumentManagementConfiguration);
     #aiService = inject(AiService);
-    #fileObjectStorage = inject(ObjectStorage, this.#config.fileObjectStorageModule);
-    #filePreviewObjectStorage = inject(ObjectStorage, this.#config.filePreviewObjectStorageModule);
-    #fileUploadObjectStorage = inject(ObjectStorage, { module: this.#config.fileUploadObjectStorageModule, configuration: { lifecycle: { expiration: { after: 5 * secondsPerMinute } } } });
+    #fileObjectStorage = inject(ObjectStorage, this.#configuration.fileObjectStorageModule);
+    #filePreviewObjectStorage = inject(ObjectStorage, this.#configuration.filePreviewObjectStorageModule);
+    #fileUploadObjectStorage = inject(ObjectStorage, { module: this.#configuration.fileUploadObjectStorageModule, configuration: { lifecycle: { expiration: { after: 5 * secondsPerMinute } } } });
     #logger = inject(Logger, DocumentFileService_1.name);
     #aiFilePartCache = new Map();
     /**
@@ -97,8 +95,8 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
      * @returns upload information
      */
     async initiateUpload({ key, contentLength }) {
-        if (contentLength > (this.#config.maxFileSize ?? Number.POSITIVE_INFINITY)) {
-            throw new ForbiddenError(`Content length exceeds the maximum limit of ${this.#config.maxFileSize} bytes.`);
+        if (contentLength > (this.#configuration.maxFileSize ?? Number.POSITIVE_INFINITY)) {
+            throw new ForbiddenError(`Content length exceeds the maximum limit of ${this.#configuration.maxFileSize} bytes.`);
         }
         const id = getRandomString(64, Alphabet.LowerUpperCaseNumbers);
         const url = await this.#fileUploadObjectStorage.getUploadUrl(id, currentTimestamp() + (5 * millisecondsPerMinute), { contentLength, metadata: { 'upload-key': key } });
@@ -113,9 +111,9 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
             if (content.uploadKey != objectMetadata['upload-key']) {
                 throw new ForbiddenError(`Invalid upload key`);
             }
-            if (objectContentLength > (this.#config.maxFileSize ?? Number.POSITIVE_INFINITY)) {
+            if (objectContentLength > (this.#configuration.maxFileSize ?? Number.POSITIVE_INFINITY)) {
                 await this.#fileUploadObjectStorage.deleteObject(object.key);
-                throw new ForbiddenError(`Content length exceeds the maximum limit of ${this.#config.maxFileSize} bytes.`);
+                throw new ForbiddenError(`Content length exceeds the maximum limit of ${this.#configuration.maxFileSize} bytes.`);
             }
         }
         const contentAsUint8Array = isUpload
@@ -136,41 +134,39 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
         await this.#fileObjectStorage.uploadObject(objectKey, contentAsUint8Array, { contentLength: contentAsUint8Array.length, contentType: mimeType });
         return metadata;
     }
-    async getContent(fileId) {
-        const objectKey = getObjectKey(fileId);
+    async getContent(document) {
+        const objectKey = getObjectKey(document.id);
         return await this.#fileObjectStorage.getContent(objectKey);
     }
-    getContentStream(fileId) {
-        const objectKey = getObjectKey(fileId);
+    getContentStream(document) {
+        const objectKey = getObjectKey(document.id);
         return this.#fileObjectStorage.getContentStream(objectKey);
     }
-    async getContentUrl(documentId, title, download = false) {
-        const document = await this.#documentRepository.load(documentId);
-        return await this.getDocumentFileContentObjectUrl(document, title ?? documentId, download);
+    async getContentUrl(document, download = false) {
+        return await this.getDocumentFileContentObjectUrl(document, document.title ?? document.id, download);
     }
-    async getPreview(fileId, page = 1) {
-        const objectKey = getObjectKey(fileId);
-        await this.createPreviewIfNotExists(fileId, page);
+    async getPreview(document, page = 1) {
+        const objectKey = getObjectKey(document.id);
+        await this.createPreviewIfNotExists(document, page);
         return await this.#filePreviewObjectStorage.getContent(objectKey);
     }
-    getPreviewStream(fileId, page = 1) {
+    getPreviewStream(document, page = 1) {
         return readableStreamFromPromise(async () => {
-            const objectKey = getObjectKey(fileId);
-            await this.createPreviewIfNotExists(fileId, page);
+            const objectKey = getObjectKey(document.id);
+            await this.createPreviewIfNotExists(document, page);
             return this.#filePreviewObjectStorage.getContentStream(objectKey);
         });
     }
-    async getPreviewUrl(fileId, page = 1) {
-        const objectKey = getObjectKey(fileId);
-        await this.createPreviewIfNotExists(fileId, page);
+    async getPreviewUrl(document, page = 1) {
+        const objectKey = getObjectKey(document.id);
+        await this.createPreviewIfNotExists(document, page);
         return await this.#filePreviewObjectStorage.getDownloadUrl(objectKey, currentTimestamp() + (5 * millisecondsPerMinute), {
             'Response-Content-Type': 'image/jpeg',
         });
     }
-    async getAiFileContentPart(documentId) {
+    async getAiFileContentPart(document) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            const document = await this.#documentRepository.load(documentId);
             const cachedAiFilePart = this.#aiFilePartCache.get(document.id);
             if (isDefined(cachedAiFilePart)) {
                 if (cachedAiFilePart.timestamp > (currentTimestamp() - (5 * millisecondsPerMinute))) {
@@ -178,7 +174,7 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
                 }
                 this.#aiFilePartCache.delete(document.id);
             }
-            const fileContentStream = this.getContentStream(document.id);
+            const fileContentStream = this.getContentStream(document);
             const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
             const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: document.mimeType });
             this.#aiFilePartCache.set(document.id, { part: filePart, timestamp: currentTimestamp() });
@@ -194,11 +190,10 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
                 await result_1;
         }
     }
-    async createPreviewIfNotExists(documentId, page = 1) {
-        const key = getObjectKey(documentId);
+    async createPreviewIfNotExists(document, page = 1) {
+        const key = getObjectKey(document.id);
         const hasPreview = await this.#filePreviewObjectStorage.exists(key);
         if (!hasPreview) {
-            const document = await this.#documentRepository.load(documentId);
             const content = await this.#fileObjectStorage.getContent(key);
             const image = await match(document.mimeType)
                 .with('application/pdf', async () => {

package/document-management/server/services/document-management-ai.service.d.ts

@@ -1,4 +1,5 @@
 import type { DocumentPropertyDataType } from '../../models/index.js';
+import { Document } from '../../models/index.js';
 type DocumentInformationExtractionPropertyResult = {
     propertyId: string;
     dataType: DocumentPropertyDataType;
@@ -14,9 +15,9 @@ export type DocumentInformationExtractionResult = {
 };
 export declare class DocumentManagementAiService {
     #private;
-    classifyDocumentType(documentId: string): Promise<string>;
-    extractDocumentInformation(documentId: string): Promise<DocumentInformationExtractionResult>;
-    findSuitableCollectionsForDocument(documentId: string, collectionIds: string[]): Promise<string[]>;
-    findSuitableRequestForDocument(documentId: string, collectionIds: string[]): Promise<string | null>;
+    classifyDocumentType(tenantId: string, documentId: string): Promise<string>;
+    extractDocumentInformation(tenantId: string, documentId: string): Promise<DocumentInformationExtractionResult>;
+    findSuitableCollectionsForDocument(document: Document, collectionIds: string[]): Promise<string[]>;
+    findSuitableRequestForDocument(document: Document, collectionIds: string[]): Promise<string | null>;
 }
 export {};