@futdevpro/nts-dynamo 1.15.154 → 1.15.155

package/src/_modules/server/safe-diagnostic/safe-diagnostic.control-service.spec.ts

@@ -1,124 +1,124 @@
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_SafeDiagnosticCause_Type } from './safe-diagnostic-cause.type-enum';
-import { DyNTS_SafeDiagnosticStage_Type } from './safe-diagnostic-stage.type-enum';
-import {
-  DyNTS_SafeDiagnosticInput_Interface,
-  DyNTS_SafeDiagnostic_Interface
-} from './safe-diagnostic.interface';
-import { DyNTS_SafeDiagnostic_ControlService } from './safe-diagnostic.control-service';
-
-describe('| DyNTS_SafeDiagnostic_ControlService', (): void => {
-  const canary: string = 'mongodb://user:secret@private-host.example/raw-driver-message';
-
-  it('| returns the exact immutable content-free allowlist', (): void => {
-    const result: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project({
-      code: 'DYNTS|APP|DB_CONNECT_FAILED',
-      stage: DyNTS_SafeDiagnosticStage_Type.databaseConnect,
-      error: new Error(canary),
-      status: 503,
-    });
-
-    expect(Object.keys(result).sort()).toEqual([
-      'causeType',
-      'code',
-      'contractVersion',
-      'fingerprint',
-      'stage',
-      'status',
-    ]);
-    expect(result).toEqual({
-      contractVersion: 'dynts-safe-diagnostic/1',
-      code: 'DYNTS|APP|DB_CONNECT_FAILED',
-      stage: DyNTS_SafeDiagnosticStage_Type.databaseConnect,
-      causeType: DyNTS_SafeDiagnosticCause_Type.nativeError,
-      fingerprint: jasmine.stringMatching(/^[a-f0-9]{64}$/),
-      status: 503,
-    });
-    expect(Object.isFrozen(result)).toBeTrue();
-    expect(JSON.stringify(result)).not.toContain(canary);
-    expect(JSON.stringify(result)).not.toContain('secret');
-  });
-
-  it('| creates a deterministic correlation without reflecting its raw subject', (): void => {
-    const input: DyNTS_SafeDiagnosticInput_Interface = {
-      code: 'DYNTS|APP|BOOT_FAILED',
-      stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
-      error: new Error(canary),
-    };
-    const first: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project(input);
-    const second: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project(input);
-
-    expect(first.fingerprint).toBe(second.fingerprint);
-    expect(first.fingerprint).not.toContain(canary);
-  });
-
-  it('| classifies Dynamo, object, primitive and absent failures without returning content', (): void => {
-    const failures: unknown[] = [
-      new DyFM_Error({ errorCode: 'TEST', message: canary }),
-      { privateValue: canary },
-      canary,
-      undefined,
-    ];
-    const expected: DyNTS_SafeDiagnosticCause_Type[] = [
-      DyNTS_SafeDiagnosticCause_Type.dynamoError,
-      DyNTS_SafeDiagnosticCause_Type.object,
-      DyNTS_SafeDiagnosticCause_Type.primitive,
-      DyNTS_SafeDiagnosticCause_Type.unknown,
-    ];
-
-    failures.forEach((error: unknown, index: number): void => {
-      const result: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project({
-        code: 'DYNTS|APP|FAILURE',
-        stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
-        error: error,
-      });
-
-      expect(result.causeType).toBe(expected[index]);
-      expect(JSON.stringify(result)).not.toContain(canary);
-    });
-  });
-
-  it('| fails closed for invalid code, status and hostile getters', (): void => {
-    const hostile: Error = new Error('placeholder');
-
-    Object.defineProperty(hostile, 'message', {
-      get: (): never => {
-        throw new Error(canary);
-      },
-    });
-    Object.defineProperty(hostile, 'stack', {
-      get: (): never => {
-        throw new Error(canary);
-      },
-    });
-
-    const result: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project({
-      code: canary,
-      stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
-      error: hostile,
-      status: 999,
-    });
-
-    expect(result.code).toBe('DYNTS_SAFE_DIAGNOSTIC_INVALID_CODE');
-    expect(result.status).toBe(500);
-    expect(result.fingerprint).toMatch(/^[a-f0-9]{64}$/);
-    expect(JSON.stringify(result)).not.toContain(canary);
-  });
-
-  it('| reports and creates framework errors from the safe result only', (): void => {
-    const logSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
-    const diagnostic: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.report({
-      code: 'DYNTS|APP|FAILURE',
-      stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
-      error: new Error(canary),
-    });
-    const error: DyFM_Error = DyNTS_SafeDiagnostic_ControlService.toError(diagnostic);
-    const serialized: string = JSON.stringify(error);
-
-    expect(logSpy).toHaveBeenCalledOnceWith('[DyNTS safe diagnostic]', diagnostic);
-    expect(serialized).not.toContain(canary);
-    expect(serialized).not.toContain('secret');
-    expect(serialized).toContain(diagnostic.fingerprint);
-  });
-});
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_SafeDiagnosticCause_Type } from './safe-diagnostic-cause.type-enum';
+import { DyNTS_SafeDiagnosticStage_Type } from './safe-diagnostic-stage.type-enum';
+import {
+  DyNTS_SafeDiagnosticInput_Interface,
+  DyNTS_SafeDiagnostic_Interface
+} from './safe-diagnostic.interface';
+import { DyNTS_SafeDiagnostic_ControlService } from './safe-diagnostic.control-service';
+
+describe('| DyNTS_SafeDiagnostic_ControlService', (): void => {
+  const canary: string = 'mongodb://user:secret@private-host.example/raw-driver-message';
+
+  it('| returns the exact immutable content-free allowlist', (): void => {
+    const result: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project({
+      code: 'DYNTS|APP|DB_CONNECT_FAILED',
+      stage: DyNTS_SafeDiagnosticStage_Type.databaseConnect,
+      error: new Error(canary),
+      status: 503,
+    });
+
+    expect(Object.keys(result).sort()).toEqual([
+      'causeType',
+      'code',
+      'contractVersion',
+      'fingerprint',
+      'stage',
+      'status',
+    ]);
+    expect(result).toEqual({
+      contractVersion: 'dynts-safe-diagnostic/1',
+      code: 'DYNTS|APP|DB_CONNECT_FAILED',
+      stage: DyNTS_SafeDiagnosticStage_Type.databaseConnect,
+      causeType: DyNTS_SafeDiagnosticCause_Type.nativeError,
+      fingerprint: jasmine.stringMatching(/^[a-f0-9]{64}$/),
+      status: 503,
+    });
+    expect(Object.isFrozen(result)).toBeTrue();
+    expect(JSON.stringify(result)).not.toContain(canary);
+    expect(JSON.stringify(result)).not.toContain('secret');
+  });
+
+  it('| creates a deterministic correlation without reflecting its raw subject', (): void => {
+    const input: DyNTS_SafeDiagnosticInput_Interface = {
+      code: 'DYNTS|APP|BOOT_FAILED',
+      stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
+      error: new Error(canary),
+    };
+    const first: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project(input);
+    const second: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project(input);
+
+    expect(first.fingerprint).toBe(second.fingerprint);
+    expect(first.fingerprint).not.toContain(canary);
+  });
+
+  it('| classifies Dynamo, object, primitive and absent failures without returning content', (): void => {
+    const failures: unknown[] = [
+      new DyFM_Error({ errorCode: 'TEST', message: canary }),
+      { privateValue: canary },
+      canary,
+      undefined,
+    ];
+    const expected: DyNTS_SafeDiagnosticCause_Type[] = [
+      DyNTS_SafeDiagnosticCause_Type.dynamoError,
+      DyNTS_SafeDiagnosticCause_Type.object,
+      DyNTS_SafeDiagnosticCause_Type.primitive,
+      DyNTS_SafeDiagnosticCause_Type.unknown,
+    ];
+
+    failures.forEach((error: unknown, index: number): void => {
+      const result: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project({
+        code: 'DYNTS|APP|FAILURE',
+        stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
+        error: error,
+      });
+
+      expect(result.causeType).toBe(expected[index]);
+      expect(JSON.stringify(result)).not.toContain(canary);
+    });
+  });
+
+  it('| fails closed for invalid code, status and hostile getters', (): void => {
+    const hostile: Error = new Error('placeholder');
+
+    Object.defineProperty(hostile, 'message', {
+      get: (): never => {
+        throw new Error(canary);
+      },
+    });
+    Object.defineProperty(hostile, 'stack', {
+      get: (): never => {
+        throw new Error(canary);
+      },
+    });
+
+    const result: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.project({
+      code: canary,
+      stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
+      error: hostile,
+      status: 999,
+    });
+
+    expect(result.code).toBe('DYNTS_SAFE_DIAGNOSTIC_INVALID_CODE');
+    expect(result.status).toBe(500);
+    expect(result.fingerprint).toMatch(/^[a-f0-9]{64}$/);
+    expect(JSON.stringify(result)).not.toContain(canary);
+  });
+
+  it('| reports and creates framework errors from the safe result only', (): void => {
+    const logSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
+    const diagnostic: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.report({
+      code: 'DYNTS|APP|FAILURE',
+      stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
+      error: new Error(canary),
+    });
+    const error: DyFM_Error = DyNTS_SafeDiagnostic_ControlService.toError(diagnostic);
+    const serialized: string = JSON.stringify(error);
+
+    expect(logSpy).toHaveBeenCalledOnceWith('[DyNTS safe diagnostic]', diagnostic);
+    expect(serialized).not.toContain(canary);
+    expect(serialized).not.toContain('secret');
+    expect(serialized).toContain(diagnostic.fingerprint);
+  });
+});

