@futdevpro/nts-dynamo 1.15.40 → 1.15.41

package/src/_modules/server/errors/errors.control-service.ts

@@ -1,85 +1,85 @@
-
-
-
-
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_DBUpdate } from '../../../_models/types/db-update.type';
-import { DyNTS_DataService } from '../../../_services/base/data.service';
-
-import {
-  DyFM_AnyError,
-  DyFM_DBFilter,
-  DyFM_DataModel_Params, DyFM_Error, DyFM_ErrorLevel, DyFM_Error_Settings,
-  DyFM_Log, DyFM_Object, DyFM_errorFlag, DyFM_Errors,
-  DyFM_RelativeDate,
-  DyFM_Paged,
-  DyFM_SearchQuery,
-  DyFM_SearchResult,
-  DyFM_Errors_FixAttempt
-} from '@futdevpro/fsm-dynamo';
-
-export abstract class DyNTS_Errors_ControlService<
-  T_Error extends DyFM_Error,
-  T_Errors extends DyFM_Errors<T_Error>
-> {
-  debugLog: boolean = false;
-  readonly version: string = DyNTS_global_settings.systemVersion;
-  duplicationCounter: number;
-
-  abstract recordError(data: T_Errors, issuer: string, alwaysRecord?: boolean): Promise<void>;
-
-  abstract handleInternalError(
-    error: DyFM_AnyError | any, 
-    issuer: string,
-    alwaysRecord?: boolean,
-  ): Promise<void>;
-
-  abstract checkErrorIsStringifyableOrResolvable(error: T_Error, issuer: string): T_Error | 'UNRESOLVABLE';
-
-  abstract getPriorityMultiplierByLevel(level: DyFM_ErrorLevel, issuer: string): number;
-
-  abstract getErrorsFromDate(
-    date: Date,
-    issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>>;
-
-  abstract deleteError(errorId: string, issuer: string, alwaysDelete?: boolean): Promise<void>;
-
-  abstract deleteAllErrors(issuer: string, alwaysDelete?: boolean): Promise<void>;
-
-  abstract recordFixAttempt(
-    errorId: string,
-    version: string,
-    hypothesis: string,
-    issuer: string,
-  ): Promise<DyFM_Errors_FixAttempt>;
-
-  abstract getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<DyFM_Paged<T_Errors>>;
-
-  abstract getErrorsPaged(
-    range: DyFM_RelativeDate,
-    pageSize: number,
-    pageIndex: number,
-    issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>>;
-
-  abstract getErrorsByCategoryPaged(
-    category: string,
-    range: DyFM_RelativeDate,
-    pageSize: number,
-    pageIndex: number,
-    issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>>;
-
-  abstract getLastErrors(
-    range: DyFM_RelativeDate,
-    pageSize: number,
-    pageIndex: number,
-    issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>>;
-
-  abstract searchErrors(
-    searchQuery: DyFM_SearchQuery<T_Errors>,
-    issuer: string,
-  ): Promise<DyFM_SearchResult<T_Errors>>;
-}
+
+
+
+
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DBUpdate } from '../../../_models/types/db-update.type';
+import { DyNTS_DataService } from '../../../_services/base/data.service';
+
+import {
+  DyFM_AnyError,
+  DyFM_DBFilter,
+  DyFM_DataModel_Params, DyFM_Error, DyFM_ErrorLevel, DyFM_Error_Settings,
+  DyFM_Log, DyFM_Object, DyFM_errorFlag, DyFM_Errors,
+  DyFM_RelativeDate,
+  DyFM_Paged,
+  DyFM_SearchQuery,
+  DyFM_SearchResult,
+  DyFM_Errors_FixAttempt
+} from '@futdevpro/fsm-dynamo';
+
+export abstract class DyNTS_Errors_ControlService<
+  T_Error extends DyFM_Error,
+  T_Errors extends DyFM_Errors<T_Error>
+> {
+  debugLog: boolean = false;
+  readonly version: string = DyNTS_global_settings.systemVersion;
+  duplicationCounter: number;
+
+  abstract recordError(data: T_Errors, issuer: string, alwaysRecord?: boolean): Promise<void>;
+
+  abstract handleInternalError(
+    error: DyFM_AnyError | any, 
+    issuer: string,
+    alwaysRecord?: boolean,
+  ): Promise<void>;
+
+  abstract checkErrorIsStringifyableOrResolvable(error: T_Error, issuer: string): T_Error | 'UNRESOLVABLE';
+
+  abstract getPriorityMultiplierByLevel(level: DyFM_ErrorLevel, issuer: string): number;
+
+  abstract getErrorsFromDate(
+    date: Date,
+    issuer: string,
+  ): Promise<DyFM_Paged<T_Errors>>;
+
+  abstract deleteError(errorId: string, issuer: string, alwaysDelete?: boolean): Promise<void>;
+
+  abstract deleteAllErrors(issuer: string, alwaysDelete?: boolean): Promise<void>;
+
+  abstract recordFixAttempt(
+    errorId: string,
+    version: string,
+    hypothesis: string,
+    issuer: string,
+  ): Promise<DyFM_Errors_FixAttempt>;
+
+  abstract getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<DyFM_Paged<T_Errors>>;
+
+  abstract getErrorsPaged(
+    range: DyFM_RelativeDate,
+    pageSize: number,
+    pageIndex: number,
+    issuer: string,
+  ): Promise<DyFM_Paged<T_Errors>>;
+
+  abstract getErrorsByCategoryPaged(
+    category: string,
+    range: DyFM_RelativeDate,
+    pageSize: number,
+    pageIndex: number,
+    issuer: string,
+  ): Promise<DyFM_Paged<T_Errors>>;
+
+  abstract getLastErrors(
+    range: DyFM_RelativeDate,
+    pageSize: number,
+    pageIndex: number,
+    issuer: string,
+  ): Promise<DyFM_Paged<T_Errors>>;
+
+  abstract searchErrors(
+    searchQuery: DyFM_SearchQuery<T_Errors>,
+    issuer: string,
+  ): Promise<DyFM_SearchResult<T_Errors>>;
+}

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

@@ -1,241 +1,241 @@
-
-import { DyNTS_Errors_Controller } from './errors.controller';
-import { DyFM_Error, DyFM_Errors, DyFM_HttpCallType, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
-import { DyNTS_Errors_ControlService } from './errors.control-service';
-import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-params.control-model';
-
-class TestError extends DyFM_Error {
-  testProperty?: string;
-}
-
-class TestErrors extends DyFM_Errors<TestError> {
-  testProperty?: string;
-}
-
-class TestErrorsControlService extends DyNTS_Errors_ControlService<TestError, TestErrors> {
-  async recordError(data: TestErrors, issuer: string, alwaysRecord?: boolean): Promise<void> {}
-  async handleInternalError(error: any, issuer: string, alwaysRecord?: boolean): Promise<void> {}
-  checkErrorIsStringifyableOrResolvable(error: TestError, issuer: string): TestError | 'UNRESOLVABLE' { return error; }
-  getPriorityMultiplierByLevel(level: any, issuer: string): number { return 0; }
-  async getErrorsFromDate(date: Date, issuer: string): Promise<any> { return { results: [] }; }
-  async deleteError(errorId: string, issuer: string, alwaysDelete?: boolean): Promise<void> {}
-  async deleteAllErrors(issuer: string, alwaysDelete?: boolean): Promise<void> {}
-  async recordFixAttempt(errorId: string, version: string, hypothesis: string, issuer: string): Promise<any> {
-    return { at: new Date(), by: issuer, version, hypothesis };
-  }
-  async getErrorsByCategoryPaged(category: string, range: any, pageSize: number, pageIndex: number, issuer: string): Promise<any> {
-    return { items: [], total: 0, pageIndex, pageSize };
-  }
-  async getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<any> { return { results: [] }; }
-  async getErrorsPaged(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<any> { return { results: [] }; }
-  async getLastErrors(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<any> { return { results: [] }; }
-  async searchErrors(searchQuery: any, issuer: string): Promise<any> { return { results: [] }; }
-}
-
-class TestErrorsController extends DyNTS_Errors_Controller<TestError, TestErrors, TestErrorsControlService> {
-  protected getError_ControlService(set: { data?: TestError, issuer: string }): TestErrorsControlService {
-    return new TestErrorsControlService();
-  }
-  protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = [];
-}
-
-describe('| DyNTS_Errors_Controller', () => {
-  let controller: TestErrorsController;
-
-  beforeEach(() => {
-    controller = new (TestErrorsController as any)();
-  });
-
-  describe('| setupEndpoints', () => {
-    it('| should setup all error endpoints', () => {
-      controller.setupEndpoints();
-
-      expect(controller.endpoints).toBeDefined();
-      expect(controller.endpoints.length).toBeGreaterThanOrEqual(6);
-    });
-
-    it('| should setup logError endpoint', () => {
-      controller.setupEndpoints();
-
-      const logErrorEndpoint = controller.endpoints.find(ep => ep.name === 'logError');
-      expect(logErrorEndpoint).toBeDefined();
-      expect(logErrorEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(logErrorEndpoint?.endpoint).toBe('/error/log');
-      expect((logErrorEndpoint as any)?.tasks).toBeDefined();
-      expect((logErrorEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup newError endpoint', () => {
-      controller.setupEndpoints();
-
-      const newErrorEndpoint = controller.endpoints.find(ep => ep.name === 'newError');
-      expect(newErrorEndpoint).toBeDefined();
-      expect(newErrorEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(newErrorEndpoint?.endpoint).toBe('/error/new');
-      expect((newErrorEndpoint as any)?.tasks).toBeDefined();
-      expect((newErrorEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup markErrorDone endpoint', () => {
-      controller.setupEndpoints();
-
-      const markErrorDoneEndpoint = controller.endpoints.find(ep => ep.name === 'markErrorDone');
-      expect(markErrorDoneEndpoint).toBeDefined();
-      expect(markErrorDoneEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(markErrorDoneEndpoint?.endpoint).toBe('/error/mark-done/:errorId');
-      expect((markErrorDoneEndpoint as any)?.tasks).toBeDefined();
-      expect((markErrorDoneEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup markAllErrorDone endpoint', () => {
-      controller.setupEndpoints();
-
-      const markAllErrorDoneEndpoint = controller.endpoints.find(ep => ep.name === 'markAllErrorDone');
-      expect(markAllErrorDoneEndpoint).toBeDefined();
-      expect(markAllErrorDoneEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(markAllErrorDoneEndpoint?.endpoint).toBe('/error/mark-all-done');
-      expect((markAllErrorDoneEndpoint as any)?.tasks).toBeDefined();
-      expect((markAllErrorDoneEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getErrors endpoint', () => {
-      controller.setupEndpoints();
-
-      const getErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'getErrors');
-      expect(getErrorsEndpoint).toBeDefined();
-      expect(getErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getErrorsEndpoint?.endpoint).toBe('/error/get-range/:range');
-      expect((getErrorsEndpoint as any)?.tasks).toBeDefined();
-      expect((getErrorsEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getErrorsPaged endpoint', () => {
-      controller.setupEndpoints();
-
-      const getErrorsPagedEndpoint = controller.endpoints.find(ep => ep.name === 'getErrorsPaged');
-      expect(getErrorsPagedEndpoint).toBeDefined();
-      expect(getErrorsPagedEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getErrorsPagedEndpoint?.endpoint).toBe('/error/get-paged/:range/:pageSize/:pageIndex');
-      expect((getErrorsPagedEndpoint as any)?.tasks).toBeDefined();
-      expect((getErrorsPagedEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getLastErrors endpoint', () => {
-      controller.setupEndpoints();
-
-      const getLastErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'getLastErrors');
-      expect(getLastErrorsEndpoint).toBeDefined();
-      expect(getLastErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getLastErrorsEndpoint?.endpoint).toBe('/error/get-last-paged/:range/:pageSize/:pageIndex');
-      expect((getLastErrorsEndpoint as any)?.tasks).toBeDefined();
-      expect((getLastErrorsEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup searchErrors endpoint', () => {
-      controller.setupEndpoints();
-
-      const searchErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'searchErrors');
-      expect(searchErrorsEndpoint).toBeDefined();
-      expect(searchErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(searchErrorsEndpoint?.endpoint).toBe('/error/search');
-      expect((searchErrorsEndpoint as any)?.tasks).toBeDefined();
-      expect((searchErrorsEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should include additionalEndpoints', () => {
-      const additionalEndpoint = new DyNTS_Endpoint_Params({
-        name: 'customEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/error/custom',
-        tasks: [],
-      });
-      (controller as any).additionalEndpoints.push(additionalEndpoint);
-
-      controller.setupEndpoints();
-
-      const customEndpoint = controller.endpoints.find(ep => ep.name === 'customEndpoint');
-      expect(customEndpoint).toBeDefined();
-    });
-
-    it('| should throw error when additionalEndpoints is not defined', () => {
-      const controllerWithoutEndpoints = new (class extends TestErrorsController {
-        protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = undefined as any;
-      } as any)();
-
-      expect(() => {
-        controllerWithoutEndpoints.setupEndpoints();
-      }).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();
-    });
-  });
-});
-
+
+import { DyNTS_Errors_Controller } from './errors.controller';
+import { DyFM_Error, DyFM_Errors, DyFM_HttpCallType, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Errors_ControlService } from './errors.control-service';
+import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-params.control-model';
+
+class TestError extends DyFM_Error {
+  testProperty?: string;
+}
+
+class TestErrors extends DyFM_Errors<TestError> {
+  testProperty?: string;
+}
+
+class TestErrorsControlService extends DyNTS_Errors_ControlService<TestError, TestErrors> {
+  async recordError(data: TestErrors, issuer: string, alwaysRecord?: boolean): Promise<void> {}
+  async handleInternalError(error: any, issuer: string, alwaysRecord?: boolean): Promise<void> {}
+  checkErrorIsStringifyableOrResolvable(error: TestError, issuer: string): TestError | 'UNRESOLVABLE' { return error; }
+  getPriorityMultiplierByLevel(level: any, issuer: string): number { return 0; }
+  async getErrorsFromDate(date: Date, issuer: string): Promise<any> { return { results: [] }; }
+  async deleteError(errorId: string, issuer: string, alwaysDelete?: boolean): Promise<void> {}
+  async deleteAllErrors(issuer: string, alwaysDelete?: boolean): Promise<void> {}
+  async recordFixAttempt(errorId: string, version: string, hypothesis: string, issuer: string): Promise<any> {
+    return { at: new Date(), by: issuer, version, hypothesis };
+  }
+  async getErrorsByCategoryPaged(category: string, range: any, pageSize: number, pageIndex: number, issuer: string): Promise<any> {
+    return { items: [], total: 0, pageIndex, pageSize };
+  }
+  async getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<any> { return { results: [] }; }
+  async getErrorsPaged(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<any> { return { results: [] }; }
+  async getLastErrors(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<any> { return { results: [] }; }
+  async searchErrors(searchQuery: any, issuer: string): Promise<any> { return { results: [] }; }
+}
+
+class TestErrorsController extends DyNTS_Errors_Controller<TestError, TestErrors, TestErrorsControlService> {
+  protected getError_ControlService(set: { data?: TestError, issuer: string }): TestErrorsControlService {
+    return new TestErrorsControlService();
+  }
+  protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = [];
+}
+
+describe('| DyNTS_Errors_Controller', () => {
+  let controller: TestErrorsController;
+
+  beforeEach(() => {
+    controller = new (TestErrorsController as any)();
+  });
+
+  describe('| setupEndpoints', () => {
+    it('| should setup all error endpoints', () => {
+      controller.setupEndpoints();
+
+      expect(controller.endpoints).toBeDefined();
+      expect(controller.endpoints.length).toBeGreaterThanOrEqual(6);
+    });
+
+    it('| should setup logError endpoint', () => {
+      controller.setupEndpoints();
+
+      const logErrorEndpoint = controller.endpoints.find(ep => ep.name === 'logError');
+      expect(logErrorEndpoint).toBeDefined();
+      expect(logErrorEndpoint?.type).toBe(DyFM_HttpCallType.post);
+      expect(logErrorEndpoint?.endpoint).toBe('/error/log');
+      expect((logErrorEndpoint as any)?.tasks).toBeDefined();
+      expect((logErrorEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup newError endpoint', () => {
+      controller.setupEndpoints();
+
+      const newErrorEndpoint = controller.endpoints.find(ep => ep.name === 'newError');
+      expect(newErrorEndpoint).toBeDefined();
+      expect(newErrorEndpoint?.type).toBe(DyFM_HttpCallType.post);
+      expect(newErrorEndpoint?.endpoint).toBe('/error/new');
+      expect((newErrorEndpoint as any)?.tasks).toBeDefined();
+      expect((newErrorEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup markErrorDone endpoint', () => {
+      controller.setupEndpoints();
+
+      const markErrorDoneEndpoint = controller.endpoints.find(ep => ep.name === 'markErrorDone');
+      expect(markErrorDoneEndpoint).toBeDefined();
+      expect(markErrorDoneEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(markErrorDoneEndpoint?.endpoint).toBe('/error/mark-done/:errorId');
+      expect((markErrorDoneEndpoint as any)?.tasks).toBeDefined();
+      expect((markErrorDoneEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup markAllErrorDone endpoint', () => {
+      controller.setupEndpoints();
+
+      const markAllErrorDoneEndpoint = controller.endpoints.find(ep => ep.name === 'markAllErrorDone');
+      expect(markAllErrorDoneEndpoint).toBeDefined();
+      expect(markAllErrorDoneEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(markAllErrorDoneEndpoint?.endpoint).toBe('/error/mark-all-done');
+      expect((markAllErrorDoneEndpoint as any)?.tasks).toBeDefined();
+      expect((markAllErrorDoneEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup getErrors endpoint', () => {
+      controller.setupEndpoints();
+
+      const getErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'getErrors');
+      expect(getErrorsEndpoint).toBeDefined();
+      expect(getErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(getErrorsEndpoint?.endpoint).toBe('/error/get-range/:range');
+      expect((getErrorsEndpoint as any)?.tasks).toBeDefined();
+      expect((getErrorsEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup getErrorsPaged endpoint', () => {
+      controller.setupEndpoints();
+
+      const getErrorsPagedEndpoint = controller.endpoints.find(ep => ep.name === 'getErrorsPaged');
+      expect(getErrorsPagedEndpoint).toBeDefined();
+      expect(getErrorsPagedEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(getErrorsPagedEndpoint?.endpoint).toBe('/error/get-paged/:range/:pageSize/:pageIndex');
+      expect((getErrorsPagedEndpoint as any)?.tasks).toBeDefined();
+      expect((getErrorsPagedEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup getLastErrors endpoint', () => {
+      controller.setupEndpoints();
+
+      const getLastErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'getLastErrors');
+      expect(getLastErrorsEndpoint).toBeDefined();
+      expect(getLastErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(getLastErrorsEndpoint?.endpoint).toBe('/error/get-last-paged/:range/:pageSize/:pageIndex');
+      expect((getLastErrorsEndpoint as any)?.tasks).toBeDefined();
+      expect((getLastErrorsEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup searchErrors endpoint', () => {
+      controller.setupEndpoints();
+
+      const searchErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'searchErrors');
+      expect(searchErrorsEndpoint).toBeDefined();
+      expect(searchErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(searchErrorsEndpoint?.endpoint).toBe('/error/search');
+      expect((searchErrorsEndpoint as any)?.tasks).toBeDefined();
+      expect((searchErrorsEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should include additionalEndpoints', () => {
+      const additionalEndpoint = new DyNTS_Endpoint_Params({
+        name: 'customEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/error/custom',
+        tasks: [],
+      });
+      (controller as any).additionalEndpoints.push(additionalEndpoint);
+
+      controller.setupEndpoints();
+
+      const customEndpoint = controller.endpoints.find(ep => ep.name === 'customEndpoint');
+      expect(customEndpoint).toBeDefined();
+    });
+
+    it('| should throw error when additionalEndpoints is not defined', () => {
+      const controllerWithoutEndpoints = new (class extends TestErrorsController {
+        protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = undefined as any;
+      } as any)();
+
+      expect(() => {
+        controllerWithoutEndpoints.setupEndpoints();
+      }).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();
+    });
+  });
+});
+