@tstdl/base 0.93.61 → 0.93.64

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

@@ -58,9 +58,11 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 var _a;
 var DocumentManagementAiService_1;
+import { readFile } from 'node:fs/promises';
 import { and, isNull as drizzleIsNull, eq, inArray } from 'drizzle-orm';
 import { P, match } from 'ts-pattern';
-import { AiService } from '../../../ai/index.js';
+import { convertToGenkitSchema, genkitGenerationOptions, injectGenkit, injectModel } from '../../../ai/genkit/index.js';
+import { formatData, formatInstructions, orderedList } from '../../../ai/prompts/index.js';
 import { TemporaryFile } from '../../../file/server/index.js';
 import { inject } from '../../../injector/inject.js';
 import { Logger } from '../../../logger/logger.js';
@@ -68,7 +70,7 @@ import { arrayAgg } from '../../../orm/index.js';
 import { injectRepository } from '../../../orm/server/index.js';
 import { array, boolean, enumeration, integer, nullable, number, object, string } from '../../../schema/index.js';
 import { distinct } from '../../../utils/array/index.js';
-import { numericDateToDateObject, tryDateObjectToNumericDate } from '../../../utils/date-time.js';
+import { numericDateToDateTime, tryDateObjectToNumericDate } from '../../../utils/date-time.js';
 import { fromEntries, objectEntries } from '../../../utils/object/object.js';
 import { assertDefined, assertDefinedPass, assertNotNull, isNotNull, isNull, isUndefined } from '../../../utils/type-guards.js';
 import { Document, DocumentProperty, DocumentRequestState, DocumentTypeProperty } from '../../models/index.js';
@@ -79,84 +81,232 @@ import { DocumentFileService } from './document-file.service.js';
 import { DocumentPropertyService } from './document-property.service.js';
 import { DocumentTagService } from './document-tag.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
