@tstdl/base 0.92.122 → 0.92.124

package/document-management/models/service-models/enriched/enriched.js

@@ -0,0 +1,39 @@
+import { match, P } from 'ts-pattern';
+import { reduce } from '../../../../utils/iterable-helpers/index.js';
+import { _throw } from '../../../../utils/throw.js';
+import { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+export function toEnrichedDocumentManagementData(data) {
+    return new EnrichedDocumentManagementData(data);
+}
+export function calculateRequestsStats(requests) {
+    let open = 0;
+    let pending = 0;
+    let closed = 0;
+    let rejected = 0;
+    let fulfilled = 0;
+    for (const request of requests) {
+        match(request)
+            .with({ state: 'open', document: null }, () => open++)
+            .with({ state: 'open', document: P.nonNullable }, () => pending++)
+            .with({ state: 'closed', document: null }, () => closed++)
+            .with({ state: 'closed', document: { approval: 'rejected' } }, () => rejected++)
+            .with({ state: 'fulfilled', document: { approval: 'approved' } }, () => fulfilled++)
+            .otherwise(() => _throw('Invalid request state'));
+    }
+    return {
+        open,
+        pending,
+        closed,
+        rejected,
+        fulfilled,
+    };
+}
+export function mergeRequestsStats(stats) {
+    return {
+        open: reduce(stats, (a, b) => a + b.open, 0),
+        pending: reduce(stats, (a, b) => a + b.pending, 0),
+        closed: reduce(stats, (a, b) => a + b.closed, 0),
+        rejected: reduce(stats, (a, b) => a + b.rejected, 0),
+        fulfilled: reduce(stats, (a, b) => a + b.fulfilled, 0),
+    };
+}

package/document-management/models/service-models/enriched/index.js

@@ -0,0 +1,9 @@
+export * from './enriched-document-assignment.view.js';
+export * from './enriched-document-category.view.js';
+export * from './enriched-document-collection.view.js';
+export * from './enriched-document-file.view.js';
+export * from './enriched-document-management-data.view.js';
+export * from './enriched-document-request.view.js';
+export * from './enriched-document-type.view.js';
+export * from './enriched-document.view.js';
+export * from './enriched.js';

package/document-management/models/service-models/index.js

@@ -2,7 +2,7 @@ export * from './categories-and-types.view-model.js';
 export * from './document-folders.view-model.js';
 export * from './document-requests-template.view-model.js';
 export * from './document.service-model.js';
-export * from './document.view-model.js';
-export * from './normalized-document-collection-view.model.js';
+export * from './document-management.view-model.js';
+export * from './enriched/index.js';
 export * from './normalized-requests-template-data.model.js';
 export * from './stats.view-model.js';

package/document-management/models/service-models/normalized-requests-template-data.model.js

@@ -1,13 +1,14 @@
-export function toNormalizedDocumentRequestsTemplateData(templateData, documentManagementData) {
+import { assertDefinedPass } from '../../../utils/type-guards.js';
+export function toEnrichedDocumentRequestsTemplateData(templateData, documentManagementData) {
     return {
         templates: templateData.templates.map((template) => ({
             ...template,
             requestTemplates: template.requestTemplates.map((requestTemplate) => ({
                 ...requestTemplate,
-                type: documentManagementData.types.find((type) => type.id == requestTemplate.typeId) ?? null
-            }))
+                type: assertDefinedPass(documentManagementData.maps.types.get(requestTemplate.typeId)),
+            })),
         })),
         categories: documentManagementData.categories,
-        types: documentManagementData.types
+        types: documentManagementData.types,
     };
 }

package/document-management/models/service-models/stats.view-model.js

