@futdevpro/nts-dynamo 1.15.40 → 1.15.41

package/src/_modules/local-vector-search/_services/lvs-local-vector-search.data-service.spec.ts

@@ -1,480 +1,480 @@
-
-import { DyNTS_LVS_VectorDataService } from './lvs-local-vector-search.data-service';
-import { DyFM_DataModel_Params, DyFM_Metadata, DyFM_BasicProperty_Type, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
-import { DyFM_OAI_Settings, DyFM_OAI_Model } from '@futdevpro/fsm-dynamo/ai/open-ai';
-import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
-import { LVS_VectorPool_ControlService } from './lvs-vector-pool.control-service';
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_GlobalService } from '../../../_services/core/global.service';
-
-class TestDataModel extends DyFM_Metadata {
-  content: string = '';
-  contentVectorized?: number[];
-}
-
-const testDataParams: DyFM_DataModel_Params<TestDataModel> = new DyFM_DataModel_Params<TestDataModel>({
-  dataName: 'test-data',
-  properties: {
-    content: { key: 'content', type: DyFM_BasicProperty_Type.string },
-    contentVectorized: {
-      key: 'contentVectorized',
-      type: DyFM_BasicProperty_Type.array,
-      vectorizedFrom: ['content'],
-      embeddingModel: DyFM_OAI_Model.textEmbedding_3Small,
-    },
-  },
-});
-
-describe('| DyNTS_LVS_VectorDataService', () => {
-  let service: DyNTS_LVS_VectorDataService<TestDataModel>;
-  let mockOpenAISettings: DyFM_OAI_Settings;
-  let testData: TestDataModel;
-  let mockDBService: jasmine.SpyObj<{
-    find: (f: unknown) => Promise<unknown[]>;
-    getAll: () => Promise<unknown[]>;
-    getDataById: (id: string) => Promise<unknown>;
-  }>;
-
-  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', 'aggregate',
-    ]);
-    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 },
-    };
-
-    testData = new TestDataModel();
-    service = new DyNTS_LVS_VectorDataService<TestDataModel>(
-      testData,
-      testDataParams,
-      mockOpenAISettings,
-      'test-issuer'
-    );
-  });
-
-  describe('| constructor', () => {
-    it('| should initialize with default search mode', () => {
-      expect(service.defaultSearchMode).toBe(LVS_Search_Mode.cosineSimilarity);
-    });
-
-    it('| should initialize with L2 normalization enabled', () => {
-      expect(service.useL2Normalization).toBe(true);
-    });
-
-    it('| should initialize vector pool', () => {
-      expect((service as any).vectorPool).toBeInstanceOf(LVS_VectorPool_ControlService);
-    });
-  });
-
-  describe('| vectorSearch', () => {
-    it('| should throw error when input is missing', async () => {
-      try {
-        await service.vectorSearch({
-          input: '',
-          searchInKey: 'contentVectorized',
-        });
-        fail('Should have thrown an error');
-      } catch (err) {
-        expect(err).toBeInstanceOf(DyFM_Error);
-        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS1');
-      }
-    });
-
-    it('| should throw error when searchInKey property not found', async () => {
-      try {
-        await service.vectorSearch({
-          input: 'test query',
-          searchInKey: 'nonExistentKey',
-        });
-        fail('Should have thrown an error');
-      } catch (err) {
-        expect(err).toBeInstanceOf(DyFM_Error);
-        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS2');
-      }
-    });
-
-    it('| should throw error when searchInKey is not vectorized', async () => {
-      try {
-        await service.vectorSearch({
-          input: 'test query',
-          searchInKey: 'content',
-        });
-        fail('Should have thrown an error');
-      } catch (err) {
-        expect(err).toBeInstanceOf(DyFM_Error);
-        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS3');
-      }
-    });
-
-    it('| should return empty array when no data found', async () => {
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve([]));
-
-      const result = await service.vectorSearch({
-        input: 'test query',
-        searchInKey: 'contentVectorized',
-      });
-
-      expect(result).toEqual([]);
-    });
-
-    it('| should perform vector search with filterBy', async () => {
-      const mockData1: TestDataModel = new TestDataModel();
-      mockData1._id = 'data-1';
-      mockData1.content = 'Test content 1';
-      mockData1.contentVectorized = [0.1, 0.2, 0.3];
-
-      const mockData2: TestDataModel = new TestDataModel();
-      mockData2._id = 'data-2';
-      mockData2.content = 'Test content 2';
-      mockData2.contentVectorized = [0.4, 0.5, 0.6];
-
-      spyOn(service, 'findDataList').and.returnValue(Promise.resolve([mockData1, mockData2]));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
-
-      const result = await service.vectorSearch({
-        input: 'test query',
-        searchInKey: 'contentVectorized',
-        filterBy: { content: 'Test' },
-        limit: 2,
-      });
-
-      expect(service.findDataList).toHaveBeenCalled();
-      expect(result).toBeDefined();
-    });
-
-    it('| should perform vector search without filterBy', async () => {
-      const mockData: TestDataModel = new TestDataModel();
-      mockData._id = 'data-1';
-      mockData.content = 'Test content';
-      mockData.contentVectorized = [0.1, 0.2, 0.3];
-
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData]));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
-
-      const result = await service.vectorSearch({
-        input: 'test query',
-        searchInKey: 'contentVectorized',
-        limit: 1,
-      });
-
-      expect(service.getAll).toHaveBeenCalled();
-      expect(result).toBeDefined();
-    });
-
-    it('| should use default limit of 3 when not provided', async () => {
-      const mockData: TestDataModel = new TestDataModel();
-      mockData._id = 'data-1';
-      mockData.content = 'Test content';
-      mockData.contentVectorized = [0.1, 0.2, 0.3];
-
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData]));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
-      spyOn((service as any).vectorPool, 'search').and.returnValue([
-        { id: 'data-1', score: 0.9 },
-      ]);
-
-      await service.vectorSearch({
-        input: 'test query',
-        searchInKey: 'contentVectorized',
-      });
-
-      expect((service as any).vectorPool.search).toHaveBeenCalledWith(
-        jasmine.any(Array),
-        3,
-        LVS_Search_Mode.cosineSimilarity
-      );
-    });
-
-    it('| should use custom search mode when provided', async () => {
-      const mockData: TestDataModel = new TestDataModel();
-      mockData._id = 'data-1';
-      mockData.content = 'Test content';
-      mockData.contentVectorized = [0.1, 0.2, 0.3];
-
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData]));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
-      spyOn((service as any).vectorPool, 'search').and.returnValue([
-        { id: 'data-1', score: 0.5 },
-      ]);
-
-      await service.vectorSearch({
-        input: 'test query',
-        searchInKey: 'contentVectorized',
-        searchMode: LVS_Search_Mode.l2Distance,
-      });
-
-      expect((service as any).vectorPool.search).toHaveBeenCalledWith(
-        jasmine.any(Array),
-        3,
-        LVS_Search_Mode.l2Distance
-      );
-    });
-
-    it('| should skip items without _id', async () => {
-      const mockData1: TestDataModel = new TestDataModel();
-      mockData1._id = 'data-1';
-      mockData1.content = 'Test content 1';
-      mockData1.contentVectorized = [0.1, 0.2, 0.3];
-
-      const mockData2: TestDataModel = new TestDataModel();
-      // No _id
-      mockData2.content = 'Test content 2';
-      mockData2.contentVectorized = [0.4, 0.5, 0.6];
-
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData1, mockData2]));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
-      spyOn((service as any).vectorPool, 'addVector');
-
-      await service.vectorSearch({
-        input: 'test query',
-        searchInKey: 'contentVectorized',
-      });
-
-      expect((service as any).vectorPool.addVector).toHaveBeenCalledTimes(1);
-      expect((service as any).vectorPool.addVector).toHaveBeenCalledWith('data-1', [0.1, 0.2, 0.3]);
-    });
-
-    it('| should skip items without vectorized value', async () => {
-      const mockData1: TestDataModel = new TestDataModel();
-      mockData1._id = 'data-1';
-      mockData1.content = 'Test content 1';
-      mockData1.contentVectorized = [0.1, 0.2, 0.3];
-
-      const mockData2: TestDataModel = new TestDataModel();
-      mockData2._id = 'data-2';
-      mockData2.content = 'Test content 2';
-      // No contentVectorized
-
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData1, mockData2]));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
-      spyOn((service as any).vectorPool, 'addVector');
-
-      await service.vectorSearch({
-        input: 'test query',
-        searchInKey: 'contentVectorized',
-      });
-
-      expect((service as any).vectorPool.addVector).toHaveBeenCalledTimes(1);
-      expect((service as any).vectorPool.addVector).toHaveBeenCalledWith('data-1', [0.1, 0.2, 0.3]);
-    });
-
-    it('| should clear vector pool after search', async () => {
-      const mockData: TestDataModel = new TestDataModel();
-      mockData._id = 'data-1';
-      mockData.content = 'Test content';
-      mockData.contentVectorized = [0.1, 0.2, 0.3];
-
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData]));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
-      spyOn((service as any).vectorPool, 'clearPool');
-      spyOn((service as any).vectorPool, 'search').and.returnValue([]);
-
-      await service.vectorSearch({
-        input: 'test query',
-        searchInKey: 'contentVectorized',
-      });
-
-      expect((service as any).vectorPool.clearPool).toHaveBeenCalled();
-    });
-
-    it('| should clear vector pool on error', async () => {
-      spyOn(service, 'getAll').and.returnValue(Promise.reject(new Error('Database error')));
-      spyOn((service as any).vectorPool, 'clearPool');
-
-      try {
-        await service.vectorSearch({
-          input: 'test query',
-          searchInKey: 'contentVectorized',
-        });
-        fail('Should have thrown an error');
-      } catch (err) {
-        expect((service as any).vectorPool.clearPool).toHaveBeenCalled();
-        expect(err).toBeInstanceOf(DyFM_Error);
-        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS0');
-      }
-    });
-
-    it('| should map search results back to data objects', async () => {
-      const mockData1: TestDataModel = new TestDataModel();
-      mockData1._id = 'data-1';
-      mockData1.content = 'Test content 1';
-      mockData1.contentVectorized = [0.1, 0.2, 0.3];
-
-      const mockData2: TestDataModel = new TestDataModel();
-      mockData2._id = 'data-2';
-      mockData2.content = 'Test content 2';
-      mockData2.contentVectorized = [0.4, 0.5, 0.6];
-
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData1, mockData2]));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
-      spyOn((service as any).vectorPool, 'search').and.returnValue([
-        { id: 'data-2', score: 0.9 },
-        { id: 'data-1', score: 0.8 },
-      ]);
-
-      const result = await service.vectorSearch({
-        input: 'test query',
-        searchInKey: 'contentVectorized',
-        limit: 2,
-      });
-
-      expect(result.length).toBe(2);
-      expect(result[0]._id).toBe('data-2');
-      expect(result[1]._id).toBe('data-1');
-    });
-  });
-
-  describe('| vectorSearch hybrid (FR-004)', () => {
-    const buildHybridCorpus = (): TestDataModel[] => {
-      const d1: TestDataModel = new TestDataModel();
-      d1._id = 'doc-user';
-      d1.content = 'the UserController handles authentication flow';
-      d1.contentVectorized = [0.4, 0.5, 0.6];
-      const d2: TestDataModel = new TestDataModel();
-      d2._id = 'doc-recipe';
-      d2.content = 'cooking recipes for desserts and cakes';
-      d2.contentVectorized = [0.45, 0.55, 0.65];
-      const d3: TestDataModel = new TestDataModel();
-      d3._id = 'doc-db';
-      d3.content = 'database setup guide for MongoDB';
-      d3.contentVectorized = [0.42, 0.52, 0.62];
-      return [d1, d2, d3];
-    };
-
-    it('| throws ha textSearchKey hianyzik hybrid modban (VS4)', async () => {
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.4, 0.5, 0.6]));
-      try {
-        await service.vectorSearch({
-          input: 'UserController',
-          searchInKey: 'contentVectorized',
-          searchMode: LVS_Search_Mode.hybrid,
-        });
-        fail('Should have thrown an error');
-      } catch (err) {
-        expect(err).toBeInstanceOf(DyFM_Error);
-        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS4');
-      }
-    });
-
-    it('| throws ha hybridWeight invalid (negativ) (VS5)', async () => {
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.4, 0.5, 0.6]));
-      try {
-        await service.vectorSearch({
-          input: 'UserController',
-          searchInKey: 'contentVectorized',
-          searchMode: LVS_Search_Mode.hybrid,
-          textSearchKey: 'content',
-          hybridWeight: { vector: -0.5, text: 1.5 },
-        });
-        fail('Should have thrown an error');
-      } catch (err) {
-        expect(err).toBeInstanceOf(DyFM_Error);
-        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS5');
-      }
-    });
-
-    it('| basic hybrid: text-relevant doc top-en', async () => {
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.4, 0.5, 0.6]));
-      const result: TestDataModel[] = await service.vectorSearch({
-        input: 'UserController',
-        searchInKey: 'contentVectorized',
-        searchMode: LVS_Search_Mode.hybrid,
-        textSearchKey: 'content',
-        limit: 3,
-      });
-      expect(result.length).toBe(3);
-      expect(result[0]._id).toBe('doc-user');
-    });
-
-    it('| weight {vector:1, text:0} → effektivan pure cosine', async () => {
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.42, 0.52, 0.62]));
-      const result: TestDataModel[] = await service.vectorSearch({
-        input: 'UserController',
-        searchInKey: 'contentVectorized',
-        searchMode: LVS_Search_Mode.hybrid,
-        textSearchKey: 'content',
-        hybridWeight: { vector: 1, text: 0 },
-        limit: 3,
-      });
-      expect(result.length).toBe(3);
-      expect(result[0]._id).toBe('doc-db');
-    });
-
-    it('| weight {vector:0, text:1} → effektivan pure BM25', async () => {
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.45, 0.55, 0.65]));
-      const result: TestDataModel[] = await service.vectorSearch({
-        input: 'authentication',
-        searchInKey: 'contentVectorized',
-        searchMode: LVS_Search_Mode.hybrid,
-        textSearchKey: 'content',
-        hybridWeight: { vector: 0, text: 1 },
-        limit: 3,
-      });
-      expect(result.length).toBe(3);
-      expect(result[0]._id).toBe('doc-user');
-    });
-
-    it('| all-zero BM25 fallback → cosine-rendezes marad', async () => {
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.45, 0.55, 0.65]));
-      const result: TestDataModel[] = await service.vectorSearch({
-        input: 'xyzzy-nonexistent-token',
-        searchInKey: 'contentVectorized',
-        searchMode: LVS_Search_Mode.hybrid,
-        textSearchKey: 'content',
-        limit: 3,
-      });
-      expect(result.length).toBe(3);
-      expect(result[0]._id).toBe('doc-recipe');
-    });
-
-    it('| limit honored hybrid modban', async () => {
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.4, 0.5, 0.6]));
-      const result: TestDataModel[] = await service.vectorSearch({
-        input: 'UserController',
-        searchInKey: 'contentVectorized',
-        searchMode: LVS_Search_Mode.hybrid,
-        textSearchKey: 'content',
-        limit: 1,
-      });
-      expect(result.length).toBe(1);
-    });
-
-    it('| ures candidate-szet → ures eredmeny', async () => {
-      spyOn(service, 'getAll').and.returnValue(Promise.resolve([]));
-      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.4, 0.5, 0.6]));
-      const result: TestDataModel[] = await service.vectorSearch({
-        input: 'UserController',
-        searchInKey: 'contentVectorized',
-        searchMode: LVS_Search_Mode.hybrid,
-        textSearchKey: 'content',
-      });
-      expect(result.length).toBe(0);
-    });
-  });
-});
-
+
+import { DyNTS_LVS_VectorDataService } from './lvs-local-vector-search.data-service';
+import { DyFM_DataModel_Params, DyFM_Metadata, DyFM_BasicProperty_Type, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
+import { DyFM_OAI_Settings, DyFM_OAI_Model } from '@futdevpro/fsm-dynamo/ai/open-ai';
+import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
+import { LVS_VectorPool_ControlService } from './lvs-vector-pool.control-service';
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_GlobalService } from '../../../_services/core/global.service';
+
+class TestDataModel extends DyFM_Metadata {
+  content: string = '';
+  contentVectorized?: number[];
+}
+
+const testDataParams: DyFM_DataModel_Params<TestDataModel> = new DyFM_DataModel_Params<TestDataModel>({
+  dataName: 'test-data',
+  properties: {
+    content: { key: 'content', type: DyFM_BasicProperty_Type.string },
+    contentVectorized: {
+      key: 'contentVectorized',
+      type: DyFM_BasicProperty_Type.array,
+      vectorizedFrom: ['content'],
+      embeddingModel: DyFM_OAI_Model.textEmbedding_3Small,
+    },
+  },
+});
+
+describe('| DyNTS_LVS_VectorDataService', () => {
+  let service: DyNTS_LVS_VectorDataService<TestDataModel>;
+  let mockOpenAISettings: DyFM_OAI_Settings;
+  let testData: TestDataModel;
+  let mockDBService: jasmine.SpyObj<{
+    find: (f: unknown) => Promise<unknown[]>;
+    getAll: () => Promise<unknown[]>;
+    getDataById: (id: string) => Promise<unknown>;
+  }>;
+
+  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', 'aggregate',
+    ]);
+    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 },
+    };
+
+    testData = new TestDataModel();
+    service = new DyNTS_LVS_VectorDataService<TestDataModel>(
+      testData,
+      testDataParams,
+      mockOpenAISettings,
+      'test-issuer'
+    );
+  });
+
+  describe('| constructor', () => {
+    it('| should initialize with default search mode', () => {
+      expect(service.defaultSearchMode).toBe(LVS_Search_Mode.cosineSimilarity);
+    });
+
+    it('| should initialize with L2 normalization enabled', () => {
+      expect(service.useL2Normalization).toBe(true);
+    });
+
+    it('| should initialize vector pool', () => {
+      expect((service as any).vectorPool).toBeInstanceOf(LVS_VectorPool_ControlService);
+    });
+  });
+
+  describe('| vectorSearch', () => {
+    it('| should throw error when input is missing', async () => {
+      try {
+        await service.vectorSearch({
+          input: '',
+          searchInKey: 'contentVectorized',
+        });
+        fail('Should have thrown an error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(DyFM_Error);
+        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS1');
+      }
+    });
+
+    it('| should throw error when searchInKey property not found', async () => {
+      try {
+        await service.vectorSearch({
+          input: 'test query',
+          searchInKey: 'nonExistentKey',
+        });
+        fail('Should have thrown an error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(DyFM_Error);
+        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS2');
+      }
+    });
+
+    it('| should throw error when searchInKey is not vectorized', async () => {
+      try {
+        await service.vectorSearch({
+          input: 'test query',
+          searchInKey: 'content',
+        });
+        fail('Should have thrown an error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(DyFM_Error);
+        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS3');
+      }
+    });
+
+    it('| should return empty array when no data found', async () => {
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve([]));
+
+      const result = await service.vectorSearch({
+        input: 'test query',
+        searchInKey: 'contentVectorized',
+      });
+
+      expect(result).toEqual([]);
+    });
+
+    it('| should perform vector search with filterBy', async () => {
+      const mockData1: TestDataModel = new TestDataModel();
+      mockData1._id = 'data-1';
+      mockData1.content = 'Test content 1';
+      mockData1.contentVectorized = [0.1, 0.2, 0.3];
+
+      const mockData2: TestDataModel = new TestDataModel();
+      mockData2._id = 'data-2';
+      mockData2.content = 'Test content 2';
+      mockData2.contentVectorized = [0.4, 0.5, 0.6];
+
+      spyOn(service, 'findDataList').and.returnValue(Promise.resolve([mockData1, mockData2]));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
+
+      const result = await service.vectorSearch({
+        input: 'test query',
+        searchInKey: 'contentVectorized',
+        filterBy: { content: 'Test' },
+        limit: 2,
+      });
+
+      expect(service.findDataList).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
+
+    it('| should perform vector search without filterBy', async () => {
+      const mockData: TestDataModel = new TestDataModel();
+      mockData._id = 'data-1';
+      mockData.content = 'Test content';
+      mockData.contentVectorized = [0.1, 0.2, 0.3];
+
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData]));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
+
+      const result = await service.vectorSearch({
+        input: 'test query',
+        searchInKey: 'contentVectorized',
+        limit: 1,
+      });
+
+      expect(service.getAll).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
+
+    it('| should use default limit of 3 when not provided', async () => {
+      const mockData: TestDataModel = new TestDataModel();
+      mockData._id = 'data-1';
+      mockData.content = 'Test content';
+      mockData.contentVectorized = [0.1, 0.2, 0.3];
+
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData]));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
+      spyOn((service as any).vectorPool, 'search').and.returnValue([
+        { id: 'data-1', score: 0.9 },
+      ]);
+
+      await service.vectorSearch({
+        input: 'test query',
+        searchInKey: 'contentVectorized',
+      });
+
+      expect((service as any).vectorPool.search).toHaveBeenCalledWith(
+        jasmine.any(Array),
+        3,
+        LVS_Search_Mode.cosineSimilarity
+      );
+    });
+
+    it('| should use custom search mode when provided', async () => {
+      const mockData: TestDataModel = new TestDataModel();
+      mockData._id = 'data-1';
+      mockData.content = 'Test content';
+      mockData.contentVectorized = [0.1, 0.2, 0.3];
+
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData]));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
+      spyOn((service as any).vectorPool, 'search').and.returnValue([
+        { id: 'data-1', score: 0.5 },
+      ]);
+
+      await service.vectorSearch({
+        input: 'test query',
+        searchInKey: 'contentVectorized',
+        searchMode: LVS_Search_Mode.l2Distance,
+      });
+
+      expect((service as any).vectorPool.search).toHaveBeenCalledWith(
+        jasmine.any(Array),
+        3,
+        LVS_Search_Mode.l2Distance
+      );
+    });
+
+    it('| should skip items without _id', async () => {
+      const mockData1: TestDataModel = new TestDataModel();
+      mockData1._id = 'data-1';
+      mockData1.content = 'Test content 1';
+      mockData1.contentVectorized = [0.1, 0.2, 0.3];
+
+      const mockData2: TestDataModel = new TestDataModel();
+      // No _id
+      mockData2.content = 'Test content 2';
+      mockData2.contentVectorized = [0.4, 0.5, 0.6];
+
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData1, mockData2]));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
+      spyOn((service as any).vectorPool, 'addVector');
+
+      await service.vectorSearch({
+        input: 'test query',
+        searchInKey: 'contentVectorized',
+      });
+
+      expect((service as any).vectorPool.addVector).toHaveBeenCalledTimes(1);
+      expect((service as any).vectorPool.addVector).toHaveBeenCalledWith('data-1', [0.1, 0.2, 0.3]);
+    });
+
+    it('| should skip items without vectorized value', async () => {
+      const mockData1: TestDataModel = new TestDataModel();
+      mockData1._id = 'data-1';
+      mockData1.content = 'Test content 1';
+      mockData1.contentVectorized = [0.1, 0.2, 0.3];
+
+      const mockData2: TestDataModel = new TestDataModel();
+      mockData2._id = 'data-2';
+      mockData2.content = 'Test content 2';
+      // No contentVectorized
+
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData1, mockData2]));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
+      spyOn((service as any).vectorPool, 'addVector');
+
+      await service.vectorSearch({
+        input: 'test query',
+        searchInKey: 'contentVectorized',
+      });
+
+      expect((service as any).vectorPool.addVector).toHaveBeenCalledTimes(1);
+      expect((service as any).vectorPool.addVector).toHaveBeenCalledWith('data-1', [0.1, 0.2, 0.3]);
+    });
+
+    it('| should clear vector pool after search', async () => {
+      const mockData: TestDataModel = new TestDataModel();
+      mockData._id = 'data-1';
+      mockData.content = 'Test content';
+      mockData.contentVectorized = [0.1, 0.2, 0.3];
+
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData]));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
+      spyOn((service as any).vectorPool, 'clearPool');
+      spyOn((service as any).vectorPool, 'search').and.returnValue([]);
+
+      await service.vectorSearch({
+        input: 'test query',
+        searchInKey: 'contentVectorized',
+      });
+
+      expect((service as any).vectorPool.clearPool).toHaveBeenCalled();
+    });
+
+    it('| should clear vector pool on error', async () => {
+      spyOn(service, 'getAll').and.returnValue(Promise.reject(new Error('Database error')));
+      spyOn((service as any).vectorPool, 'clearPool');
+
+      try {
+        await service.vectorSearch({
+          input: 'test query',
+          searchInKey: 'contentVectorized',
+        });
+        fail('Should have thrown an error');
+      } catch (err) {
+        expect((service as any).vectorPool.clearPool).toHaveBeenCalled();
+        expect(err).toBeInstanceOf(DyFM_Error);
+        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS0');
+      }
+    });
+
+    it('| should map search results back to data objects', async () => {
+      const mockData1: TestDataModel = new TestDataModel();
+      mockData1._id = 'data-1';
+      mockData1.content = 'Test content 1';
+      mockData1.contentVectorized = [0.1, 0.2, 0.3];
+
+      const mockData2: TestDataModel = new TestDataModel();
+      mockData2._id = 'data-2';
+      mockData2.content = 'Test content 2';
+      mockData2.contentVectorized = [0.4, 0.5, 0.6];
+
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve([mockData1, mockData2]));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.1, 0.2, 0.3]));
+      spyOn((service as any).vectorPool, 'search').and.returnValue([
+        { id: 'data-2', score: 0.9 },
+        { id: 'data-1', score: 0.8 },
+      ]);
+
+      const result = await service.vectorSearch({
+        input: 'test query',
+        searchInKey: 'contentVectorized',
+        limit: 2,
+      });
+
+      expect(result.length).toBe(2);
+      expect(result[0]._id).toBe('data-2');
+      expect(result[1]._id).toBe('data-1');
+    });
+  });
+
+  describe('| vectorSearch hybrid (FR-004)', () => {
+    const buildHybridCorpus = (): TestDataModel[] => {
+      const d1: TestDataModel = new TestDataModel();
+      d1._id = 'doc-user';
+      d1.content = 'the UserController handles authentication flow';
+      d1.contentVectorized = [0.4, 0.5, 0.6];
+      const d2: TestDataModel = new TestDataModel();
+      d2._id = 'doc-recipe';
+      d2.content = 'cooking recipes for desserts and cakes';
+      d2.contentVectorized = [0.45, 0.55, 0.65];
+      const d3: TestDataModel = new TestDataModel();
+      d3._id = 'doc-db';
+      d3.content = 'database setup guide for MongoDB';
+      d3.contentVectorized = [0.42, 0.52, 0.62];
+      return [d1, d2, d3];
+    };
+
+    it('| throws ha textSearchKey hianyzik hybrid modban (VS4)', async () => {
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.4, 0.5, 0.6]));
+      try {
+        await service.vectorSearch({
+          input: 'UserController',
+          searchInKey: 'contentVectorized',
+          searchMode: LVS_Search_Mode.hybrid,
+        });
+        fail('Should have thrown an error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(DyFM_Error);
+        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS4');
+      }
+    });
+
+    it('| throws ha hybridWeight invalid (negativ) (VS5)', async () => {
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.4, 0.5, 0.6]));
+      try {
+        await service.vectorSearch({
+          input: 'UserController',
+          searchInKey: 'contentVectorized',
+          searchMode: LVS_Search_Mode.hybrid,
+          textSearchKey: 'content',
+          hybridWeight: { vector: -0.5, text: 1.5 },
+        });
+        fail('Should have thrown an error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(DyFM_Error);
+        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-LVS-VS5');
+      }
+    });
+
+    it('| basic hybrid: text-relevant doc top-en', async () => {
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.4, 0.5, 0.6]));
+      const result: TestDataModel[] = await service.vectorSearch({
+        input: 'UserController',
+        searchInKey: 'contentVectorized',
+        searchMode: LVS_Search_Mode.hybrid,
+        textSearchKey: 'content',
+        limit: 3,
+      });
+      expect(result.length).toBe(3);
+      expect(result[0]._id).toBe('doc-user');
+    });
+
+    it('| weight {vector:1, text:0} → effektivan pure cosine', async () => {
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.42, 0.52, 0.62]));
+      const result: TestDataModel[] = await service.vectorSearch({
+        input: 'UserController',
+        searchInKey: 'contentVectorized',
+        searchMode: LVS_Search_Mode.hybrid,
+        textSearchKey: 'content',
+        hybridWeight: { vector: 1, text: 0 },
+        limit: 3,
+      });
+      expect(result.length).toBe(3);
+      expect(result[0]._id).toBe('doc-db');
+    });
+
+    it('| weight {vector:0, text:1} → effektivan pure BM25', async () => {
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.45, 0.55, 0.65]));
+      const result: TestDataModel[] = await service.vectorSearch({
+        input: 'authentication',
+        searchInKey: 'contentVectorized',
+        searchMode: LVS_Search_Mode.hybrid,
+        textSearchKey: 'content',
+        hybridWeight: { vector: 0, text: 1 },
+        limit: 3,
+      });
+      expect(result.length).toBe(3);
+      expect(result[0]._id).toBe('doc-user');
+    });
+
+    it('| all-zero BM25 fallback → cosine-rendezes marad', async () => {
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.45, 0.55, 0.65]));
+      const result: TestDataModel[] = await service.vectorSearch({
+        input: 'xyzzy-nonexistent-token',
+        searchInKey: 'contentVectorized',
+        searchMode: LVS_Search_Mode.hybrid,
+        textSearchKey: 'content',
+        limit: 3,
+      });
+      expect(result.length).toBe(3);
+      expect(result[0]._id).toBe('doc-recipe');
+    });
+
+    it('| limit honored hybrid modban', async () => {
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve(buildHybridCorpus()));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.4, 0.5, 0.6]));
+      const result: TestDataModel[] = await service.vectorSearch({
+        input: 'UserController',
+        searchInKey: 'contentVectorized',
+        searchMode: LVS_Search_Mode.hybrid,
+        textSearchKey: 'content',
+        limit: 1,
+      });
+      expect(result.length).toBe(1);
+    });
+
+    it('| ures candidate-szet → ures eredmeny', async () => {
+      spyOn(service, 'getAll').and.returnValue(Promise.resolve([]));
+      spyOn(service, 'vectorize').and.returnValue(Promise.resolve([0.4, 0.5, 0.6]));
+      const result: TestDataModel[] = await service.vectorSearch({
+        input: 'UserController',
+        searchInKey: 'contentVectorized',
+        searchMode: LVS_Search_Mode.hybrid,
+        textSearchKey: 'content',
+      });
+      expect(result.length).toBe(0);
+    });
+  });
+});
+