fix(private): convert underscore methods to private

EME-5173

Co-authored-by: Gabor Nemeth <[email protected]>

src/logger/logger.ts

@@ -30,20 +30,20 @@ export interface LoggerConfig {
 }
 
 export class Logger {
-  _namespace: string;
-  _enabled: boolean;
+  private readonly namespace: string;
+  private readonly enabled: boolean;
 
   constructor(namespace: string, enabled: boolean) {
-    this._namespace = namespace;
-    this._enabled = enabled;
+    this.namespace = namespace;
+    this.enabled = enabled;
   }
 
   static configure(options: Partial<LoggerConfig>) {
-    this._validate(options);
+    this.validate(options);
     Object.assign(Logger.config, options);
   }
 
-  static _validate(options: Partial<LoggerConfig>) {
+  private static validate(options: Partial<LoggerConfig>) {
     Object.keys(options).forEach((key) => {
       if (!allowedKeys.includes(key)) {
         throw new Error('Only the following keys are allowed: formatter, output');
@@ -58,41 +58,57 @@ export class Logger {
   };
 
   isEnabled() {
-    return this._enabled;
+    return this.enabled;
   }
 
   trace(action: string, data: unknown = {}) {
-    this._log('trace', action, data);
+    this.log('trace', action, data);
   }
 
   debug(action: string, data: unknown = {}) {
-    this._log('debug', action, data);
+    this.log('debug', action, data);
   }
 
   info(action: string, data: unknown = {}) {
-    this._log('info', action, data);
+    this.log('info', action, data);
   }
 
   warn(action: string, data: unknown = {}) {
-    this._log('warn', action, data);
+    this.log('warn', action, data);
   }
 
   error(action: string, data: unknown = {}) {
-    this._log('error', action, data);
+    this.log('error', action, data);
   }
 
   fatal(action: string, data: unknown = {}) {
-    this._log('fatal', action, data);
+    this.log('fatal', action, data);
   }
 
-  _log(level: string, action: string, data: unknown) {
-    if (!this._enabled) {
+  customError(severity: string, action: string, error: Error, data: unknown = {}) {
+    this.log(severity, action, Object.assign(this.getErrorDetails(error), data));
+  }
+
+  fromError(action: string, error: unknown, data: unknown = {}) {
+    this.customError('error', action, error as Error, data);
+  }
+
+  warnFromError(action: string, error: unknown, data: unknown = {}) {
+    this.customError('warn', action, error as Error, data);
+  }
+
+  timer() {
+    return new Timer(this);
+  }
+
+  private log(level: string, action: string, data: unknown) {
+    if (!this.enabled) {
       return;
     }
 
     let dataToLog = Object.assign(
       {
-        name: this._namespace,
+        name: this.namespace,
         action: action,
         level: config.levels[level].number,
         time: new Date().toISOString(),
@@ -107,31 +123,15 @@ export class Logger {
     Logger.config.output(Logger.config.formatter(dataToLog));
   }
 
-  customError(severity: string, action: string, error: Error, data: unknown = {}) {
-    this._log(severity, action, Object.assign(this._getErrorDetails(error), data));
-  }
-
-  fromError(action: string, error: unknown, data: unknown = {}) {
-    this.customError('error', action, error as Error, data);
-  }
-
-  warnFromError(action: string, error: unknown, data: unknown = {}) {
-    this.customError('warn', action, error as Error, data);
-  }
-
-  timer() {
-    return new Timer(this);
-  }
-
-  _shortenStackTrace(stack: string) {
+  private shortenStackTrace(stack: string) {
     if (!stack) {
       return;
     }
 
     return stack.length > STACK_TRACE_LIMIT ? stack.substring(0, STACK_TRACE_LIMIT) + ' ...' : stack;
   }
 
-  _shortenData(data: unknown) {
+  private shortenData(data: unknown) {
     if (typeof data === 'undefined') {
       return;
     }
@@ -141,22 +141,22 @@ export class Logger {
     return stringifiedData.length > DATA_LIMIT ? stringifiedData.substring(0, DATA_LIMIT) + ' ...' : stringifiedData;
   }
 
-  _getErrorDetails(error: Error) {
+  private getErrorDetails(error: Error) {
     if (!(error instanceof Object)) {
       return {};
     }
 
     const baseDetails = {
       error_name: error.name,
-      error_stack: this._shortenStackTrace(error.stack || ''),
+      error_stack: this.shortenStackTrace(error.stack || ''),
       error_message: error.message,
-      error_data: this._shortenData((error as ErrorWithData).data),
+      error_data: this.shortenData((error as ErrorWithData).data),
     };
 
-    return Object.assign(baseDetails, this._getAxiosErrorDetails(error as AxiosError));
+    return Object.assign(baseDetails, this.getAxiosErrorDetails(error as AxiosError));
   }
 
-  _getAxiosErrorDetails(error: AxiosError) {
+  private getAxiosErrorDetails(error: AxiosError) {
     if (!error.isAxiosError) {
       return {};
     }
@@ -166,7 +166,7 @@ export class Logger {
       request_url: error.config.url,
       response_status: error.response ? error.response.status : undefined,
       response_status_text: error.response ? error.response.statusText : undefined,
-      response_data: error.response ? this._shortenData(error.response.data) : undefined,
+      response_data: error.response ? this.shortenData(error.response.data) : undefined,
     };
   }
 }

src/timer/timer.ts

@@ -1,49 +1,49 @@
 import { Logger } from '../logger/logger';
 
 export class Timer {
-  _logger: Logger;
-  _start: number;
+  private readonly start: number;
+  private readonly logger: Logger;
 
   constructor(logger: Logger) {
-    this._logger = logger;
-    this._start = new Date().getTime();
+    this.logger = logger;
+    this.start = new Date().getTime();
   }
 
   trace(action: string, data: unknown = {}) {
-    this._logger.trace(action, Object.assign({ duration: this._duration() }, data));
+    this.logger.trace(action, Object.assign({ duration: this.duration() }, data));
   }
 
   debug(action: string, data: unknown = {}) {
-    this._logger.debug(action, Object.assign({ duration: this._duration() }, data));
+    this.logger.debug(action, Object.assign({ duration: this.duration() }, data));
   }
 
   info(action: string, data: unknown = {}) {
-    this._logger.info(action, Object.assign({ duration: this._duration() }, data));
+    this.logger.info(action, Object.assign({ duration: this.duration() }, data));
   }
 
   warn(action: string, data: unknown = {}) {
-    this._logger.warn(action, Object.assign({ duration: this._duration() }, data));
+    this.logger.warn(action, Object.assign({ duration: this.duration() }, data));
   }
 
   error(action: string, data: unknown = {}) {
-    this._logger.error(action, Object.assign({ duration: this._duration() }, data));
+    this.logger.error(action, Object.assign({ duration: this.duration() }, data));
   }
 
   fatal(action: string, data: unknown = {}) {
-    this._logger.fatal(action, Object.assign({ duration: this._duration() }, data));
+    this.logger.fatal(action, Object.assign({ duration: this.duration() }, data));
   }
 
   fromError(action: string, error: unknown, data: unknown = {}) {
-    this._logger.fromError(action, error, Object.assign({ duration: this._duration() }, data));
+    this.logger.fromError(action, error, Object.assign({ duration: this.duration() }, data));
   }
 
   warnFromError(action: string, error: unknown, data: unknown = {}) {
-    this._logger.warnFromError(action, error, Object.assign({ duration: this._duration() }, data));
+    this.logger.warnFromError(action, error, Object.assign({ duration: this.duration() }, data));
   }
 
-  _duration(): number {
+  private duration(): number {
     const end = new Date().getTime();
 
-    return end - this._start;
+    return end - this.start;
   }
 }