@@ -8,25 +8,35 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { NumberProperty } from '../../../schema/index.js';
-export class RequestFilesStats {
-    requiredFilesCount;
-    requiredFilesLeft;
-    pendingFilesCount;
-    approvedFilesCount;
+export class RequestStats {
+    total;
+    documentPending;
+    approvalPending;
+    approvals;
+    rejections;
+    closedWithoutDocument;
 }
 __decorate([
     NumberProperty(),
     __metadata("design:type", Number)
-], RequestFilesStats.prototype, "requiredFilesCount", void 0);
+], RequestStats.prototype, "total", void 0);
 __decorate([
     NumberProperty(),
     __metadata("design:type", Number)
-], RequestFilesStats.prototype, "requiredFilesLeft", void 0);
+], RequestStats.prototype, "documentPending", void 0);
 __decorate([
     NumberProperty(),
     __metadata("design:type", Number)
-], RequestFilesStats.prototype, "pendingFilesCount", void 0);
+], RequestStats.prototype, "approvalPending", void 0);
 __decorate([
     NumberProperty(),
     __metadata("design:type", Number)
-], RequestFilesStats.prototype, "approvedFilesCount", void 0);
+], RequestStats.prototype, "approvals", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestStats.prototype, "rejections", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestStats.prototype, "closedWithoutDocument", void 0);

package/document-management/server/module.js

@@ -1,21 +1,17 @@
 import './schemas.js';
 import { inject, Injector } from '../../injector/index.js';
 import { Database, migrate } from '../../orm/server/database.js';
