@futdevpro/nts-dynamo 1.15.89 → 1.15.90

package/src/_modules/oauth2/index.ts

@@ -1,17 +1,17 @@
-/* try {
-  require.resolve('crypto-js');
-} catch (error) {
-  console.log(
-    '❌ CryptoJS package not found, please install it with: pnpm add crypto-js'
-  );
-} */
-
-// This module is implementing solutions for OAuth2.0 protocol for the server.
-
-
-export * from './_routes/oauth2.controller';
-
-export * from './_services/oauth2.auth-service';
-export * from './_services/oauth2.control-service';
-
-
+/* try {
+  require.resolve('crypto-js');
+} catch (error) {
+  console.log(
+    '❌ CryptoJS package not found, please install it with: pnpm add crypto-js'
+  );
+} */
+
+// This module is implementing solutions for OAuth2.0 protocol for the server.
+
+
+export * from './_routes/oauth2.controller';
+
+export * from './_services/oauth2.auth-service';
+export * from './_services/oauth2.control-service';
+
+

package/src/_modules/scheduler/_models/scheduler-job.interface.ts

@@ -0,0 +1,35 @@
+/**
+ * Egy regisztralhato utemzett job a DyNTS_Scheduler_Service-hez.
+ *
+ * A handler IDEMPOTENS es RESTART-BIZTOS kell legyen: ne a scheduler futasi
+ * idejere, hanem sajat igazsagforras-timestampekre (pl. egy DB rekord
+ * `autoAcceptAt` mezojere) tamaszkodjon. Igy egy esetleges duplikalt vagy
+ * kihagyott futas sem okoz inkonzisztenciat.
+ */
+export interface DyNTS_ScheduledJob {
+  /** Egyedi job-kulcs (pl. "sp-auto-accept"). */
+  key: string;
+  /** Futasok kozotti ido ms-ben (pozitiv). */
+  intervalMs: number;
+  /** Elso futas kesleltetese ms-ben. Ha nincs megadva → intervalMs. */
+  initialDelayMs?: number;
+  /** A futtatando feladat. Sync vagy async egyarant lehet. */
+  handler: () => Promise<void> | void;
+}
+
+/** Egy job-futas allapota. */
+export type DyNTS_ScheduledJobRunStatus = 'running' | 'success' | 'failed';
+
+/** Egy job-futas naplo-eleme (in-memory ring bufferben). */
+export interface DyNTS_ScheduledJobRun {
+  /** A futtatott job kulcsa. */
+  jobKey: string;
+  /** Indulas idopontja (ISO). */
+  startedAt: string;
+  /** Befejezes idopontja (ISO), ha mar lefutott. */
+  finishedAt?: string;
+  /** Allapot. */
+  status: DyNTS_ScheduledJobRunStatus;
+  /** Hibauzenet, ha a futas elbukott (sosem `[object Object]`). */
+  error?: string;
+}

package/src/_modules/scheduler/get-scheduler-routing-module.util.ts

@@ -0,0 +1,33 @@
+import { DyNTS_RoutingModule_Settings } from '../../_models/interfaces/routing-module-settings.interface';
+import { DyNTS_RoutingModule } from '../../_services/route/routing-module.service';
+import { DyNTS_Scheduler_Controller, DyNTS_SchedulerController_Config } from './scheduler.controller';
+
+/**
+ * Letrehoz egy /scheduler routing module-t a job-utemzo futas-naplojanak lekeresehez.
+ *
+ * Hasznalat (auth NELKUL):
+ *   DyNTS_getSchedulerRoutingModule()
+ *
+ * Hasznalat (auth-TAL):
+ *   DyNTS_getSchedulerRoutingModule({ authPreProcess: authService.authenticate_sercretKey })
+ *
+ * FONTOS: a job-ok regisztralasa + inditasa kulon tortenik a szerver indulasakor:
+ *   const scheduler = DyNTS_Scheduler_Service.getInstance();
+ *   scheduler.registerJob({ ... });
+ *   scheduler.start();
+ */
+export function DyNTS_getSchedulerRoutingModule(
+  config?: DyNTS_SchedulerController_Config
+): DyNTS_RoutingModule {
+  // Konfiguracio atadasa a controller-nek (static, mert a singleton elott kell)
+  if (config) {
+    DyNTS_Scheduler_Controller.configure(config);
+  }
+
+  const set: DyNTS_RoutingModule_Settings = {
+    route: '/scheduler',
+    controllers: [DyNTS_Scheduler_Controller.getInstance()],
+  };
+
+  return new DyNTS_RoutingModule(set);
+}

