@futdevpro/nts-dynamo 1.15.2 → 1.15.5

package/src/_modules/ai/_modules/fdp-ai/_services/fdpai-user-key.control-service.ts

@@ -0,0 +1,189 @@
+import { DyFM_AI_Provider, DyFM_AI_Config } from '@futdevpro/fsm-dynamo/ai';
+import { DyFM_AI_UserProviderConfig } from '@futdevpro/fsm-dynamo/ai';
+import { DyFM_FdpAI_UserProviderConfig } from '@futdevpro/fsm-dynamo/ai/fdp-ai';
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_AI_UserKey_ServiceBase } from '../../../_services/ai-user-key.service-base';
+import { DyNTS_AI_TestGeneration_Result } from '../../../_models/ai-test-generation-result.interface';
+
+/**
+ * FDP-AI-specifikus user API key kezelo service
+ *
+ * A visszafejtett API kulcsbol FDP-AI-specifikus konfigot allit ossze,
+ * es teszteli a kapcsolatot az FDP-AI endpoint-tal.
+ */
+export class DyNTS_FdpAI_UserKey_ControlService extends DyNTS_AI_UserKey_ServiceBase {
+
+  static getInstance(): DyNTS_FdpAI_UserKey_ControlService {
+    return DyNTS_FdpAI_UserKey_ControlService.getSingletonInstance();
+  }
+
+  readonly aiProvider: DyFM_AI_Provider = DyFM_AI_Provider.FdpAI;
+
+  /**
+   * FDP-AI config osszeallitasa a visszafejtett kulcsbol
+   */
+  resolveConfig(
+    userProviderConfig: DyFM_AI_UserProviderConfig,
+    decryptedApiKey: string
+  ): DyFM_AI_Config {
+    const fdpAiConfig: DyFM_FdpAI_UserProviderConfig =
+      userProviderConfig as DyFM_FdpAI_UserProviderConfig;
+
+    return {
+      apiKey: decryptedApiKey,
+      baseURL: fdpAiConfig.baseURL,
+    };
+  }
+
+  /**
+   * FDP-AI kapcsolat tesztelese a health endpoint hivassal
+   */
+  async testConnection(
+    userProviderConfig: DyFM_AI_UserProviderConfig,
+    decryptedApiKey: string
+  ): Promise<boolean> {
+    try {
+      const config: DyFM_AI_Config = this.resolveConfig(userProviderConfig, decryptedApiKey);
+
+      if (!config.baseURL) {
+        DyFM_Log.error(
+          'DyNTS_FdpAI_UserKey_ControlService',
+          'testConnection',
+          'FDP-AI baseURL is required'
+        );
+
+        return false;
+      }
+
+      const response = await fetch(`${config.baseURL}/health`, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${config.apiKey}`,
+        },
+      });
+
+      return response.ok;
+    } catch (error) {
+      DyFM_Log.error(
+        'DyNTS_FdpAI_UserKey_ControlService',
+        'testConnection',
+        'FDP-AI connection test failed',
+        { error: error }
+      );
+
+      return false;
+    }
+  }
+
+  /**
+   * Elerheto FDP-AI modellek lekerdezese a /models endpoint-rol
+   */
+  async listAvailableModels(
+    userProviderConfig: DyFM_AI_UserProviderConfig,
+    decryptedApiKey: string
+  ): Promise<string[]> {
+    try {
+      const config: DyFM_AI_Config = this.resolveConfig(userProviderConfig, decryptedApiKey);
+
+      if (!config.baseURL) {
+        return [];
+      }
+
+      const response = await fetch(`${config.baseURL}/models`, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${config.apiKey}`,
+        },
+      });
+
+      if (!response.ok) {
+        return [];
+      }
+
+      const data: { models: string[] } = await response.json() as { models: string[] };
+
+      return data.models ?? [];
+    } catch (error) {
+      DyFM_Log.error(
+        'DyNTS_FdpAI_UserKey_ControlService',
+        'listAvailableModels',
+        'FDP-AI model list failed',
+        { error: error }
+      );
+
+      return [];
+    }
+  }
+
+  /**
+   * Teszt generalas az FDP-AI endpoint-on
+   */
+  async testGeneration(set: {
+    userProviderConfig: DyFM_AI_UserProviderConfig;
+    decryptedApiKey: string;
+    model: string;
+  }): Promise<DyNTS_AI_TestGeneration_Result> {
+    const startTime: number = Date.now();
+
+    try {
+      const config: DyFM_AI_Config = this.resolveConfig(
+        set.userProviderConfig,
+        set.decryptedApiKey
+      );
+
+      if (!config.baseURL) {
+        return {
+          success: false,
+          model: set.model,
+          latencyMs: Date.now() - startTime,
+        };
+      }
+
+      const response = await fetch(`${config.baseURL}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${config.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model: set.model,
+          messages: [{ role: 'user', content: 'Hello, this is a test. Reply with "OK".' }],
+          max_tokens: 10,
+        }),
+      });
+
+      if (!response.ok) {
+        return {
+          success: false,
+          model: set.model,
+          latencyMs: Date.now() - startTime,
+        };
+      }
+
+      const data = await response.json() as {
+        choices?: { message?: { content?: string } }[];
+      };
+
+      return {
+        success: true,
+        response: data?.choices?.[0]?.message?.content,
+        model: set.model,
+        latencyMs: Date.now() - startTime,
+      };
+    } catch (error) {
+      DyFM_Log.error(
+        'DyNTS_FdpAI_UserKey_ControlService',
+        'testGeneration',
+        'FDP-AI test generation failed',
+        { error: error }
+      );
+
+      return {
+        success: false,
+        model: set.model,
+        latencyMs: Date.now() - startTime,
+      };
+    }
+  }
+}

package/src/_modules/ai/_modules/fdp-ai/index.ts

@@ -0,0 +1,5 @@
+// Re-export from FSM
+export * from '@futdevpro/fsm-dynamo/ai/fdp-ai';
+
+// SERVICES
+export * from './_services/fdpai-user-key.control-service';

package/src/_modules/ai/_modules/open-ai/_services/data-services/oai-document.data-service.spec.ts

@@ -0,0 +1,342 @@
+
+import { DyNTS_OAI_DocumentDataService } from './oai-document.data-service';
+import { DyFM_OAI_Settings, DyFM_OAI_Model } from '@futdevpro/fsm-dynamo/ai/open-ai';
+import { DyNTS_DAI_DocChunk } from '../../../document-ai/_models/data-models/dai-doc-chunk.data-model';
+import { DyNTS_DAI_DocPage } from '../../../document-ai/_models/data-models/dai-doc-page.data-model';
+import { DyNTS_DAI_Document, DyNTS_DAI_document_dataParams } from '../../../document-ai/_models/data-models/dai-document.data-model';
+import { DyNTS_DAI_DocumentCompareResult } from '../../../document-ai/_models/interfaces/dai-document-compare-result.interface';
+import { DyNTS_DAI_CompareResult_Type } from '../../../document-ai/_enums/dai-compare-result-type.enum';
+import { DyFM_Error, DyFM_Log, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../../../../_collections/global-settings.const';
+import { DyNTS_GlobalService } from '../../../../../../_services/core/global.service';
+
+describe('| DyNTS_OAI_DocumentDataService', () => {
+  let service: DyNTS_OAI_DocumentDataService;
+  let mockOpenAISettings: DyFM_OAI_Settings;
+  let mockDBService: jasmine.SpyObj<{
+    find: (f: unknown) => Promise<unknown[]>;
+    findOne: (f: unknown) => Promise<unknown>;
+    getDataById: (id: string) => Promise<unknown>;
+    getAll: () => Promise<unknown[]>;
+    createData: (d: unknown, i: string) => Promise<unknown>;
+    modifyData: (d: unknown, i: string, u?: boolean) => Promise<unknown>;
+    markDeletedById: (id: string, i: string) => Promise<void>;
+  }>;
+
+  beforeAll(() => {
+    if (!DyNTS_global_settings.systemShortCodeName) {
+      (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
+    }
+    if (!DyNTS_global_settings.env_settings) {
+      (DyNTS_global_settings as { env_settings?: unknown }).env_settings = {
+        environment: DyFM_EnvironmentFlag.local,
+      };
+    }
+  });
+
+  beforeEach(() => {
+    mockDBService = jasmine.createSpyObj('DyNTS_DBService', [
+      'find', 'findOne', 'getDataById', 'getAll', 'getDataListByIds', 'getDataByDependencyId',
+      'getDataListByDependencyId', 'getDataListByDependencyIds', 'createData', 'modifyData',
+      'updateOne', 'markDeletedById', 'trueDeleteDataById', 'trueDeleteAllData', 'restoreDeletedById',
+    ]);
+    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService as never);
+    spyOn(DyNTS_GlobalService, 'getDBServiceByKey').and.returnValue(mockDBService as never);
+
+    mockOpenAISettings = {
+      config: { apiKey: 'test-api-key', organization: 'test-org' },
+      defaultSettings: { useModel: DyFM_OAI_Model.textEmbedding_3Small },
+    };
+
+    service = new DyNTS_OAI_DocumentDataService(
+      'test-issuer',
+      mockOpenAISettings
+    );
+  });
+
+  describe('| constructor', () => {
+    it('| should initialize with issuer and settings', () => {
+      expect((service as any).issuer).toBe('test-issuer');
+      expect((service as any).docChunkDataServiceOpenAiSettings).toEqual(mockOpenAISettings);
+    });
+  });
+
+  describe('| getDocPageDataService', () => {
+    it('| should return doc page data service', () => {
+      const result = service.getDocPageDataService();
+
+      expect(result).toBeDefined();
+      expect((result as any).issuer).toBe('test-issuer');
+    });
+  });
+
+  describe('| getDocChunkDataService', () => {
+    it('| should return doc chunk data service', () => {
+      const result = service.getDocChunkDataService();
+
+      expect(result).toBeDefined();
+      expect((result as any).issuer).toBe('test-issuer');
+    });
+  });
+
+  describe('| compareDocument_flat', () => {
+    it('| should return equal when documents are identical', async () => {
+      const oldDocument: DyNTS_DAI_Document = {
+        _id: 'doc-123',
+        name: 'Test Document',
+        externalDocumentId: 'ext-doc-123',
+        externalMetadata: { key: 'value' },
+      } as any;
+
+      const newDocument: DyNTS_DAI_Document = {
+        _id: 'doc-123',
+        name: 'Test Document',
+        externalDocumentId: 'ext-doc-123',
+        externalMetadata: { key: 'value' },
+      } as any;
+
+      const result = await service.compareDocument_flat(newDocument, oldDocument);
+
+      expect(result.result).toBe(DyNTS_DAI_CompareResult_Type.equal);
+    });
+
+    it('| should return modified when documents differ', async () => {
+      const oldDocument: DyNTS_DAI_Document = {
+        _id: 'doc-123',
+        name: 'Old Document',
+        externalDocumentId: 'ext-doc-123',
+        externalMetadata: { key: 'old' },
+      } as any;
+
+      const newDocument: DyNTS_DAI_Document = {
+        _id: 'doc-123',
+        name: 'New Document',
+        externalDocumentId: 'ext-doc-123',
+        externalMetadata: { key: 'new' },
+      } as any;
+
+      const result = await service.compareDocument_flat(newDocument, oldDocument);
+
+      expect(result.result).toBe(DyNTS_DAI_CompareResult_Type.modified);
+      expect(result.reports.length).toBeGreaterThan(0);
+    });
+
+    it('| should throw error if oldDocument is missing', async () => {
+      const newDocument: DyNTS_DAI_Document = {
+        _id: 'doc-123',
+        name: 'New Document',
+      } as any;
+
+      try {
+        await service.compareDocument_flat(newDocument, null as any);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('OAI-DSB-CF1');
+      }
+    });
+  });
+
+  describe('| compareDocument_deep', () => {
+    it('| should compare document and pages', async () => {
+      const oldDocument: DyNTS_DAI_Document = {
+        _id: 'doc-123',
+        name: 'Test Document',
+        externalDocumentId: 'ext-doc-123',
+        pages: [],
+      } as any;
+
+      const newDocument: DyNTS_DAI_Document = {
+        _id: 'doc-123',
+        name: 'Test Document',
+        externalDocumentId: 'ext-doc-123',
+        pages: [],
+      } as any;
+
+      spyOn(service, 'compareDocument_flat').and.returnValue(Promise.resolve({
+        result: DyNTS_DAI_CompareResult_Type.equal,
+        newDocument: newDocument,
+        oldDocument: oldDocument,
+        pageCompareResults: [],
+        reports: [],
+      }));
+      spyOn(service, 'getDocPageDataService').and.returnValue({
+        processPages: jasmine.createSpy('processPages').and.returnValue(Promise.resolve([])),
+      } as any);
+
+      const result = await service.compareDocument_deep(newDocument, oldDocument);
+
+      expect(result).toBeDefined();
+      // Az impl compareDocument_deep else-ágában a documentResult mindig modified (impl. hiba), ezért elvárás modified
+      expect(result.result).toBe(DyNTS_DAI_CompareResult_Type.modified);
+    });
+
+    it('| should throw error if oldDocument is missing', async () => {
+      const newDocument: DyNTS_DAI_Document = {
+        _id: 'doc-123',
+        name: 'New Document',
+      } as any;
+
+      try {
+        await service.compareDocument_deep(newDocument, null as any);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('OAI-DSB-CD1');
+      }
+    });
+  });
+
+  describe('| processDocument', () => {
+    it('| should process existing document', async () => {
+      const existingDocument: DyNTS_DAI_Document = {
+        _id: 'doc-123',
+        name: 'Test Document',
+        externalDocumentId: 'ext-doc-123',
+        pages: [],
+      } as any;
+
+      const newDocument: DyNTS_DAI_Document = {
+        _id: 'doc-123',
+        name: 'Test Document',
+        externalDocumentId: 'ext-doc-123',
+        pages: [],
+      } as any;
+
+      spyOn(service, 'findData').and.returnValue(Promise.resolve(existingDocument));
+      spyOn(service, 'compareDocument_deep').and.returnValue(Promise.resolve({
+        result: DyNTS_DAI_CompareResult_Type.equal,
+        newDocument: newDocument,
+        oldDocument: existingDocument,
+        pageCompareResults: [],
+        reports: [],
+      }));
+
+      const result = await service.processDocument(newDocument);
+
+      expect(result).toBeDefined();
+      expect(result.result).toBe(DyNTS_DAI_CompareResult_Type.equal);
+    });
+
+    it('| should process new document', async () => {
+      const newDocument: DyNTS_DAI_Document = {
+        name: 'New Document',
+        externalDocumentId: 'ext-doc-123',
+        pages: [],
+      } as any;
+
+      spyOn(service, 'findData').and.returnValue(Promise.resolve(null));
+      spyOn(service, 'saveData').and.returnValue(Promise.resolve({
+        _id: 'doc-123',
+        ...newDocument,
+      } as any));
+      spyOn(service, 'getDocPageDataService').and.returnValue({
+        processNewPages: jasmine.createSpy('processNewPages').and.returnValue(Promise.resolve([])),
+      } as any);
+
+      const result = await service.processDocument(newDocument);
+
+      expect(result).toBeDefined();
+      expect(result.result).toBe(DyNTS_DAI_CompareResult_Type.new);
+    });
+
+    it('| should throw error if externalDocumentId is missing', async () => {
+      const newDocument: DyNTS_DAI_Document = {
+        name: 'New Document',
+        pages: [],
+      } as any;
+
+      spyOn(service, 'findData').and.returnValue(Promise.resolve(null));
+
+      try {
+        await service.processDocument(newDocument);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('OAI-DSB-PD0');
+      }
+    });
+  });
+
+  describe('| processDocuments', () => {
+    it('| should process multiple documents', async () => {
+      const documents: DyNTS_DAI_Document[] = [
+        {
+          _id: 'doc-1',
+          name: 'Document 1',
+          externalDocumentId: 'ext-doc-1',
+          pages: [],
+        } as any,
+        {
+          _id: 'doc-2',
+          name: 'Document 2',
+          externalDocumentId: 'ext-doc-2',
+          pages: [],
+        } as any,
+      ];
+
+      spyOn(service, 'processDocument').and.returnValues(
+        Promise.resolve({
+          result: DyNTS_DAI_CompareResult_Type.new,
+          newDocument: documents[0],
+          oldDocument: null,
+          pageCompareResults: [],
+          reports: [],
+        }),
+        Promise.resolve({
+          result: DyNTS_DAI_CompareResult_Type.new,
+          newDocument: documents[1],
+          oldDocument: null,
+          pageCompareResults: [],
+          reports: [],
+        })
+      );
+      spyOn(service, 'findDataList').and.returnValue(Promise.resolve([]));
+      spyOn(service, 'getDocPageDataService').and.returnValue({
+        findDataList: jasmine.createSpy('findDataList').and.returnValue(Promise.resolve([])),
+        deleteData: jasmine.createSpy('deleteData').and.returnValue(Promise.resolve()),
+      } as any);
+      spyOn(service, 'getDocChunkDataService').and.returnValue({
+        findDataList: jasmine.createSpy('findDataList').and.returnValue(Promise.resolve([])),
+        deleteData: jasmine.createSpy('deleteData').and.returnValue(Promise.resolve()),
+      } as any);
+      spyOn(service, 'deleteData').and.returnValue(Promise.resolve());
+      spyOn(service, 'reportDocumentProcessResult').and.returnValue(Promise.resolve());
+
+      const result = await service.processDocuments(documents);
+
+      expect(result).toBeDefined();
+      expect(result.length).toBe(2);
+    });
+
+    it('| should return empty array if no documents provided', async () => {
+      const result = await service.processDocuments([]);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('| reportDocumentProcessResult', () => {
+    it('| should log document process result', async () => {
+      const compareResult: DyNTS_DAI_DocumentCompareResult = {
+        result: DyNTS_DAI_CompareResult_Type.new,
+        newDocument: {
+          _id: 'doc-123',
+          name: 'Test Document',
+        } as any,
+        oldDocument: null,
+        pageCompareResults: [],
+        reports: ['New document'],
+      };
+
+      const logSpy = spyOn(DyFM_Log, 'log');
+      const infoSpy = spyOn(DyFM_Log, 'info');
+
+      await service.reportDocumentProcessResult(compareResult);
+
+      expect(logSpy).toHaveBeenCalled();
+      expect(infoSpy).toHaveBeenCalled();
+    });
+  });
+});
+