-import { isDefined } from '../../utils/type-guards.js';
-import { DocumentManagementAncillaryService, DocumentManagementService } from './services/index.js';
+import { DocumentManagementAncillaryService } from './services/document-management-ancillary.service.js';
 export class DocumentManagementConfig {
     ancillaryService;
     fileObjectStorageModule;
+    filePreviewObjectStorageModule;
     database;
-    customService;
 }
 ;
 export function configureDocumentManagement(config) {
     Injector.register(DocumentManagementConfig, { useValue: config });
     Injector.register(DocumentManagementAncillaryService, { useToken: config.ancillaryService });
-    if (isDefined(config.customService)) {
-        Injector.register(DocumentManagementService, { useToken: config.customService });
-    }
 }
 export async function migrateDocumentManagementSchema() {
     const connection = inject(DocumentManagementConfig, undefined, { optional: true })?.database?.connection;
@@ -23,6 +19,6 @@ export async function migrateDocumentManagementSchema() {
     await migrate(database, {
         migrationsSchema: 'document_management',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', '')
+        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
     });
 }

package/document-management/server/schemas.js

@@ -1,37 +1,32 @@
 import { databaseSchema } from '../../orm/server/database-schema.js';
-import { DocumentCategory } from '../models/document-category.model.js';
-import { DocumentCollectionDocument } from '../models/document-collection-document.model.js';
-import { DocumentCollection } from '../models/document-collection.model.js';
-import { DocumentFile } from '../models/document-file.model.js';
-import { DocumentPropertyValue, DocumentRequestAssignmentTaskPropertyValue, DocumentRequestFilePropertyValue } from '../models/document-property-value.model.js';
-import { DocumentProperty, DocumentPropertyDataType } from '../models/document-property.model.js';
-import { DocumentRequestAssignmentTaskCollection } from '../models/document-request-assignment-task-collection.model.js';
-import { DocumentRequestAssignmentTask } from '../models/document-request-assignment-task.model.js';
-import { DocumentRequestCollection } from '../models/document-request-collection.model.js';
-import { DocumentRequestFile } from '../models/document-request-file.model.js';
-import { DocumentRequestTemplate } from '../models/document-request-template.js';
-import { DocumentRequest } from '../models/document-request.model.js';
-import { DocumentRequestsTemplate } from '../models/document-requests-template.js';
-import { DocumentTypeProperty } from '../models/document-type-property.model.js';
-import { DocumentType } from '../models/document-type.model.js';
-import { Document } from '../models/document.model.js';
+import { Document, DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTarget, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentRequest, DocumentRequestCollection, DocumentRequestState, DocumentRequestsTemplate, DocumentRequestSubmission, DocumentRequestTemplate, DocumentType, DocumentTypeProperty, DocumentTypeValidation, DocumentValidationDefinition, DocumentValidationExecution, DocumentValidationExecutionRelatedDocument, DocumentValidationExecutionState, DocumentValidationResultStatus, DocumentWorkflow, DocumentWorkflowState, DocumentWorkflowStep } from '../models/index.js';
 export const documentManagementSchema = databaseSchema('document_management');
-export const dataType = documentManagementSchema.getEnum(DocumentPropertyDataType, 'DocumentPropertyDataType');
+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 documentWorkflowState = documentManagementSchema.getEnum(DocumentWorkflowState);
+export const documentWorkflowStep = documentManagementSchema.getEnum(DocumentWorkflowStep);
 export const document = documentManagementSchema.getTable(Document);
+export const documentAssignmentScope = documentManagementSchema.getTable(DocumentAssignmentScope);
+export const documentAssignmentTask = documentManagementSchema.getTable(DocumentAssignmentTask);
 export const documentCategory = documentManagementSchema.getTable(DocumentCategory);
 export const documentCollection = documentManagementSchema.getTable(DocumentCollection);
-export const documentCollectionDocument = documentManagementSchema.getTable(DocumentCollectionDocument);
+export const documentCollectionAssignment = documentManagementSchema.getTable(DocumentCollectionAssignment);
 export const documentFile = documentManagementSchema.getTable(DocumentFile);
 export const documentProperty = documentManagementSchema.getTable(DocumentProperty);
 export const documentPropertyValue = documentManagementSchema.getTable(DocumentPropertyValue);
 export const documentRequest = documentManagementSchema.getTable(DocumentRequest);
-export const documentRequestAssignmentTask = documentManagementSchema.getTable(DocumentRequestAssignmentTask);
-export const documentRequestAssignmentTaskCollection = documentManagementSchema.getTable(DocumentRequestAssignmentTaskCollection);
-export const documentRequestAssignmentTaskPropertyValue = documentManagementSchema.getTable(DocumentRequestAssignmentTaskPropertyValue);
 export const documentRequestCollection = documentManagementSchema.getTable(DocumentRequestCollection);
-export const documentRequestFile = documentManagementSchema.getTable(DocumentRequestFile);
-export const documentRequestFilePropertyValue = documentManagementSchema.getTable(DocumentRequestFilePropertyValue);
 export const documentRequestsTemplate = documentManagementSchema.getTable(DocumentRequestsTemplate);
+export const documentRequestSubmission = documentManagementSchema.getTable(DocumentRequestSubmission);
 export const documentRequestTemplate = documentManagementSchema.getTable(DocumentRequestTemplate);
 export const documentType = documentManagementSchema.getTable(DocumentType);
 export const documentTypeProperty = documentManagementSchema.getTable(DocumentTypeProperty);
+export const documentTypeValidation = documentManagementSchema.getTable(DocumentTypeValidation);
+export const documentValidationDefinition = documentManagementSchema.getTable(DocumentValidationDefinition);
+export const documentValidationExecution = documentManagementSchema.getTable(DocumentValidationExecution);
+export const documentValidationExecutionRelatedDocument = documentManagementSchema.getTable(DocumentValidationExecutionRelatedDocument);
+export const documentWorkflow = documentManagementSchema.getTable(DocumentWorkflow);

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

@@ -0,0 +1,66 @@
+var _a;
+import { DocumentCategory, DocumentType } from '../../../document-management/models/index.js';
+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';
+import { isUndefined } from '../../../utils/type-guards.js';
+export const enumTypeKey = 'enum-type';
+export class DocumentCategoryTypeService extends Transactional {
+    #documentCategoryRepository = injectRepository(DocumentCategory);
+    #documentTypeRepository = injectRepository(DocumentType);
+    #logger = inject(Logger, _a.name);
+    async loadCategory(id) {
+        return this.#documentCategoryRepository.load(id);
+    }
+    async loadType(id) {
+        return this.#documentTypeRepository.load(id);
+    }
+    async createCategory(label, parentId, enumKey) {
+        return this.#documentCategoryRepository.insert({ label, parentId, metadata: { attributes: { [enumTypeKey]: enumKey } } });
+    }
+    async createType(label, categoryId, enumKey) {
+        return this.#documentTypeRepository.insert({ label, categoryId, metadata: { attributes: { [enumTypeKey]: enumKey } } });
+    }
+    async updateCategory(id, update) {
+        return this.#documentCategoryRepository.update(id, update);
+    }
+    async updateType(id, update) {
+        return this.#documentTypeRepository.update(id, update);
+    }
+    async loadCategoryGraph(categoryId) {
+        const category = await this.#documentCategoryRepository.load(categoryId);
+        if (category.parentId == null) {
+            return [category];
+        }
+        const parents = await this.loadCategoryGraph(category.parentId);
+        return [...parents, category];
+    }
+    async loadCategoriesAndTypes() {
+        const [categories, types] = await Promise.all([
+            this.#documentCategoryRepository.loadManyByQuery({}, { order: 'label' }),
+            this.#documentTypeRepository.loadManyByQuery({}, { order: 'label' }),
+        ]);
+        return { categories, types };
+    }
+    async loadCategoryViews() {
+        const { categories, types } = await this.loadCategoriesAndTypes();
+        const categoryChildrenMap = groupToMap(categories, (category) => category.parentId);
+        const categoryTypesMap = groupToMap(types, (type) => type.categoryId);
+        const rootCategories = categoryChildrenMap.get(null);
+        if (isUndefined(rootCategories)) {
+            return [];
+        }
+        return rootCategories.map((category) => getView(category, categoryChildrenMap, categoryTypesMap));
+    }
+}
+_a = DocumentCategoryTypeService;
+function getView(category, categoryChildrenMap, categoryTypesMap) {
+    const childCategories = categoryChildrenMap.get(category.id) ?? [];
+    return {
+        ...category,
+        children: childCategories.map((c) => getView(c, categoryChildrenMap, categoryTypesMap)),
+        types: categoryTypesMap.get(category.id) ?? [],
+    };
+}

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

@@ -0,0 +1,41 @@
+import { and, eq, sql } from 'drizzle-orm';
+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 { Document, DocumentCollection, DocumentCollectionAssignment } from '../../models/index.js';
+import { document, documentCollectionAssignment } from '../schemas.js';
+export class DocumentCollectionService extends Transactional {
+    #documentRepository = injectRepository(Document);
+    #documentCollectionAssignmentRepository = injectRepository(DocumentCollectionAssignment);
+    repository = injectRepository(DocumentCollection);
+    async loadCollectionGraph(collectionId) {
+        const collection = await this.repository.load(collectionId);
+        if (collection.parentId == null) {
+            return [collection];
+        }
+        const parents = await this.loadCollectionGraph(collection.parentId);
+        return [...parents, collection];
+    }
+    async createCollection(parentId) {
+        return this.repository.withSession(this.session).insert({ parentId });
+    }
+    async collectionHasDocumentByFilter(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)));
+        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 }));
+        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 });
+    }
+}

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

