@tstdl/base 0.93.61 → 0.93.64

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

@@ -8,6 +8,13 @@
       "when": 1750253838549,
       "tag": "0000_ordinary_pretty_boy",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1764857079867,
+      "tag": "0001_lyrical_wong",
+      "breakpoints": true
     }
   ]
 }

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

@@ -7,29 +7,29 @@ export declare class DocumentCategoryTypeService extends Transactional {
     loadCategory(tenantId: string, id: string): Promise<DocumentCategory>;
     loadType(tenantId: string, id: string): Promise<DocumentType>;
     createCategory(data: {
-        tenantId: string | null;
+        tenantId: string;
         label: string;
         parentId: string | null;
         enumKey?: string;
     }): Promise<DocumentCategory>;
     createType(data: {
-        tenantId: string | null;
+        tenantId: string;
         label: string;
         categoryId: string;
         enumKey?: string;
     }): Promise<DocumentType>;
-    updateCategory(tenantId: string | null, id: string, update: {
+    updateCategory(tenantId: string, id: string, update: {
         label?: string;
         parentId?: string | null;
     }): Promise<DocumentCategory>;
-    updateType(tenantId: string | null, id: string, update: {
+    updateType(tenantId: string, id: string, update: {
         label?: string;
         categoryId?: string;
     }): Promise<DocumentType>;
     loadCategoryGraph(tenantId: string, categoryId: string): Promise<DocumentCategory[]>;
-    loadCategoriesAndTypes(tenantId: string | null): Promise<{
+    loadCategoriesAndTypes(tenantId: string): Promise<{
         categories: DocumentCategory[];
         types: DocumentType[];
     }>;
-    loadCategoryViews(tenantId: string | null): Promise<DocumentCategoryView[]>;
+    loadCategoryViews(tenantId: string): Promise<DocumentCategoryView[]>;
 }

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

@@ -14,10 +14,10 @@ let DocumentCategoryTypeService = class DocumentCategoryTypeService extends Tran
     categoryRepository = injectRepository(DocumentCategory);
     typeRepository = injectRepository(DocumentType);
     async loadCategory(tenantId, id) {
-        return await this.categoryRepository.loadByQuery({ id, tenantId: { $or: [null, tenantId] } });
+        return await this.categoryRepository.loadByQuery({ tenantId, id });
     }
     async loadType(tenantId, id) {
-        return await this.typeRepository.loadByQuery({ id, tenantId: { $or: [null, tenantId] } });
+        return await this.typeRepository.loadByQuery({ tenantId, id });
     }
     async createCategory(data) {
         return await this.categoryRepository.insert({
@@ -29,7 +29,7 @@ let DocumentCategoryTypeService = class DocumentCategoryTypeService extends Tran
     }
     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 });
+        await this.categoryRepository.loadByQuery({ tenantId: data.tenantId, id: data.categoryId });
         return await this.typeRepository.insert({
             tenantId: data.tenantId,
             label: data.label,
@@ -44,7 +44,7 @@ let DocumentCategoryTypeService = class DocumentCategoryTypeService extends Tran
         return await this.typeRepository.updateByQuery({ tenantId, id }, update);
     }
     async loadCategoryGraph(tenantId, categoryId) {
-        const category = await this.categoryRepository.loadByQuery({ tenantId: { $or: [null, tenantId] }, id: categoryId });
+        const category = await this.categoryRepository.loadByQuery({ tenantId, id: categoryId });
         if (category.parentId == null) {
             return [category];
         }
@@ -53,8 +53,8 @@ let DocumentCategoryTypeService = class DocumentCategoryTypeService extends Tran
     }
     async loadCategoriesAndTypes(tenantId) {
         const [categories, types] = await Promise.all([
-            this.categoryRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } }, { order: 'label' }),
-            this.typeRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } }, { order: 'label' }),
+            this.categoryRepository.loadManyByQuery({ tenantId }, { order: 'label' }),
+            this.typeRepository.loadManyByQuery({ tenantId }, { order: 'label' }),
         ]);
         return { categories, types };
     }

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