package/src/_modules/scheduler/index.ts

@@ -0,0 +1,8 @@
+export { DyNTS_Scheduler_Service } from './scheduler.service';
+export { DyNTS_Scheduler_Controller, DyNTS_SchedulerController_Config } from './scheduler.controller';
+export { DyNTS_getSchedulerRoutingModule } from './get-scheduler-routing-module.util';
+export {
+  DyNTS_ScheduledJob,
+  DyNTS_ScheduledJobRun,
+  DyNTS_ScheduledJobRunStatus,
+} from './_models/scheduler-job.interface';

package/src/_modules/scheduler/scheduler.controller.spec.ts

@@ -0,0 +1,42 @@
+import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_Scheduler_Controller } from './scheduler.controller';
+
+describe('| DyNTS_Scheduler_Controller', (): void => {
+  let controller: DyNTS_Scheduler_Controller;
+
+  beforeEach((): void => {
+    controller = DyNTS_Scheduler_Controller.getInstance();
+  });
+
+  it('| is a singleton instance', (): void => {
+    const a: DyNTS_Scheduler_Controller = DyNTS_Scheduler_Controller.getInstance();
+    const b: DyNTS_Scheduler_Controller = DyNTS_Scheduler_Controller.getInstance();
+    expect(a).toBe(b);
+    expect(a).toBeInstanceOf(DyNTS_Scheduler_Controller);
+  });
+
+  it('| sets up the /runs endpoint', (): void => {
+    controller.setupEndpoints();
+
+    expect(controller.endpoints).toBeDefined();
+    expect(controller.endpoints.length).toBeGreaterThan(0);
+
+    const runsEndpoint = controller.endpoints.find((ep) => ep.name === 'getSchedulerRuns');
+    expect(runsEndpoint).toBeDefined();
+    expect(runsEndpoint?.type).toBe(DyFM_HttpCallType.get);
+  });
+
+  it('| applies an auth preProcess when configured', (): void => {
+    DyNTS_Scheduler_Controller.configure({
+      authPreProcess: async (): Promise<void> => {},
+    });
+    controller.setupEndpoints();
+
+    const runsEndpoint = controller.endpoints.find((ep) => ep.name === 'getSchedulerRuns');
+    expect((runsEndpoint as any)?.preProcesses?.length).toBeGreaterThan(0);
+
+    // visszaallitas, hogy ne szivarogjon at masik teszthez
+    DyNTS_Scheduler_Controller.configure({});
+  });
+});

package/src/_modules/scheduler/scheduler.controller.ts

@@ -0,0 +1,69 @@
+import { Request, Response } from 'express';
+
+import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_Controller } from '../../_services/route/controller.service';
+import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
+import { DyNTS_Scheduler_Service } from './scheduler.service';
+
+/**
+ * A scheduler controller konfiguracioja.
+ * Az authPreProcess opcionalis — ha megadod, a /runs endpoint vedett lesz.
+ */
+export interface DyNTS_SchedulerController_Config {
+  /** Opcionalis auth preprocess. Ha nincs megadva → nyilt hozzaferes. */
+  authPreProcess?: (req: Request, res: Response) => Promise<void>;
+}
+
+/**
+ * NTS Scheduler Controller — read-only futas-naplo endpoint a job-utemzohoz.
+ *
+ * Hasznalat:
+ *   DyNTS_getSchedulerRoutingModule()  — auth nelkul
+ *   DyNTS_getSchedulerRoutingModule({ authPreProcess: myAuth })  — auth-tal
+ */
+export class DyNTS_Scheduler_Controller extends DyNTS_Controller {
+
+  private static config: DyNTS_SchedulerController_Config = {};
+
+  static configure(config: DyNTS_SchedulerController_Config): void {
+    DyNTS_Scheduler_Controller.config = config;
+  }
+
+  static getInstance(): DyNTS_Scheduler_Controller {
+    return DyNTS_Scheduler_Controller.getSingletonInstance();
+  }
+
+  private readonly schedulerService: DyNTS_Scheduler_Service = DyNTS_Scheduler_Service.getInstance();
+
+  setupEndpoints(): void {
+    const preProcesses: ((req: Request, res: Response) => Promise<void>)[] = [];
+    if (DyNTS_Scheduler_Controller.config.authPreProcess) {
+      preProcesses.push(DyNTS_Scheduler_Controller.config.authPreProcess);
+    }
+
+    this.endpoints = [
+      // GET /runs?limit=100 — utolso N futas, legujabb elol
+      new DyNTS_Endpoint_Params({
+        name: 'getSchedulerRuns',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/runs',
+        preProcesses: preProcesses,
+        logRequest: false,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            const limit: number = Math.min(parseInt(req.query.limit as string) || 100, 500);
+            const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = this.schedulerService.getRuns(limit);
+
+            res.send({
+              jobs: this.schedulerService.getJobKeys(),
+              started: this.schedulerService.isStarted(),
+              returned: runs.length,
+              runs: runs,
+            });
+          },
+        ],
+      }),
+    ];
+  }
+}