@@ -0,0 +1,204 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var _a;
+import sharp, {} from 'sharp';
+import { match } from 'ts-pattern';
+import { AiService } from '../../../ai/ai.service.js';
+import { NotImplementedError } from '../../../errors/not-implemented.error.js';
+import { getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
+import { TemporaryFile } from '../../../file/server/index.js';
+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 { digest } from '../../../utils/cryptography.js';
+import { currentTimestamp } from '../../../utils/date-time.js';
+import { readableStreamFromPromise, readBinaryStream } from '../../../utils/stream/index.js';
+import { isDefined, isUint8Array } from '../../../utils/type-guards.js';
+import { millisecondsPerMinute } from '../../../utils/units.js';
+import { Document, DocumentFile } from '../../models/index.js';
+import { DocumentManagementConfig } from '../module.js';
+export class DocumentFileService extends Transactional {
+    #documentFileRepository = injectRepository(DocumentFile);
+    #documentRepository = injectRepository(Document);
+    #aiService = inject(AiService);
+    #fileObjectStorage = inject(ObjectStorage, inject(DocumentManagementConfig).fileObjectStorageModule);
+    #filePreviewObjectStorage = inject(ObjectStorage, inject(DocumentManagementConfig).filePreviewObjectStorageModule);
+    #logger = inject(Logger, _a.name);
+    #aiFilePartCache = new Map();
+    async load(id) {
+        return this.#documentFileRepository.load(id);
+    }
+    async create(content, originalFileName) {
+        const contentAsUint8Array = isUint8Array(content) ? content : await readBinaryStream(content);
+        const hash = await digest('SHA-256', contentAsUint8Array).toHex();
+        const mimeType = await getMimeType(contentAsUint8Array);
+        return this.transaction(async (tx) => {
+            const documentFile = await this.#documentFileRepository
+                .withTransaction(tx)
+                .insert({
+                originalFileName,
+                mimeType,
+                hash,
+                size: contentAsUint8Array.length,
+            });
+            const key = getDocumentFileKey(documentFile.id);
+            await this.#fileObjectStorage.uploadObject(key, contentAsUint8Array);
+            return documentFile;
+        });
+    }
+    async getContent(fileId) {
+        const key = getDocumentFileKey(fileId);
+        return this.#fileObjectStorage.getContent(key);
+    }
+    getContentStream(fileId) {
+        const key = getDocumentFileKey(fileId);
+        return this.#fileObjectStorage.getContentStream(key);
+    }
+    async getContentUrl(fileId, title, download = false) {
+        const file = await this.#documentFileRepository.load(fileId);
+        return this.getDocumentFileContentObjectUrl(title ?? fileId, file, download);
+    }
+    async getPreview(fileId, page = 1) {
+        const key = getDocumentFileKey(fileId);
+        await this.createPreviewIfNotExists(fileId, page);
+        return this.#filePreviewObjectStorage.getContent(key);
+    }
+    getPreviewStream(fileId, page = 1) {
+        return readableStreamFromPromise(async () => {
+            const key = getDocumentFileKey(fileId);
+            await this.createPreviewIfNotExists(fileId, page);
+            return this.#filePreviewObjectStorage.getContentStream(key);
+        });
+    }
+    async getPreviewUrl(fileId, page = 1) {
+        const key = getDocumentFileKey(fileId);
+        await this.createPreviewIfNotExists(fileId, page);
+        return this.#filePreviewObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
+            'Response-Content-Type': 'image/jpeg',
+        });
+    }
+    async getAiFileContentPart(documentId) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const document = await this.#documentRepository.load(documentId);
+            const cachedAiFilePart = this.#aiFilePartCache.get(document.fileId);
+            if (isDefined(cachedAiFilePart)) {
+                if (cachedAiFilePart.timestamp > (currentTimestamp() - (5 * millisecondsPerMinute))) {
+                    return cachedAiFilePart.part;
+                }
+                this.#aiFilePartCache.delete(documentId);
+            }
+            const file = await this.load(document.fileId);
+            const fileContentStream = this.getContentStream(document.id);
+            const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
+            const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: file.mimeType });
+            this.#aiFilePartCache.set(document.fileId, { part: filePart, timestamp: currentTimestamp() });
+            return filePart;
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    async createPreviewIfNotExists(fileId, page = 1) {
+        const key = getDocumentFileKey(fileId);
+        const hasPreview = await this.#filePreviewObjectStorage.exists(key);
+        if (!hasPreview) {
+            const file = await this.#documentFileRepository.load(fileId);
+            const content = await this.#fileObjectStorage.getContent(key);
+            const image = await match(file.mimeType)
+                .with('application/pdf', async () => {
+                const imageBytes = await pdfToImage(content, page, 768, 'jpeg');
+                return imageToPreview(imageBytes);
+            })
+                .with('image/*', async () => 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' } });
+        }
+    }
+    async getDocumentFileContentObjectUrl(title, file, download) {
+        const key = getDocumentFileKey(file.id);
+        const fileExtension = getMimeTypeExtensions(file.mimeType)[0] ?? 'bin';
+        const disposition = download ? 'attachment' : 'inline';
+        const filename = `${title}.${fileExtension}`;
+        return this.#fileObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
+            'Response-Content-Type': file.mimeType,
+            'Response-Content-Disposition': `${disposition}; filename = "${encodeURIComponent(filename)}"`,
+        });
+    }
+}
+_a = DocumentFileService;
+function getDocumentFileKey(id) {
+    return `${id.slice(0, 2)}/${id.slice(0, 4)}/${id}`;
+}
+async function imageToPreview(input) {
+    return sharp(input)
+        .resize({
+        width: 768,
+        height: 768,
+        fit: 'cover',
+        position: 'top',
+        withoutEnlargement: true,
+        fastShrinkOnLoad: false,
+    })
+        .toFormat('jpeg', { quality: 75 })
+        .toBuffer();
+}