@futdevpro/nts-dynamo 1.15.58 → 1.15.64

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

@@ -9,6 +9,11 @@ import { DyFM_Error } from '@futdevpro/fsm-dynamo';
 import { DyNTS_Sqlite_Reader_Util } from './dynts-sqlite-reader.util';
 import { DyNTS_SqliteColumnInfo } from '../_models/interfaces/dynts-sqlite-reader.interface';
 
+interface NameInterface {
+  name: string;
+}
+
+
 /**
  * `DyNTS_Sqlite_Reader_Util` spec (BFR-AM-009). Egy temp `.db` fájlt hozunk létre (a reader path-szal
  * + `fileMustExist:true` nyit, ezért valódi fájl kell — a `:memory:` path-ön nem ad fájlt), feltöltjük,
@@ -20,142 +25,152 @@ import { DyNTS_SqliteColumnInfo } from '../_models/interfaces/dynts-sqlite-reade
  *   - `query` NEM-SELECT (INSERT/UPDATE/DELETE/DROP/multi-statement) → READONLY-hiba (elutasít),
  *   - hiányzó path / nem-létező fájl → strukturált hiba.
  */
-describe('DyNTS_Sqlite_Reader_Util (read-only SQLite reader, BFR-AM-009)', () => {
+describe('| DyNTS_Sqlite_Reader_Util (read-only SQLite reader, BFR-AM-009)', () => {
+
+  /** A temp DB-fájl útvonala (minden teszt-futáshoz egyedi). */
+  let dbPath: string;
 
-    /** A temp DB-fájl útvonala (minden teszt-futáshoz egyedi). */
-    let dbPath: string;
+  beforeAll(() => {
+    dbPath = path.join(os.tmpdir(), `dynts-sqlite-spec-${process.pid}-${Date.now()}.db`);
+    const db: Database.Database = new Database(dbPath);
 
-    beforeAll(() => {
-        dbPath = path.join(os.tmpdir(), `dynts-sqlite-spec-${process.pid}-${Date.now()}.db`);
-        const db: Database.Database = new Database(dbPath);
-        db.exec(`
+    db.exec(`
             CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT NOT NULL, age INTEGER);
             CREATE TABLE posts (id INTEGER PRIMARY KEY, title TEXT);
         `);
-        db.prepare('INSERT INTO users (id, name, age) VALUES (?, ?, ?)').run(1, 'Ada', 36);
-        db.prepare('INSERT INTO users (id, name, age) VALUES (?, ?, ?)').run(2, 'Grace', 40);
-        db.prepare('INSERT INTO posts (id, title) VALUES (?, ?)').run(1, 'Hello');
-        db.close();
-    });
-
-    afterAll(() => {
-        if (dbPath && fs.existsSync(dbPath)) {
-            fs.unlinkSync(dbPath);
-        }
-    });
-
-    /** Egy hívás, ami egy adott errorCode-dal kell hogy dobjon (strukturált, NEM néma). */
-    const expectErrorCode = (fn: () => unknown, expectedCode: string): void => {
-        let thrown: unknown;
-        try {
-            fn();
-        } catch (error) {
-            thrown = error;
-        }
-        expect(thrown).withContext(`dobnia kellett (${expectedCode})`).toBeDefined();
-        const code: string | undefined =
+    db.prepare('INSERT INTO users (id, name, age) VALUES (?, ?, ?)').run(1, 'Ada', 36);
+    db.prepare('INSERT INTO users (id, name, age) VALUES (?, ?, ?)').run(2, 'Grace', 40);
+    db.prepare('INSERT INTO posts (id, title) VALUES (?, ?)').run(1, 'Hello');
+    db.close();
+  });
+
+  afterAll(() => {
+    if (dbPath && fs.existsSync(dbPath)) {
+      fs.unlinkSync(dbPath);
+    }
+  });
+
+  /** Egy hívás, ami egy adott errorCode-dal kell hogy dobjon (strukturált, NEM néma). */
+  const expectErrorCode = (fn: () => unknown, expectedCode: string): void => {
+    let thrown: unknown;
+
+    try {
+      fn();
+    } catch (error) {
+      thrown = error;
+    }
+    expect(thrown).withContext(`dobnia kellett (${expectedCode})`).toBeDefined();
+    const code: string | undefined =
             thrown instanceof DyFM_Error ? DyFM_Error.getErrorCode(thrown) : undefined;
-        expect(code).withContext('a hibakód').toBe(expectedCode);
-    };
-
-    describe('listTables', () => {
-        it('a user-táblák ABC-sorrendben (a belső sqlite_% táblák kiszűrve)', () => {
-            expect(DyNTS_Sqlite_Reader_Util.listTables(dbPath)).toEqual(['posts', 'users']);
-        });
-    });
-
-    describe('getSchema', () => {
-        it('a users tábla oszlop-info-ja (name/type/notNull/primaryKey)', () => {
-            const schema: DyNTS_SqliteColumnInfo[] = DyNTS_Sqlite_Reader_Util.getSchema(dbPath, 'users');
-            expect(schema.map((column) => column.name)).toEqual(['id', 'name', 'age']);
-            const idColumn: DyNTS_SqliteColumnInfo = schema.find((column) => column.name === 'id')!;
-            expect(idColumn.primaryKey).toBe(true);
-            const nameColumn: DyNTS_SqliteColumnInfo = schema.find((column) => column.name === 'name')!;
-            expect(nameColumn.notNull).toBe(true);
-            expect(nameColumn.type).toBe('TEXT');
-        });
-
-        it('nem-létező tábla → DyNTS-SQLITE-READ-002 (NEM néma)', () => {
-            expectErrorCode(() => DyNTS_Sqlite_Reader_Util.getSchema(dbPath, 'no_such_table'), 'DyNTS-SQLITE-READ-002');
-        });
-    });
-
-    describe('readTable', () => {
-        it('a users tábla minden sora', () => {
-            const rows: { id: number; name: string }[] =
+
+    expect(code).withContext('a hibakód').toBe(expectedCode);
+  };
+
+  describe('| listTables', () => {
+    it('| a user-táblák ABC-sorrendben (a belső sqlite_% táblák kiszűrve)', () => {
+      expect(DyNTS_Sqlite_Reader_Util.listTables(dbPath)).toEqual([ 'posts', 'users' ]);
+    });
+  });
+
+  describe('| getSchema', () => {
+    it('| a users tábla oszlop-info-ja (name/type/notNull/primaryKey)', () => {
+      const schema: DyNTS_SqliteColumnInfo[] = DyNTS_Sqlite_Reader_Util.getSchema(dbPath, 'users');
+
+      expect(schema.map((column) => column.name)).toEqual([ 'id', 'name', 'age' ]);
+      const idColumn: DyNTS_SqliteColumnInfo = schema.find((column) => column.name === 'id');
+
+      expect(idColumn.primaryKey).toBe(true);
+      const nameColumn: DyNTS_SqliteColumnInfo = schema.find((column) => column.name === 'name');
+
+      expect(nameColumn.notNull).toBe(true);
+      expect(nameColumn.type).toBe('TEXT');
+    });
+
+    it('| nem-létező tábla → DyNTS-SQLITE-READ-002 (NEM néma)', () => {
+      expectErrorCode(() => DyNTS_Sqlite_Reader_Util.getSchema(dbPath, 'no_such_table'), 'DyNTS-SQLITE-READ-002');
+    });
+  });
+
+  describe('| readTable', () => {
+    it('| a users tábla minden sora', () => {
+      const rows: { id: number; name: string }[] =
                 DyNTS_Sqlite_Reader_Util.readTable(dbPath, 'users') as { id: number; name: string }[];
-            expect(rows.length).toBe(2);
-            expect(rows.map((row) => row.name).sort()).toEqual(['Ada', 'Grace']);
-        });
-
-        it('nem-létező tábla → DyNTS-SQLITE-READ-002 (NEM néma-[])', () => {
-            expectErrorCode(() => DyNTS_Sqlite_Reader_Util.readTable(dbPath, 'ghost'), 'DyNTS-SQLITE-READ-002');
-        });
-    });
-
-    describe('query (SELECT-only)', () => {
-        it('egy SELECT lekérdezés sorai', () => {
-            const rows: { name: string }[] =
-                DyNTS_Sqlite_Reader_Util.query(dbPath, 'SELECT name FROM users ORDER BY age DESC') as { name: string }[];
-            expect(rows.map((row) => row.name)).toEqual(['Grace', 'Ada']);
-        });
-
-        it('paraméteres SELECT (prepared-statement param)', () => {
-            const rows: { name: string }[] =
-                DyNTS_Sqlite_Reader_Util.query(dbPath, 'SELECT * FROM users WHERE age > ?', [37]) as { name: string }[];
-            expect(rows.map((row) => row.name)).toEqual(['Grace']);
-        });
-
-        it('WITH (CTE) is engedett (read-only)', () => {
-            const rows: { n: number }[] = DyNTS_Sqlite_Reader_Util.query(dbPath,
-                'WITH adults AS (SELECT * FROM users WHERE age >= 36) SELECT COUNT(*) AS n FROM adults') as { n: number }[];
-            expect(rows[0].n).toBe(2);
-        });
-
-        it('INSERT → DyNTS-SQLITE-READONLY-001 (elutasít a forrás-rétegben)', () => {
-            expectErrorCode(
-                () => DyNTS_Sqlite_Reader_Util.query(dbPath, "INSERT INTO users (id, name) VALUES (9, 'x')"),
-                'DyNTS-SQLITE-READONLY-001');
-        });
-
-        it('UPDATE → DyNTS-SQLITE-READONLY-001', () => {
-            expectErrorCode(
-                () => DyNTS_Sqlite_Reader_Util.query(dbPath, "UPDATE users SET name='x' WHERE id=1"),
-                'DyNTS-SQLITE-READONLY-001');
-        });
-
-        it('DELETE → DyNTS-SQLITE-READONLY-001', () => {
-            expectErrorCode(
-                () => DyNTS_Sqlite_Reader_Util.query(dbPath, 'DELETE FROM users'),
-                'DyNTS-SQLITE-READONLY-001');
-        });
-
-        it('DROP → DyNTS-SQLITE-READONLY-001', () => {
-            expectErrorCode(
-                () => DyNTS_Sqlite_Reader_Util.query(dbPath, 'DROP TABLE users'),
-                'DyNTS-SQLITE-READONLY-001');
-        });
-
-        it('multi-statement (SELECT; DELETE) → DyNTS-SQLITE-READONLY-001 (nem rejthető írás SELECT mögé)', () => {
-            expectErrorCode(
-                () => DyNTS_Sqlite_Reader_Util.query(dbPath, 'SELECT 1; DELETE FROM users'),
-                'DyNTS-SQLITE-READONLY-001');
-        });
-
-        it('üres SQL → DyNTS-SQLITE-READONLY-001', () => {
-            expectErrorCode(() => DyNTS_Sqlite_Reader_Util.query(dbPath, '   '), 'DyNTS-SQLITE-READONLY-001');
-        });
-    });
-
-    describe('path-validáció (fail-soft, NEM crash)', () => {
-        it('üres path → DyNTS-SQLITE-READ-001', () => {
-            expectErrorCode(() => DyNTS_Sqlite_Reader_Util.listTables(''), 'DyNTS-SQLITE-READ-001');
-        });
-
-        it('nem-létező fájl → DyNTS-SQLITE-READ-001', () => {
-            expectErrorCode(
-                () => DyNTS_Sqlite_Reader_Util.listTables(path.join(os.tmpdir(), 'no-such-db-file-xyz.db')),
-                'DyNTS-SQLITE-READ-001');
-        });
+
+      expect(rows.length).toBe(2);
+      expect(rows.map((row) => row.name).sort()).toEqual([ 'Ada', 'Grace' ]);
+    });
+
+    it('| nem-létező tábla → DyNTS-SQLITE-READ-002 (NEM néma-[])', () => {
+      expectErrorCode(() => DyNTS_Sqlite_Reader_Util.readTable(dbPath, 'ghost'), 'DyNTS-SQLITE-READ-002');
+    });
+  });
+
+  describe('| query (SELECT-only)', () => {
+    it('| egy SELECT lekérdezés sorai', () => {
+      const rows: NameInterface[] =
+                DyNTS_Sqlite_Reader_Util.query(dbPath, 'SELECT name FROM users ORDER BY age DESC') as NameInterface[];
+
+      expect(rows.map((row) => row.name)).toEqual([ 'Grace', 'Ada' ]);
+    });
+
+    it('| paraméteres SELECT (prepared-statement param)', () => {
+      const rows: NameInterface[] =
+                DyNTS_Sqlite_Reader_Util.query(dbPath, 'SELECT * FROM users WHERE age > ?', [ 37 ]) as NameInterface[];
+
+      expect(rows.map((row) => row.name)).toEqual([ 'Grace' ]);
+    });
+
+    it('| WITH (CTE) is engedett (read-only)', () => {
+      const rows: { n: number }[] = DyNTS_Sqlite_Reader_Util.query(dbPath,
+        'WITH adults AS (SELECT * FROM users WHERE age >= 36) SELECT COUNT(*) AS n FROM adults') as { n: number }[];
+
+      expect(rows[0].n).toBe(2);
+    });
+
+    it('| INSERT → DyNTS-SQLITE-READONLY-001 (elutasít a forrás-rétegben)', () => {
+      expectErrorCode(
+        () => DyNTS_Sqlite_Reader_Util.query(dbPath, 'INSERT INTO users (id, name) VALUES (9, \'x\')'),
+        'DyNTS-SQLITE-READONLY-001');
+    });
+
+    it('| UPDATE → DyNTS-SQLITE-READONLY-001', () => {
+      expectErrorCode(
+        () => DyNTS_Sqlite_Reader_Util.query(dbPath, 'UPDATE users SET name=\'x\' WHERE id=1'),
+        'DyNTS-SQLITE-READONLY-001');
+    });
+
+    it('| DELETE → DyNTS-SQLITE-READONLY-001', () => {
+      expectErrorCode(
+        () => DyNTS_Sqlite_Reader_Util.query(dbPath, 'DELETE FROM users'),
+        'DyNTS-SQLITE-READONLY-001');
+    });
+
+    it('| DROP → DyNTS-SQLITE-READONLY-001', () => {
+      expectErrorCode(
+        () => DyNTS_Sqlite_Reader_Util.query(dbPath, 'DROP TABLE users'),
+        'DyNTS-SQLITE-READONLY-001');
+    });
+
+    it('| multi-statement (SELECT; DELETE) → DyNTS-SQLITE-READONLY-001 (nem rejthető írás SELECT mögé)', () => {
+      expectErrorCode(
+        () => DyNTS_Sqlite_Reader_Util.query(dbPath, 'SELECT 1; DELETE FROM users'),
+        'DyNTS-SQLITE-READONLY-001');
+    });
+
+    it('| üres SQL → DyNTS-SQLITE-READONLY-001', () => {
+      expectErrorCode(() => DyNTS_Sqlite_Reader_Util.query(dbPath, '   '), 'DyNTS-SQLITE-READONLY-001');
+    });
+  });
+
+  describe('| path-validáció (fail-soft, NEM crash)', () => {
+    it('| üres path → DyNTS-SQLITE-READ-001', () => {
+      expectErrorCode(() => DyNTS_Sqlite_Reader_Util.listTables(''), 'DyNTS-SQLITE-READ-001');
+    });
+
+    it('| nem-létező fájl → DyNTS-SQLITE-READ-001', () => {
+      expectErrorCode(
+        () => DyNTS_Sqlite_Reader_Util.listTables(path.join(os.tmpdir(), 'no-such-db-file-xyz.db')),
+        'DyNTS-SQLITE-READ-001');
     });
+  });
 });

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 },