@futdevpro/nts-dynamo 1.15.58 → 1.15.60

package/src/_modules/data-readers/_collections/dynts-sqlite-reader.util.ts

@@ -5,8 +5,7 @@ import Database from 'better-sqlite3';
 import { DyFM_Error } from '@futdevpro/fsm-dynamo';
 
 import {
-    DyNTS_SqliteColumnInfo,
-    DyNTS_SqliteReadOptions,
+  DyNTS_SqliteColumnInfo
 } from '../_models/interfaces/dynts-sqlite-reader.interface';
 
 /**
@@ -29,156 +28,168 @@ import {
  */
 export class DyNTS_Sqlite_Reader_Util {
 
-    /** A hibák issuer-e (a strukturált DyFM_Error-okhoz). */
-    private static readonly issuer: string = 'DyNTS_Sqlite_Reader_Util';
+  /** A hibák issuer-e (a strukturált DyFM_Error-okhoz). */
+  private static readonly issuer: string = 'DyNTS_Sqlite_Reader_Util';
 
-    /** A `query()` SELECT-only guard regex-e: a (trimmelt, lowercase) SQL `select`/`with`-tel kezdődik. */
-    private static readonly SELECT_ONLY: RegExp = /^\s*(select|with)\b/i;
+  /** A `query()` SELECT-only guard regex-e: a (trimmelt, lowercase) SQL `select`/`with`-tel kezdődik. */
+  private static readonly SELECT_ONLY: RegExp = /^\s*(select|with)\b/i;
 
-    /**
+  /**
      * Egy tábla ÖSSZES sorának read-only olvasása (`SELECT * FROM <table>`). A `table` nevet
      * `sqlite_master` ellen validáljuk (csak létező táblanév fut, így nincs SQL-injekciós felület a
      * tábla-néven). Nem-létező tábla → strukturált hiba (NEM néma-[]).
      */
-    public static readTable(dbPath: string, table: string): unknown[] {
-        return DyNTS_Sqlite_Reader_Util.withDb(dbPath, (db) => {
-            if (!DyNTS_Sqlite_Reader_Util.tableExists(db, table)) {
-                throw new DyFM_Error({
-                    errorCode: 'DyNTS-SQLITE-READ-002',
-                    message: `Table '${table}' does not exist in the SQLite DB: '${dbPath}'.`,
-                    issuer: DyNTS_Sqlite_Reader_Util.issuer,
-                });
-            }
-            // A `table` itt már egy igazolt, létező táblanév (sqlite_master), nem nyers user-input.
-            return db.prepare(`SELECT * FROM "${table}"`).all();
+  public static readTable(dbPath: string, table: string): unknown[] {
+    return DyNTS_Sqlite_Reader_Util.withDb(dbPath, (db) => {
+      if (!DyNTS_Sqlite_Reader_Util.tableExists(db, table)) {
+        throw new DyFM_Error({
+          errorCode: 'DyNTS-SQLITE-READ-002',
+          message: `Table '${table}' does not exist in the SQLite DB: '${dbPath}'.`,
+          issuer: DyNTS_Sqlite_Reader_Util.issuer,
         });
-    }
+      }
+
+      // A `table` itt már egy igazolt, létező táblanév (sqlite_master), nem nyers user-input.
+      return db.prepare(`SELECT * FROM "${table}"`).all();
+    });
+  }
 
-    /**
+  /**
      * Egy tetszőleges **SELECT-only** lekérdezés read-only futtatása. A guard elutasít minden nem-SELECT
      * (insert/update/delete/drop/attach/pragma-write/…) SQL-t → `DyNTS-SQLITE-READONLY-001`. A
      * `params` opcionális prepared-statement paraméterek (pozícionális `?` vagy named `@x`).
      */
-    public static query(dbPath: string, sql: string, params?: unknown[] | { [key: string]: unknown }): unknown[] {
-        DyNTS_Sqlite_Reader_Util.assertSelectOnly(sql);
-        return DyNTS_Sqlite_Reader_Util.withDb(dbPath, (db) => {
-            const statement: Database.Statement = db.prepare(sql);
-            // A `better-sqlite3` `.all()` csak read-statement-en ad sort; write-statement-en dobna —
-            // a SELECT-only guard ezt már a forrás-rétegben kizárja (defenzív kettősség).
-            return params === undefined ? statement.all() : statement.all(params as never);
-        });
-    }
+  public static query(dbPath: string, sql: string, params?: unknown[] | { [key: string]: unknown }): unknown[] {
+    DyNTS_Sqlite_Reader_Util.assertSelectOnly(sql);
 
-    /** A DB ÖSSZES (nem-belső) táblanevének read-only listája (`sqlite_master`, ABC-sorrendben). */
-    public static listTables(dbPath: string): string[] {
-        return DyNTS_Sqlite_Reader_Util.withDb(dbPath, (db) => {
-            const rows: { name: string }[] = db.prepare(
-                "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name",
-            ).all() as { name: string }[];
-            return rows.map((row) => row.name);
-        });
-    }
+    return DyNTS_Sqlite_Reader_Util.withDb(dbPath, (db) => {
+      const statement: Database.Statement = db.prepare(sql);
+
+      // A `better-sqlite3` `.all()` csak read-statement-en ad sort; write-statement-en dobna —
+      // a SELECT-only guard ezt már a forrás-rétegben kizárja (defenzív kettősség).
+      return params === undefined ? statement.all() : statement.all(params);
+    });
+  }
+
+  /** A DB ÖSSZES (nem-belső) táblanevének read-only listája (`sqlite_master`, ABC-sorrendben). */
+  public static listTables(dbPath: string): string[] {
+    return DyNTS_Sqlite_Reader_Util.withDb(dbPath, (db) => {
+      const rows: { name: string }[] = db.prepare(
+        'SELECT name FROM sqlite_master WHERE type=\'table\' AND name NOT LIKE \'sqlite_%\' ORDER BY name',
+      ).all() as { name: string }[];
 
-    /**
+      return rows.map((row) => row.name);
+    });
+  }
+
+  /**
      * Egy tábla séma-leírása (`PRAGMA table_info(<table>)` — a SQLite read-only introspekciója). A
      * `table` nevet `sqlite_master` ellen validáljuk (nem-létező → strukturált hiba). Az oszlop-info
      * (`cid`/`name`/`type`/`notNull`/`defaultValue`/`primaryKey`) normalizált shape-ben tér vissza.
      */
-    public static getSchema(dbPath: string, table: string): DyNTS_SqliteColumnInfo[] {
-        return DyNTS_Sqlite_Reader_Util.withDb(dbPath, (db) => {
-            if (!DyNTS_Sqlite_Reader_Util.tableExists(db, table)) {
-                throw new DyFM_Error({
-                    errorCode: 'DyNTS-SQLITE-READ-002',
-                    message: `Table '${table}' does not exist in the SQLite DB: '${dbPath}'.`,
-                    issuer: DyNTS_Sqlite_Reader_Util.issuer,
-                });
-            }
-            const rows: PragmaColumnRow[] = db.pragma(`table_info("${table}")`) as PragmaColumnRow[];
-            return rows.map((row) => ({
-                cid: row.cid,
-                name: row.name,
-                type: row.type,
-                notNull: row.notnull === 1,
-                defaultValue: row.dflt_value,
-                primaryKey: row.pk > 0,
-            }));
+  public static getSchema(dbPath: string, table: string): DyNTS_SqliteColumnInfo[] {
+    return DyNTS_Sqlite_Reader_Util.withDb(dbPath, (db) => {
+      if (!DyNTS_Sqlite_Reader_Util.tableExists(db, table)) {
+        throw new DyFM_Error({
+          errorCode: 'DyNTS-SQLITE-READ-002',
+          message: `Table '${table}' does not exist in the SQLite DB: '${dbPath}'.`,
+          issuer: DyNTS_Sqlite_Reader_Util.issuer,
         });
-    }
+      }
+      const rows: PragmaColumnRow[] = db.pragma(`table_info("${table}")`) as PragmaColumnRow[];
 
-    // =========================================================================
-    // Belső segédek (read-only megnyitás + guard-ok)
-    // =========================================================================
+      return rows.map((row) => ({
+        cid: row.cid,
+        name: row.name,
+        type: row.type,
+        notNull: row.notnull === 1,
+        defaultValue: row.dflt_value,
+        primaryKey: row.pk > 0,
+      }));
+    });
+  }
 
-    /**
+  // =========================================================================
+  // Belső segédek (read-only megnyitás + guard-ok)
+  // =========================================================================
+
+  /**
      * A DB read-only megnyitása + a callback futtatása + GARANTÁLT zárás (try/finally). A `path`
      * validálva (üres/nem-létező → strukturált hiba); a megnyitás-/olvasás-hibát strukturált
      * `DyFM_Error`-rá fordítjuk (a már-DyFM_Error-t NEM csomagoljuk újra). A `readonly:true` az
      * első védvonal (a SQLite-engine elutasít minden írást).
      */
-    private static withDb<T>(dbPath: string, work: (db: Database.Database) => T, options?: DyNTS_SqliteReadOptions): T {
-        if (!dbPath || !dbPath.trim().length) {
-            throw new DyFM_Error({
-                errorCode: 'DyNTS-SQLITE-READ-001',
-                message: 'A SQLite read requires a non-empty `dbPath` (path to the `.db` file).',
-                issuer: DyNTS_Sqlite_Reader_Util.issuer,
-            });
-        }
-        if (!fs.existsSync(dbPath)) {
-            throw new DyFM_Error({
-                errorCode: 'DyNTS-SQLITE-READ-001',
-                message: `The SQLite DB file was not found: '${dbPath}'.`,
-                issuer: DyNTS_Sqlite_Reader_Util.issuer,
-            });
-        }
-        let db: Database.Database | undefined = undefined;
-        try {
-            db = new Database(dbPath, { readonly: true, fileMustExist: true });
-            return work(db);
-        } catch (error) {
-            if (error instanceof DyFM_Error) {
-                throw error;
-            }
-            throw new DyFM_Error({
-                errorCode: 'DyNTS-SQLITE-READ-003',
-                message: `Opening/reading the SQLite DB failed: '${dbPath}'.\n  error: `
+  private static withDb<T>(dbPath: string, work: (db: Database.Database) => T): T {
+    if (!dbPath?.trim().length) {
+      throw new DyFM_Error({
+        errorCode: 'DyNTS-SQLITE-READ-001',
+        message: 'A SQLite read requires a non-empty `dbPath` (path to the `.db` file).',
+        issuer: DyNTS_Sqlite_Reader_Util.issuer,
+      });
+    }
+
+    if (!fs.existsSync(dbPath)) {
+      throw new DyFM_Error({
+        errorCode: 'DyNTS-SQLITE-READ-001',
+        message: `The SQLite DB file was not found: '${dbPath}'.`,
+        issuer: DyNTS_Sqlite_Reader_Util.issuer,
+      });
+    }
+    let db: Database.Database | undefined = undefined;
+
+    try {
+      db = new Database(dbPath, { readonly: true, fileMustExist: true });
+
+      return work(db);
+    } catch (error) {
+      if (error instanceof DyFM_Error) {
+        throw error;
+      }
+
+      throw new DyFM_Error({
+        errorCode: 'DyNTS-SQLITE-READ-003',
+        message: `Opening/reading the SQLite DB failed: '${dbPath}'.\n  error: `
                     + `${DyFM_Error.getErrorMessage(error)}`,
-                issuer: DyNTS_Sqlite_Reader_Util.issuer,
-                error: error,
-            });
-        } finally {
-            if (db) {
-                db.close();
-            }
-        }
+        issuer: DyNTS_Sqlite_Reader_Util.issuer,
+        error: error,
+      });
+    } finally {
+      if (db) {
+        db.close();
+      }
     }
+  }
+
+  /** A SELECT-only guard: nem-SELECT/WITH kezdetű VAGY multi-statement SQL → strukturált hiba. */
+  private static assertSelectOnly(sql: string): void {
+    const trimmed: string = (sql ?? '').trim();
 
-    /** A SELECT-only guard: nem-SELECT/WITH kezdetű VAGY multi-statement SQL → strukturált hiba. */
-    private static assertSelectOnly(sql: string): void {
-        const trimmed: string = (sql ?? '').trim();
-        if (!trimmed.length || !DyNTS_Sqlite_Reader_Util.SELECT_ONLY.test(trimmed)) {
-            throw new DyFM_Error({
-                errorCode: 'DyNTS-SQLITE-READONLY-001',
-                message: 'Only read-only SELECT/WITH queries are allowed (the reader is read-only).',
-                issuer: DyNTS_Sqlite_Reader_Util.issuer,
-            });
-        }
-        // Multi-statement (`;` után további nem-üres tartalom) tiltott — egy SELECT mögé nem rejthető írás.
-        const withoutTrailingSemicolon: string = trimmed.replace(/;\s*$/, '');
-        if (withoutTrailingSemicolon.includes(';')) {
-            throw new DyFM_Error({
-                errorCode: 'DyNTS-SQLITE-READONLY-001',
-                message: 'Multi-statement SQL is not allowed (only a single read-only SELECT/WITH).',
-                issuer: DyNTS_Sqlite_Reader_Util.issuer,
-            });
-        }
+    if (!trimmed.length || !DyNTS_Sqlite_Reader_Util.SELECT_ONLY.test(trimmed)) {
+      throw new DyFM_Error({
+        errorCode: 'DyNTS-SQLITE-READONLY-001',
+        message: 'Only read-only SELECT/WITH queries are allowed (the reader is read-only).',
+        issuer: DyNTS_Sqlite_Reader_Util.issuer,
+      });
     }
+    // Multi-statement (`;` után további nem-üres tartalom) tiltott — egy SELECT mögé nem rejthető írás.
+    const withoutTrailingSemicolon: string = trimmed.replace(/;\s*$/, '');
 
-    /** Egy tábla létezésének read-only ellenőrzése (`sqlite_master`). */
-    private static tableExists(db: Database.Database, table: string): boolean {
-        const found: unknown =
-            db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table);
-        return Boolean(found);
+    if (withoutTrailingSemicolon.includes(';')) {
+      throw new DyFM_Error({
+        errorCode: 'DyNTS-SQLITE-READONLY-001',
+        message: 'Multi-statement SQL is not allowed (only a single read-only SELECT/WITH).',
+        issuer: DyNTS_Sqlite_Reader_Util.issuer,
+      });
     }
+  }
+
+  /** Egy tábla létezésének read-only ellenőrzése (`sqlite_master`). */
+  private static tableExists(db: Database.Database, table: string): boolean {
+    const found: unknown =
+            db.prepare('SELECT name FROM sqlite_master WHERE type=\'table\' AND name=?').get(table);
+
+    return Boolean(found);
+  }
 }
 
 /** A `PRAGMA table_info` nyers sor-shape-je (a `better-sqlite3` ezt adja vissza). */

package/src/_modules/local-vector-search/_models/data-models/lvs-vector-persist.data-model.ts

@@ -2,7 +2,7 @@
 import { DyFM_DataModel_Params, DyFM_Metadata, DyFM_Object } from '@futdevpro/fsm-dynamo';
 
 /**
- * `DyNTS_LVS_VectorPersist_DataModel` (BFR-AM-001) — egy MongoDB-ben perzistált vektor-rekord, ami a
+ * `DyNTS_LVS_VectorPersist` (BFR-AM-001) — egy MongoDB-ben perzistált vektor-rekord, ami a
  * `LVS_VectorPool_ControlService` **in-memory** pool-jának tartós háttértára. A FAM (fdp-agent-memory)
  * workaround-ját generalizálja: a vektorok a SAJÁT Mongo-ban élnek, boot-kor a memória-pool-ba
  * hidratálódnak — **NEM** MongoDB Atlas Vector Search.
@@ -15,7 +15,7 @@ import { DyFM_DataModel_Params, DyFM_Metadata, DyFM_Object } from '@futdevpro/fs
  * ősből jön. A `metadata` `unknown` (Mongoose `Mixed`) — a fogyasztó tetszőleges kísérő-adatot tárolhat
  * (a séma NEM validál); az `embedding` `number[]` a perzistált nyers vektor.
  */
-export class DyNTS_LVS_VectorPersist_DataModel extends DyFM_Metadata {
+export class DyNTS_LVS_VectorPersist extends DyFM_Metadata {
 
   /** A pool-on belüli vektor-kulcs (a `pool.addVector(vectorId, ...)` ezzel illeszt). */
   vectorId?: string;
@@ -32,8 +32,9 @@ export class DyNTS_LVS_VectorPersist_DataModel extends DyFM_Metadata {
   /** Opcionális fogyasztó-specifikus kísérő-adat (Mongoose `Mixed`; a séma NEM validál). */
   metadata?: unknown;
 
-  constructor(set?: Partial<DyNTS_LVS_VectorPersist_DataModel>) {
+  constructor(set?: Partial<DyNTS_LVS_VectorPersist>) {
     super(set);
+
     if (set) {
       DyFM_Object.cleanAssign(this, set);
     }
@@ -46,8 +47,8 @@ export class DyNTS_LVS_VectorPersist_DataModel extends DyFM_Metadata {
  * `vectorId` + `collectionKey` index-elt (a hidratálás `collectionKey`-re, az upsert/remove a
  * `vectorId`+`collectionKey` párra szűr).
  */
-export const dyNTS_lvsVectorPersist_dataParams: DyFM_DataModel_Params<DyNTS_LVS_VectorPersist_DataModel> =
-  new DyFM_DataModel_Params<DyNTS_LVS_VectorPersist_DataModel>({
+export const DyNTS_lvsVectorPersist_dataParams: DyFM_DataModel_Params<DyNTS_LVS_VectorPersist> =
+  new DyFM_DataModel_Params<DyNTS_LVS_VectorPersist>({
     dataName: 'dynts_lvs_vector',
     properties: {
       vectorId: { type: 'string', index: true, required: true },

package/src/_modules/local-vector-search/_services/lvs-persistent-vector-pool.control-service.spec.ts

@@ -5,12 +5,12 @@ import { DyNTS_global_settings } from '../../../_collections/global-settings.con
 import { DyNTS_GlobalService } from '../../../_services/core/global.service';
 import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
 import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
-import { DyNTS_LVS_VectorPersist_DataModel } from '../_models/data-models/lvs-vector-persist.data-model';
+import { DyNTS_LVS_VectorPersist } from '../_models/data-models/lvs-vector-persist.data-model';
 import { DyNTS_LVS_VectorPersist_DataService } from './lvs-vector-persist.data-service';
-import { DyNTS_LVS_PersistentVectorPool } from './lvs-persistent-vector-pool.control-service';
+import { DyNTS_LVS_PersistentVectorPool_ControlService } from './lvs-persistent-vector-pool.control-service';
 
 /**
- * BFR-AM-001 — a `DyNTS_LVS_PersistentVectorPool` (kompozíció: in-memory pool + Mongo-persist) spec-jei.
+ * BFR-AM-001 — a `DyNTS_LVS_PersistentVectorPool_ControlService` (kompozíció: in-memory pool + Mongo-persist) spec-jei.
  *
  * A DB-réteget egy IN-MEMORY fake-store helyettesíti: a `DyNTS_LVS_VectorPersist_DataService.prototype`
  * `upsertVector`/`removeVector`/`findByCollectionKey` metódusait stub-oljuk (a `getDBService` eager
@@ -18,12 +18,12 @@ import { DyNTS_LVS_PersistentVectorPool } from './lvs-persistent-vector-pool.con
  * így a perzisztencia memóriában modellezett, ÉLŐ Mongo nélkül (skip-guard nem szükséges). A fő bizonyíték:
  * **persist-then-hydrate round-trip** újraépíti a VALÓDI `LVS_VectorPool_ControlService` in-memory indexét.
  */
-describe('| DyNTS_LVS_PersistentVectorPool', () => {
+describe('| DyNTS_LVS_PersistentVectorPool_ControlService', () => {
 
   let mockDBService: jasmine.SpyObj<{ find: () => Promise<unknown[]>; findOne: () => Promise<unknown> }>;
 
   /** Fake tartós tár: `collectionKey` → (`vectorId` → rekord). A persist-stubok ezt írják/olvassák. */
-  let store: Map<string, Map<string, DyNTS_LVS_VectorPersist_DataModel>>;
+  let store: Map<string, Map<string, DyNTS_LVS_VectorPersist>>;
 
   beforeAll(() => {
     if (!DyNTS_global_settings.systemShortCodeName) {
@@ -44,16 +44,16 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
     spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService as never);
 
     // A fake tartós tár + a persist-service prototype-stubok (memóriában modellezett Mongo).
-    store = new Map<string, Map<string, DyNTS_LVS_VectorPersist_DataModel>>();
+    store = new Map<string, Map<string, DyNTS_LVS_VectorPersist>>();
 
     spyOn(DyNTS_LVS_VectorPersist_DataService.prototype, 'upsertVector').and.callFake(
       (set: { collectionKey: string; vectorId: string; embedding: number[]; metadata?: unknown }) => {
-        let coll: Map<string, DyNTS_LVS_VectorPersist_DataModel> | undefined = store.get(set.collectionKey);
+        let coll: Map<string, DyNTS_LVS_VectorPersist> | undefined = store.get(set.collectionKey);
         if (!coll) {
-          coll = new Map<string, DyNTS_LVS_VectorPersist_DataModel>();
+          coll = new Map<string, DyNTS_LVS_VectorPersist>();
           store.set(set.collectionKey, coll);
         }
-        coll.set(set.vectorId, new DyNTS_LVS_VectorPersist_DataModel({
+        coll.set(set.vectorId, new DyNTS_LVS_VectorPersist({
           collectionKey: set.collectionKey,
           vectorId: set.vectorId,
           embedding: set.embedding,
@@ -85,12 +85,12 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
   };
 
   it('| should persist on addVector and store the dimension', async () => {
-    const pool: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    const pool: DyNTS_LVS_PersistentVectorPool_ControlService =
+      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
 
     await pool.addVector('v1', [0.1, 0.2, 0.3], { tag: 'x' });
 
-    const persisted: DyNTS_LVS_VectorPersist_DataModel | undefined = store.get('pool-a')?.get('v1');
+    const persisted: DyNTS_LVS_VectorPersist | undefined = store.get('pool-a')?.get('v1');
     expect(persisted).toBeDefined();
     expect(persisted.embedding).toEqual([0.1, 0.2, 0.3]);
     expect(persisted.dimensions).toBe(3);
@@ -101,16 +101,16 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
 
   it('| persist-then-hydrate round-trip rebuilds the in-memory pool', async () => {
     // (1) Egy pool-ba 3 vektort persistálunk.
-    const writer: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    const writer: DyNTS_LVS_PersistentVectorPool_ControlService =
+      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
     await writer.addVector('v0', axis(4, 0));
     await writer.addVector('v1', axis(4, 1));
     await writer.addVector('v2', axis(4, 2));
     expect(store.get('pool-a').size).toBe(3);
 
     // (2) Egy FRISS wrapper (üres memória-pool) — szerver-restart szimuláció.
-    const rebuilt: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    const rebuilt: DyNTS_LVS_PersistentVectorPool_ControlService =
+      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
     expect(rebuilt.getPool().getAll().size).toBe(0);
 
     // (3) Hidratálás Mongo-ból → a memória-pool újraépül.
@@ -126,38 +126,38 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
   });
 
   it('| should only hydrate the matching collectionKey (pool partitioning)', async () => {
-    const a: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
-    const b: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-b', issuer: 'test' });
+    const a: DyNTS_LVS_PersistentVectorPool_ControlService =
+      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
+    const b: DyNTS_LVS_PersistentVectorPool_ControlService =
+      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-b', issuer: 'test' });
 
     await a.addVector('a1', axis(3, 0));
     await b.addVector('b1', axis(3, 1));
     await b.addVector('b2', axis(3, 2));
 
-    const rebuiltA: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    const rebuiltA: DyNTS_LVS_PersistentVectorPool_ControlService =
+      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
     expect(await rebuiltA.hydrateFromMongo()).toBe(1);
     expect(Array.from(rebuiltA.getPool().getAll().keys())).toEqual(['a1']);
   });
 
   it('| upsert (re-add) is reflected in both the pool and the store', async () => {
-    const pool: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    const pool: DyNTS_LVS_PersistentVectorPool_ControlService =
+      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
 
     await pool.addVector('v1', [1, 0, 0]);
     await pool.updateVector('v1', [0, 1, 0], { v: 2 });
 
     // a tárban EGY rekord van, a frissített értékkel + dimenzióval:
     expect(store.get('pool-a').size).toBe(1);
-    const persisted: DyNTS_LVS_VectorPersist_DataModel = store.get('pool-a').get('v1');
+    const persisted: DyNTS_LVS_VectorPersist = store.get('pool-a').get('v1');
     expect(persisted.embedding).toEqual([0, 1, 0]);
     expect(persisted.dimensions).toBe(3);
     expect(persisted.metadata).toEqual({ v: 2 });
 
     // és egy friss hidratálás a frissített vektort hozza:
-    const rebuilt: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    const rebuilt: DyNTS_LVS_PersistentVectorPool_ControlService =
+      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
     await rebuilt.hydrateFromMongo();
     const hits: LVS_SearchResult[] = rebuilt.search([0, 1, 0], 1, LVS_Search_Mode.cosineSimilarity);
     expect(hits[0].id).toBe('v1');
@@ -165,8 +165,8 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
   });
 
   it('| removeVector is reflected in both the pool and the store', async () => {
-    const pool: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    const pool: DyNTS_LVS_PersistentVectorPool_ControlService =
+      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
 
     await pool.addVector('v1', axis(3, 0));
     await pool.addVector('v2', axis(3, 1));
@@ -181,15 +181,15 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
   });
 
   it('| hydrate(records) rebuilds the pool without a Mongo read and skips incomplete records', () => {
-    const pool: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    const pool: DyNTS_LVS_PersistentVectorPool_ControlService =
+      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
 
     const loaded: number = pool.hydrate([
-      new DyNTS_LVS_VectorPersist_DataModel({ collectionKey: 'pool-a', vectorId: 'v1', embedding: axis(2, 0) }),
-      new DyNTS_LVS_VectorPersist_DataModel({ collectionKey: 'pool-a', vectorId: 'v2', embedding: axis(2, 1) }),
+      new DyNTS_LVS_VectorPersist({ collectionKey: 'pool-a', vectorId: 'v1', embedding: axis(2, 0) }),
+      new DyNTS_LVS_VectorPersist({ collectionKey: 'pool-a', vectorId: 'v2', embedding: axis(2, 1) }),
       // hiányos rekordok (átugorva):
-      new DyNTS_LVS_VectorPersist_DataModel({ collectionKey: 'pool-a', vectorId: 'v3', embedding: [] }),
-      new DyNTS_LVS_VectorPersist_DataModel({ collectionKey: 'pool-a', embedding: axis(2, 0) }),
+      new DyNTS_LVS_VectorPersist({ collectionKey: 'pool-a', vectorId: 'v3', embedding: [] }),
+      new DyNTS_LVS_VectorPersist({ collectionKey: 'pool-a', embedding: axis(2, 0) }),
     ]);
 
     expect(loaded).toBe(2);

package/src/_modules/local-vector-search/_services/lvs-persistent-vector-pool.control-service.ts

@@ -3,12 +3,12 @@ import { DyFM_Log } from '@futdevpro/fsm-dynamo';
 
 import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
 import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
-import { DyNTS_LVS_VectorPersist_DataModel } from '../_models/data-models/lvs-vector-persist.data-model';
+import { DyNTS_LVS_VectorPersist } from '../_models/data-models/lvs-vector-persist.data-model';
 import { DyNTS_LVS_VectorPersist_DataService } from './lvs-vector-persist.data-service';
 import { LVS_VectorPool_ControlService } from './lvs-vector-pool.control-service';
 
 /**
- * `DyNTS_LVS_PersistentVectorPool` (BFR-AM-001) — egy `LVS_VectorPool_ControlService` in-memory pool +
+ * `DyNTS_LVS_PersistentVectorPool_ControlService` (BFR-AM-001) — egy `LVS_VectorPool_ControlService` in-memory pool +
  * MongoDB-perzisztencia **kompozíciója**. A FAM (fdp-agent-memory) `FAM_VectorSearch_ControlService`
  * persist+hydrate workaround-ját generalizálja bedrock-szintre: a vektorok a SAJÁT Mongo-ban
  * (`dynts_lvs_vector`) élnek, boot-kor a memória-pool-ba hidratálódnak — **NEM** MongoDB Atlas
@@ -24,7 +24,7 @@ import { LVS_VectorPool_ControlService } from './lvs-vector-pool.control-service
  * `getDBService`-t hív, ezért a wrapper NEM tart élő data-service-mezőt — minden DB-művelet előtt lazy
  * `new DyNTS_LVS_VectorPersist_DataService(...)` (a `getPersistService` ezt adja).
  */
-export class DyNTS_LVS_PersistentVectorPool {
+export class DyNTS_LVS_PersistentVectorPool_ControlService {
 
   /** A wrapped in-memory pool (a Dynamo LVS engine; VÁLTOZATLAN — kompozíció, nem módosítás). */
   private readonly pool: LVS_VectorPool_ControlService;
@@ -98,12 +98,13 @@ export class DyNTS_LVS_PersistentVectorPool {
    * Visszaadja a betöltött vektorok számát. **NEM** Atlas — saját Mongo + in-memory pool.
    */
   async hydrateFromMongo(): Promise<number> {
-    const records: DyNTS_LVS_VectorPersist_DataModel[] =
+    const records: DyNTS_LVS_VectorPersist[] =
       await this.getPersistService().findByCollectionKey(this.collectionKey);
 
     this.pool.clearPool();
 
     let loaded: number = 0;
+
     for (const record of records) {
       if (!record.vectorId || !record.embedding?.length) {
         continue;
@@ -115,6 +116,7 @@ export class DyNTS_LVS_PersistentVectorPool {
     DyFM_Log.log(
       `[DyNTS LVS hydrate] '${this.collectionKey}' pool: ${loaded} vektor betöltve az in-memory pool-ba.`,
     );
+
     return loaded;
   }
 
@@ -123,9 +125,10 @@ export class DyNTS_LVS_PersistentVectorPool {
    * kezében van a rekord-halmaz (pl. batch-boot). A pool-t előbb üríti (idempotens). Visszaadja a
    * betöltött vektorok számát.
    */
-  hydrate(records: DyNTS_LVS_VectorPersist_DataModel[]): number {
+  hydrate(records: DyNTS_LVS_VectorPersist[]): number {
     this.pool.clearPool();
     let loaded: number = 0;
+
     for (const record of records) {
       if (!record.vectorId || !record.embedding?.length) {
         continue;
@@ -133,6 +136,7 @@ export class DyNTS_LVS_PersistentVectorPool {
       this.pool.addVector(record.vectorId, record.embedding);
       loaded++;
     }
+
     return loaded;
   }