@tstdl/base 0.92.132 → 0.92.135

package/api/response.js

@@ -35,8 +35,8 @@ export function createErrorResponse(errorOrName, message = '', details) {
                     name: errorOrName.name,
                     message: errorOrName.message,
                     details,
-                    data
-                }
+                    data,
+                },
             };
         }
         else {
@@ -44,8 +44,8 @@ export function createErrorResponse(errorOrName, message = '', details) {
                 error: {
                     name: errorOrName.name,
                     message: errorOrName.message,
-                    details
-                }
+                    details,
+                },
             };
         }
     }
@@ -54,8 +54,8 @@ export function createErrorResponse(errorOrName, message = '', details) {
             error: {
                 name: errorOrName,
                 message,
-                details
-            }
+                details,
+            },
         };
     }
     return response;

package/api/server/api-request-token.provider.d.ts

@@ -5,3 +5,6 @@ export declare abstract class ApiRequestTokenProvider {
 export declare class NoopApiRequestTokenProvider extends ApiRequestTokenProvider {
     getToken<T>(): T;
 }
+export declare class MockApiRequestTokenProvider extends ApiRequestTokenProvider {
+    getToken<T>(): T;
+}

package/api/server/api-request-token.provider.js

@@ -16,3 +16,12 @@ NoopApiRequestTokenProvider = __decorate([
     Singleton({ alias: ApiRequestTokenProvider })
 ], NoopApiRequestTokenProvider);
 export { NoopApiRequestTokenProvider };
+let MockApiRequestTokenProvider = class MockApiRequestTokenProvider extends ApiRequestTokenProvider {
+    getToken() {
+        return {};
+    }
+};
+MockApiRequestTokenProvider = __decorate([
+    Singleton({ alias: ApiRequestTokenProvider })
+], MockApiRequestTokenProvider);
+export { MockApiRequestTokenProvider };

package/api/server/module.js

@@ -4,7 +4,7 @@ import { ensureApiController } from './api-controller.js';
 import { ApiRequestTokenProvider } from './api-request-token.provider.js';
 import { API_CONTROLLER, API_MODULE_OPTIONS } from './tokens.js';
 export const apiModuleOptions = {
-    controllers: []
+    controllers: [],
 };
 export function configureApiServer(options) {
     if (isDefined(options.controllers)) {

package/database/mongo/module.js

@@ -6,7 +6,7 @@ import { Collection, Database, MongoClient } from './classes.js';
 export const mongoModuleConfig = {
     defaultConnection: { url: 'mongodb://localhost:27017/test-db' },
     defaultDatabase: undefined,
-    logPrefix: 'Mongo'
+    logPrefix: 'Mongo',
 };
 export function configureMongo(config) {
     mongoModuleConfig.defaultDatabase = config.defaultDatabase ?? mongoModuleConfig.defaultDatabase;
@@ -31,10 +31,10 @@ Injector.registerSingleton(MongoClient, {
     },
     async afterResolve(client, _argument, { cancellationSignal, data: { url, logger } }) {
         await connect(`mongo at ${url}`, async () => client.connect(), logger, cancellationSignal);
-    }
+    },
 }, {
     defaultArgumentProvider: () => mongoModuleConfig.defaultConnection,
-    argumentIdentityProvider: JSON.stringify
+    argumentIdentityProvider: JSON.stringify,
 });
 Injector.registerSingleton(Database, {
     useFactory: (argument, context) => {
@@ -45,7 +45,7 @@ Injector.registerSingleton(Database, {
     },
     defaultArgumentProvider: () => ({ database: mongoModuleConfig.defaultDatabase, connection: mongoModuleConfig.defaultConnection }),
 }, {
-    argumentIdentityProvider: JSON.stringify
+    argumentIdentityProvider: JSON.stringify,
 });
 Injector.registerSingleton(Collection, {
     useFactory: (config, context) => {
@@ -62,7 +62,7 @@ Injector.registerSingleton(Collection, {
             }
         }
         await database.createCollection(config.collection);
-    }
+    },
 }, {
-    argumentIdentityProvider: JSON.stringify
+    argumentIdentityProvider: JSON.stringify,
 });

package/document-management/api/document-management.api.d.ts

@@ -71,6 +71,15 @@ export declare const documentManagementApiDefinition: {
             result: typeof DocumentType;
             credentials: true;
         };
+        initiateDocumentUpload: {
+            resource: string;
+            method: "POST";
+            result: import("../../schema/index.js").ObjectSchema<{
+                uploadId: string;
+                uploadUrl: string;
+            }>;
+            credentials: true;
+        };
         createDocument: {
             resource: string;
             method: "POST";
@@ -94,6 +103,7 @@ export declare const documentManagementApiDefinition: {
                         scope: string | string[];
                     };
                 };
+                uploadId: string;
                 properties?: {
                     propertyId: import("../../orm/schemas/uuid.js").Uuid;
                     value: string | number | boolean | null;
@@ -105,8 +115,6 @@ export declare const documentManagementApiDefinition: {
                     attributes: import("../../orm/types.js").HasDefault<import("../../orm/schemas/json.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
                 }> | undefined;
             }>;
-            body: Uint8ArrayConstructor;
-            maxBytes: number;
             result: typeof Document;
             credentials: true;
         };
@@ -370,6 +378,15 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
             result: typeof DocumentType;
             credentials: true;
         };
+        initiateDocumentUpload: {
+            resource: string;
+            method: "POST";
+            result: import("../../schema/index.js").ObjectSchema<{
+                uploadId: string;
+                uploadUrl: string;
+            }>;
+            credentials: true;
+        };
         createDocument: {
             resource: string;
             method: "POST";
@@ -393,6 +410,7 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
                         scope: string | string[];
                     };
                 };
+                uploadId: string;
                 properties?: {
                     propertyId: import("../../orm/schemas/uuid.js").Uuid;
                     value: string | number | boolean | null;
@@ -404,8 +422,6 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
                     attributes: import("../../orm/types.js").HasDefault<import("../../orm/schemas/json.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
                 }> | undefined;
             }>;
-            body: Uint8ArrayConstructor;
-            maxBytes: number;
             result: typeof Document;
             credentials: true;
         };

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