package/src/_modules/scheduler/scheduler.service.spec.ts

@@ -0,0 +1,141 @@
+import { DyNTS_Scheduler_Service } from './scheduler.service';
+
+describe('| DyNTS_Scheduler_Service', (): void => {
+  let svc: DyNTS_Scheduler_Service;
+
+  beforeEach((): void => {
+    svc = DyNTS_Scheduler_Service.getInstance();
+    svc._resetForTesting();
+  });
+
+  afterEach((): void => {
+    svc._resetForTesting();
+  });
+
+  describe('| singleton', (): void => {
+    it('| returns the same instance', (): void => {
+      const a: DyNTS_Scheduler_Service = DyNTS_Scheduler_Service.getInstance();
+      const b: DyNTS_Scheduler_Service = DyNTS_Scheduler_Service.getInstance();
+      expect(a).toBe(b);
+      expect(a).toBeInstanceOf(DyNTS_Scheduler_Service);
+    });
+  });
+
+  describe('| registerJob', (): void => {
+    it('| registers a job by key', (): void => {
+      svc.registerJob({ key: 'a', intervalMs: 1000, handler: (): void => {} });
+      expect(svc.getJobKeys()).toEqual(['a']);
+    });
+
+    it('| throws on duplicate key', (): void => {
+      svc.registerJob({ key: 'dup', intervalMs: 1000, handler: (): void => {} });
+      expect((): void => svc.registerJob({ key: 'dup', intervalMs: 1000, handler: (): void => {} })).toThrow();
+    });
+
+    it('| throws on missing key', (): void => {
+      expect((): void => svc.registerJob({ key: '', intervalMs: 1000, handler: (): void => {} })).toThrow();
+    });
+
+    it('| throws on non-positive intervalMs', (): void => {
+      expect((): void => svc.registerJob({ key: 'x', intervalMs: 0, handler: (): void => {} })).toThrow();
+    });
+  });
+
+  describe('| unregisterJob', (): void => {
+    it('| removes a registered job', (): void => {
+      svc.registerJob({ key: 'a', intervalMs: 1000, handler: (): void => {} });
+      svc.unregisterJob('a');
+      expect(svc.getJobKeys()).toEqual([]);
+    });
+
+    it('| is a no-op for unknown key', (): void => {
+      expect((): void => svc.unregisterJob('nope')).not.toThrow();
+    });
+  });
+
+  describe('| start / stop', (): void => {
+    it('| start marks the scheduler started', (): void => {
+      expect(svc.isStarted()).toBe(false);
+      svc.start();
+      expect(svc.isStarted()).toBe(true);
+    });
+
+    it('| stop marks the scheduler stopped', (): void => {
+      svc.start();
+      svc.stop();
+      expect(svc.isStarted()).toBe(false);
+    });
+
+    it('| start is idempotent', (): void => {
+      svc.start();
+      svc.start();
+      expect(svc.isStarted()).toBe(true);
+    });
+  });
+
+  describe('| runNow', (): void => {
+    it('| executes the handler and records a success run', async (): Promise<void> => {
+      let calls: number = 0;
+      svc.registerJob({ key: 'ok', intervalMs: 1000, handler: (): void => { calls++; } });
+
+      await svc.runNow('ok');
+
+      expect(calls).toBe(1);
+      const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = svc.getRuns();
+      expect(runs.length).toBe(1);
+      expect(runs[0].jobKey).toBe('ok');
+      expect(runs[0].status).toBe('success');
+      expect(runs[0].finishedAt).toBeDefined();
+    });
+
+    it('| records a failed run with a rich error message', async (): Promise<void> => {
+      svc.registerJob({ key: 'bad', intervalMs: 1000, handler: (): void => { throw new Error('boom'); } });
+
+      await svc.runNow('bad');
+
+      const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = svc.getRuns();
+      expect(runs[0].status).toBe('failed');
+      expect(runs[0].error).toContain('boom');
+    });
+
+    it('| throws for an unknown job key', async (): Promise<void> => {
+      let thrown: unknown = null;
+      try { await svc.runNow('nope'); } catch (error: unknown) { thrown = error; }
+      expect(thrown).not.toBeNull();
+    });
+
+    it('| skip-if-running prevents overlapping executions', async (): Promise<void> => {
+      let active: number = 0;
+      let maxActive: number = 0;
+      svc.registerJob({
+        key: 'lock',
+        intervalMs: 1000,
+        handler: async (): Promise<void> => {
+          active++;
+          maxActive = Math.max(maxActive, active);
+          await new Promise<void>((resolve: () => void): void => { setTimeout(resolve, 20); });
+          active--;
+        },
+      });
+
+      await Promise.all([svc.runNow('lock'), svc.runNow('lock')]);
+
+      expect(maxActive).toBe(1);
+    });
+  });
+
+  describe('| getRuns', (): void => {
+    it('| returns the most recent run first', async (): Promise<void> => {
+      svc.registerJob({ key: 'first', intervalMs: 1000, handler: (): void => {} });
+      svc.registerJob({ key: 'second', intervalMs: 1000, handler: (): void => {} });
+
+      await svc.runNow('first');
+      await svc.runNow('second');
+
+      const runs: ReturnType<DyNTS_Scheduler_Service['getRuns']> = svc.getRuns();
+      expect(runs.length).toBe(2);
+      expect(runs[0].jobKey).toBe('second');
+      expect(runs[1].jobKey).toBe('first');
+    });
+  });
+});

