@futdevpro/nts-dynamo 1.15.20 → 1.15.23

package/src/_modules/logs/file-logs.controller.ts

@@ -0,0 +1,165 @@
+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_FileLog_Entry } from './_models/file-log-entry.interface';
+import { DyNTS_FileLog_ReadResult, DyNTS_FileLog_ReadOptions } from './_models/file-log-read-result.interface';
+import { DyNTS_FileLog_Service } from './file-log.service';
+
+
+/**
+ * Config a `DyNTS_FileLogs_Controller`-hez (opcionalis auth pre-process).
+ */
+export interface DyNTS_FileLogsController_Config {
+  /**
+   * Opcionalis auth pre-process — ha megadod, a controller-en levo endpointok
+   * vedettek. Tipikusan: `DyNTS_AdminApiKey_AuthService.getInstance().verify`.
+   */
+  authPreProcess?: (req: Request, res: Response) => Promise<void>;
+}
+
+
+/**
+ * NTS File Logs Controller — endpointok a `DyNTS_FileLog_Service` altal irt
+ * log fajl-ok lekeresehez.
+ *
+ * **Endpoint-ok:**
+ *   GET /list                — log fajlok listazasa (basename, sizeBytes, mtimeMs, isCurrent)
+ *   GET /file/:filename      — egy fajl olvasasa, line-based: ?tail=N | ?head=N | ?rangeStart=A&rangeEnd=B
+ *
+ * **Mount-olas (host app):**
+ *   app.use(DyNTS_getFileLogsRoutingModule({
+ *     authPreProcess: adminAuth.verify,  // opcionalis
+ *     route: '/admin/file-logs',          // default '/file-logs'
+ *   }));
+ *
+ * **Status code-ok:**
+ *   200 — sikeres response (lehet ures lista is)
+ *   400 — invalid query parameter (tail/head/range)
+ *   401 — auth pre-process throw-ol DyFM_Error(401)
+ *   404 — fajl nem letezik vagy nem megfelelo nev (whitelist failure / path traversal kiserlet)
+ *   503 — a DyNTS_FileLog_Service nincs install-olva (vagy file_log.enabled=false)
+ */
+export class DyNTS_FileLogs_Controller extends DyNTS_Controller {
+
+  private static config: DyNTS_FileLogsController_Config = {};
+
+  static configure(config: DyNTS_FileLogsController_Config): void {
+    DyNTS_FileLogs_Controller.config = config;
+  }
+
+  static getInstance(): DyNTS_FileLogs_Controller {
+    return DyNTS_FileLogs_Controller.getSingletonInstance();
+  }
+
+  private readonly fileLogService: DyNTS_FileLog_Service = DyNTS_FileLog_Service.getInstance();
+
+  setupEndpoints(): void {
+    const preProcesses: ((req: Request, res: Response) => Promise<void>)[] = [];
+    if (DyNTS_FileLogs_Controller.config.authPreProcess) {
+      preProcesses.push(DyNTS_FileLogs_Controller.config.authPreProcess);
+    }
+
+    this.endpoints = [
+      // GET /list — fajllista
+      new DyNTS_Endpoint_Params({
+        name: 'listFileLogs',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/list',
+        preProcesses: preProcesses,
+        logRequest: false,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            if (!this.fileLogService.isInstalled()) {
+              res.status(503).send({
+                error: 'FileLog service is not installed.',
+                hint: 'Set DyNTS_global_settings.log_settings.file_log.enabled = true and call DyNTS_FileLog_Service.getInstance().install() at server startup.',
+              });
+              return;
+            }
+
+            const files: DyNTS_FileLog_Entry[] = this.fileLogService.listLogFiles();
+            const totalSizeBytes: number = files.reduce(
+              (acc: number, f: DyNTS_FileLog_Entry): number => acc + f.sizeBytes, 0,
+            );
+
+            res.send({
+              count:          files.length,
+              totalSizeBytes: totalSizeBytes,
+              files:          files,
+            });
+          },
+        ],
+      }),
+
+      // GET /file/:filename — egy fajl olvasasa tail / head / range modban
+      new DyNTS_Endpoint_Params({
+        name: 'readFileLog',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/file/:filename',
+        preProcesses: preProcesses,
+        logRequest: false,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            if (!this.fileLogService.isInstalled()) {
+              res.status(503).send({
+                error: 'FileLog service is not installed.',
+              });
+              return;
+            }
+
+            const filename: string = req.params.filename;
+            const options: DyNTS_FileLog_ReadOptions = {};
+
+            // Mod prioritas: range > head > tail. Csak a megadott mezo aktivalja az adott modot.
+            if (req.query.rangeStart !== undefined && req.query.rangeEnd !== undefined) {
+              const start: number = parseInt(req.query.rangeStart as string, 10);
+              const end: number = parseInt(req.query.rangeEnd as string, 10);
+              if (!Number.isFinite(start) || !Number.isFinite(end) || start < 1 || end < start) {
+                res.status(400).send({ error: 'Invalid rangeStart/rangeEnd query parameters' });
+                return;
+              }
+              options.rangeStart = start;
+              options.rangeEnd = end;
+            } else if (req.query.head !== undefined) {
+              const head: number = parseInt(req.query.head as string, 10);
+              if (!Number.isFinite(head) || head < 1) {
+                res.status(400).send({ error: 'Invalid head query parameter' });
+                return;
+              }
+              options.head = head;
+            } else if (req.query.tail !== undefined) {
+              const tail: number = parseInt(req.query.tail as string, 10);
+              if (!Number.isFinite(tail) || tail < 1) {
+                res.status(400).send({ error: 'Invalid tail query parameter' });
+                return;
+              }
+              options.tail = tail;
+            }
+            // egyik query mezo sincs → service alapertelmezett tail (200)
+
+            try {
+              const result: DyNTS_FileLog_ReadResult = this.fileLogService.readLogFile(filename, options);
+              res.send(result);
+            } catch (err: unknown) {
+              const msg: string = err instanceof Error ? err.message : String(err);
+              if (msg === 'FileLog service not installed') {
+                res.status(503).send({ error: msg });
+                return;
+              }
+              if (msg === 'invalid filename' || msg === 'file not found') {
+                res.status(404).send({ error: msg, filename: filename });
+                return;
+              }
+              // Egyeb hibak (pl. FS read failure) — 500
+              res.status(500).send({ error: msg });
+            }
+          },
+        ],
+      }),
+    ];
+  }
+}