-const CLASSIFY_MODEL = 'small';
-const EXTRACT_MODEL = 'medium';
-const ASSIGN_MODEL = 'small';
+// --- Prompts ---
+const ocrSystemPrompt = `
+You are an expert OCR and Document Digitization engine.
+
+${formatInstructions({
+    'Primary Objective': 'Convert the provided document into semantically structured, clean Markdown.',
+    'Critical Constraints': orderedList([
+        'Output ONLY the Markdown content. Do not include introductory text, conversational filler, or code block fences (```).',
+        'Do not describe the visual appearance (e.g., "This looks like an invoice"). Transcribe the content only.',
+    ]),
+    'Formatting Rules': orderedList({
+        'Headings': 'Use # for the main document title (once). Use ##, ### for sections based on logical hierarchy.',
+        'Text Content': 'Transcribe text verbatim. Do not correct spelling or grammar, summarize, or rewrite.',
+        'Tables': 'Strictly use Markdown table syntax. Align columns logically based on the visual grid.',
+        'Lists': 'Detect bullet points and numbered lists and format them as Markdown lists.',
+        'Emphasis': 'Use **bold** and _italics_ only where visually distinct in the source.',
+        'Columns': 'Read multi-column text as a single continuous flow.',
+    }),
+    'Complex Elements': {
+        'Images/Visuals': 'Replace non-textual diagrams with `> [Visual: Brief description of the image/chart]`.',
+        'Signatures': 'Mark distinct signatures as `> [Signature: {Name if legible/Context}]`.',
+        'Forms': 'Represent checkboxes as `[ ]` (unchecked) or `[x]` (checked). Format label/value pairs on separate lines or as a definition list if applicable.',
+        'Math': 'Transcribe equations using LaTeX syntax enclosed in `$...$` for inline or `$$...$$` for block equations.',
+    },
+    'Page Handling': [
+        'Metadata: Start every page with `<!-- Page {n} Start -->` and end with `<!-- Page {n} End -->` on separate lines.',
+        'Artifacts: Exclude running headers, footers, and page numbers unless they contain unique data not found elsewhere.',
+    ],
+    'Error Handling': [
+        'Mark illegible text as `[Illegible]`.',
+        'Mark cut-off text as `[Cut off]`.',
+    ],
+})}
+`.trim();
+const ocrUserPrompt = 'Transcribe the attached document into Markdown following the system instructions.';
+const classifySystemPrompt = `
+You are a Document Taxonomy Specialist.
+
+${formatInstructions({
+    'Task': `Analyze the visual layout and text content of the document to categorize it into exactly one of the provided hierarchical types.`,
+    'Input Context': 'You will be provided with a list of valid category labels (e.g., "Finance -> Invoice").',
+    'Analysis Strategy': orderedList([
+        'Scan the header and title for explicit document type names (e.g., "Invoice", "Contract", "Bill of Lading").',
+        'Analyze the layout structure (e.g., columns often imply Invoices/Receipts; dense paragraphs imply Contracts/Letters).',
+        'Identify key entities (e.g., "Total Due" implies financial; "Signed by" implies legal).',
+    ]),
+    'Selection Logic': orderedList([
+        'Exact Match: If the document explicitly states its type, select the corresponding category.',
+        'Content Match: If implicit, match the intent.',
+        'Specificity: Always choose the most specific leaf-node category available.',
+        'Fallback: If ambiguous, choose the category that best describes the *primary* purpose of the document.',
+    ]),
+})}
+`.trim();
+const classifyUserPrompt = 'Determine the single most accurate document type from the provided list based on the document following the system instructions.';
+const extractSystemPrompt = `
+You are a Structured Data Extraction Analyst.
+
+${formatInstructions({
+    'Task': 'Analyze the document and extract metadata into the defined JSON schema.',
+    'General Guidelines': orderedList({
+        'Language': 'Ensure all generated text (titles, summaries) matches the primary language of the document.',
+        'Null Handling': 'If a specific field or property is not present in the document, return null. Do not guess or hallucinate values.',
+    }),
+    'Field Specific Instructions': {
+        'Title': 'Create a concise, searchable filename-style title (e.g., "Invoice - Oct 2023").',
+        'Subtitle': 'Extract context usually found below the header (e.g., Project Name, Reference Number).',
+        'Summary': 'Write a 2-3 sentence executive summary. Mention the what type of information can be found in the document and its purpose.',
+        'Tags': 'Generate 3-5 keywords for categorization. Only use important information missing in title, subtitle and properties. Prioritize reusing of existing tags where possible.',
+        'Date': 'Identify the *creation* date of the document. If multiple dates exist, prioritize the primary date (like invoice or letter Date)',
+    },
+    'Property Extraction': [
+        'You will be given a list of specific dynamic properties to look for.',
+        'Extract values *exactly* as they appear for strings.',
+        'Normalize numbers and dates to standard formats.',
+        'If a property is ambiguous, favor the value most prominent in the document layout.',
+        'If a property is missing, set its value to null.',
+    ],
+})}`.trim();
+const extractUserPrompt = 'Analyze the document and extract metadata and specific properties defined in the output schema following the system instructions.';
+const assignCollectionSystemPrompt = `
+You are a Digital Filing Assistant.
+
+${formatInstructions({
+    'Task': `Assign the document to relevant collections based on its metadata and content.`,
+    'Input': 'Document Metadata and a list of Available Collections.',
+    'Matching Logic': orderedList([
+        'Direct Key-Match: Look for exact keyword matches between the collection name and the document metadata.',
+        'Semantic Fit: Determine if the document functionally belongs to a group.',
+        'Project Association: If the document references a specific project code or name found in a collection name, assign it there.',
+    ]),
+    'Output': 'Return an array of matching collection IDs. If no collection is a strong fit, return an empty array.',
+})}
+`.trim();
+const assignCollectionUserPrompt = 'Select the most appropriate collections for this document from the provided list following the system instructions.';
+const assignRequestSystemPrompt = `
+You are a Workflow Routing Agent.
+
+${formatInstructions({
+    'Task': 'Match the provided document to an existing Open Document Request.',
+    'Input': 'Document Metadata and a list of Open Requests.',
+    'Matching Rules': orderedList({
+        'Hard Constraints': 'If a Request has a "Comment" or specific property requirement, the document MUST fulfill it strictly (e.g., "Need bill from July" must match date).',
+        'Ambiguity': 'If multiple requests match, select the one with the most specific constraints that are satisfied.',
+        'Negative Match': 'If the document satisfies the metadata but violates a comment constraint, it is unsuitable.',
+    }),
+    'Output': 'The ID of the matching request, or null if no request matches.',
+})}
+`.trim();
+const assignRequestUserPrompt = 'Evaluate the document against the list of open requests and find the best match following the system instructions.';
 let DocumentManagementAiService = DocumentManagementAiService_1 = class DocumentManagementAiService {
+    #genkit = injectGenkit();
+    #ocrModel = injectModel('gemini-2.5-flash-lite').withConfig({ temperature: 0.25, topP: 0.75, topK: 8 });
+    #classifyModel = injectModel('gemini-2.5-flash').withConfig({ temperature: 0.25, topP: 0.75, topK: 8 });
+    #extractModel = injectModel('gemini-2.5-flash').withConfig({ temperature: 0.25, topP: 0.75, topK: 8 });
+    #assignModel = injectModel('gemini-2.5-flash').withConfig({ temperature: 0.25, topP: 0.75, topK: 8 });
     #documentCollectionService = inject(DocumentCollectionService);
     #documentTagService = inject(DocumentTagService);
     #documentCategoryTypeService = inject(DocumentCategoryTypeService);
     #documentFileService = inject(DocumentFileService);
     #documentPropertyService = inject(DocumentPropertyService);
-    #aiService = inject(AiService);
     #documentPropertyRepository = injectRepository(DocumentProperty);
     #documentRepository = injectRepository(Document);
     #documentTypePropertyRepository = injectRepository(DocumentTypeProperty);
     #logger = inject(Logger, DocumentManagementAiService_1.name);
-    async classifyDocumentType(tenantId, documentId) {
+    async extractDocumentContent(tenantId, documentId) {
         const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
+            const fileContentStream = this.#documentFileService.getContentStream(document);
+            const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
+            const buffer = await readFile(tmpFile.path);
+            const base64Data = buffer.toString('base64');
+            const dataUrl = `data:${document.mimeType};base64,${base64Data}`;
+            this.#logger.trace(`Extracting content from document ${document.id}`);
+            const result = await this.#genkit.generate({
+                model: this.#ocrModel,
+                output: { schema: convertToGenkitSchema(object({ content: string() })) },
+                system: ocrSystemPrompt,
+                prompt: [
+                    { media: { url: dataUrl } },
+                    { text: ocrUserPrompt },
+                ],
+            });
+            if (isNull(result.output)) {
+                throw new Error(`AI returned null output for document "${document.id}".`);
+            }
+            return result.output.content;
+        }
+        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 classifyDocumentType(tenantId, documentId) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
         try {
             const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
             if (isNotNull(document.typeId)) {
                 return document.typeId;
             }
             const fileContentStream = this.#documentFileService.getContentStream(document);
-            const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
-            const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: document.mimeType });
+            const tmpFile = __addDisposableResource(env_2, await TemporaryFile.from(fileContentStream), true);
+            const buffer = await readFile(tmpFile.path);
+            const base64Data = buffer.toString('base64');
+            const dataUrl = `data:${document.mimeType};base64,${base64Data}`;
             const categories = await this.#documentCategoryTypeService.loadCategoryViews(tenantId);
             const typeLabelEntries = getDescriptiveTypeLabels(categories);
             const typeLabels = typeLabelEntries.map(({ label }) => label);
             this.#logger.trace(`Classifying document ${document.id}`);
-            const documentTypeGeneration = await this.#aiService.generate({
-                model: CLASSIFY_MODEL,
-                generationOptions: {
+            const result = await this.#genkit.generate(genkitGenerationOptions({
+                model: this.#classifyModel,
+                config: {
                     maxOutputTokens: 128,
-                    temperature: 0.1,
-                    topP: 0.75,
-                    topK: 4,
-                    thinkingBudget: 0,
+                    thinkingConfig: { thinkingBudget: 0 },
                 },
-                generationSchema: object({
-                    documentType: enumeration(typeLabels),
-                }),
-                contents: [
-                    {
-                        role: 'user',
-                        parts: [
-                            { file: filePart.file },
-                            { text: `Klassifiziere den Inhalt des Dokuments in das angegebenen JSON Schema.` },
-                        ],
-                    },
+                output: {
+                    schema: object({
+                        documentType: enumeration(typeLabels),
+                    }),
+                },
+                system: classifySystemPrompt,
+                prompt: [
+                    { media: { url: dataUrl } },
+                    { text: classifyUserPrompt },
                 ],
-            });
-            const typeId = typeLabelEntries.find((entry) => entry.label == documentTypeGeneration.json.documentType)?.id;
+            }));
+            if (isNull(result.output)) {
+                throw new Error(`AI returned null output for document classification "${document.id}".`);
+            }
+            const output = result.output;
+            const typeId = typeLabelEntries.find((entry) => entry.label == output.documentType)?.id;
             assertDefined(typeId, `Could not classify document ${document.id}`);
             return typeId;
         }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
         }
         finally {
-            const result_1 = __disposeResources(env_1);
-            if (result_1)
-                await result_1;
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
         }
     }
     async extractDocumentInformation(tenantId, documentId) {
-        const env_2 = { stack: [], error: void 0, hasError: false };
+        const env_3 = { stack: [], error: void 0, hasError: false };
         try {
             const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
             const existingTags = await this.#documentTagService.loadTags(tenantId);
             const fileContentStream = this.#documentFileService.getContentStream(document);
-            const tmpFile = __addDisposableResource(env_2, await TemporaryFile.from(fileContentStream), true);
-            const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: document.mimeType });
+            const tmpFile = __addDisposableResource(env_3, await TemporaryFile.from(fileContentStream), true);
+            const buffer = await readFile(tmpFile.path);
+            const base64Data = buffer.toString('base64');
+            const dataUrl = `data:${document.mimeType};base64,${base64Data}`;
             if (isNull(document.typeId)) {
                 throw new Error(`Document ${document.id} has no type`);
             }
-            const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, typeId: document.typeId });
+            const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId, typeId: document.typeId });
             const propertyIds = typeProperties.map((property) => property.propertyId);
-            const properties = (propertyIds.length > 0) ? await this.#documentPropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, id: { $in: propertyIds } }) : undefined;
+            const properties = (propertyIds.length > 0) ? await this.#documentPropertyRepository.loadManyByQuery({ tenantId, id: { $in: propertyIds } }) : undefined;
             const propertiesSchemaEntries = properties?.map((property) => {
                 const schema = match(property.dataType)
                     .with('text', () => nullable(string()))
@@ -177,39 +327,31 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
                     ? {}
                     : { documentProperties: object(fromEntries(propertiesSchemaEntries)) }),
             });
-            const context = { existingTags };
+            const tagLabels = existingTags.map((tag) => tag.label);
             this.#logger.trace(`Extracting document ${document.id}`);
-            const { json: extraction } = await this.#aiService.generate({
-                model: EXTRACT_MODEL,
-                generationOptions: {
+            const result = await this.#genkit.generate(genkitGenerationOptions({
+                model: this.#extractModel,
+                output: { schema: generationSchema },
+                config: {
                     maxOutputTokens: 2048,
-                    temperature: 0.2,
-                    topP: 0.5,
-                    topK: 16,
-                    thinkingBudget: 0,
+                    thinkingConfig: { thinkingBudget: 0 },
                 },
-                generationSchema,
-                contents: [
+                system: extractSystemPrompt,
+                prompt: [
+                    { media: { url: dataUrl } },
                     {
-                        role: 'user',
-                        parts: [
-                            { file: filePart.file },
-                            {
-                                text: `<context>
-${JSON.stringify(context, null, 2)}
-</context>
-              Extrahiere den Inhalt des Dokuments in das angegebenen JSON Schema.
+                        text: `
+${formatData({ existingTags: tagLabels })}
 
-Vermeide es, den Titel im Untertitel zu wiederholen.
-Gib in der summary ausführlich an, welche Informationen in dem Dokument vorkommen (ohne konkrete Werte).
-Erstelle bis zu 5 Tags. Verwende vorhandene Tags, wenn sie passen. Erstelle neue Tags, wenn es keine passenden gibt.
-Vermeide es, den Titel oder Untertitel als Tag zu verwenden.
-Antworte auf deutsch.`,
-                            },
-                        ],
+${extractUserPrompt}
+`.trim(),
                     },
                 ],
-            });
+            }));
+            if (isNull(result.output)) {
+                throw new Error(`AI returned null output for document extraction "${document.id}".`);
+            }
+            const extraction = result.output;
             const filteredDocumentTags = extraction.documentTags.filter((tag) => (tag != extraction.documentTitle) && (tag != extraction.documentSubtitle));
             const date = isNotNull(extraction.documentDate) ? tryAiOutputDateObjectToNumericDate(extraction.documentDate) : null;
             const parsedProperties = isUndefined(extraction.documentProperties)
@@ -238,14 +380,14 @@ Antworte auf deutsch.`,
                 properties: parsedProperties,
             };
         }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
         }
         finally {
-            const result_2 = __disposeResources(env_2);
-            if (result_2)
-                await result_2;
+            const result_3 = __disposeResources(env_3);
+            if (result_3)
+                await result_3;
         }
     }
     async findSuitableCollectionsForDocument(document, collectionIds) {
@@ -261,41 +403,36 @@ Antworte auf deutsch.`,
         }));
         const documentTagLabels = documentTags.map((tag) => tag.label);
         const propertyEntries = documentProperties.map((property) => [property.label, property.value]);
-        const context = {
-            document: {
-                title: document.title ?? undefined,
-                subtitle: document.subtitle ?? undefined,
-                date: isNotNull(document.date) ? numericDateToDateObject(document.date) : undefined,
-                summary: document.summary ?? undefined,
-                tags: (documentTagLabels.length > 0) ? documentTagLabels : undefined,
-                properties: fromEntries(propertyEntries),
-            },
-            collections,
+        const documentData = {
+            title: document.title ?? null,
+            subtitle: document.subtitle ?? null,
+            date: isNotNull(document.date) ? numericDateToDateTime(document.date).toISODate() : null,
+            tags: (documentTagLabels.length > 0) ? documentTagLabels : null,
+            summary: document.summary ?? null,
         };
-        const result = await this.#aiService.generate({
-            model: ASSIGN_MODEL,
-            generationOptions: {
-                maxOutputTokens: 100,
-                temperature: 0,
-                topP: 0.2,
-                topK: 16,
-                thinkingBudget: 0,
+        const result = await this.#genkit.generate(genkitGenerationOptions({
+            model: this.#assignModel,
+            output: { schema: object({ collectionIds: array(string()) }) },
+            config: {
+                maxOutputTokens: 512,
+                thinkingConfig: {
+                    thinkingBudget: 0,
+                },
             },
-            generationSchema: object({ collectionIds: array(string()) }),
-            contents: [{
-                    role: 'user',
-                    parts: [
-                        {
-                            text: `<context>
-${JSON.stringify(context, null, 2)}
-</context>
+            system: assignCollectionSystemPrompt,
+            prompt: [{
+                    text: `
+${formatData({ document: documentData, documentProperties: fromEntries(propertyEntries) })}
+
+${formatData({ collections })}
 
-Ordne das Dokument unter "document" einer oder mehreren passenden Collection unter "collections" zu. Gib es als JSON im angegebenen Schema aus. Wenn keine Collection passt, gib collectionIds als leeres Array zurück.`,
-                        },
-                    ],
+${assignCollectionUserPrompt}`,
                 }],
-        });
-        return result.json.collectionIds;
+        }));
+        if (isNull(result.output)) {
+            throw new Error(`AI returned null output for collection assignment "${document.id}".`);
+        }
+        return result.output.collectionIds;
     }
     async findSuitableRequestForDocument(document, collectionIds) {
         const session = this.#documentPropertyRepository.session;
@@ -322,44 +459,40 @@ Ordne das Dokument unter "document" einer oder mehreren passenden Collection unt
         const requests = openRequestsWithoutDocument.map((request) => ({
             id: request.id,
             collections: request.collectionIds.map((collectionId) => assertDefinedPass(collectionNamesMap[collectionId]).name),
-            comment: request.comment ?? undefined,
+            comment: request.comment ?? null,
         }));
         const propertyEntries = documentProperties.map((property) => [property.label, property.value]);
-        const context = {
-            document: {
-                title: document.title ?? undefined,
-                subtitle: document.subtitle ?? undefined,
-                date: isNotNull(document.date) ? numericDateToDateObject(document.date) : undefined,
-                summary: document.summary ?? undefined,
-                tags: (documentTagLabels.length > 0) ? documentTagLabels : undefined,
-                properties: fromEntries(propertyEntries),
-            },
-            requests,
+        const documentData = {
+            title: document.title ?? null,
+            subtitle: document.subtitle ?? null,
+            date: isNotNull(document.date) ? numericDateToDateTime(document.date).toISODate() : null,
+            tags: (documentTagLabels.length > 0) ? documentTagLabels : null,
+            summary: document.summary ?? null,
         };
-        const result = await this.#aiService.generate({
-            model: ASSIGN_MODEL,
-            generationOptions: {
-                maxOutputTokens: 100,
-                temperature: 0,
-                topP: 0.2,
-                topK: 16,
-                thinkingBudget: 0,
+        const result = await this.#genkit.generate(genkitGenerationOptions({
+            model: this.#assignModel,
+            config: {
+                maxOutputTokens: 128,
+                thinkingConfig: {
+                    thinkingBudget: 0,
+                },
             },
-            generationSchema: object({ requestId: nullable(string()) }),
-            contents: [{
-                    role: 'user',
-                    parts: [
-                        {
-                            text: `<context>
-${JSON.stringify(context, null, 2)}
-</context>
+            output: { schema: object({ requestId: nullable(string()) }) },
+            system: assignRequestSystemPrompt,
+            prompt: [{
+                    text: `
+${formatData({ document: documentData, documentProperties: fromEntries(propertyEntries) })}
+
+${formatData({ requests })}
 
-Ordne das Dokument unter "document" der passenden Anforderungen unter "requests" zu. Gib es als JSON im angegebenen Schema aus. Wenn keine Anforderung passt, setze requestId auf null.`,
-                        },
-                    ],
+${assignRequestUserPrompt}
+`.trim(),
                 }],
-        });
-        return result.json.requestId;
+        }));
+        if (isNull(result.output)) {
+            throw new Error(`AI returned null output for request assignment "${document.id}".`);
+        }
+        return result.output.requestId;
     }
 };
 DocumentManagementAiService = DocumentManagementAiService_1 = __decorate([

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

@@ -96,8 +96,8 @@ export declare class DocumentManagementService extends Transactional {
     getRelevantDocumentCollectionIds(tenantId: string, documentId: string): Promise<string[]>;
     loadDataStream(tenantId: string, collectionIds: string[], cancellationSignal: CancellationSignal): AsyncGenerator<DocumentManagementData>;
     loadData(tenantId: string, collectionIds: string[]): Promise<DocumentManagementData>;
-    loadDocumentRequestsTemplateData(tenantId: string | null): Promise<DocumentRequestsTemplateData>;
-    initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string, DocumentPropertyKey extends string>(tenantId: string | null, data: CategoriesAndTypesInitializationData<CategoryKey, TypeKey, DocumentPropertyKey>): Promise<{
+    loadDocumentRequestsTemplateData(tenantId: string): Promise<DocumentRequestsTemplateData>;
+    initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string, DocumentPropertyKey extends string>(tenantId: string, data: CategoriesAndTypesInitializationData<CategoryKey, TypeKey, DocumentPropertyKey>): Promise<{
         categories: Record<CategoryKey, DocumentCategory>;
         types: Record<TypeKey, DocumentType>;
         properties: Record<DocumentPropertyKey, DocumentProperty>;

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

@@ -46,18 +46,18 @@ export declare class DocumentPropertyService extends Transactional {
         }, {}, {}>;
         value: import("drizzle-orm").SQL.Aliased<string | number | boolean | null>;
     }, "documentProperties">;
-    loadViews(tenantId: string | null): Promise<DocumentPropertyView[]>;
+    loadViews(tenantId: string): Promise<DocumentPropertyView[]>;
     createProperty(data: {
-        tenantId: string | null;
+        tenantId: string;
         label: string;
         dataType: DocumentPropertyDataType;
         enumKey?: string;
     }): Promise<DocumentProperty>;
-    updateProperty(tenantId: string | null, id: string, update: {
+    updateProperty(tenantId: string, id: string, update: {
         label?: string;
         dataType?: DocumentPropertyDataType;
     }): Promise<DocumentProperty>;
-    assignPropertyToType(tenantId: string | null, typeId: string, propertyId: string): Promise<void>;
+    assignPropertyToType(tenantId: string, typeId: string, propertyId: string): Promise<void>;
     loadDocumentPropertyValues(tenantId: string, documentId: OneOrMany<string>, includeNulls?: boolean): Promise<DocumentPropertyValueView[]>;
     setPropertyValues(document: Document, propertyValues: SetDocumentPropertyParameters[]): Promise<void>;
 }

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

@@ -46,8 +46,8 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
         .innerJoin(documentProperty, and(eq(documentProperty.id, documentTypeProperty.propertyId), or(drizzleIsNull(documentProperty.tenantId), eq(documentProperty.tenantId, document.tenantId))))
         .leftJoin(documentPropertyValue, and(eq(documentPropertyValue.tenantId, document.tenantId), eq(documentPropertyValue.documentId, document.id), eq(documentPropertyValue.propertyId, documentProperty.id))));
     async loadViews(tenantId) {
-        const properties = await this.#documentPropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } });
-        const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } });
+        const properties = await this.#documentPropertyRepository.loadManyByQuery({ tenantId });
+        const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId });
         return properties.map((property) => {
             const typeIds = typeProperties
                 .filter((typeProperty) => typeProperty.propertyId == property.id)
@@ -94,7 +94,7 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
         }
         await this.transaction(async (tx) => {
             const propertyIds = propertyValues.map((property) => property.propertyId);
-            const properties = await this.#documentPropertyRepository.withTransaction(tx).loadManyByQuery({ tenantId: { $or: [null, document.tenantId] }, id: { $in: propertyIds } });
+            const properties = await this.#documentPropertyRepository.withTransaction(tx).loadManyByQuery({ tenantId: document.tenantId, id: { $in: propertyIds } });
             const propertiesMap = getEntityMap(properties);
             const upserts = propertyValues.filter((value) => isNotNull(value.value)).map(({ propertyId, value, metadata }) => {
                 const property = propertiesMap.get(propertyId);

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

@@ -5,8 +5,8 @@ import type { RequestStats } from '../../service-models/index.js';
 export declare class DocumentRequestService extends Transactional {
     #private;
     getRequestStats(tenantId: string, collectionIds: OneOrMany<string>): Promise<RequestStats>;
-    createRequestsTemplate(tenantId: string | null, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description'>): Promise<DocumentRequestsTemplate>;
-    updateRequestsTemplate(tenantId: string | null, id: string, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description' | 'metadata'>): Promise<DocumentRequestsTemplate>;
+    createRequestsTemplate(tenantId: string, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description'>): Promise<DocumentRequestsTemplate>;
+    updateRequestsTemplate(tenantId: string, id: string, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description' | 'metadata'>): Promise<DocumentRequestsTemplate>;
     applyRequestsTemplate(tenantId: string, id: string, collectionIds: string[]): Promise<void>;
     deleteRequestsTemplate(tenantId: string, id: string): Promise<DocumentRequestsTemplate>;
     createRequestTemplate(tenantId: string, requestsTemplateId: string, typeId: string, comment: string): Promise<DocumentRequestTemplate>;

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

@@ -46,7 +46,7 @@ let DocumentRequestService = class DocumentRequestService extends Transactional
         return await this.#documentRequestsTemplateRepository.updateByQuery({ tenantId, id }, parameters);
     }
     async applyRequestsTemplate(tenantId, id, collectionIds) {
-        const requestTemplates = await this.#documentRequestTemplateRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, requestsTemplateId: id });
+        const requestTemplates = await this.#documentRequestTemplateRepository.loadManyByQuery({ tenantId, requestsTemplateId: id });
         await this.transaction(async (tx) => {
             for (const { typeId, comment } of requestTemplates) {
                 await this.withTransaction(tx).createRequest(tenantId, typeId, collectionIds, comment);

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

@@ -3,7 +3,7 @@ import { DocumentTag, DocumentTagAssignment, type Document } from '../../models/
 export declare class DocumentTagService extends Transactional {
     readonly tagRepository: import("../../../orm/server/index.js").EntityRepository<DocumentTag>;
     readonly tagAssignmentRepository: import("../../../orm/server/index.js").EntityRepository<DocumentTagAssignment>;
-    loadTags(tenantId: string | null): Promise<DocumentTag[]>;
+    loadTags(tenantId: string): Promise<DocumentTag[]>;
     loadOrCreate(tenantId: string, labels: string[]): Promise<DocumentTag[]>;
     loadDocumentTags(tenantId: string, documentId: string): Promise<DocumentTag[]>;
     assignTags(document: Document, labels: string[]): Promise<void>;

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

@@ -14,7 +14,7 @@ let DocumentTagService = class DocumentTagService extends Transactional {
     tagRepository = injectRepository(DocumentTag);
     tagAssignmentRepository = injectRepository(DocumentTagAssignment);
     async loadTags(tenantId) {
-        return await this.tagRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } }, { order: { label: 'asc' } });
+        return await this.tagRepository.loadManyByQuery({ tenantId }, { order: { label: 'asc' } });
     }
     async loadOrCreate(tenantId, labels) {
         if (labels.length === 0) {
@@ -22,7 +22,7 @@ let DocumentTagService = class DocumentTagService extends Transactional {
         }
         return await this.tagRepository.transaction(async (tx) => {
             const existingTags = await this.tagRepository.withTransaction(tx).loadManyByQuery({
-                tenantId: { $or: [null, tenantId] },
+                tenantId,
                 label: { $in: labels },
             });
             const newLabels = labels.filter((label) => !existingTags.some((tag) => tag.label == label));