@futdevpro/nts-dynamo 1.15.151 → 1.15.154

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

@@ -1,167 +1,167 @@
-
-import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_GlobalService } from '../../../_services/core/global.service';
-import { DyNTS_LVS_VectorPersist } from '../_models/data-models/lvs-vector-persist.data-model';
-import { DyNTS_LVS_VectorPersist_DataService } from './lvs-vector-persist.data-service';
-
-/**
- * BFR-AM-001 — a `DyNTS_LVS_VectorPersist_DataService` spec-jei. A base-ctor eager `getDBService`-jét
- * stub-oljuk (memory: dynts_dataservice_eager_resolve), így NEM kell élő Mongo. Az upsert atomikus
- * `$set`-jét (Mixed `metadata` — memory: mongoose_mixed_atomic_write) + a dimenzió-tárolást bizonyítja.
- */
-describe('| DyNTS_LVS_VectorPersist_DataService', () => {
-
-  let mockDBService: jasmine.SpyObj<{ find: () => Promise<unknown[]>; findOne: () => 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']);
-    mockDBService.find.and.returnValue(Promise.resolve([]));
-    mockDBService.findOne.and.returnValue(Promise.resolve(null));
-    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService as never);
-  });
-
-  describe('| constructor', () => {
-
-    it('| should create the service with a data model', () => {
-      const data: DyNTS_LVS_VectorPersist = new DyNTS_LVS_VectorPersist({
-        collectionKey: 'pool-a',
-        vectorId: 'v1',
-        embedding: [1, 2, 3],
-      });
-
-      const service: DyNTS_LVS_VectorPersist_DataService =
-        new DyNTS_LVS_VectorPersist_DataService({ data: data, issuer: 'issuer-123' });
-
-      expect(service).toBeInstanceOf(DyNTS_LVS_VectorPersist_DataService);
-      expect(service.data).toBeDefined();
-      expect(service.data.vectorId).toBe('v1');
-      expect(service.data.collectionKey).toBe('pool-a');
-    });
-
-    it('| should create the service without data', () => {
-      const service: DyNTS_LVS_VectorPersist_DataService =
-        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
-
-      expect(service).toBeInstanceOf(DyNTS_LVS_VectorPersist_DataService);
-      expect(service.data).toBeInstanceOf(DyNTS_LVS_VectorPersist);
-    });
-  });
-
-  describe('| findByCollectionKey', () => {
-
-    it('| should query the persisted vectors for a collectionKey', async () => {
-      const service: DyNTS_LVS_VectorPersist_DataService =
-        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
-
-      const records: DyNTS_LVS_VectorPersist[] = [
-        new DyNTS_LVS_VectorPersist({ collectionKey: 'pool-a', vectorId: 'v1', embedding: [1, 0] }),
-      ];
-      const findSpy = spyOn(service, 'findDataList').and.returnValue(Promise.resolve(records));
-
-      const result: DyNTS_LVS_VectorPersist[] = await service.findByCollectionKey('pool-a');
-
-      expect(findSpy).toHaveBeenCalledTimes(1);
-      const filterArg = findSpy.calls.mostRecent().args[0] as { collectionKey: string };
-      expect(filterArg.collectionKey).toBe('pool-a');
-      expect(result).toBe(records);
-    });
-  });
-
-  describe('| upsertVector — atomic $set + dimension store', () => {
-
-    it('| should issue an updateOne $set (with dimensions) for an EXISTING record', async () => {
-      const service: DyNTS_LVS_VectorPersist_DataService =
-        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
-
-      const existing: DyNTS_LVS_VectorPersist = new DyNTS_LVS_VectorPersist({
-        collectionKey: 'pool-a', vectorId: 'v1', embedding: [1, 2, 3],
-      });
-      existing._id = 'rec-1';
-
-      spyOn(service, 'findData').and.returnValue(Promise.resolve(existing));
-      const updateSpy = spyOn(service, 'updateData').and.returnValue(Promise.resolve());
-      const saveSpy = spyOn(service, 'saveData').and.returnValue(Promise.resolve(existing));
-
-      await service.upsertVector({
-        collectionKey: 'pool-a', vectorId: 'v1', embedding: [4, 5, 6, 7], metadata: { tag: 'x' },
-      });
-
-      expect(saveSpy).not.toHaveBeenCalled();
-      expect(updateSpy).toHaveBeenCalledTimes(1);
-      const arg = updateSpy.calls.mostRecent().args[0] as {
-        filterBy: { _id: string };
-        update: { $set: { embedding: number[]; dimensions: number; metadata: unknown } };
-      };
-      expect(arg.filterBy._id).toBe('rec-1');
-      expect(arg.update.$set.embedding).toEqual([4, 5, 6, 7]);
-      expect(arg.update.$set.dimensions).toBe(4);
-      expect(arg.update.$set.metadata).toEqual({ tag: 'x' });
-    });
-
-    it('| should saveData a NEW record (with stored dimensions) when none exists', async () => {
-      const service: DyNTS_LVS_VectorPersist_DataService =
-        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
-
-      spyOn(service, 'findData').and.returnValue(Promise.resolve(null));
-      const updateSpy = spyOn(service, 'updateData').and.returnValue(Promise.resolve());
-      const saveSpy = spyOn(service, 'saveData')
-        .and.callFake((data?: DyNTS_LVS_VectorPersist) =>
-          Promise.resolve(data as DyNTS_LVS_VectorPersist));
-
-      await service.upsertVector({ collectionKey: 'pool-a', vectorId: 'v2', embedding: [0.1, 0.2] });
-
-      expect(updateSpy).not.toHaveBeenCalled();
-      expect(saveSpy).toHaveBeenCalledTimes(1);
-      const written = saveSpy.calls.mostRecent().args[0] as DyNTS_LVS_VectorPersist;
-      expect(written.vectorId).toBe('v2');
-      expect(written.collectionKey).toBe('pool-a');
-      expect(written.embedding).toEqual([0.1, 0.2]);
-      expect(written.dimensions).toBe(2);
-    });
-  });
-
-  describe('| removeVector', () => {
-
-    it('| should absolute-delete the matching record', async () => {
-      const service: DyNTS_LVS_VectorPersist_DataService =
-        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
-
-      const existing: DyNTS_LVS_VectorPersist = new DyNTS_LVS_VectorPersist({
-        collectionKey: 'pool-a', vectorId: 'v1', embedding: [1, 0],
-      });
-      existing._id = 'rec-1';
-
-      spyOn(service, 'findData').and.returnValue(Promise.resolve(existing));
-      const deleteSpy = spyOn(service, 'deleteData').and.returnValue(Promise.resolve());
-
-      await service.removeVector('pool-a', 'v1');
-
-      expect(deleteSpy).toHaveBeenCalledWith('rec-1', true);
-    });
-
-    it('| should be a no-op when no matching record exists', async () => {
-      const service: DyNTS_LVS_VectorPersist_DataService =
-        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
-
-      spyOn(service, 'findData').and.returnValue(Promise.resolve(null));
-      const deleteSpy = spyOn(service, 'deleteData').and.returnValue(Promise.resolve());
-
-      await service.removeVector('pool-a', 'missing');
-
-      expect(deleteSpy).not.toHaveBeenCalled();
-    });
-  });
-});
+
+import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_GlobalService } from '../../../_services/core/global.service';
+import { DyNTS_LVS_VectorPersist } from '../_models/data-models/lvs-vector-persist.data-model';
+import { DyNTS_LVS_VectorPersist_DataService } from './lvs-vector-persist.data-service';
+
+/**
+ * BFR-AM-001 — a `DyNTS_LVS_VectorPersist_DataService` spec-jei. A base-ctor eager `getDBService`-jét
+ * stub-oljuk (memory: dynts_dataservice_eager_resolve), így NEM kell élő Mongo. Az upsert atomikus
+ * `$set`-jét (Mixed `metadata` — memory: mongoose_mixed_atomic_write) + a dimenzió-tárolást bizonyítja.
+ */
+describe('| DyNTS_LVS_VectorPersist_DataService', () => {
+
+  let mockDBService: jasmine.SpyObj<{ find: () => Promise<unknown[]>; findOne: () => 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']);
+    mockDBService.find.and.returnValue(Promise.resolve([]));
+    mockDBService.findOne.and.returnValue(Promise.resolve(null));
+    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService as never);
+  });
+
+  describe('| constructor', () => {
+
+    it('| should create the service with a data model', () => {
+      const data: DyNTS_LVS_VectorPersist = new DyNTS_LVS_VectorPersist({
+        collectionKey: 'pool-a',
+        vectorId: 'v1',
+        embedding: [1, 2, 3],
+      });
+
+      const service: DyNTS_LVS_VectorPersist_DataService =
+        new DyNTS_LVS_VectorPersist_DataService({ data: data, issuer: 'issuer-123' });
+
+      expect(service).toBeInstanceOf(DyNTS_LVS_VectorPersist_DataService);
+      expect(service.data).toBeDefined();
+      expect(service.data.vectorId).toBe('v1');
+      expect(service.data.collectionKey).toBe('pool-a');
+    });
+
+    it('| should create the service without data', () => {
+      const service: DyNTS_LVS_VectorPersist_DataService =
+        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
+
+      expect(service).toBeInstanceOf(DyNTS_LVS_VectorPersist_DataService);
+      expect(service.data).toBeInstanceOf(DyNTS_LVS_VectorPersist);
+    });
+  });
+
+  describe('| findByCollectionKey', () => {
+
+    it('| should query the persisted vectors for a collectionKey', async () => {
+      const service: DyNTS_LVS_VectorPersist_DataService =
+        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
+
+      const records: DyNTS_LVS_VectorPersist[] = [
+        new DyNTS_LVS_VectorPersist({ collectionKey: 'pool-a', vectorId: 'v1', embedding: [1, 0] }),
+      ];
+      const findSpy = spyOn(service, 'findDataList').and.returnValue(Promise.resolve(records));
+
+      const result: DyNTS_LVS_VectorPersist[] = await service.findByCollectionKey('pool-a');
+
+      expect(findSpy).toHaveBeenCalledTimes(1);
+      const filterArg = findSpy.calls.mostRecent().args[0] as { collectionKey: string };
+      expect(filterArg.collectionKey).toBe('pool-a');
+      expect(result).toBe(records);
+    });
+  });
+
+  describe('| upsertVector — atomic $set + dimension store', () => {
+
+    it('| should issue an updateOne $set (with dimensions) for an EXISTING record', async () => {
+      const service: DyNTS_LVS_VectorPersist_DataService =
+        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
+
+      const existing: DyNTS_LVS_VectorPersist = new DyNTS_LVS_VectorPersist({
+        collectionKey: 'pool-a', vectorId: 'v1', embedding: [1, 2, 3],
+      });
+      existing._id = 'rec-1';
+
+      spyOn(service, 'findData').and.returnValue(Promise.resolve(existing));
+      const updateSpy = spyOn(service, 'updateData').and.returnValue(Promise.resolve());
+      const saveSpy = spyOn(service, 'saveData').and.returnValue(Promise.resolve(existing));
+
+      await service.upsertVector({
+        collectionKey: 'pool-a', vectorId: 'v1', embedding: [4, 5, 6, 7], metadata: { tag: 'x' },
+      });
+
+      expect(saveSpy).not.toHaveBeenCalled();
+      expect(updateSpy).toHaveBeenCalledTimes(1);
+      const arg = updateSpy.calls.mostRecent().args[0] as {
+        filterBy: { _id: string };
+        update: { $set: { embedding: number[]; dimensions: number; metadata: unknown } };
+      };
+      expect(arg.filterBy._id).toBe('rec-1');
+      expect(arg.update.$set.embedding).toEqual([4, 5, 6, 7]);
+      expect(arg.update.$set.dimensions).toBe(4);
+      expect(arg.update.$set.metadata).toEqual({ tag: 'x' });
+    });
+
+    it('| should saveData a NEW record (with stored dimensions) when none exists', async () => {
+      const service: DyNTS_LVS_VectorPersist_DataService =
+        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
+
+      spyOn(service, 'findData').and.returnValue(Promise.resolve(null));
+      const updateSpy = spyOn(service, 'updateData').and.returnValue(Promise.resolve());
+      const saveSpy = spyOn(service, 'saveData')
+        .and.callFake((data?: DyNTS_LVS_VectorPersist) =>
+          Promise.resolve(data as DyNTS_LVS_VectorPersist));
+
+      await service.upsertVector({ collectionKey: 'pool-a', vectorId: 'v2', embedding: [0.1, 0.2] });
+
+      expect(updateSpy).not.toHaveBeenCalled();
+      expect(saveSpy).toHaveBeenCalledTimes(1);
+      const written = saveSpy.calls.mostRecent().args[0] as DyNTS_LVS_VectorPersist;
+      expect(written.vectorId).toBe('v2');
+      expect(written.collectionKey).toBe('pool-a');
+      expect(written.embedding).toEqual([0.1, 0.2]);
+      expect(written.dimensions).toBe(2);
+    });
+  });
+
+  describe('| removeVector', () => {
+
+    it('| should absolute-delete the matching record', async () => {
+      const service: DyNTS_LVS_VectorPersist_DataService =
+        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
+
+      const existing: DyNTS_LVS_VectorPersist = new DyNTS_LVS_VectorPersist({
+        collectionKey: 'pool-a', vectorId: 'v1', embedding: [1, 0],
+      });
+      existing._id = 'rec-1';
+
+      spyOn(service, 'findData').and.returnValue(Promise.resolve(existing));
+      const deleteSpy = spyOn(service, 'deleteData').and.returnValue(Promise.resolve());
+
+      await service.removeVector('pool-a', 'v1');
+
+      expect(deleteSpy).toHaveBeenCalledWith('rec-1', true);
+    });
+
+    it('| should be a no-op when no matching record exists', async () => {
+      const service: DyNTS_LVS_VectorPersist_DataService =
+        new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
+
+      spyOn(service, 'findData').and.returnValue(Promise.resolve(null));
+      const deleteSpy = spyOn(service, 'deleteData').and.returnValue(Promise.resolve());
+
+      await service.removeVector('pool-a', 'missing');
+
+      expect(deleteSpy).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -1,130 +1,130 @@
-
-import { DyFM_DBFilter, DyFM_DBFilterSimple } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_DataService } from '../../../_services/base/data.service';
-import {
-  DyNTS_LVS_VectorPersist,
-  DyNTS_lvsVectorPersist_dataParams
-} from '../_models/data-models/lvs-vector-persist.data-model';
-
-/**
- * `DyNTS_LVS_VectorPersist_DataService` (BFR-AM-001) — a `dynts_lvs_vector` collection CRUD-rétege; a
- * `LVS_VectorPool_ControlService` in-memory pool-jának tartós Mongo-háttértára. `extends
- * DyNTS_DataService`; a nts-konvenció szerinti `{ data?, issuer }` constructor.
- *
- * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a `DyNTS_DataService` base-ctor EAGER
- * `getDBService`-t hív → a hívó NEM tarthat élő data-service-példányt mezőként; minden művelet előtt
- * lazy `new DyNTS_LVS_VectorPersist_DataService(...)` kell (a `DyNTS_LVS_PersistentVectorPool_ControlService` így jár el).
- *
- * **Atomikus írás (memory: mongoose_mixed_atomic_write):** az upsert a `(collectionKey, vectorId)`
- * logikai-kulcson MEGLÉVŐ rekordot `updateOne({...},{$set:{embedding,dimensions,metadata}})`-tel
- * frissíti (a Mixed `metadata` `findOne→mutate→save` SILENT-DROP-ja ellen); ÚJ rekordot `saveData`-val ír.
- */
-export class DyNTS_LVS_VectorPersist_DataService extends DyNTS_DataService<DyNTS_LVS_VectorPersist> {
-
-  constructor(
-    set: {
-      data?: DyNTS_LVS_VectorPersist,
-      issuer: string,
-    },
-  ) {
-    super(
-      set.data instanceof DyNTS_LVS_VectorPersist
-        ? set.data
-        : new DyNTS_LVS_VectorPersist(set.data),
-      DyNTS_lvsVectorPersist_dataParams,
-      set.issuer,
-    );
-  }
-
-  /**
-   * Egy (logikai) pool ÖSSZES perzistált, nem-soft-delete-elt vektor-rekordja — a boot-hidratáláshoz
-   * (a `DyNTS_LVS_PersistentVectorPool_ControlService.hydrateFromMongo` ezt tölti az in-memory pool-ba).
-   */
-  async findByCollectionKey(collectionKey: string): Promise<DyNTS_LVS_VectorPersist[]> {
-    return this.findDataList(
-      { collectionKey: collectionKey },
-      true,
-    );
-  }
-
-  /**
-   * BFR-AM-013 (hydration-paging): LEAN + projektált (CSAK `vectorId` + `embedding` — a content-szöveg
-   * és metadata NÉLKÜL) cursor-batch scan a boot-hidratáláshoz. A heap-tranziens felső korlátja EGY batch
-   * (a teljes result-set + Mongoose-doc-boxing kimarad). Soft-delete-elt rekordok kihagyva.
-   */
-  async findLeanBatchedByCollectionKey(
-    collectionKey: string,
-    set: {
-      batchSize?: number,
-      handler: (batch: Partial<DyNTS_LVS_VectorPersist>[]) => Promise<void> | void,
-    }
-  ): Promise<number> {
-    return this.dataDBService.findLeanBatched(
-      { collectionKey: collectionKey, _deleted: undefined },
-      {
-        projection: { vectorId: 1, embedding: 1 },
-        batchSize: set.batchSize,
-        handler: set.handler,
-      }
-    );
-  }
-
-  /**
-   * Egy vektor ATOMIKUS upsert-je a `(collectionKey, vectorId)` logikai-kulcson. MEGLÉVŐ rekordnál
-   * `$set` (a Mixed `metadata` silent-drop ellen — memory: mongoose_mixed_atomic_write); ÚJ rekordnál
-   * `saveData`. A dimenzió az `embedding.length`-ből rögzül.
-   */
-  async upsertVector(set: {
-    collectionKey: string,
-    vectorId: string,
-    embedding: number[],
-    metadata?: unknown,
-  }): Promise<void> {
-    const existing: DyNTS_LVS_VectorPersist = await this.findData(
-      { collectionKey: set.collectionKey, vectorId: set.vectorId },
-      true,
-    );
-
-    if (existing?._id) {
-      await this.updateData({
-        filterBy: { _id: existing._id },
-        update: {
-          $set: {
-            embedding: set.embedding,
-            dimensions: set.embedding.length,
-            metadata: set.metadata,
-          },
-        },
-      });
-
-      return;
-    }
-
-    await this.saveData(
-      new DyNTS_LVS_VectorPersist({
-        collectionKey: set.collectionKey,
-        vectorId: set.vectorId,
-        embedding: set.embedding,
-        dimensions: set.embedding.length,
-        metadata: set.metadata,
-      }),
-      true,
-    );
-  }
-
-  /**
-   * Egy vektor-rekord végleges törlése a `(collectionKey, vectorId)` logikai-kulcson (a pool
-   * `removeVector`-ja után — a tartós tár is törli). `addArchive` nincs → `absolute` true-val töröl.
-   */
-  async removeVector(collectionKey: string, vectorId: string): Promise<void> {
-    const existing: DyNTS_LVS_VectorPersist = await this.findData(
-      { collectionKey: collectionKey, vectorId: vectorId },
-      true,
-    );
-
-    if (existing?._id) {
-      await this.deleteData(existing._id, true);
-    }
-  }
-}
+
+import { DyFM_DBFilter, DyFM_DBFilterSimple } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_DataService } from '../../../_services/base/data.service';
+import {
+  DyNTS_LVS_VectorPersist,
+  DyNTS_lvsVectorPersist_dataParams
+} from '../_models/data-models/lvs-vector-persist.data-model';
+
+/**
+ * `DyNTS_LVS_VectorPersist_DataService` (BFR-AM-001) — a `dynts_lvs_vector` collection CRUD-rétege; a
+ * `LVS_VectorPool_ControlService` in-memory pool-jának tartós Mongo-háttértára. `extends
+ * DyNTS_DataService`; a nts-konvenció szerinti `{ data?, issuer }` constructor.
+ *
+ * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a `DyNTS_DataService` base-ctor EAGER
+ * `getDBService`-t hív → a hívó NEM tarthat élő data-service-példányt mezőként; minden művelet előtt
+ * lazy `new DyNTS_LVS_VectorPersist_DataService(...)` kell (a `DyNTS_LVS_PersistentVectorPool_ControlService` így jár el).
+ *
+ * **Atomikus írás (memory: mongoose_mixed_atomic_write):** az upsert a `(collectionKey, vectorId)`
+ * logikai-kulcson MEGLÉVŐ rekordot `updateOne({...},{$set:{embedding,dimensions,metadata}})`-tel
+ * frissíti (a Mixed `metadata` `findOne→mutate→save` SILENT-DROP-ja ellen); ÚJ rekordot `saveData`-val ír.
+ */
+export class DyNTS_LVS_VectorPersist_DataService extends DyNTS_DataService<DyNTS_LVS_VectorPersist> {
+
+  constructor(
+    set: {
+      data?: DyNTS_LVS_VectorPersist,
+      issuer: string,
+    },
+  ) {
+    super(
+      set.data instanceof DyNTS_LVS_VectorPersist
+        ? set.data
+        : new DyNTS_LVS_VectorPersist(set.data),
+      DyNTS_lvsVectorPersist_dataParams,
+      set.issuer,
+    );
+  }
+
+  /**
+   * Egy (logikai) pool ÖSSZES perzistált, nem-soft-delete-elt vektor-rekordja — a boot-hidratáláshoz
+   * (a `DyNTS_LVS_PersistentVectorPool_ControlService.hydrateFromMongo` ezt tölti az in-memory pool-ba).
+   */
+  async findByCollectionKey(collectionKey: string): Promise<DyNTS_LVS_VectorPersist[]> {
+    return this.findDataList(
+      { collectionKey: collectionKey },
+      true,
+    );
+  }
+
+  /**
+   * BFR-AM-013 (hydration-paging): LEAN + projektált (CSAK `vectorId` + `embedding` — a content-szöveg
+   * és metadata NÉLKÜL) cursor-batch scan a boot-hidratáláshoz. A heap-tranziens felső korlátja EGY batch
+   * (a teljes result-set + Mongoose-doc-boxing kimarad). Soft-delete-elt rekordok kihagyva.
+   */
+  async findLeanBatchedByCollectionKey(
+    collectionKey: string,
+    set: {
+      batchSize?: number,
+      handler: (batch: Partial<DyNTS_LVS_VectorPersist>[]) => Promise<void> | void,
+    }
+  ): Promise<number> {
+    return this.dataDBService.findLeanBatched(
+      { collectionKey: collectionKey, _deleted: undefined },
+      {
+        projection: { vectorId: 1, embedding: 1 },
+        batchSize: set.batchSize,
+        handler: set.handler,
+      }
+    );
+  }
+
+  /**
+   * Egy vektor ATOMIKUS upsert-je a `(collectionKey, vectorId)` logikai-kulcson. MEGLÉVŐ rekordnál
+   * `$set` (a Mixed `metadata` silent-drop ellen — memory: mongoose_mixed_atomic_write); ÚJ rekordnál
+   * `saveData`. A dimenzió az `embedding.length`-ből rögzül.
+   */
+  async upsertVector(set: {
+    collectionKey: string,
+    vectorId: string,
+    embedding: number[],
+    metadata?: unknown,
+  }): Promise<void> {
+    const existing: DyNTS_LVS_VectorPersist = await this.findData(
+      { collectionKey: set.collectionKey, vectorId: set.vectorId },
+      true,
+    );
+
+    if (existing?._id) {
+      await this.updateData({
+        filterBy: { _id: existing._id },
+        update: {
+          $set: {
+            embedding: set.embedding,
+            dimensions: set.embedding.length,
+            metadata: set.metadata,
+          },
+        },
+      });
+
+      return;
+    }
+
+    await this.saveData(
+      new DyNTS_LVS_VectorPersist({
+        collectionKey: set.collectionKey,
+        vectorId: set.vectorId,
+        embedding: set.embedding,
+        dimensions: set.embedding.length,
+        metadata: set.metadata,
+      }),
+      true,
+    );
+  }
+
+  /**
+   * Egy vektor-rekord végleges törlése a `(collectionKey, vectorId)` logikai-kulcson (a pool
+   * `removeVector`-ja után — a tartós tár is törli). `addArchive` nincs → `absolute` true-val töröl.
+   */
+  async removeVector(collectionKey: string, vectorId: string): Promise<void> {
+    const existing: DyNTS_LVS_VectorPersist = await this.findData(
+      { collectionKey: collectionKey, vectorId: vectorId },
+      true,
+    );
+
+    if (existing?._id) {
+      await this.deleteData(existing._id, true);
+    }
+  }
+}