package/src/_modules/logs/get-file-logs-routing-module.util.ts

@@ -0,0 +1,51 @@
+import { DyNTS_RoutingModule_Settings } from '../../_models/interfaces/routing-module-settings.interface';
+import { DyNTS_RoutingModule } from '../../_services/route/routing-module.service';
+
+import { DyNTS_FileLogs_Controller, DyNTS_FileLogsController_Config } from './file-logs.controller';
+
+
+/**
+ * Config a `DyNTS_getFileLogsRoutingModule()`-hoz.
+ */
+export interface DyNTS_FileLogsRoutingModule_Config extends DyNTS_FileLogsController_Config {
+  /** Route prefix. Default: `/file-logs`. */
+  route?: string;
+}
+
+
+/**
+ * Letrehoz egy routing module-t a `DyNTS_FileLogs_Controller`-rel.
+ *
+ * **Hasznalat (auth nelkul, fejlesztoi env):**
+ *   ```ts
+ *   app.use(DyNTS_getFileLogsRoutingModule());
+ *   ```
+ *
+ * **Hasznalat (admin API key auth-tal — javasolt produkcios env-re):**
+ *   ```ts
+ *   const adminAuth = DyNTS_AdminApiKey_AuthService.getInstance();
+ *   app.use(DyNTS_getFileLogsRoutingModule({
+ *     authPreProcess: adminAuth.verify,
+ *     route: '/admin/file-logs',  // opcionalis override
+ *   }));
+ *   ```
+ *
+ * **Elofeltetel:** `DyNTS_FileLog_Service.getInstance().install()` lefutott
+ * a szerver startup-on (es a `log_settings.file_log.enabled = true`).
+ * Egyebkent a controller endpointjai 503-at adnak.
+ */
+export function DyNTS_getFileLogsRoutingModule(
+  config?: DyNTS_FileLogsRoutingModule_Config,
+): DyNTS_RoutingModule {
+  // Controller config atadasa (static — getInstance() elott)
+  if (config) {
+    DyNTS_FileLogs_Controller.configure({ authPreProcess: config.authPreProcess });
+  }
+
+  const settings: DyNTS_RoutingModule_Settings = {
+    route: config?.route ?? '/file-logs',
+    controllers: [DyNTS_FileLogs_Controller.getInstance()],
+  };
+
+  return new DyNTS_RoutingModule(settings);
+}

package/src/_modules/logs/index.ts