package/src/_modules/server/safe-diagnostic/safe-diagnostic.control-service.ts

@@ -1,99 +1,99 @@
-import { createHash } from 'crypto';
-
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_SafeDiagnosticCause_Type } from './safe-diagnostic-cause.type-enum';
-import {
-  DyNTS_SafeDiagnosticInput_Interface,
-  DyNTS_SafeDiagnostic_Interface
-} from './safe-diagnostic.interface';
-
-/** Projects arbitrary failures to a versioned, content-free public diagnostic. */
-export class DyNTS_SafeDiagnostic_ControlService {
-  private static readonly contractVersion: 'dynts-safe-diagnostic/1' = 'dynts-safe-diagnostic/1';
-  private static readonly defaultCode: string = 'DYNTS_SAFE_DIAGNOSTIC_INVALID_CODE';
-  private static readonly defaultStatus: number = 500;
-
-  /** Returns an immutable exact allowlist and never reflects raw failure content. */
-  static project(input: DyNTS_SafeDiagnosticInput_Interface): DyNTS_SafeDiagnostic_Interface {
-    const code: string = this.getCode(input.code);
-    const causeType: DyNTS_SafeDiagnosticCause_Type = this.getCauseType(input.error);
-    const status: number = this.getStatus(input.status);
-    const fingerprint: string = this.getFingerprint([
-      this.contractVersion,
-      code,
-      input.stage,
-      causeType,
-      status.toString(),
-    ]);
-
-    return Object.freeze({
-      contractVersion: this.contractVersion,
-      code: code,
-      stage: input.stage,
-      causeType: causeType,
-      fingerprint: fingerprint,
-      status: status,
-    });
-  }
-
-  /** Logs only the projected allowlist and returns the same immutable diagnostic. */
-  static report(input: DyNTS_SafeDiagnosticInput_Interface): DyNTS_SafeDiagnostic_Interface {
-    const diagnostic: DyNTS_SafeDiagnostic_Interface = this.project(input);
-
-    DyFM_Log.error('[DyNTS safe diagnostic]', diagnostic);
-
-    return diagnostic;
-  }
-
-  /** Creates a framework error that carries only the safe diagnostic allowlist. */
-  static toError(diagnostic: DyNTS_SafeDiagnostic_Interface): DyFM_Error {
-    return new DyFM_Error({
-      errorCode: diagnostic.code,
-      message: `Framework failure at ${diagnostic.stage}. Correlation: ${diagnostic.fingerprint}.`,
-      userMessage: 'A server operation failed. Contact the responsible team with the correlation fingerprint.',
-      additionalContent: { diagnostic: diagnostic },
-      status: diagnostic.status,
-    });
-  }
-
-  private static getCode(code: string): string {
-    return /^[A-Z][A-Z0-9_|-]{2,127}$/.test(code) ? code : this.defaultCode;
-  }
-
-  private static getCauseType(error: unknown): DyNTS_SafeDiagnosticCause_Type {
-    try {
-      if (error instanceof DyFM_Error) {
-        return DyNTS_SafeDiagnosticCause_Type.dynamoError;
-      }
-
-      if (error instanceof Error) {
-        return DyNTS_SafeDiagnosticCause_Type.nativeError;
-      }
-
-      if (error !== null && typeof error === 'object') {
-        return DyNTS_SafeDiagnosticCause_Type.object;
-      }
-
-      if (error !== undefined) {
-        return DyNTS_SafeDiagnosticCause_Type.primitive;
-      }
-    } catch {
-      return DyNTS_SafeDiagnosticCause_Type.unknown;
-    }
-
-    return DyNTS_SafeDiagnosticCause_Type.unknown;
-  }
-
-  private static getStatus(status?: number): number {
-    if (typeof status !== 'number' || !Number.isInteger(status) || status < 100 || status > 599) {
-      return this.defaultStatus;
-    }
-
-    return status;
-  }
-
-  private static getFingerprint(subject: string[]): string {
-    return createHash('sha256').update(subject.join('\u0000'), 'utf8').digest('hex');
-  }
-}
+import { createHash } from 'crypto';
+
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_SafeDiagnosticCause_Type } from './safe-diagnostic-cause.type-enum';
+import {
+  DyNTS_SafeDiagnosticInput_Interface,
+  DyNTS_SafeDiagnostic_Interface
+} from './safe-diagnostic.interface';
+
+/** Projects arbitrary failures to a versioned, content-free public diagnostic. */
+export class DyNTS_SafeDiagnostic_ControlService {
+  private static readonly contractVersion: 'dynts-safe-diagnostic/1' = 'dynts-safe-diagnostic/1';
+  private static readonly defaultCode: string = 'DYNTS_SAFE_DIAGNOSTIC_INVALID_CODE';
+  private static readonly defaultStatus: number = 500;
+
+  /** Returns an immutable exact allowlist and never reflects raw failure content. */
+  static project(input: DyNTS_SafeDiagnosticInput_Interface): DyNTS_SafeDiagnostic_Interface {
+    const code: string = this.getCode(input.code);
+    const causeType: DyNTS_SafeDiagnosticCause_Type = this.getCauseType(input.error);
+    const status: number = this.getStatus(input.status);
+    const fingerprint: string = this.getFingerprint([
+      this.contractVersion,
+      code,
+      input.stage,
+      causeType,
+      status.toString(),
+    ]);
+
+    return Object.freeze({
+      contractVersion: this.contractVersion,
+      code: code,
+      stage: input.stage,
+      causeType: causeType,
+      fingerprint: fingerprint,
+      status: status,
+    });
+  }
+
+  /** Logs only the projected allowlist and returns the same immutable diagnostic. */
+  static report(input: DyNTS_SafeDiagnosticInput_Interface): DyNTS_SafeDiagnostic_Interface {
+    const diagnostic: DyNTS_SafeDiagnostic_Interface = this.project(input);
+
+    DyFM_Log.error('[DyNTS safe diagnostic]', diagnostic);
+
+    return diagnostic;
+  }
+
+  /** Creates a framework error that carries only the safe diagnostic allowlist. */
+  static toError(diagnostic: DyNTS_SafeDiagnostic_Interface): DyFM_Error {
+    return new DyFM_Error({
+      errorCode: diagnostic.code,
+      message: `Framework failure at ${diagnostic.stage}. Correlation: ${diagnostic.fingerprint}.`,
+      userMessage: 'A server operation failed. Contact the responsible team with the correlation fingerprint.',
+      additionalContent: { diagnostic: diagnostic },
+      status: diagnostic.status,
+    });
+  }
+
+  private static getCode(code: string): string {
+    return /^[A-Z][A-Z0-9_|-]{2,127}$/.test(code) ? code : this.defaultCode;
+  }
+
+  private static getCauseType(error: unknown): DyNTS_SafeDiagnosticCause_Type {
+    try {
+      if (error instanceof DyFM_Error) {
+        return DyNTS_SafeDiagnosticCause_Type.dynamoError;
+      }
+
+      if (error instanceof Error) {
+        return DyNTS_SafeDiagnosticCause_Type.nativeError;
+      }
+
+      if (error !== null && typeof error === 'object') {
+        return DyNTS_SafeDiagnosticCause_Type.object;
+      }
+
+      if (error !== undefined) {
+        return DyNTS_SafeDiagnosticCause_Type.primitive;
+      }
+    } catch {
+      return DyNTS_SafeDiagnosticCause_Type.unknown;
+    }
+
+    return DyNTS_SafeDiagnosticCause_Type.unknown;
+  }
+
+  private static getStatus(status?: number): number {
+    if (typeof status !== 'number' || !Number.isInteger(status) || status < 100 || status > 599) {
+      return this.defaultStatus;
+    }
+
+    return status;
+  }
+
+  private static getFingerprint(subject: string[]): string {
+    return createHash('sha256').update(subject.join('\u0000'), 'utf8').digest('hex');
+  }
+}

