@futdevpro/nts-dynamo 1.15.20 → 1.15.21

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

@@ -0,0 +1,245 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+import { DyNTS_FileLog_Service } from './file-log.service';
+import { DyNTS_FileLogs_Controller } from './file-logs.controller';
+
+
+/** Minimal Request mock builder. */
+const mockReq = (args: { params?: Record<string, string>; query?: Record<string, any> } = {}): any => ({
+  params: args.params ?? {},
+  query: args.query ?? {},
+  headers: {},
+});
+
+/** Minimal Response mock that records status + send payload. */
+interface MockRes {
+  statusCode: number;
+  payload: any;
+  status: (code: number) => MockRes;
+  send: (data: any) => MockRes;
+}
+const mockRes = (): MockRes => {
+  const res: MockRes = {
+    statusCode: 200,
+    payload: undefined,
+    status(code: number): MockRes { res.statusCode = code; return res; },
+    send(data: any): MockRes { res.payload = data; return res; },
+  };
+  return res;
+};
+
+
+/** Extract a task function by endpoint name. */
+const taskByName = (controller: DyNTS_FileLogs_Controller, name: string): ((req: any, res: any) => Promise<void>) => {
+  const ep: any = controller.endpoints.find((e: any) => e.name === name);
+  if (!ep) { throw new Error(`endpoint ${name} not found`); }
+  return ep.tasks[0];
+};
+
+
+describe('| DyNTS_FileLogs_Controller', (): void => {
+  let tempDir: string;
+  let originalFileLogConfig: typeof DyNTS_global_settings.log_settings.file_log;
+
+  beforeEach((): void => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nts-filelogs-ctrl-'));
+    originalFileLogConfig = DyNTS_global_settings.log_settings.file_log;
+  });
+
+  afterEach((): void => {
+    DyNTS_FileLog_Service.getInstance()._teardownForTesting();
+    DyNTS_FileLogs_Controller.configure({});
+    DyNTS_global_settings.log_settings.file_log = originalFileLogConfig;
+    try { fs.rmSync(tempDir, { recursive: true, force: true }); } catch { /* swallow */ }
+  });
+
+
+  describe('| singleton + endpoint shape', (): void => {
+    it('| getInstance() singleton', (): void => {
+      const a = DyNTS_FileLogs_Controller.getInstance();
+      const b = DyNTS_FileLogs_Controller.getInstance();
+      expect(a).toBe(b);
+    });
+
+    it('| setupEndpoints letrehozza /list + /file/:filename endpointokat', (): void => {
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+
+      const list = ctrl.endpoints.find((e: any) => e.name === 'listFileLogs');
+      const read = ctrl.endpoints.find((e: any) => e.name === 'readFileLog');
+      expect(list).toBeDefined();
+      expect(list?.type).toBe(DyFM_HttpCallType.get);
+      expect(read).toBeDefined();
+      expect(read?.type).toBe(DyFM_HttpCallType.get);
+    });
+
+    it('| authPreProcess hozzaadodik preProcesses-be ha config-olva', (): void => {
+      const myAuth = async (): Promise<void> => { /* noop */ };
+      DyNTS_FileLogs_Controller.configure({ authPreProcess: myAuth });
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const list: any = ctrl.endpoints.find((e: any) => e.name === 'listFileLogs');
+      expect(list).toBeDefined();
+      // A preProcesses property private, de cast-tal ellenorizheto
+      const pre: any = (list as any).preProcesses;
+      expect(pre).toBeDefined();
+      expect(pre.length).toBe(1);
+      expect(pre[0]).toBe(myAuth);
+    });
+  });
+
+
+  describe('| GET /list', (): void => {
+    it('| 503 ha a service nincs installalva', async (): Promise<void> => {
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const task = taskByName(ctrl, 'listFileLogs');
+
+      const res = mockRes();
+      await task(mockReq(), res);
+      expect(res.statusCode).toBe(503);
+      expect(res.payload.error).toContain('not installed');
+    });
+
+    it('| 200 + files lista ha installalva van', async (): Promise<void> => {
+      DyNTS_global_settings.log_settings.file_log = { enabled: true, logDir: tempDir, filenamePrefix: 'spec-' };
+      DyNTS_FileLog_Service.getInstance().install();
+      // Egy extra spec- fajlt kezzel
+      fs.writeFileSync(path.join(tempDir, 'spec-extra-2026.log'), 'extra-content');
+
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const task = taskByName(ctrl, 'listFileLogs');
+
+      const res = mockRes();
+      await task(mockReq(), res);
+      expect(res.statusCode).toBe(200);
+      expect(res.payload.count).toBeGreaterThanOrEqual(2);  // session + extra
+      expect(res.payload.totalSizeBytes).toBeGreaterThan(0);
+      expect(Array.isArray(res.payload.files)).toBe(true);
+    });
+  });
+
+
+  describe('| GET /file/:filename', (): void => {
+    let testFile: string;
+
+    beforeEach((): void => {
+      DyNTS_global_settings.log_settings.file_log = { enabled: true, logDir: tempDir, filenamePrefix: 'spec-' };
+      DyNTS_FileLog_Service.getInstance().install();
+      testFile = `spec-read-${Date.now()}.log`;
+      const lines: string[] = [];
+      for (let i: number = 1; i <= 30; i++) {
+        lines.push(`row-${i}`);
+      }
+      fs.writeFileSync(path.join(tempDir, testFile), lines.join('\n') + '\n');
+    });
+
+    it('| 503 ha a service nincs installalva', async (): Promise<void> => {
+      DyNTS_FileLog_Service.getInstance()._teardownForTesting();
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const task = taskByName(ctrl, 'readFileLog');
+
+      const res = mockRes();
+      await task(mockReq({ params: { filename: testFile } }), res);
+      expect(res.statusCode).toBe(503);
+    });
+
+    it('| 200 + tail mod default', async (): Promise<void> => {
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const task = taskByName(ctrl, 'readFileLog');
+
+      const res = mockRes();
+      await task(mockReq({ params: { filename: testFile }, query: { tail: '5' } }), res);
+      expect(res.statusCode).toBe(200);
+      expect(res.payload.mode).toBe('tail');
+      expect(res.payload.lines).toEqual(['row-26', 'row-27', 'row-28', 'row-29', 'row-30']);
+      expect(res.payload.totalLines).toBe(30);
+    });
+
+    it('| 200 + head mod', async (): Promise<void> => {
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const task = taskByName(ctrl, 'readFileLog');
+
+      const res = mockRes();
+      await task(mockReq({ params: { filename: testFile }, query: { head: '3' } }), res);
+      expect(res.statusCode).toBe(200);
+      expect(res.payload.mode).toBe('head');
+      expect(res.payload.lines).toEqual(['row-1', 'row-2', 'row-3']);
+    });
+
+    it('| 200 + range mod', async (): Promise<void> => {
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const task = taskByName(ctrl, 'readFileLog');
+
+      const res = mockRes();
+      await task(mockReq({ params: { filename: testFile }, query: { rangeStart: '5', rangeEnd: '8' } }), res);
+      expect(res.statusCode).toBe(200);
+      expect(res.payload.mode).toBe('range');
+      expect(res.payload.lines).toEqual(['row-5', 'row-6', 'row-7', 'row-8']);
+    });
+
+    it('| 400 invalid tail (negativ)', async (): Promise<void> => {
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const task = taskByName(ctrl, 'readFileLog');
+
+      const res = mockRes();
+      await task(mockReq({ params: { filename: testFile }, query: { tail: '-5' } }), res);
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('| 400 invalid range (end < start)', async (): Promise<void> => {
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const task = taskByName(ctrl, 'readFileLog');
+
+      const res = mockRes();
+      await task(mockReq({ params: { filename: testFile }, query: { rangeStart: '10', rangeEnd: '5' } }), res);
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('| 404 invalid filename (prefix nem matchel)', async (): Promise<void> => {
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const task = taskByName(ctrl, 'readFileLog');
+
+      const res = mockRes();
+      await task(mockReq({ params: { filename: 'evil-2026.log' } }), res);
+      expect(res.statusCode).toBe(404);
+      expect(res.payload.error).toBe('invalid filename');
+    });
+
+    it('| 404 path traversal (`../`)', async (): Promise<void> => {
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const task = taskByName(ctrl, 'readFileLog');
+
+      const res = mockRes();
+      await task(mockReq({ params: { filename: '../etc/passwd' } }), res);
+      expect(res.statusCode).toBe(404);
+      expect(res.payload.error).toBe('invalid filename');
+    });
+
+    it('| 404 file nem letezik (de valid prefix)', async (): Promise<void> => {
+      const ctrl = DyNTS_FileLogs_Controller.getInstance();
+      ctrl.setupEndpoints();
+      const task = taskByName(ctrl, 'readFileLog');
+
+      const res = mockRes();
+      await task(mockReq({ params: { filename: 'spec-nonexistent.log' } }), res);
+      expect(res.statusCode).toBe(404);
+      expect(res.payload.error).toBe('file not found');
+    });
+  });
+});

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';