@@ -2,3 +2,10 @@ export { DyNTS_Logs_Service } from './logs.service';
 export { DyNTS_Logs_Controller, DyNTS_LogsController_Config } from './logs.controller';
 export { DyNTS_getLogsRoutingModule } from './get-logs-routing-module.util';
 export { DyNTS_FileLog_Service } from './file-log.service';
+export { DyNTS_FileLogs_Controller, DyNTS_FileLogsController_Config } from './file-logs.controller';
+export {
+  DyNTS_getFileLogsRoutingModule,
+  DyNTS_FileLogsRoutingModule_Config,
+} from './get-file-logs-routing-module.util';
+export { DyNTS_FileLog_Entry } from './_models/file-log-entry.interface';
+export { DyNTS_FileLog_ReadResult, DyNTS_FileLog_ReadOptions } from './_models/file-log-read-result.interface';

package/src/_modules/server/errors/errors.controller.spec.ts

@@ -161,5 +161,75 @@ describe('| DyNTS_Errors_Controller', () => {
       }).toThrow();
     });
   });
+
+  describe('| opt-in admin auth retrofit (BL-20260420-004)', (): void => {
+    afterEach((): void => {
+      DyNTS_Errors_Controller._resetAuthConfigForTesting();
+    });
+
+    it('| default: NO preProcesses on any endpoint (backwards compatible)', (): void => {
+      controller.setupEndpoints();
+      for (const ep of controller.endpoints) {
+        const pre: any = (ep as any).preProcesses;
+        // Ures array vagy undefined elfogadhato — fontos hogy NE legyen auth
+        expect(pre === undefined || pre.length === 0).toBe(true);
+      }
+    });
+
+    it('| configure({ authPreProcess }) → mind a 8 endpoint kap preProcesses-t', (): void => {
+      const fakeAuth = async (): Promise<void> => { /* noop */ };
+      DyNTS_Errors_Controller.configure({ authPreProcess: fakeAuth });
+      // Uj controller instance kell — a setupEndpoints olvassa a static config-ot
+      const c = new (TestErrorsController as any)();
+      c.setupEndpoints();
+
+      const builtIn: string[] = [
+        'logError', 'newError',
+        'markErrorDone', 'markAllErrorDone',
+        'getErrors', 'getErrorsPaged', 'getLastErrors',
+        'searchErrors',
+      ];
+      for (const name of builtIn) {
+        const ep: any = c.endpoints.find((e: any) => e.name === name);
+        expect(ep).withContext(`endpoint ${name} missing`).toBeDefined();
+        const pre: any = (ep as any).preProcesses;
+        expect(pre.length).withContext(`endpoint ${name} preProcesses`).toBe(1);
+        expect(pre[0]).toBe(fakeAuth);
+      }
+    });
+
+    it('| configure({ authPreProcess, protectedEndpoints: subset }) → csak a megadott neveken aktiv', (): void => {
+      const fakeAuth = async (): Promise<void> => { /* noop */ };
+      DyNTS_Errors_Controller.configure({
+        authPreProcess: fakeAuth,
+        protectedEndpoints: ['markAllErrorDone', 'logError'],
+      });
+      const c = new (TestErrorsController as any)();
+      c.setupEndpoints();
+
+      const markAll: any = c.endpoints.find((e: any) => e.name === 'markAllErrorDone');
+      const log: any    = c.endpoints.find((e: any) => e.name === 'logError');
+      const getErrors: any = c.endpoints.find((e: any) => e.name === 'getErrors');
+
+      expect((markAll as any).preProcesses.length).toBe(1);
+      expect((log as any).preProcesses.length).toBe(1);
+      expect((getErrors as any).preProcesses?.length ?? 0).toBe(0);
+    });
+
+    it('| getAuthConfig() returns the active config', (): void => {
+      const fakeAuth = async (): Promise<void> => { /* noop */ };
+      DyNTS_Errors_Controller.configure({ authPreProcess: fakeAuth, protectedEndpoints: ['logError'] });
+      const cfg = DyNTS_Errors_Controller.getAuthConfig();
+      expect(cfg.authPreProcess).toBe(fakeAuth);
+      expect(cfg.protectedEndpoints).toEqual(['logError']);
+    });
+
+    it('| _resetAuthConfigForTesting() clears the config', (): void => {
+      DyNTS_Errors_Controller.configure({ authPreProcess: async (): Promise<void> => { /* noop */ } });
+      DyNTS_Errors_Controller._resetAuthConfigForTesting();
+      const cfg = DyNTS_Errors_Controller.getAuthConfig();
+      expect(cfg.authPreProcess).toBeUndefined();
+    });
+  });
 });
 