package/src/_modules/server/safe-diagnostic/safe-diagnostic.interface.ts

@@ -1,20 +1,20 @@
-import { DyNTS_SafeDiagnosticCause_Type } from './safe-diagnostic-cause.type-enum';
-import { DyNTS_SafeDiagnosticStage_Type } from './safe-diagnostic-stage.type-enum';
-
-/** Caller-owned input whose raw failure content is never returned or logged. */
-export interface DyNTS_SafeDiagnosticInput_Interface {
-  code: string;
-  stage: DyNTS_SafeDiagnosticStage_Type;
-  error?: unknown;
-  status?: number;
-}
-
-/** Exact public allowlist emitted by the safe diagnostic boundary. */
-export interface DyNTS_SafeDiagnostic_Interface {
-  contractVersion: 'dynts-safe-diagnostic/1';
-  code: string;
-  stage: DyNTS_SafeDiagnosticStage_Type;
-  causeType: DyNTS_SafeDiagnosticCause_Type;
-  fingerprint: string;
-  status: number;
-}
+import { DyNTS_SafeDiagnosticCause_Type } from './safe-diagnostic-cause.type-enum';
+import { DyNTS_SafeDiagnosticStage_Type } from './safe-diagnostic-stage.type-enum';
+
+/** Caller-owned input whose raw failure content is never returned or logged. */
+export interface DyNTS_SafeDiagnosticInput_Interface {
+  code: string;
+  stage: DyNTS_SafeDiagnosticStage_Type;
+  error?: unknown;
+  status?: number;
+}
+
+/** Exact public allowlist emitted by the safe diagnostic boundary. */
+export interface DyNTS_SafeDiagnostic_Interface {
+  contractVersion: 'dynts-safe-diagnostic/1';
+  code: string;
+  stage: DyNTS_SafeDiagnosticStage_Type;
+  causeType: DyNTS_SafeDiagnosticCause_Type;
+  fingerprint: string;
+  status: number;
+}