@@ -29,6 +29,8 @@ export declare class DocumentFileService extends Transactional {
     getContent(document: Document): Promise<Uint8Array>;
     getContentStream(document: Document): ReadableStream<Uint8Array>;
     getContentUrl(document: Document, download?: boolean): Promise<string>;
+    /** Gets the underlying object storage object for the document file */
+    getObject(document: Document): Promise<import("../../../object-storage/index.js").ObjectStorageObject>;
     getPreview(document: Document, page?: number): Promise<Uint8Array>;
     getPreviewStream(document: Document, page?: number): ReadableStream<Uint8Array>;
     getPreviewUrl(document: Document, page?: number): Promise<string>;

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

@@ -56,8 +56,6 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-var _a;
-var DocumentFileService_1;
 import sharp, {} from 'sharp';
 import { match } from 'ts-pattern';
 import { AiService } from '../../../ai/ai.service.js';
@@ -66,7 +64,6 @@ import { NotImplementedError } from '../../../errors/not-implemented.error.js';
 import { getMimeType, getMimeTypeExtensions, mimeTypes } 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 { pdfToImage } from '../../../pdf/index.js';
@@ -80,13 +77,12 @@ import { millisecondsPerMinute, secondsPerMinute } from '../../../utils/units.js
 import { Document } from '../../models/index.js';
 import { DocumentManagementConfiguration } from '../module.js';
 import { DocumentManagementSingleton } from './singleton.js';
-let DocumentFileService = DocumentFileService_1 = class DocumentFileService extends Transactional {
+let DocumentFileService = class DocumentFileService extends Transactional {
     #configuration = inject(DocumentManagementConfiguration);
     #aiService = inject(AiService);
     #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();
     /**
      * Initiates a file upload
@@ -145,6 +141,11 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
     async getContentUrl(document, download = false) {
         return await this.getDocumentFileContentObjectUrl(document, document.title ?? document.id, download);
     }
+    /** Gets the underlying object storage object for the document file */
+    async getObject(document) {
+        const objectKey = getObjectKey(document.id);
+        return await this.#fileObjectStorage.getObject(objectKey);
+    }
     async getPreview(document, page = 1) {
         const objectKey = getObjectKey(document.id);
         await this.createPreviewIfNotExists(document, page);
@@ -197,12 +198,12 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
             const content = await this.#fileObjectStorage.getContent(key);
             const image = await match(document.mimeType)
                 .with('application/pdf', async () => {
-                const imageBytes = await pdfToImage(content, page, 768, 'jpeg');
+                const imageBytes = await pdfToImage(content, page, 768, 'png');
                 return await imageToPreview(imageBytes);
             })
                 .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, contentType: 'image/jpeg' });
+            await this.#filePreviewObjectStorage.uploadObject(key, image, { contentLength: image.length, contentType: 'image/webp' });
         }
     }
     async getDocumentFileContentObjectUrl(document, title, download) {
@@ -216,7 +217,7 @@ let DocumentFileService = DocumentFileService_1 = class DocumentFileService exte
         });
     }
 };
-DocumentFileService = DocumentFileService_1 = __decorate([
+DocumentFileService = __decorate([
     DocumentManagementSingleton()
 ], DocumentFileService);
 export { DocumentFileService };
@@ -233,6 +234,6 @@ async function imageToPreview(input) {
         withoutEnlargement: true,
         fastShrinkOnLoad: false,
     })
-        .toFormat('jpeg', { quality: 75 })
+        .toFormat('webp', { quality: 75 })
         .toBuffer();
 }

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

@@ -15,6 +15,7 @@ export type DocumentInformationExtractionResult = {
 };
 export declare class DocumentManagementAiService {
     #private;
+    extractDocumentContent(tenantId: string, documentId: string): Promise<string>;
     classifyDocumentType(tenantId: string, documentId: string): Promise<string>;
     extractDocumentInformation(tenantId: string, documentId: string): Promise<DocumentInformationExtractionResult>;
     findSuitableCollectionsForDocument(document: Document, collectionIds: string[]): Promise<string[]>;