package/src/_modules/server/errors/errors.controller.ts

@@ -7,6 +7,49 @@ import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-
 import { DyNTS_Errors_ControlService } from './errors.control-service';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
 
+
+/**
+ * Auth retrofit config a `DyNTS_Errors_Controller`-hez. Opt-in — ha az
+ * `authPreProcess` nincs megadva, a controller a regi (auth nelkuli)
+ * viselkedest tartja.
+ *
+ * **Subclass-szintu konfiguracio:** az `authConfig` static, igy az abstract
+ * osztaly minden subclass-a kozott OSZTOTT. Ha tobb subclass-od van kulonbozo
+ * policy-val, hivd a `configure()`-t a megfelelo subclasson — TypeScript a
+ * static field-eket per-class hatarozza meg.
+ */
+export interface DyNTS_ErrorsController_AuthConfig {
+  /**
+   * Pre-process fuggveny ami minden vedett endpoint elott fut. Tipikusan:
+   * `DyNTS_AdminApiKey_AuthService.getInstance().verify`.
+   *
+   * Ha hianyzik vagy `undefined`, a controller NEM ad hozza auth-ot semelyik
+   * endpoint-hoz (regi viselkedes, opt-in safety).
+   */
+  authPreProcess?: (req: Request, res: Response) => Promise<void>;
+
+  /**
+   * Vedett endpoint nevek listaja. Ha hianyzik, az osszes 8 endpoint vedett
+   * (`authPreProcess` jelenleteben).
+   *
+   * Endpoint nevek: 'logError', 'newError', 'markErrorDone', 'markAllErrorDone',
+   * 'getErrors', 'getErrorsPaged', 'getLastErrors', 'searchErrors'.
+   */
+  protectedEndpoints?: string[];
+}
+
+
+/**
+ * Az osszes built-in endpoint neve — a `configure({ protectedEndpoints })`
+ * default-jat es a config validacio-t segiti.
+ */
+const ALL_ENDPOINT_NAMES: string[] = [
+  'logError', 'newError',
+  'markErrorDone', 'markAllErrorDone',
+  'getErrors', 'getErrorsPaged', 'getLastErrors',
+  'searchErrors',
+];
+
 /**
  * Endpoints:
  * 
@@ -49,6 +92,57 @@ export abstract class DyNTS_Errors_Controller<
   ): T_Error_ControlService;
   protected readonly additionalEndpoints: DyNTS_Endpoint_Params[] = [];
 
+  /**
+   * Static auth config — opt-in retrofit. Default ures objektum → NO auth
+   * (a meglevo integraciok valtoznatlan viselkedessel folytatodnak).
+   */
+  protected static authConfig: DyNTS_ErrorsController_AuthConfig = {};
+
+  /**
+   * Static config setter. Hivhato barmikor a szerver startup-jan az endpoint
+   * registration ELOTT.
+   *
+   * Use case (host app):
+   * ```ts
+   * const adminAuth = DyNTS_AdminApiKey_AuthService.getInstance();
+   * DyNTS_Errors_Controller.configure({ authPreProcess: adminAuth.verify });
+   * // vagy fine-grained:
+   * DyNTS_Errors_Controller.configure({
+   *   authPreProcess: adminAuth.verify,
+   *   protectedEndpoints: ['markAllErrorDone', 'logError'],
+   * });
+   * ```
+   */
+  static configure(config: DyNTS_ErrorsController_AuthConfig): void {
+    DyNTS_Errors_Controller.authConfig = config;
+  }
+
+  /**
+   * Aktualis auth config olvasasa (test/diagnosztika celokra).
+   */
+  static getAuthConfig(): DyNTS_ErrorsController_AuthConfig {
+    return DyNTS_Errors_Controller.authConfig;
+  }
+
+  /**
+   * Test-only: visszaallitja az auth config-ot ures objektumra. Production code NE hivja.
+   */
+  static _resetAuthConfigForTesting(): void {
+    DyNTS_Errors_Controller.authConfig = {};
+  }
+
+  /**
+   * Vissza-adja az adott endpoint-hoz tartozo `preProcesses` array-t.
+   * Ha az auth NINCS configurolva (default) vagy az endpoint nincs a
+   * `protectedEndpoints` listan, ures array-t ad vissza.
+   */
+  protected getPreProcessesFor(endpointName: string): ((req: Request, res: Response) => Promise<void>)[] {
+    const cfg: DyNTS_ErrorsController_AuthConfig = DyNTS_Errors_Controller.authConfig;
+    if (!cfg.authPreProcess) { return []; }
+    const protectedNames: string[] = cfg.protectedEndpoints ?? ALL_ENDPOINT_NAMES;
+    return protectedNames.includes(endpointName) ? [cfg.authPreProcess] : [];
+  }
+
   setupEndpoints(): void {
     /* if (!this.getErrorDataService) {
       throw new DyFM_Error({
@@ -69,6 +163,7 @@ export abstract class DyNTS_Errors_Controller<
         name: 'logError',
         type: DyFM_HttpCallType.post,
         endpoint: '/error/log',
+        preProcesses: this.getPreProcessesFor('logError'),
         tasks: [
           async (req: Request, res: Response, issuer: string = 'unknown-issuer'): Promise<void> => {
             const error_CS: T_Error_ControlService = this.getError_ControlService({
@@ -87,6 +182,7 @@ export abstract class DyNTS_Errors_Controller<
         name: 'newError',
         type: DyFM_HttpCallType.post,
         endpoint: '/error/new',
+        preProcesses: this.getPreProcessesFor('newError'),
         tasks: [
           async (req: Request, res: Response, issuer: string = 'unknown-issuer'): Promise<void> => {
             const error_CS: T_Error_ControlService = this.getError_ControlService({
@@ -106,6 +202,7 @@ export abstract class DyNTS_Errors_Controller<
         name: 'markErrorDone',
         type: DyFM_HttpCallType.get,
         endpoint: '/error/mark-done/:errorId',
+        preProcesses: this.getPreProcessesFor('markErrorDone'),
         tasks: [
           async (req: Request, res: Response, issuer: string = 'unknown-issuer'): Promise<void> => {
             const error_CS: T_Error_ControlService = this.getError_ControlService({
@@ -125,6 +222,7 @@ export abstract class DyNTS_Errors_Controller<
         name: 'markAllErrorDone',
         type: DyFM_HttpCallType.get,
         endpoint: '/error/mark-all-done',
+        preProcesses: this.getPreProcessesFor('markAllErrorDone'),
         tasks: [
           async (req: Request, res: Response, issuer: string = 'unknown-issuer'): Promise<void> => {
             const error_CS: T_Error_ControlService = this.getError_ControlService({
@@ -164,6 +262,7 @@ export abstract class DyNTS_Errors_Controller<
         name: 'getErrors',
         type: DyFM_HttpCallType.get,
         endpoint: '/error/get-range/:range',
+        preProcesses: this.getPreProcessesFor('getErrors'),
         tasks: [
           async (req: Request, res: Response, issuer: string = 'unknown-issuer') : Promise<void> => {
             const error_CS: T_Error_ControlService = this.getError_ControlService({
@@ -184,6 +283,7 @@ export abstract class DyNTS_Errors_Controller<
         name: 'getErrorsPaged',
         type: DyFM_HttpCallType.get,
         endpoint: '/error/get-paged/:range/:pageSize/:pageIndex',
+        preProcesses: this.getPreProcessesFor('getErrorsPaged'),
         tasks: [
           async (req: Request, res: Response, issuer: string = 'unknown-issuer') : Promise<void> => {
             const error_CS: T_Error_ControlService = this.getError_ControlService({
@@ -215,6 +315,7 @@ export abstract class DyNTS_Errors_Controller<
         name: 'getLastErrors',
         type: DyFM_HttpCallType.get,
         endpoint: '/error/get-last-paged/:range/:pageSize/:pageIndex',
+        preProcesses: this.getPreProcessesFor('getLastErrors'),
         tasks: [
           async (req: Request, res: Response, issuer: string = 'unknown-issuer') : Promise<void> => {
             const error_CS: T_Error_ControlService = this.getError_ControlService({
@@ -246,6 +347,7 @@ export abstract class DyNTS_Errors_Controller<
         name: 'searchErrors',
         type: DyFM_HttpCallType.get,
         endpoint: '/error/search',
+        preProcesses: this.getPreProcessesFor('searchErrors'),
         tasks: [
           async (req: Request, res: Response, issuer: string = 'unknown-issuer') : Promise<void> => {
             const error_CS: T_Error_ControlService = this.getError_ControlService({