@futdevpro/nts-dynamo 1.15.58 → 1.15.64

package/src/_modules/mcp/_services/dynts-mcp.adapter.ts

@@ -1,20 +1,25 @@
+// A `@modelcontextprotocol/sdk` ESM-only csomag; a deep subpath-importjai (server/index, server/stdio,
+// types) KÖTELEZŐEN `.js`-suffixet igényelnek (az SDK `exports`-map így oldja fel) — ezért a `no-js-import`
+// szabály ITT indokoltan kikapcsolva (C2, FAM-REV bedrock-fix). Suffix-strip → resolve-hiba.
+/* eslint-disable @futdevpro/dynamo/no-js-import */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, CallToolResult, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+/* eslint-enable @futdevpro/dynamo/no-js-import */
 
 import { DyFM_Error } from '@futdevpro/fsm-dynamo';
 
 import {
-    DyNTS_Mcp_CallResult,
-    DyNTS_Mcp_ServerInfo,
-    DyNTS_Mcp_ToolDefinition,
-    DyNTS_Mcp_ToolOutcome,
+  DyNTS_Mcp_CallResult,
+  DyNTS_Mcp_ServerInfo,
+  DyNTS_Mcp_ToolDefinition,
+  DyNTS_Mcp_ToolOutcome
 } from '../_models/interfaces/dynts-mcp.interface';
 
 /**
  * `DyNTS_Mcp_Adapter` (BFR-AM-003) — a hivatalos `@modelcontextprotocol/sdk` köré épített **vékony
  * adaptor-réteg**. EZ az EGYETLEN hely a `/mcp` submodule-ban, ahol a SDK-típusok megjelennek — a
- * `DyNTS_Mcp_ServerBase` + a consumer tool-jai SDK-mentesek, így egy jövőbeli transport-/SDK-csere
+ * `DyNTS_Mcp_Server_ServiceBase` + a consumer tool-jai SDK-mentesek, így egy jövőbeli transport-/SDK-csere
  * NON-breaking (csak ez az osztály cserélődik).
  *
  * Felelősség (3 dolog, semmi domain-logika):
@@ -28,130 +33,136 @@ import {
  */
 export class DyNTS_Mcp_Adapter {
 
-    /** A SDK MCP-szerver (a transport-agnosztikus protocol-réteg). */
-    private readonly server: Server;
+  /** A SDK MCP-szerver (a transport-agnosztikus protocol-réteg). */
+  private readonly server: Server;
 
-    /** A regisztrált tool-definíciók `name` → def map-je (a `tools/call` dispatch-hez). */
-    private readonly tools: Map<string, DyNTS_Mcp_ToolDefinition> =
-        new Map<string, DyNTS_Mcp_ToolDefinition>();
+  /** A regisztrált tool-definíciók `name` → def map-je (a `tools/call` dispatch-hez). */
+  private readonly tools: Map<string, DyNTS_Mcp_ToolDefinition> =
+    new Map<string, DyNTS_Mcp_ToolDefinition>();
 
-    constructor(set: DyNTS_Mcp_ServerInfo) {
-        this.server = new Server(
-            { name: set.name, version: set.version },
-            { capabilities: { tools: {} } },
-        );
-        this.installHandlers();
-    }
+  constructor(set: DyNTS_Mcp_ServerInfo) {
+    this.server = new Server(
+      { name: set.name, version: set.version },
+      { capabilities: { tools: {} } },
+    );
+    this.installHandlers();
+  }
 
-    /**
+  /**
      * Az EGYETLEN tool-regisztrációs choke-pont. A regisztrált tool-ok hirdetődnek a `tools/list`-ben
      * és dispatch-elhetők a `tools/call`-on. Az azonos nevű ismételt regisztráció felülír (last-wins).
      */
-    public registerTool(definition: DyNTS_Mcp_ToolDefinition): void {
-        this.tools.set(definition.name, definition);
-    }
+  public registerTool(definition: DyNTS_Mcp_ToolDefinition): void {
+    this.tools.set(definition.name, definition);
+  }
 
-    /** A hirdetett (regisztrált) tool-nevek (a contract/diszjunkció-teszthez). */
-    public getAdvertisedToolNames(): string[] {
-        return Array.from(this.tools.keys());
-    }
+  /** A hirdetett (regisztrált) tool-nevek (a contract/diszjunkció-teszthez). */
+  public getAdvertisedToolNames(): string[] {
+    return Array.from(this.tools.keys());
+  }
 
-    /**
+  /**
      * A stdio transport csatlakoztatása + a szerver indítása. A `connect` után a `tools/list` a
      * regisztrált tool-okat hirdeti. A boot-üzenetek a stderr-en (a hívó App felel).
      */
-    public async startStdio(): Promise<void> {
-        const transport: StdioServerTransport = new StdioServerTransport();
-        await this.server.connect(transport);
-    }
+  public async startStdio(): Promise<void> {
+    const transport: StdioServerTransport = new StdioServerTransport();
 
-    /** A szerver leállítása (graceful close — teszt-/shutdown-úthoz). */
-    public async close(): Promise<void> {
-        await this.server.close();
-    }
+    await this.server.connect(transport);
+  }
+
+  /** A szerver leállítása (graceful close — teszt-/shutdown-úthoz). */
+  public async close(): Promise<void> {
+    await this.server.close();
+  }
 
-    /**
+  /**
      * Egy tool-hívás KÖZVETLEN dispatch-elése (a transport-megkerülésével) — a contract/registry-teszt
      * ezt hívja a stdio-szerver indítása nélkül. Ugyanaz a logika fut, mint a SDK `tools/call`-on:
      * ismeretlen tool → strukturált hiba; handler-hiba → `isError:true` fordítás.
      */
-    public async dispatchToolCall(set: { name: string; arguments?: unknown }): Promise<DyNTS_Mcp_CallResult> {
-        const definition: DyNTS_Mcp_ToolDefinition | undefined = this.tools.get(set.name);
-        if (!definition) {
-            return this.errorResult(`Unknown tool: '${set.name}'. Advertised tools: `
+  public async dispatchToolCall(set: { name: string; arguments?: unknown }): Promise<DyNTS_Mcp_CallResult> {
+    const definition: DyNTS_Mcp_ToolDefinition | undefined = this.tools.get(set.name);
+
+    if (!definition) {
+      return this.errorResult(`Unknown tool: '${set.name}'. Advertised tools: `
                 + `${this.getAdvertisedToolNames().join(', ')}.`);
-        }
-        try {
-            const outcome: DyNTS_Mcp_ToolOutcome = await definition.handler(set.arguments);
-            return this.toCallResult(outcome);
-        } catch (error) {
-            return this.errorResult(this.describeError(error), error);
-        }
     }
+    try {
+      const outcome: DyNTS_Mcp_ToolOutcome = await definition.handler(set.arguments);
 
-    // =========================================================================
-    // SDK request-handler bekötés (tools/list + tools/call)
-    // =========================================================================
-
-    /** A `tools/list` és a `tools/call` JSON-RPC handler bekötése a SDK-szerverre. */
-    private installHandlers(): void {
-        // tools/list — PONTOSAN a regisztrált (advertised) tool-okat hirdeti.
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: Array.from(this.tools.values()).map((definition) => ({
-                name: definition.name,
-                description: definition.description,
-                inputSchema: definition.inputSchema,
-            })),
-        }));
-
-        // tools/call — a megfelelő handler futtatása + egységes hiba-fordítás (a közös dispatch-en át).
-        // A `DyNTS_Mcp_CallResult` a SDK `CallToolResult` egy al-shape-je (text-content + isError) — a
-        // SDK-cast KIZÁRÓLAG itt, az adaptor-boundary-n él (a SDK izolálva marad).
-        this.server.setRequestHandler(CallToolRequestSchema, async (request): Promise<CallToolResult> =>
+      return this.toCallResult(outcome);
+    } catch (error) {
+      return this.errorResult(this.describeError(error), error);
+    }
+  }
+
+  // =========================================================================
+  // SDK request-handler bekötés (tools/list + tools/call)
+  // =========================================================================
+
+  /** A `tools/list` és a `tools/call` JSON-RPC handler bekötése a SDK-szerverre. */
+  private installHandlers(): void {
+    // tools/list — PONTOSAN a regisztrált (advertised) tool-okat hirdeti.
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: Array.from(this.tools.values()).map((definition) => ({
+        name: definition.name,
+        description: definition.description,
+        inputSchema: definition.inputSchema,
+      })),
+    }));
+
+    // tools/call — a megfelelő handler futtatása + egységes hiba-fordítás (a közös dispatch-en át).
+    // A `DyNTS_Mcp_CallResult` a SDK `CallToolResult` egy al-shape-je (text-content + isError) — a
+    // SDK-cast KIZÁRÓLAG itt, az adaptor-boundary-n él (a SDK izolálva marad).
+    this.server.setRequestHandler(CallToolRequestSchema, async (request): Promise<CallToolResult> =>
             (await this.dispatchToolCall({
-                name: request.params.name,
-                arguments: request.params.arguments,
+              name: request.params.name,
+              arguments: request.params.arguments,
             })) as CallToolResult);