@@ -8,7 +8,6 @@ import { compileClient } from '../../api/client/index.js';
 import { defineApi } from '../../api/index.js';
 import { ReplaceClass } from '../../injector/decorators.js';
 import { array, boolean, literal, object, optional, string } from '../../schema/index.js';
-import { megabyte } from '../../utils/units.js';
 import { Document, DocumentCategory, DocumentRequest, DocumentRequestsTemplate, DocumentRequestTemplate, DocumentType } from '../models/index.js';
 import { addOrArchiveDocumentToOrFromCollectionParametersSchema, applyDocumentRequestsTemplateParametersSchema, createDocumentCategoryParametersSchema, createDocumentParametersSchema, createDocumentRequestParametersSchema, createDocumentRequestsTemplateParametersSchema, createDocumentRequestTemplateParametersSchema, createDocumentTypeParametersSchema, deleteDocumentRequestParametersSchema, deleteDocumentRequestsTemplateParametersSchema, deleteDocumentRequestTemplateParametersSchema, DocumentCategoryView, DocumentManagementData, DocumentRequestsTemplateData, loadDataParametersSchema, updateDocumentParametersSchema, updateDocumentRequestParametersSchema, updateDocumentRequestsTemplateParametersSchema, updateDocumentRequestTemplateParametersSchema } from '../service-models/index.js';
 export const documentManagementApiDefinition = defineApi({
@@ -67,12 +66,19 @@ export const documentManagementApiDefinition = defineApi({
             result: DocumentType,
             credentials: true,
         },
+        initiateDocumentUpload: {
+            resource: 'document-uploads',
+            method: 'POST',
+            result: object({
+                uploadId: string(),
+                uploadUrl: string(),
+            }),
+            credentials: true,
+        },
         createDocument: {
             resource: 'documents',
             method: 'POST',
             parameters: createDocumentParametersSchema,
-            body: Uint8Array,
-            maxBytes: 50 * megabyte,
             result: Document,
             credentials: true,
         },

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

@@ -9,6 +9,7 @@ export declare class DocumentManagementApiController implements ApiController<Do
     getContentUrl(context: ApiRequestContext<DocumentManagementApiDefinition, 'getContentUrl'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'getContentUrl'>>;
     createCategory(context: ApiRequestContext<DocumentManagementApiDefinition, 'createCategory'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'createCategory'>>;
     createType(context: ApiRequestContext<DocumentManagementApiDefinition, 'createType'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'createType'>>;
+    initiateDocumentUpload(context: ApiRequestContext<DocumentManagementApiDefinition, 'initiateDocumentUpload'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'initiateDocumentUpload'>>;
     createDocument(context: ApiRequestContext<DocumentManagementApiDefinition, 'createDocument'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'createDocument'>>;
     createDocumentRequestsTemplate(context: ApiRequestContext<DocumentManagementApiDefinition, 'createDocumentRequestsTemplate'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'createDocumentRequestsTemplate'>>;
     updateDocumentRequestsTemplate(_context: ApiRequestContext<DocumentManagementApiDefinition, 'updateDocumentRequestsTemplate'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'updateDocumentRequestsTemplate'>>;

package/document-management/server/api/document-management.api.js

@@ -92,8 +92,15 @@ let DocumentManagementApiController = DocumentManagementApiController_1 = class
         }
         return await this.#documentCategoryTypeService.createType(context.parameters.label, context.parameters.categoryId);
     }
+    async initiateDocumentUpload(context) {
+        const token = await context.getToken();
+        const subject = await this.#ancillaryService.getSubject(token);
+        return await this.#documentFileService.initiateUpload({ key: subject });
+    }
     async createDocument(context) {
         const token = await context.getToken();
+        const subject = await this.#ancillaryService.getSubject(token);
+        const { uploadId, ...createParameters } = context.parameters;
         const [collectionIds, requiresAssign] = await match(context.parameters.assignment)
             .with({ collections: P.select() }, (collectionIds) => [toArray(collectionIds), true])
             .with({ request: P.select() }, async (requestId) => {
@@ -115,8 +122,8 @@ let DocumentManagementApiController = DocumentManagementApiController_1 = class
                 }
             }
         }
-        const actionUserId = await this.#ancillaryService.getUserId(token);
-        return await this.#documentService.create(context.parameters, context.body, { createUserId: actionUserId });
+        const actionUserId = await this.#ancillaryService.getSubject(token);
+        return await this.#documentService.create(createParameters, { uploadId, uploadKey: subject }, { createUserId: actionUserId });
     }
     async createDocumentRequestsTemplate(context) {
         const token = await context.getToken();

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

@@ -5,6 +5,7 @@ import { DocumentManagementAncillaryService } from './services/document-manageme
 export declare class DocumentManagementConfig {
     ancillaryService: InjectionToken<DocumentManagementAncillaryService>;
     fileObjectStorageModule: string;
+    fileUploadObjectStorageModule: string;
     filePreviewObjectStorageModule: string;
     database?: DatabaseConfig;
 }

package/document-management/server/module.js

@@ -5,6 +5,7 @@ import { DocumentManagementAncillaryService } from './services/document-manageme
 export class DocumentManagementConfig {
     ancillaryService;
     fileObjectStorageModule;
+    fileUploadObjectStorageModule;
     filePreviewObjectStorageModule;
     database;
 }

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

@@ -4,7 +4,23 @@ import { DocumentFile } from '../../models/index.js';
 export declare class DocumentFileService extends Transactional {
     #private;
     load(id: string): Promise<DocumentFile>;
+    /**
+     * Initiates a file upload
+     * @param key - key which can be used to authorize the creation of the file. Same key must be provided to {@link create} method, or it will throw an error.
+     * The key could be the user id from the request token. This ensures that the file can only be created by the user who initiated the upload.
+     * @returns upload information
+     */
+    initiateUpload({ key }: {
+        key: string;
+    }): Promise<{
+        uploadId: string;
+        uploadUrl: string;
+    }>;
     create(content: Uint8Array | ReadableStream<Uint8Array>, originalFileName: string | null): Promise<DocumentFile>;
+    create(content: {
+        uploadId: string;
+        uploadKey: string;
+    }, originalFileName: string | null): Promise<[DocumentFile, Uint8Array]>;
     getContent(fileId: string): Promise<Uint8Array>;
     getContentStream(fileId: string): ReadableStream<Uint8Array>;
     getContentUrl(fileId: string, title: string | null, download?: boolean): Promise<string>;

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

@@ -61,6 +61,7 @@ var DocumentFileService_1;
 import sharp, {} from 'sharp';
 import { match } from 'ts-pattern';
 import { AiService } from '../../../ai/ai.service.js';
+import { ForbiddenError } from '../../../errors/forbidden.error.js';
 import { NotImplementedError } from '../../../errors/not-implemented.error.js';
 import { getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
 import { TemporaryFile } from '../../../file/server/index.js';
@@ -70,30 +71,55 @@ 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';
 import { currentTimestamp } from '../../../utils/date-time.js';
+import { getRandomString } from '../../../utils/random.js';
 import { readableStreamFromPromise, readBinaryStream } from '../../../utils/stream/index.js';
-import { isDefined, isUint8Array } from '../../../utils/type-guards.js';
-import { millisecondsPerMinute } from '../../../utils/units.js';
+import { isDefined, isNotReadableStream, isNotUint8Array, isUint8Array } from '../../../utils/type-guards.js';
+import { millisecondsPerMinute, secondsPerMinute } from '../../../utils/units.js';
 import { Document, DocumentFile } from '../../models/index.js';
 import { DocumentManagementConfig } from '../module.js';
 import { DocumentManagementSingleton } from './singleton.js';
 let DocumentFileService = DocumentFileService_1 = class DocumentFileService extends Transactional {
+    #config = inject(DocumentManagementConfig);
     #documentFileRepository = injectRepository(DocumentFile);
     #documentRepository = injectRepository(Document);
     #aiService = inject(AiService);
-    #fileObjectStorage = inject(ObjectStorage, inject(DocumentManagementConfig).fileObjectStorageModule);
-    #filePreviewObjectStorage = inject(ObjectStorage, inject(DocumentManagementConfig).filePreviewObjectStorageModule);
+    #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 } } } });
     #logger = inject(Logger, DocumentFileService_1.name);
     #aiFilePartCache = new Map();
     async load(id) {
-        return this.#documentFileRepository.load(id);
+        return await this.#documentFileRepository.load(id);
+    }
+    /**
+     * Initiates a file upload
+     * @param key - key which can be used to authorize the creation of the file. Same key must be provided to {@link create} method, or it will throw an error.
+     * The key could be the user id from the request token. This ensures that the file can only be created by the user who initiated the upload.
+     * @returns upload information
+     */
+    async initiateUpload({ key }) {
+        const id = getRandomString(64, Alphabet.LowerUpperCaseNumbers);
+        const url = await this.#fileUploadObjectStorage.getUploadUrl(id, currentTimestamp() + (5 * millisecondsPerMinute), { metadata: { 'upload-key': key } });
+        return { uploadId: id, uploadUrl: url };
     }
     async create(content, originalFileName) {
-        const contentAsUint8Array = isUint8Array(content) ? content : await readBinaryStream(content);
+        const isUpload = isNotUint8Array(content) && isNotReadableStream(content);
+        if (isUpload) {
+            const object = await this.#fileUploadObjectStorage.getObject(content.uploadId);
+            const objectMetadata = await object.getMetadata();
+            if (content.uploadKey != objectMetadata['upload-key']) {
+                throw new ForbiddenError(`Invalid upload key`);
+            }
+        }
+        const contentAsUint8Array = isUpload
+            ? await this.#fileUploadObjectStorage.getContent(content.uploadId)
+            : (isUint8Array(content) ? content : await readBinaryStream(content));
         const hash = await digest('SHA-256', contentAsUint8Array).toHex();
         const mimeType = await getMimeType(contentAsUint8Array);
-        return this.transaction(async (tx) => {
+        return await this.transaction(async (tx) => {
             const documentFile = await this.#documentFileRepository
                 .withTransaction(tx)
                 .insert({
@@ -102,39 +128,43 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
                 hash,
                 size: contentAsUint8Array.length,
             });
-            const key = getDocumentFileKey(documentFile.id);
-            await this.#fileObjectStorage.uploadObject(key, contentAsUint8Array);
+            const objectKey = getDocumentFileKey(documentFile.id);
+            if (isUpload) {
+                await this.#fileUploadObjectStorage.moveObject(content.uploadId, [this.#fileObjectStorage, objectKey]);
+                return [documentFile, contentAsUint8Array];
+            }
+            await this.#fileObjectStorage.uploadObject(objectKey, contentAsUint8Array, { contentLength: contentAsUint8Array.length, contentType: mimeType });
             return documentFile;
         });
     }
     async getContent(fileId) {
-        const key = getDocumentFileKey(fileId);
-        return this.#fileObjectStorage.getContent(key);
+        const objectKey = getDocumentFileKey(fileId);
+        return await this.#fileObjectStorage.getContent(objectKey);
     }
     getContentStream(fileId) {
-        const key = getDocumentFileKey(fileId);
-        return this.#fileObjectStorage.getContentStream(key);
+        const objectKey = getDocumentFileKey(fileId);
+        return this.#fileObjectStorage.getContentStream(objectKey);
     }
     async getContentUrl(fileId, title, download = false) {
         const file = await this.#documentFileRepository.load(fileId);
-        return this.getDocumentFileContentObjectUrl(title ?? fileId, file, download);
+        return await this.getDocumentFileContentObjectUrl(title ?? fileId, file, download);
     }
     async getPreview(fileId, page = 1) {
-        const key = getDocumentFileKey(fileId);
+        const objectKey = getDocumentFileKey(fileId);
         await this.createPreviewIfNotExists(fileId, page);
-        return this.#filePreviewObjectStorage.getContent(key);
+        return await this.#filePreviewObjectStorage.getContent(objectKey);
     }
     getPreviewStream(fileId, page = 1) {
         return readableStreamFromPromise(async () => {
-            const key = getDocumentFileKey(fileId);
+            const objectKey = getDocumentFileKey(fileId);
             await this.createPreviewIfNotExists(fileId, page);
-            return this.#filePreviewObjectStorage.getContentStream(key);
+            return this.#filePreviewObjectStorage.getContentStream(objectKey);
         });
     }
     async getPreviewUrl(fileId, page = 1) {
-        const key = getDocumentFileKey(fileId);
+        const objectKey = getDocumentFileKey(fileId);
         await this.createPreviewIfNotExists(fileId, page);
-        return this.#filePreviewObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
+        return await this.#filePreviewObjectStorage.getDownloadUrl(objectKey, currentTimestamp() + (5 * millisecondsPerMinute), {
             'Response-Content-Type': 'image/jpeg',
         });
     }
@@ -175,11 +205,11 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
             const image = await match(file.mimeType)
                 .with('application/pdf', async () => {
                 const imageBytes = await pdfToImage(content, page, 768, 'jpeg');
-                return imageToPreview(imageBytes);
+                return await imageToPreview(imageBytes);
             })
-                .with('image/*', async () => imageToPreview(content))
+                .with('image/*', async () => await imageToPreview(content))
                 .otherwise(() => { throw new NotImplementedError('Preview generation is not implemented for this file type.'); });
-            await this.#filePreviewObjectStorage.uploadObject(key, image, { contentLength: image.length, metadata: { 'Content-Type': 'image/jpeg' } });
+            await this.#filePreviewObjectStorage.uploadObject(key, image, { contentLength: image.length, contentType: 'image/jpeg' });
         }
     }
     async getDocumentFileContentObjectUrl(title, file, download) {
@@ -187,7 +217,7 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
         const fileExtension = getMimeTypeExtensions(file.mimeType)[0] ?? 'bin';
         const disposition = download ? 'attachment' : 'inline';
         const filename = `${title}.${fileExtension}`;
-        return this.#fileObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
+        return await this.#fileObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
             'Response-Content-Type': file.mimeType,
             'Response-Content-Disposition': `${disposition}; filename = "${encodeURIComponent(filename)}"`,
         });
@@ -201,7 +231,7 @@ function getDocumentFileKey(id) {
     return `${id.slice(0, 2)}/${id.slice(0, 4)}/${id}`;
 }
 async function imageToPreview(input) {
-    return sharp(input)
+    return await sharp(input)
         .resize({
         width: 768,
         height: 768,

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

@@ -93,7 +93,7 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
         try {
             const document = await this.#documentRepository.load(documentId);
             const file = await this.#documentFileService.load(document.fileId);
-            const fileContentStream = this.#documentFileService.getContentStream(document.id);
+            const fileContentStream = this.#documentFileService.getContentStream(document.fileId);
             const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
             const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: file.mimeType });
             const categories = await this.#documentCategoryTypeService.loadCategoryViews();

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

@@ -28,10 +28,10 @@ export declare abstract class DocumentManagementAncillaryService<Token = unknown
      */
     abstract _resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[] | Promise<DocumentCollectionMetadata[]>;
     /**
-     * Gets the user ID from the request token.
+     * Gets the subject from the request token.
      * @param token The token of the request
      */
-    abstract getUserId(token?: Token): string | Promise<string>;
+    abstract getSubject(token?: Token): string | Promise<string>;
     /**
      * Checks if a user can read/view a specific document collection and its documents.
      * @param collectionId The ID of the document collection.

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

@@ -6,14 +6,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Enumerable } from '../../../enumerable/index.js';
 import { inject } from '../../../injector/index.js';
-import { getEntityMap } from '../../../orm/index.js';
 import { Transactional, injectRepository } from '../../../orm/server/index.js';
 import { distinct } from '../../../utils/array/index.js';
 import { compareByValueSelectionToOrder } from '../../../utils/comparison.js';
 import { groupToMap, groupToSingleMap } from '../../../utils/iterable-helpers/index.js';
 import { fromEntries, objectEntries } from '../../../utils/object/index.js';
-import { assertDefinedPass, isNotNull, isNotNullOrUndefined, isNull, isUndefined } from '../../../utils/type-guards.js';
-import { DocumentApproval, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentValidationExecution, DocumentWorkflowStep } from '../../models/index.js';
+import { assertDefinedPass, isDefined, isNotNull, isNotNullOrUndefined, isNull, isUndefined } from '../../../utils/type-guards.js';
+import { DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentValidationExecution, DocumentWorkflowStep } from '../../models/index.js';
 import { DocumentCategoryTypeService, enumTypeKey } from './document-category-type.service.js';
 import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
 import { DocumentPropertyService } from './document-property.service.js';
@@ -30,6 +29,8 @@ let DocumentManagementService = class DocumentManagementService extends Transact
     #documentService = inject(DocumentService);
     #documentPropertyService = inject(DocumentPropertyService);
     #documentRequestCollectionAssignmentRepository = injectRepository(DocumentRequestCollectionAssignment);
+    #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
+    #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
     #documentRequestRepository = injectRepository(DocumentRequest);
     #documentRequestsTemplateRepository = injectRepository(DocumentRequestsTemplate);
     #documentRequestTemplateRepository = injectRepository(DocumentRequestTemplate);
@@ -38,19 +39,25 @@ let DocumentManagementService = class DocumentManagementService extends Transact
     #documentValidationExecutionRepository = injectRepository(DocumentValidationExecution);
     async loadData(collectionIds) {
         return await this.transaction(async (tx) => {
-            const [collections, collectionsMetadataMap, documentAssignments, requestAssignments, categories, types] = await Promise.all([
+            const [collections, collectionsMetadataMap, documentCollectionAssignments, requestAssignments, assignmentScopes, categories, types] = await Promise.all([
                 this.#documentCollectionRepository.withTransaction(tx).loadMany(collectionIds),
                 this.#ancillaryService.resolveMetadataMap(...collectionIds),
                 this.#documentCollectionAssignmentRepository.withTransaction(tx).loadManyByQuery({ collectionId: { $in: collectionIds } }),
                 this.#documentRequestCollectionAssignmentRepository.withTransaction(tx).loadManyByQuery({ collectionId: { $in: collectionIds } }),
+                this.#documentAssignmentScopeRepository.withTransaction(tx).loadManyByQuery({ collectionId: { $in: collectionIds } }),
                 this.#documentCategoryRepository.withTransaction(tx).loadManyByQuery({}, { order: 'label' }),
                 this.#documentTypeRepository.withTransaction(tx).loadManyByQuery({}, { order: 'label' }),
             ]);
             const requestIds = requestAssignments.map((requestCollection) => requestCollection.requestId);
-            const requests = await this.#documentRequestRepository.withTransaction(tx).loadManyByQuery({ id: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } });
-            const assignmentDocumentIds = documentAssignments.map((assignment) => assignment.documentId);
+            const taskIds = assignmentScopes.map((scope) => scope.taskId);
+            const [requests, assignmentTasks] = await Promise.all([
+                this.#documentRequestRepository.withTransaction(tx).loadManyByQuery({ id: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
+                this.#documentAssignmentTaskRepository.withTransaction(tx).loadMany(taskIds),
+            ]);
+            const assignmentDocumentIds = documentCollectionAssignments.map((assignment) => assignment.documentId);
             const requestDocumentIds = requests.map((request) => request.documentId).filter(isNotNull);
-            const documentIds = distinct([...assignmentDocumentIds, ...requestDocumentIds]);
+            const assignmentTaskDocumentIds = assignmentTasks.map((task) => task.documentId);
+            const documentIds = distinct([...assignmentDocumentIds, ...requestDocumentIds, ...assignmentTaskDocumentIds]);
             const [documents, propertyValues] = await Promise.all([
                 this.#documentService.withTransaction(tx).repository.loadManyByQuery({ id: { $in: documentIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
                 this.#documentPropertyService.withTransaction(tx).loadDocumentProperties(documentIds),
@@ -61,7 +68,6 @@ let DocumentManagementService = class DocumentManagementService extends Transact
                 this.#documentFileRepository.withTransaction(tx).loadManyByQuery({ id: { $in: documentFileIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
                 this.#documentWorkflowService.loadLatestWorkflows(workflowRelevantDocumentIds),
             ]);
-            const documentIdMap = getEntityMap(documents);
             const documentWorkflowMap = groupToSingleMap(currentWorkflows, (workflow) => workflow.documentId);
             const valuesMap = Enumerable.from(propertyValues).groupToMap((value) => value.documentId);
             const validationWorkflowIds = currentWorkflows.map((workflow) => (workflow.step == DocumentWorkflowStep.Validation) ? workflow.id : null).filter(isNotNull);
@@ -78,9 +84,16 @@ let DocumentManagementService = class DocumentManagementService extends Transact
             const documentViews = documents.map((document) => {
                 const currentWorkflow = documentWorkflowMap.get(document.id) ?? null;
                 const validations = (isNotNull(currentWorkflow) && (currentWorkflow.step == DocumentWorkflowStep.Validation)) ? workflowValidationMap.get(currentWorkflow.id) ?? [] : null;
+                const assignmentTask = assignmentTasks.find((task) => task.documentId == document.id);
+                const assignmentTaskScope = isDefined(assignmentTask) ? assignmentScopes.filter((scope) => scope.taskId == assignmentTask.id).map((scope) => scope.collectionId) : [];
                 return {
                     ...document,
-                    collectionAssignments: documentAssignments.filter((collectionDocument) => collectionDocument.documentId == document.id),
+                    assignment: {
+                        collections: documentCollectionAssignments.filter((collectionDocument) => collectionDocument.documentId == document.id),
+                        assignmentTask: isDefined(assignmentTask)
+                            ? { target: assignmentTask.target, scope: assignmentTaskScope }
+                            : null,
+                    },
                     properties: valuesMap.get(document.id) ?? [],
                     currentWorkflow,
                     validations,
@@ -88,8 +101,7 @@ let DocumentManagementService = class DocumentManagementService extends Transact
             });
             const requestViews = requests.map((request) => ({
                 ...request,
-                collectionIds: requestAssignments.filter((requestCollection) => requestCollection.requestId == request.id).map((requestCollection) => requestCollection.collectionId),
-                document: isNull(request.documentId) ? null : documentIdMap.get(request.documentId) ?? null,
+                collectionIds: requestAssignments.filter((requestCollection) => requestCollection.requestId == request.id).map((requestCollection) => requestCollection.collectionId)
             }));
             return {
                 collections: collectionViews,

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

@@ -4,6 +4,7 @@ import { afterResolve } from '../../../injector/interfaces.js';
 import { Transactional } from '../../../orm/server/transactional.js';
 export declare class DocumentWorkflowService extends Transactional {
     #private;
+    private readonly documentService;
     readonly repository: import("../../../orm/server/repository.js").EntityRepository<DocumentWorkflow>;
     [afterResolve](_: unknown, { cancellationSignal }: AfterResolveContext<any>): void;
     loadLatestWorkflow(documentId: string): Promise<DocumentWorkflow>;

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

@@ -21,6 +21,8 @@ import { Transactional } from '../../../orm/server/transactional.js';
 import { Queue } from '../../../queue/queue.js';
 import { _throw } from '../../../utils/throw.js';
 import { isNotNull, isNull } from '../../../utils/type-guards.js';
+import { desc, inArray } from 'drizzle-orm';
+import { documentWorkflow } from '../schemas.js';
 import { DocumentCollectionService } from './document-collection.service.js';
 import { DocumentManagementAiService } from './document-management-ai.service.js';
 import { DocumentRequestService } from './document-request.service.js';
@@ -28,13 +30,13 @@ import { DocumentService } from './document.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
 let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflowService extends Transactional {
     #documentManagementAiService = inject(DocumentManagementAiService);
-    #documentService = inject(DocumentService);
     #documentCollectionService = inject(DocumentCollectionService);
     #documentRequestService = inject(DocumentRequestService);
     #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
     #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
     #queue = inject((Queue), { name: 'DocumentWorkflow', processTimeout: 5 * 60 * 1000, maxTries: 3 });
     #logger = inject(Logger, DocumentWorkflowService_1.name);
+    documentService = inject(DocumentService, undefined, { forwardRef: true });
     repository = injectRepository(DocumentWorkflow).withSession(this.session);
     [afterResolve](_, { cancellationSignal }) {
         if (this.isInTransaction) {
@@ -49,7 +51,16 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
         return await this.repository.tryLoadByQuery({ documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
     }
     async loadLatestWorkflows(documentIds) {
-        return await this.repository.loadManyByQuery({ documentId: { $in: documentIds } }, { distinct: ['metadata.createTimestamp', 'documentId'], order: { 'metadata.createTimestamp': 'desc' } });
+        const orderedDocumentWorkflows = this.repository.session.$with('orderedDocumentWorkflows').as((qb) => qb
+            .select()
+            .from(documentWorkflow)
+            .where(inArray(documentWorkflow.documentId, documentIds))
+            .orderBy(desc(documentWorkflow.createTimestamp)));
+        const latestWorkflows = await this.repository.session
+            .with(orderedDocumentWorkflows)
+            .selectDistinctOn([orderedDocumentWorkflows.documentId])
+            .from(orderedDocumentWorkflows);
+        return await this.repository.mapManyToEntity(latestWorkflows);
     }
     async proceedWorkflow(documentId, userId) {
         await this.transaction(async (tx) => {
@@ -104,11 +115,11 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
     }
     async processClassificationWorkflow(workflow) {
         const typeId = await this.#documentManagementAiService.classifyDocumentType(workflow.documentId);
-        await this.#documentService.repository.update(workflow.documentId, { typeId, approval: DocumentApproval.Pending });
+        await this.documentService.repository.update(workflow.documentId, { typeId, approval: DocumentApproval.Pending });
     }
     async processExtractionWorkflow(workflow) {
         const extraction = await this.#documentManagementAiService.extractDocumentInformation(workflow.documentId);
-        await this.#documentService.update(workflow.documentId, extraction);
+        await this.documentService.update(workflow.documentId, extraction);
     }
     async processAssignmentWorkflow(workflow) {
         const assignmentTask = await this.#documentAssignmentTaskRepository.loadByQuery({ documentId: workflow.documentId });