package/src/_modules/scheduler/scheduler.service.ts

@@ -0,0 +1,176 @@
+import { Subscription, timer } from 'rxjs';
+
+import { DyNTS_SingletonServiceBase } from '../../_services/base/singleton.service-base';
+import {
+  DyNTS_ScheduledJob,
+  DyNTS_ScheduledJobRun,
+} from './_models/scheduler-job.interface';
+
+/** Belso reprezentacio egy regisztralt job-rol + aktiv timer-rol. */
+interface DyNTS_RegisteredJob {
+  job: DyNTS_ScheduledJob;
+  subscription?: Subscription;
+  running: boolean;
+}
+
+/**
+ * Altalanos, idozitett-job utemzo a DyNTS szerverekhez.
+ *
+ * - **Regisztralhato**: `registerJob({ key, intervalMs, handler })`.
+ * - **Idempotens / skip-if-running**: egy job-bol egyszerre csak egy futas megy
+ *   (a lassu futas nem torlodik fel).
+ * - **Restart-biztos**: a scheduler NEM perzisztal futasi allapotot — a helyesseget
+ *   a handler igazsagforras-timestampjei adjak (lasd DyNTS_ScheduledJob doc).
+ * - **Naplo**: az utolso N futas in-memory ring bufferben (`getRuns()`), hiba eseten
+ *   rich hibauzenettel (sosem `[object Object]`).
+ *
+ * Hasznalat (szerver indulasakor):
+ *   const scheduler = DyNTS_Scheduler_Service.getInstance();
+ *   scheduler.registerJob({ key: 'sp-auto-accept', intervalMs: 24 * 60 * 60 * 1000, handler });
+ *   scheduler.start();
+ */
+export class DyNTS_Scheduler_Service extends DyNTS_SingletonServiceBase {
+
+  static getInstance(): DyNTS_Scheduler_Service {
+    return DyNTS_Scheduler_Service.getSingletonInstance() as DyNTS_Scheduler_Service;
+  }
+
+  private readonly jobs: Map<string, DyNTS_RegisteredJob> = new Map<string, DyNTS_RegisteredJob>();
+  private readonly runs: DyNTS_ScheduledJobRun[] = [];
+  private readonly maxRuns: number = 500;
+  private started: boolean = false;
+
+  /**
+   * Job regisztralasa. Ha a scheduler mar el (`start()` lefutott), a job timer-e
+   * azonnal elindul. Duplikalt kulcs / hibas intervalMs eseten hibat dob.
+   */
+  registerJob(job: DyNTS_ScheduledJob): void {
+    if (!job || !job.key) {
+      throw new Error('DyNTS_Scheduler_Service.registerJob: job.key kotelezo');
+    }
+    if (this.jobs.has(job.key)) {
+      throw new Error(`DyNTS_Scheduler_Service.registerJob: a(z) "${job.key}" job mar regisztralva van`);
+    }
+    if (typeof job.intervalMs !== 'number' || job.intervalMs <= 0) {
+      throw new Error(`DyNTS_Scheduler_Service.registerJob: a(z) "${job.key}" job-hoz pozitiv intervalMs kell`);
+    }
+
+    const registered: DyNTS_RegisteredJob = { job: job, running: false };
+    this.jobs.set(job.key, registered);
+
+    if (this.started) {
+      this.startJob(registered);
+    }
+  }
+
+  /** Job leiratkoztatasa + eltavolitasa. Ismeretlen kulcs eseten no-op. */
+  unregisterJob(key: string): void {
+    const registered: DyNTS_RegisteredJob | undefined = this.jobs.get(key);
+    if (!registered) { return; }
+    registered.subscription?.unsubscribe();
+    this.jobs.delete(key);
+  }
+
+  /** Minden regisztralt job timer-enek inditasa. Idempotens. */
+  start(): void {
+    if (this.started) { return; }
+    this.started = true;
+    this.jobs.forEach((registered: DyNTS_RegisteredJob) => this.startJob(registered));
+  }
+
+  /** Minden job timer-enek leallitasa (a regisztraciok megmaradnak). */
+  stop(): void {
+    this.jobs.forEach((registered: DyNTS_RegisteredJob) => {
+      registered.subscription?.unsubscribe();
+      registered.subscription = undefined;
+    });
+    this.started = false;
+  }
+
+  /** Egy job azonnali, kezi futtatasa (a skip-if-running lock-ot tiszteletben tartva). */
+  async runNow(key: string): Promise<void> {
+    const registered: DyNTS_RegisteredJob | undefined = this.jobs.get(key);
+    if (!registered) {
+      throw new Error(`DyNTS_Scheduler_Service.runNow: a(z) "${key}" job nincs regisztralva`);
+    }
+    await this.executeJob(registered);
+  }
+
+  /** El van-e inditva a scheduler. */
+  isStarted(): boolean {
+    return this.started;
+  }
+
+  /** Eppen fut-e az adott job. */
+  isRunning(key: string): boolean {
+    return this.jobs.get(key)?.running ?? false;
+  }
+
+  /** A regisztralt job-kulcsok. */
+  getJobKeys(): string[] {
+    return Array.from(this.jobs.keys());
+  }
+
+  /** Az utolso N futas, legujabb elol. */
+  getRuns(limit: number = 100): DyNTS_ScheduledJobRun[] {
+    const safeLimit: number = Math.max(0, Math.min(limit, this.runs.length));
+    return this.runs.slice(this.runs.length - safeLimit).reverse();
+  }
+
+  /** Teszt-segedlet: minden timer leall + minden regisztracio/naplo torlodik. */
+  _resetForTesting(): void {
+    this.stop();
+    this.jobs.clear();
+    this.runs.length = 0;
+  }
+
+  private startJob(registered: DyNTS_RegisteredJob): void {
+    if (registered.subscription) { return; }
+    const initialDelay: number = registered.job.initialDelayMs ?? registered.job.intervalMs;
+    registered.subscription = timer(initialDelay, registered.job.intervalMs)
+      .subscribe(() => { void this.executeJob(registered); });
+  }
+
+  private async executeJob(registered: DyNTS_RegisteredJob): Promise<void> {
+    if (registered.running) { return; }
+    registered.running = true;
+
+    const run: DyNTS_ScheduledJobRun = {
+      jobKey: registered.job.key,
+      startedAt: new Date().toISOString(),
+      status: 'running',
+    };
+    this.pushRun(run);
+
+    try {
+      await registered.job.handler();
+      run.status = 'success';
+    } catch (error: unknown) {
+      run.status = 'failed';
+      run.error = this.toErrorMessage(error);
+      this.logError(registered.job.key, error);
+    } finally {
+      run.finishedAt = new Date().toISOString();
+      registered.running = false;
+    }
+  }
+
+  private pushRun(run: DyNTS_ScheduledJobRun): void {
+    this.runs.push(run);
+    if (this.runs.length > this.maxRuns) {
+      this.runs.shift();
+    }
+  }
+
+  private toErrorMessage(error: unknown): string {
+    if (error instanceof Error) { return error.message; }
+    try { return JSON.stringify(error); } catch { return String(error); }
+  }
+
+  private logError(jobKey: string, error: unknown): void {
+    // A console.error-t a DyNTS_Logs_Service (ha telepitve van) automatikusan bufferli.
+    // TODO (kovetkezo iteracio): bekotni a DyNTS_GlobalService.globalErrorHandler-be.
+    // eslint-disable-next-line no-console
+    console.error(` ! Scheduler job "${jobKey}" failed:`, error);
+  }
+}