+  }
+
+  // =========================================================================
+  // CallToolResult fordítás (a transport-payload — text-JSON; egységes hiba-fordítás)
+  // =========================================================================
+
+  /** Egy sikeres (vagy strukturált-hiba) handler-outcome → `CallToolResult` (text-JSON content). */
+  private toCallResult(outcome: DyNTS_Mcp_ToolOutcome): DyNTS_Mcp_CallResult {
+    return {
+      content: [{ type: 'text', text: this.stringify(outcome.data) }],
+      isError: outcome.isError === true,
+    };
+  }
+
+  /** Egy hiba → `CallToolResult { isError:true }` strukturált hiba-payload-dal (soha nem néma). */
+  private errorResult(message: string, error?: unknown): DyNTS_Mcp_CallResult {
+    const errorCode: string | undefined = error instanceof DyFM_Error
+      ? DyFM_Error.getErrorCode(error)
+      : undefined;
+    const payload: object = { ok: false, error: { errorCode: errorCode, message: message } };
+
+    return { content: [{ type: 'text', text: this.stringify(payload) }], isError: true };
+  }
+
+  /** Egy hiba ember-olvasható üzenete (DyFM_Error → message; Error → message; egyéb → fallback). */
+  private describeError(error: unknown): string {
+    if (error instanceof DyFM_Error) {
+      return DyFM_Error.getErrorMessage(error) || 'Unknown DyFM error.';
     }
 
-    // =========================================================================
-    // CallToolResult fordítás (a transport-payload — text-JSON; egységes hiba-fordítás)
-    // =========================================================================
-
-    /** Egy sikeres (vagy strukturált-hiba) handler-outcome → `CallToolResult` (text-JSON content). */
-    private toCallResult(outcome: DyNTS_Mcp_ToolOutcome): DyNTS_Mcp_CallResult {
-        return {
-            content: [{ type: 'text', text: this.stringify(outcome.data) }],
-            isError: outcome.isError === true,
-        };
-    }
-
-    /** Egy hiba → `CallToolResult { isError:true }` strukturált hiba-payload-dal (soha nem néma). */
-    private errorResult(message: string, error?: unknown): DyNTS_Mcp_CallResult {
-        const errorCode: string | undefined = error instanceof DyFM_Error
-            ? DyFM_Error.getErrorCode(error)
-            : undefined;
-        const payload: object = { ok: false, error: { errorCode: errorCode, message: message } };
-        return { content: [{ type: 'text', text: this.stringify(payload) }], isError: true };
+    if (error instanceof Error) {
+      return error.message;
     }
 
-    /** Egy hiba ember-olvasható üzenete (DyFM_Error → message; Error → message; egyéb → fallback). */
-    private describeError(error: unknown): string {
-        if (error instanceof DyFM_Error) {
-            return DyFM_Error.getErrorMessage(error) || 'Unknown DyFM error.';
-        }
-        if (error instanceof Error) {
-            return error.message;
-        }
-        return 'Unknown error during tool execution.';
-    }
+    return 'Unknown error during tool execution.';
+  }
 
-    /** JSON-stringify (a transport text-content payload-ja); szerializálás-hiba → strukturált hiba. */
-    private stringify(data: unknown): string {
-        try {
-            return JSON.stringify(data);
-        } catch {
-            return JSON.stringify({ ok: false, error: { message: 'The response is not JSON-serializable.' } });
-        }
+  /** JSON-stringify (a transport text-content payload-ja); szerializálás-hiba → strukturált hiba. */
+  private stringify(data: unknown): string {
+    try {
+      return JSON.stringify(data);
+    } catch {
+      return JSON.stringify({ ok: false, error: { message: 'The response is not JSON-serializable.' } });
     }
+  }
 }

package/src/_modules/mcp/index.ts

@@ -2,7 +2,7 @@
 
 // MCP MODULE (BFR-AM-003) — domain-agnosztikus Model Context Protocol szerver-base + transport +
 // tool-registry, a hivatalos `@modelcontextprotocol/sdk` köré izolált adaptorral. A consumer
-// leszármazik a `DyNTS_Mcp_ServerBase`-ből + a SAJÁT tool-jait regisztrálja (a bedrock NEM definiál
+// leszármazik a `DyNTS_Mcp_Server_ServiceBase`-ből + a SAJÁT tool-jait regisztrálja (a bedrock NEM definiál
 // domain-tool-t). A SDK KIZÁRÓLAG a `DyNTS_Mcp_Adapter` mögött él (transport-csere NON-breaking).
 
 // INTERFACES

package/src/_modules/scoped-config/_models/data-models/dynts-scoped-config.data-model.ts

@@ -17,7 +17,7 @@ import { DyNTS_ScopedConfig_Level } from '../../_enums/dynts-scoped-config-level
  * dolga. A `value` írása **`$set`-tel atomikus** (Mongoose Mixed silent-drop ellen — lásd
  * `DyNTS_ScopedConfig_DataService.setValue`).
  */
-export class DyNTS_ScopedConfig_DataModel extends DyFM_Metadata {
+export class DyNTS_ScopedConfig extends DyFM_Metadata {
 
   // --- a feloldási kulcs ---
 
@@ -49,8 +49,9 @@ export class DyNTS_ScopedConfig_DataModel extends DyFM_Metadata {
   /** Opcionális indoklás. */
   note?: string;
 
-  constructor(set?: Partial<DyNTS_ScopedConfig_DataModel>) {
+  constructor(set?: Partial<DyNTS_ScopedConfig>) {
     super(set);
+
     if (set) {
       DyFM_Object.cleanAssign(this, set);
     }
@@ -64,8 +65,8 @@ export class DyNTS_ScopedConfig_DataModel extends DyFM_Metadata {
  * A `value` `type:'object'` (Mongoose `Mixed`) — a séma NEM validál; a típushelyesség a fogyasztó
  * katalógusának + set-kori validációjának dolga.
  */
-export const dyNTS_scopedConfig_dataParams: DyFM_DataModel_Params<DyNTS_ScopedConfig_DataModel> =
-  new DyFM_DataModel_Params<DyNTS_ScopedConfig_DataModel>({
+export const DyNTS_scopedConfig_dataParams: DyFM_DataModel_Params<DyNTS_ScopedConfig> =
+  new DyFM_DataModel_Params<DyNTS_ScopedConfig>({
     dataName: 'dynts_scoped_config',
     addArchive: true,
     properties: {

package/src/_modules/scoped-config/_models/interfaces/dynts-scoped-config.interface.ts

@@ -1,6 +1,4 @@
 
-import { DyNTS_ScopedConfig_Level } from '../../_enums/dynts-scoped-config-level.enum';
-
 /**
  * Scoped-config shared vokabulár (BFR-AM-004). Egy fájlban a szorosan összetartozó típusok
  * (a `*.interface.ts` az egy-export-per-file konvenció ismert kivétele — mint a FAM `fam-config.interface.ts`).

package/src/_modules/scoped-config/_services/dynts-scoped-config.control-service.spec.ts

@@ -4,9 +4,9 @@ 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_ScopedConfig_Level } from '../_enums/dynts-scoped-config-level.enum';
-import { DyNTS_ScopedConfig_DataModel } from '../_models/data-models/dynts-scoped-config.data-model';
+import { DyNTS_ScopedConfig } from '../_models/data-models/dynts-scoped-config.data-model';
 import {
-  DyNTS_ScopedConfigResolvedValue,
+  DyNTS_ScopedConfigResolvedValue
 } from '../_models/interfaces/dynts-scoped-config.interface';
 import { DyNTS_ScopedConfig_DataService } from './dynts-scoped-config.data-service';
 import { DyNTS_ScopedConfig_ControlService } from './dynts-scoped-config.control-service';
@@ -27,13 +27,14 @@ describe('| DyNTS_ScopedConfig_ControlService', () => {
   let mockDBService: jasmine.SpyObj<{ find: () => Promise<unknown[]>; findOne: () => Promise<unknown> }>;
 
   /** Egy aktív rekord gyors gyártása a kontrollált rekord-halmazhoz. */
-  const makeRecord = (set: Partial<DyNTS_ScopedConfig_DataModel>): DyNTS_ScopedConfig_DataModel =>
-    new DyNTS_ScopedConfig_DataModel(set);
+  const makeRecord = (set: Partial<DyNTS_ScopedConfig>): DyNTS_ScopedConfig =>
+    new DyNTS_ScopedConfig(set);
 
   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,
@@ -43,7 +44,7 @@ describe('| DyNTS_ScopedConfig_ControlService', () => {
 
   beforeEach(() => {
     // A base-ctor eager getDBService-jét stub-oljuk, hogy a lazy DataService-példányok ne dobjanak.
-    mockDBService = jasmine.createSpyObj('DyNTS_DBService', ['find', 'findOne']);
+    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);
@@ -55,7 +56,7 @@ describe('| DyNTS_ScopedConfig_ControlService', () => {
   });
 
   /** A kontrollált aktív rekord-halmaz beállítása (a `loadEffectiveRecords` ezt kapja vissza). */
-  const stubRecords = (records: DyNTS_ScopedConfig_DataModel[]): void => {
+  const stubRecords = (records: DyNTS_ScopedConfig[]): void => {
     spyOn(DyNTS_ScopedConfig_DataService.prototype, 'findActiveList').and.returnValue(Promise.resolve(records));
   };
 
@@ -188,7 +189,8 @@ describe('| DyNTS_ScopedConfig_ControlService', () => {
   describe('| resolve — Mixed value get', () => {
 
     it('| should resolve a string[] (Mixed) value intact', async () => {
-      const patterns: string[] = ['**/node_modules/**', '**/.git/**'];
+      const patterns: string[] = [ '**/node_modules/**', '**/.git/**' ];
+
       stubRecords([
         makeRecord({ level: DyNTS_ScopedConfig_Level.global, key: 'scan.ignorePatterns', value: patterns }),
       ]);
@@ -202,6 +204,7 @@ describe('| DyNTS_ScopedConfig_ControlService', () => {
 
     it('| should resolve an object (Mixed) value intact', async () => {
       const obj = { provider: 'openai', model: 'text-embedding-3-large' };
+
       stubRecords([
         makeRecord({ level: DyNTS_ScopedConfig_Level.global, key: 'embedding.config', value: obj }),
       ]);
@@ -239,6 +242,7 @@ describe('| DyNTS_ScopedConfig_ControlService', () => {
     it('| should return empty object when no records configured', async () => {
       stubRecords([]);
       const all = await control.resolveAll({ table: 'documents' });
+
       expect(Object.keys(all).length).toBe(0);
     });
   });
@@ -246,9 +250,9 @@ describe('| DyNTS_ScopedConfig_ControlService', () => {
   describe('| set', () => {
 
     it('| should archive an existing active record then write the new one', async () => {
-      const existing: DyNTS_ScopedConfig_DataModel =
+      const existing: DyNTS_ScopedConfig =
         makeRecord({ _id: 'old-id', level: DyNTS_ScopedConfig_Level.global, key: 'read.topK', value: 10 });
-      const savedNew: DyNTS_ScopedConfig_DataModel =
+      const savedNew: DyNTS_ScopedConfig =
         makeRecord({ _id: 'new-id', level: DyNTS_ScopedConfig_Level.global, key: 'read.topK', value: 25 });
 
       const findActiveSpy = spyOn(DyNTS_ScopedConfig_DataService.prototype, 'findActive')
@@ -258,14 +262,15 @@ describe('| DyNTS_ScopedConfig_ControlService', () => {
       const saveSpy = spyOn(DyNTS_ScopedConfig_DataService.prototype, 'saveData')
         .and.returnValue(Promise.resolve(savedNew));
 
-      const result: DyNTS_ScopedConfig_DataModel =
+      const result: DyNTS_ScopedConfig =
         await control.set(DyNTS_ScopedConfig_Level.global, 'read.topK', 25, { setBy: 'cli' });
 
       expect(findActiveSpy).toHaveBeenCalled();
       expect(deleteSpy).toHaveBeenCalledWith('old-id');
       expect(saveSpy).toHaveBeenCalled();
       // A kiírt rekord a helyes kulcsot + értéket + audit-ot hordozza.
-      const written: DyNTS_ScopedConfig_DataModel = saveSpy.calls.mostRecent().args[0] as DyNTS_ScopedConfig_DataModel;
+      const written: DyNTS_ScopedConfig = saveSpy.calls.mostRecent().args[0];
+
       expect(written.key).toBe('read.topK');
       expect(written.value).toBe(25);
       expect(written.setBy).toBe('cli');
@@ -275,10 +280,11 @@ describe('| DyNTS_ScopedConfig_ControlService', () => {
     it('| should write a new record without deleting when no active record exists', async () => {
       spyOn(DyNTS_ScopedConfig_DataService.prototype, 'findActive').and.returnValue(Promise.resolve(null));
       const deleteSpy = spyOn(DyNTS_ScopedConfig_DataService.prototype, 'deleteData').and.returnValue(Promise.resolve());
+
       spyOn(DyNTS_ScopedConfig_DataService.prototype, 'saveData')
-        .and.callFake((data?: DyNTS_ScopedConfig_DataModel) => Promise.resolve(data as DyNTS_ScopedConfig_DataModel));
+        .and.callFake((data?: DyNTS_ScopedConfig) => Promise.resolve(data));
 
-      const result: DyNTS_ScopedConfig_DataModel = await control.set(
+      const result: DyNTS_ScopedConfig = await control.set(
         DyNTS_ScopedConfig_Level.table,
         'read.topK',
         20,

package/src/_modules/scoped-config/_services/dynts-scoped-config.control-service.ts

@@ -2,14 +2,14 @@
 import { DyFM_DBFilterSimple } from '@futdevpro/fsm-dynamo';
 
 import { DyNTS_ScopedConfig_Level } from '../_enums/dynts-scoped-config-level.enum';
-import { DyNTS_ScopedConfig_DataModel } from '../_models/data-models/dynts-scoped-config.data-model';
+import { DyNTS_ScopedConfig } from '../_models/data-models/dynts-scoped-config.data-model';
 import {
   DyNTS_ScopedConfigResolveContext,
   DyNTS_ScopedConfigResolvedFrom,
   DyNTS_ScopedConfigResolvedValue,
   DyNTS_ScopedConfigResolveOptions,
   DyNTS_ScopedConfigSetOptions,
-  DyNTS_ScopedConfigValue,
+  DyNTS_ScopedConfigValue
 } from '../_models/interfaces/dynts-scoped-config.interface';
 import { DyNTS_ScopedConfig_DataService } from './dynts-scoped-config.data-service';
 
@@ -18,7 +18,7 @@ import { DyNTS_ScopedConfig_DataService } from './dynts-scoped-config.data-servi
  */
 interface DyNTS_ScopedConfigCacheEntry {
   /** A cache-elt aktív rekordok (egy kontextus-szeletre). */
-  records: DyNTS_ScopedConfig_DataModel[];
+  records: DyNTS_ScopedConfig[];
   /** Lejárati timestamp (epoch ms). */
   expiresAt: number;
 }
@@ -55,6 +55,7 @@ export class DyNTS_ScopedConfig_ControlService {
     if (!DyNTS_ScopedConfig_ControlService._instance) {
       DyNTS_ScopedConfig_ControlService._instance = new DyNTS_ScopedConfig_ControlService();
     }
+
     return DyNTS_ScopedConfig_ControlService._instance;
   }
 
@@ -77,7 +78,8 @@ export class DyNTS_ScopedConfig_ControlService {
       table: options?.table,
       scopePath: options?.scopePath,
     };
-    const records: DyNTS_ScopedConfig_DataModel[] = await this.loadEffectiveRecords(context);
+    const records: DyNTS_ScopedConfig[] = await this.loadEffectiveRecords(context);
+
     return this.resolveFromRecords<T>(key, records, context, options?.builtinDefault);
   }
 
@@ -88,12 +90,14 @@ export class DyNTS_ScopedConfig_ControlService {
    * — azokat a fogyasztó iterálja a saját katalógusából a `resolve`-on át).
    */
   async resolveAll(context?: DyNTS_ScopedConfigResolveContext): Promise<{ [key: string]: DyNTS_ScopedConfigResolvedValue }> {
-    const records: DyNTS_ScopedConfig_DataModel[] = await this.loadEffectiveRecords(context);
+    const records: DyNTS_ScopedConfig[] = await this.loadEffectiveRecords(context);
     const result: { [key: string]: DyNTS_ScopedConfigResolvedValue } = {};
     const keys: Set<string> = new Set<string>(records.map((record) => record.key));
+
     for (const key of keys) {
       result[key] = this.resolveFromRecords(key, records, context);
     }
+
     return result;
   }
 
@@ -103,7 +107,7 @@ export class DyNTS_ScopedConfig_ControlService {
    */
   private resolveFromRecords<T = DyNTS_ScopedConfigValue>(
     key: string,
-    records: DyNTS_ScopedConfig_DataModel[],
+    records: DyNTS_ScopedConfig[],
     context?: DyNTS_ScopedConfigResolveContext,
     builtinDefault?: T,
   ): DyNTS_ScopedConfigResolvedValue<T> {
@@ -114,12 +118,13 @@ export class DyNTS_ScopedConfig_ControlService {
     if (table && scopePath.length) {
       for (let i = scopePath.length - 1; i >= 0; i--) {
         const scopeId: string = scopePath[i].scopeId;
-        const hit: DyNTS_ScopedConfig_DataModel | undefined = records.find((record) =>
+        const hit: DyNTS_ScopedConfig | undefined = records.find((record) =>
           record.level === DyNTS_ScopedConfig_Level.scope &&
           record.tableScope === table &&
           record.scopeId === scopeId &&
           record.key === key,
         );
+
         if (hit) {
           return this.toResolved<T>(hit, 'scope');
         }
@@ -128,34 +133,36 @@ export class DyNTS_ScopedConfig_ControlService {
 
     // 2. TABLE szint.
     if (table) {
-      const hit: DyNTS_ScopedConfig_DataModel | undefined = records.find((record) =>
+      const hit: DyNTS_ScopedConfig | undefined = records.find((record) =>
         record.level === DyNTS_ScopedConfig_Level.table &&
         record.tableScope === table &&
         record.key === key,
       );
+
       if (hit) {
         return this.toResolved<T>(hit, 'table');
       }
     }
 
     // 3. GLOBAL szint.
-    const globalHit: DyNTS_ScopedConfig_DataModel | undefined = records.find((record) =>
+    const globalHit: DyNTS_ScopedConfig | undefined = records.find((record) =>
       record.level === DyNTS_ScopedConfig_Level.global && record.key === key,
     );
+
     if (globalHit) {
       return this.toResolved<T>(globalHit, 'global');
     }
 
     // 4. builtinDefault (a hívó fallback-je; a bedrock NEM tart katalógust).
     return {
-      value: builtinDefault as T,
+      value: builtinDefault,
       resolvedFrom: 'builtin',
     };
   }
 
   /** Egy DB-rekordot a feloldott-érték shape-re (a forrás-szinttel + audittal). */
   private toResolved<T = DyNTS_ScopedConfigValue>(
-    record: DyNTS_ScopedConfig_DataModel,
+    record: DyNTS_ScopedConfig,
     resolvedFrom: DyNTS_ScopedConfigResolvedFrom,
   ): DyNTS_ScopedConfigResolvedValue<T> {
     return {
@@ -171,26 +178,30 @@ export class DyNTS_ScopedConfig_ControlService {
    * A kontextusra releváns aktív rekordok betöltése EGY Mongo-körrel, cache-elve. A filter a global +
    * (ha van) table + a scopePath összes scopeId-jára szűkít — a merge memóriában fut. `set` invalidál.
    */
-  private async loadEffectiveRecords(context?: DyNTS_ScopedConfigResolveContext): Promise<DyNTS_ScopedConfig_DataModel[]> {
+  private async loadEffectiveRecords(context?: DyNTS_ScopedConfigResolveContext): Promise<DyNTS_ScopedConfig[]> {
     const cacheKey: string = this.cacheKey(context);
     const cached: DyNTS_ScopedConfigCacheEntry | undefined = this.cache.get(cacheKey);
+
     if (cached && cached.expiresAt > Date.now()) {
       return cached.records;
     }
 
-    const orClauses: DyFM_DBFilterSimple<DyNTS_ScopedConfig_DataModel>[] = [{ level: DyNTS_ScopedConfig_Level.global }];
+    const orClauses: DyFM_DBFilterSimple<DyNTS_ScopedConfig>[] = [{ level: DyNTS_ScopedConfig_Level.global }];
+
     if (context?.table) {
       orClauses.push({ level: DyNTS_ScopedConfig_Level.table, tableScope: context.table });
       const scopeIds: string[] = (context.scopePath ?? []).map((ref) => ref.scopeId);
+
       if (scopeIds.length) {
         orClauses.push({ level: DyNTS_ScopedConfig_Level.scope, tableScope: context.table, scopeId: { $in: scopeIds } });
       }
     }
 
     const dataService: DyNTS_ScopedConfig_DataService = new DyNTS_ScopedConfig_DataService({ issuer: this.issuer });
-    const records: DyNTS_ScopedConfig_DataModel[] = await dataService.findActiveList({ $or: orClauses });
+    const records: DyNTS_ScopedConfig[] = await dataService.findActiveList({ $or: orClauses });
 
     this.cache.set(cacheKey, { records: records, expiresAt: Date.now() + this.cacheTtlMs });
+
     return records;
   }
 
@@ -198,6 +209,7 @@ export class DyNTS_ScopedConfig_ControlService {
   private cacheKey(context?: DyNTS_ScopedConfigResolveContext): string {
     const table: string = context?.table ?? '-';
     const scopeIds: string = (context?.scopePath ?? []).map((ref) => ref.scopeId).join('>') || '-';
+
     return `${table}|${scopeIds}`;
   }
 
@@ -229,22 +241,23 @@ export class DyNTS_ScopedConfig_ControlService {
     key: string,
     value: unknown,
     options: DyNTS_ScopedConfigSetOptions = {},
-  ): Promise<DyNTS_ScopedConfig_DataModel> {
+  ): Promise<DyNTS_ScopedConfig> {
     this.assertLevelConsistency(level, key, options);
 
     const issuer: string = options.issuer ?? this.issuer;
-    const filter: DyFM_DBFilterSimple<DyNTS_ScopedConfig_DataModel> =
+    const filter: DyFM_DBFilterSimple<DyNTS_ScopedConfig> =
       DyNTS_ScopedConfig_DataService.levelKeyFilter(level, key, options);
 
     // Régi aktív rekord (ha van) → soft-delete (archív; history-megőrzés).
     const findService: DyNTS_ScopedConfig_DataService = new DyNTS_ScopedConfig_DataService({ issuer: issuer });
-    const existing: DyNTS_ScopedConfig_DataModel = await findService.findActive(filter);
+    const existing: DyNTS_ScopedConfig = await findService.findActive(filter);
+
     if (existing && existing._id) {
       await findService.deleteData(existing._id);
     }
 
     // Új aktív rekord — a `value` Mixed.
-    const record: DyNTS_ScopedConfig_DataModel = new DyNTS_ScopedConfig_DataModel({
+    const record: DyNTS_ScopedConfig = new DyNTS_ScopedConfig({
       level: level,
       tableScope: options.tableScope,
       scopeId: options.scopeId,
@@ -255,9 +268,10 @@ export class DyNTS_ScopedConfig_ControlService {
       note: options.note,
     });
     const writeService: DyNTS_ScopedConfig_DataService = new DyNTS_ScopedConfig_DataService({ data: record, issuer: issuer });
-    const saved: DyNTS_ScopedConfig_DataModel = await writeService.saveData(record);
+    const saved: DyNTS_ScopedConfig = await writeService.saveData(record);
 
     this.invalidateCache();
+
     return saved;
   }
 
@@ -269,6 +283,7 @@ export class DyNTS_ScopedConfig_ControlService {
     if ((level === DyNTS_ScopedConfig_Level.table || level === DyNTS_ScopedConfig_Level.scope) && !options.tableScope) {
       throw new Error(`DyNTS_ScopedConfig: '${key}' '${level}' szintű beállításához kötelező a tableScope.`);
     }
+
     if (level === DyNTS_ScopedConfig_Level.scope && !options.scopeId) {
       throw new Error(`DyNTS_ScopedConfig: '${key}' 'scope' szintű beállításához kötelező a scopeId.`);
     }
@@ -286,10 +301,11 @@ export class DyNTS_ScopedConfig_ControlService {
     level: DyNTS_ScopedConfig_Level,
     key: string,
     options: DyNTS_ScopedConfigSetOptions = {},
-  ): Promise<DyNTS_ScopedConfig_DataModel[]> {
-    const filter: DyFM_DBFilterSimple<DyNTS_ScopedConfig_DataModel> =
+  ): Promise<DyNTS_ScopedConfig[]> {
+    const filter: DyFM_DBFilterSimple<DyNTS_ScopedConfig> =
       DyNTS_ScopedConfig_DataService.levelKeyFilter(level, key, options);
     const dataService: DyNTS_ScopedConfig_DataService = new DyNTS_ScopedConfig_DataService({ issuer: options.issuer ?? this.issuer });
+
     return dataService.getArchiveDataService().findDataList(filter, true);
   }
 }