package/src/_services/core/global.service.ts

@@ -1,4 +1,4 @@
-import {
+import {
   DyFM_AnyError,
   DyFM_Array,
   DyFM_DataModel_Params,
@@ -6,28 +6,28 @@ import {
   DyFM_Error_Settings,
   DyFM_global_settings,
   DyFM_Log,
-  DyFM_Metadata
-} from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_AuthService } from './auth.service';
-import { DyNTS_EmailService } from './email.service';
-import { DyNTS_Service_Collection } from './service-collection.service';
-/* import { DyNTS_DBServiceCollection } from './db-service-collection.service'; */
-/* import { DyNTS_EmailServiceCollection } from './email-service-collection.service'; */
-import { DyNTS_DBService } from '../base/db.service';
-import { DyNTS_SingletonService } from '../base/singleton.service';
-/* import { DyNTS_archiveFlag } from '../../_collections/archive-flag.const'; */
-import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
-import {
-  DyNTS_GlobalErrorHandlerFn,
-  DyNTS_GlobalService_Settings
-} from '../../_models/interfaces/global-service-settings.interface';
-import { DyNTS_SafeDiagnosticStage_Type } from '../../_modules/server/safe-diagnostic/safe-diagnostic-stage.type-enum';
-import {
-  DyNTS_SafeDiagnostic_ControlService
-} from '../../_modules/server/safe-diagnostic/safe-diagnostic.control-service';
+  DyFM_Metadata
+} from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_AuthService } from './auth.service';
+import { DyNTS_EmailService } from './email.service';
+import { DyNTS_Service_Collection } from './service-collection.service';
+/* import { DyNTS_DBServiceCollection } from './db-service-collection.service'; */
+/* import { DyNTS_EmailServiceCollection } from './email-service-collection.service'; */
+import { DyNTS_DBService } from '../base/db.service';
+import { DyNTS_SingletonService } from '../base/singleton.service';
+/* import { DyNTS_archiveFlag } from '../../_collections/archive-flag.const'; */
+import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
+import {
+  DyNTS_GlobalErrorHandlerFn,
+  DyNTS_GlobalService_Settings
+} from '../../_models/interfaces/global-service-settings.interface';
+import { DyNTS_SafeDiagnosticStage_Type } from '../../_modules/server/safe-diagnostic/safe-diagnostic-stage.type-enum';
+import {
+  DyNTS_SafeDiagnostic_ControlService
+} from '../../_modules/server/safe-diagnostic/safe-diagnostic.control-service';
 
 /**
  * This is the main Global/Core Service Collection used by DynamoNTS, 
@@ -74,14 +74,14 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
     `We encountered an unhandled Control Service Error, ` +
     `\nplease contact the responsible development team.`; 
 
-  static globalErrorHandler: DyNTS_GlobalErrorHandlerFn = 
-    async (error: DyFM_AnyError): Promise<void> => {
-      DyNTS_SafeDiagnostic_ControlService.report({
-        code: 'DYNTS|GLOBAL|HANDLER_NOT_SET',
-        stage: DyNTS_SafeDiagnosticStage_Type.globalErrorHandler,
-        error: error,
-      });
-    };
+  static globalErrorHandler: DyNTS_GlobalErrorHandlerFn = 
+    async (error: DyFM_AnyError): Promise<void> => {
+      DyNTS_SafeDiagnostic_ControlService.report({
+        code: 'DYNTS|GLOBAL|HANDLER_NOT_SET',
+        stage: DyNTS_SafeDiagnosticStage_Type.globalErrorHandler,
+        error: error,
+      });
+    };
     
   /**
    * You need to setup global Services through this function
@@ -183,16 +183,16 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
         return;
       }
 
-      try {
-        this.instance.dbServiceCollection[dbModel.dataName] = new DyNTS_DBService(dbModel);
-      } catch (error) {
-        DyNTS_SafeDiagnostic_ControlService.report({
-          code: 'DYNTS|GLOBAL|DB_SERVICE_CREATE_FAILED',
-          stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
-          error: error,
-        });
-        
-        throw new DyFM_Error({
+      try {
+        this.instance.dbServiceCollection[dbModel.dataName] = new DyNTS_DBService(dbModel);
+      } catch (error) {
+        DyNTS_SafeDiagnostic_ControlService.report({
+          code: 'DYNTS|GLOBAL|DB_SERVICE_CREATE_FAILED',
+          stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
+          error: error,
+        });
+        
+        throw new DyFM_Error({
           ...this.getDefaultErrorSettings('setDBServices', error, 'DyNTS_GlobalService'),
 
           additionalContent: {
@@ -269,7 +269,7 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
 
   private static async setErrorHandler(errorHandler?: DyNTS_GlobalErrorHandlerFn): Promise<void> {
     try {
-      DyNTS_GlobalService.globalErrorHandler = (async (error: unknown): Promise<void> => {
+      DyNTS_GlobalService.globalErrorHandler = (async (error: unknown): Promise<void> => {
         try {
           if (errorHandler) {
             await errorHandler(error);
@@ -284,19 +284,19 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
               'please check if it is using the same node_modules as the app)'
           );
 
-          DyNTS_SafeDiagnostic_ControlService.report({
-            code: 'DYNTS|GLOBAL|UNHANDLED_ERROR',
-            stage: DyNTS_SafeDiagnosticStage_Type.globalErrorHandler,
-            error: error,
-          });
-        } catch (error) {
-          DyNTS_SafeDiagnostic_ControlService.report({
-            code: 'DYNTS|GLOBAL|HANDLER_FAILED',
-            stage: DyNTS_SafeDiagnosticStage_Type.globalErrorHandler,
-            error: error,
-          });
-        }
-      });
+          DyNTS_SafeDiagnostic_ControlService.report({
+            code: 'DYNTS|GLOBAL|UNHANDLED_ERROR',
+            stage: DyNTS_SafeDiagnosticStage_Type.globalErrorHandler,
+            error: error,
+          });
+        } catch (error) {
+          DyNTS_SafeDiagnostic_ControlService.report({
+            code: 'DYNTS|GLOBAL|HANDLER_FAILED',
+            stage: DyNTS_SafeDiagnosticStage_Type.globalErrorHandler,
+            error: error,
+          });
+        }
+      });
     } catch (error) {
       throw new DyFM_Error({
         ...this.getDefaultErrorSettings('setErrorHandler', error, 'DyNTS_GlobalService'),