package/src/_modules/scoped-config/_enums/dynts-scoped-config-level.enum.ts

@@ -1,22 +1,22 @@
-
-/**
- * `DyNTS_ScopedConfig_Level` — a DB-backed scoped config feloldási-szintjei (BFR-AM-004).
- *
- * A precedencia: **scope (leaf→root) > table > global > builtin-default**. Egy `DyNTS_ScopedConfig`
- * dokumentum mindig pontosan EGY szinten él; a `level` + `tableScope` + `scopeId` hármas adja a
- * feloldási-kulcsot (a `key`-vel együtt a logikai unique-constraint).
- *
- * **Domain-agnosztikus:** a konkrét table-/scope-nevek a fogyasztó dolga; a bedrock csak a generikus
- * precedencia-engine + a tárolás szintjeit definiálja (a katalógus/kulcsok NEM ide tartoznak).
- */
-export enum DyNTS_ScopedConfig_Level {
-
-  /** Rendszer-szintű default (a legalacsonyabb precedencia a builtin felett). */
-  global = 'global',
-
-  /** Egy adott logikai tár/táblázat szintje (`tableScope` kötelező). */
-  table = 'table',
-
-  /** A legspecifikusabb szint: egy konkrét scope-entitás (`tableScope` + `scopeId` kötelező). */
-  scope = 'scope',
-}
+
+/**
+ * `DyNTS_ScopedConfig_Level` — a DB-backed scoped config feloldási-szintjei (BFR-AM-004).
+ *
+ * A precedencia: **scope (leaf→root) > table > global > builtin-default**. Egy `DyNTS_ScopedConfig`
+ * dokumentum mindig pontosan EGY szinten él; a `level` + `tableScope` + `scopeId` hármas adja a
+ * feloldási-kulcsot (a `key`-vel együtt a logikai unique-constraint).
+ *
+ * **Domain-agnosztikus:** a konkrét table-/scope-nevek a fogyasztó dolga; a bedrock csak a generikus
+ * precedencia-engine + a tárolás szintjeit definiálja (a katalógus/kulcsok NEM ide tartoznak).
+ */
+export enum DyNTS_ScopedConfig_Level {
+
+  /** Rendszer-szintű default (a legalacsonyabb precedencia a builtin felett). */
+  global = 'global',
+
+  /** Egy adott logikai tár/táblázat szintje (`tableScope` kötelező). */
+  table = 'table',
+
+  /** A legspecifikusabb szint: egy konkrét scope-entitás (`tableScope` + `scopeId` kötelező). */
+  scope = 'scope',
+}