@platform-x/hep-notification-client 1.3.0 → 1.3.2

package/src/common/service/requestService.ts

@@ -0,0 +1,87 @@
+import axios from 'axios';
+import { Logger } from '../util/logger';
+import https from 'https';
+import { ApiError } from '../util/errorHandler';
+import { HTTP_CONTENT_TYPE_JSON } from '../../platform-x/constants';
+
+interface RequestHandlerPostOptions {
+  url: string;
+  body: any;
+  options?: any;
+}
+
+interface RequestHandlerGetOptions {
+  url: string;
+  options?: any;
+}
+
+export class HttpRequestHandler {
+  private requestTimeout = 1000 * 30;
+  // NOSONAR-NEXT-LINE
+  constructor() {} // NOSONAR
+  /**
+   * post - handler to do post api calls
+   * @param requestConfig
+   * @returns
+   */
+  public async post(requestConfig: RequestHandlerPostOptions) {
+    Logger.info(
+      'HttpRequestHandler: Reached post method',
+      'post'
+    );
+    const { url, body } = requestConfig;
+    const defaultOptions = {
+      headers: {
+        'Content-Type': HTTP_CONTENT_TYPE_JSON,
+      },
+    };
+    let options = requestConfig.options || defaultOptions;
+    options.httpsAgent = new https.Agent({
+      rejectUnauthorized: true,
+    });
+    if (!options.headers) {
+      options.headers = {};
+    }
+    options.timeout = this.requestTimeout;
+    return axios
+      .post(url, body, options)
+      .then((res: any) => {
+        Logger.info('HttpRequestHandler: Successfull Response', 'post');
+        return res.data;
+      })
+      .catch((err: any) => {
+        let apiError = new ApiError(err.message, err.response?.status);
+        Logger.error('HttpRequestHandler: Error in post', 'post', err);
+        throw apiError;
+      });
+  }
+  /**
+   * get - handler to do get api calls
+   * @param requestConfig
+   * @returns
+   */
+  public async get(requestConfig: RequestHandlerGetOptions) {
+    Logger.info('HttpRequestHandler: Reached get method', 'get');
+    const { url } = requestConfig;
+    const defaultOptions = {};
+    let options = requestConfig.options || defaultOptions;
+    options.httpsAgent = new https.Agent({
+      rejectUnauthorized: true,
+    });
+    if (!options.headers) {
+      options.headers = {};
+    }
+    options.timeout = this.requestTimeout;
+    return axios
+      .get(url, options)
+      .then((res: any) => {
+        Logger.info('HttpRequestHandler: Successfull Response', 'get');
+        return res.data;
+      })
+      .catch((err: any) => {
+        let apiError = new ApiError(err.message, err.response?.status);
+        Logger.error('HttpRequestHandler: Error in get', 'get', err);
+        throw apiError;
+      });
+  }
+}

package/{dist/src/common/service/secretKeyManager.services.js → src/common/service/secretKeyManager.services.ts}

@@ -1,7 +1,7 @@
-"use strict";
 // import { secretManager } from 'hep-secret-access';
 // import config from '../../config';
 // import { DynamicValues } from '../../platform-x/constants';
+
 // export class SecretKeyServices {
 //   private ruleCache = new Map<string, any | null>();
 //   /**
@@ -35,4 +35,3 @@
 //     }
 //   }
 // }
-//# sourceMappingURL=secretKeyManager.services.js.map

package/src/common/service/twilioService.ts

@@ -0,0 +1,58 @@
+import twilio from 'twilio';
+import { Logger } from '../util/logger';
+import { DynamicValues } from '../../platform-x/constants';
+import { getIAMSecrets } from '../..';
+
+export class TwilioService {
+    private client: twilio.Twilio;
+    private senderNumber: string;
+
+    /**
+     * Constructor to initialize Twilio client and sender number
+     * @param accountSid - Twilio Account SID
+     * @param authToken - Twilio Auth Token
+     * @param senderNumber - Twilio Sender Phone Number
+     */
+    private constructor(twilioConfig: any) {
+        this.client = twilio(twilioConfig?.[DynamicValues?.TWILIO_ACCOUNT_SID], twilioConfig?.[DynamicValues?.TWILIO_AUTH_TOKEN]);
+        this.senderNumber = twilioConfig?.[DynamicValues?.TWILIO_SENDER_NUMBER];
+    }
+
+    static async TwilioClassObject() {
+        const secrets = await getIAMSecrets();
+        return new TwilioService(secrets);
+    }
+
+    /**
+     * Send an SMS using Twilio
+     * @param to - Recipient's phone number
+     * @param message - Message content
+     * @returns Promise resolving with the Twilio response
+     */
+    async sendSMS(to: string, message: string) {
+        Logger.info(
+            'twilioService: Reached sendSMS',
+            'sendSMS'
+          );
+          Logger.debug(
+            'twilioService: check message and recipient number',
+            'sendSMS',
+            {to, message}
+          );
+        try {
+            const response = await this.client.messages.create({
+                body: message,
+                from: this.senderNumber,
+                to,
+            });
+            return response;
+        } catch (error) {
+            Logger.error(
+                'twilioService: error in send SMS by twilio',
+                'sendSMS',
+                error
+              );
+            throw new Error('Failed to send SMS');
+        }
+    }
+}

package/src/common/util/commonUtil.ts

@@ -0,0 +1,39 @@
+import { throwError } from "./errorHandler";
+
+/**
+ * Validate a phone number for format and length
+ * @param phoneNumber
+ * @returns
+ */
+export const validatePhoneNumber = (phoneNumber: string): boolean => {
+  // Regular expression for validating international phone numbers
+  const phoneRegex = /^\+?[1-9]\d{1,14}$/; // E.164 format
+  return phoneRegex?.test(phoneNumber);
+};
+
+/**
+ * Validate a message for length and content
+ * @param message
+ * @returns
+ */
+export const  validateMessage = (message: string): boolean => {
+  const maxLength:number = 250; // Standard SMS max length
+  return message?.trim()?.length > 0 && message?.length <= maxLength;
+};
+
+/**
+ * Validate both phone number and message
+ * @param phoneNumber
+ * @param message
+ * @returns
+ */
+export const validate = (phoneNumber: string, message: string): { valid: boolean; errors: any } => {
+  const errors: any = [];
+  if (!validatePhoneNumber(phoneNumber)) {
+    throwError('Invalid phone number format. Ensure it follows +915647374757 like this.');
+  }
+  if (!validateMessage(message)) {
+    throwError('Message must be between 1 and 250 characters.');
+  }
+  return {valid:true, errors:''};
+};

package/src/common/util/errorHandler.ts

@@ -0,0 +1,120 @@
+export const enum HTTP_STATUS_CODE {
+	INTERNAL_SERVER_ERROR=500
+}
+export const HTTP_STATUS_MAP = new Map([
+    [500, 'Internal Server Error']
+]);
+export const enum HTTP_STATUS_TYPE {
+    INTERNAL_SERVER_ERROR='Internal Server Error'
+}
+
+export class CommonErrorTemplate extends Error {
+  public code: number;
+  public type: string;
+
+  constructor(msg: string, code?: number) {
+    super(msg);
+    this.code = code || HTTP_STATUS_CODE.INTERNAL_SERVER_ERROR;
+    this.type =
+      HTTP_STATUS_MAP.get(this.code) || HTTP_STATUS_TYPE.INTERNAL_SERVER_ERROR;
+  }
+
+  public toJSON() {
+    return {
+      code: this.code,
+      type: this.type,
+      message: this.message,
+    };
+  }
+}
+
+export class ApiError extends CommonErrorTemplate {
+  constructor(msg: string, code?: number) {
+    super(msg, code);
+    this.name = 'ApiError';
+    Error.captureStackTrace(this, ApiError);
+  }
+}
+
+export class SolrError extends CommonErrorTemplate {
+  constructor(msg: string, code?: number) {
+    super(msg, code);
+    this.name = 'SolrError';
+    Error.captureStackTrace(this, SolrError);
+  }
+}
+
+export class CustomError {
+  public code!: number | undefined;
+  public type!: string | undefined;
+  public message!: string | undefined;
+  public stack!: string | undefined;
+  public errorObj: Error | undefined | null;
+
+  constructor(
+    errObj?: any,
+    code?: number,
+    type?: string,
+    message?: string,
+    stack?: string
+  ) {
+    this.code = code;
+    this.type = type;
+    this.message = message;
+    this.stack = stack;
+    this.errorObj = errObj;
+  }
+
+  public toJSON() {
+    // NOSONAR
+    return {
+      code: this.code,
+      type: this.type,
+      message: this.message,
+    };
+  }
+}
+/**
+ * errorMapper - to map error object to custom error
+ */
+export const errorMapper = (err: any, statusCode?: number, type?: string) => {
+  let error!: any;
+  let customError: CustomError;
+  let code: number = statusCode || HTTP_STATUS_CODE.INTERNAL_SERVER_ERROR;
+  let errorType: string =
+    type || HTTP_STATUS_MAP.get(code) || HTTP_STATUS_TYPE.INTERNAL_SERVER_ERROR;
+
+  if (typeof err === 'string') {
+    error = new Error(err);
+    customError = new CustomError(
+      null,
+      code,
+      errorType,
+      error.message,
+      error.stack
+    );
+    return customError;
+  } else if (
+    err.stack &&
+    err.message &&
+    !(err instanceof CustomError) &&
+    !err.toJSON
+  ) {
+    customError = new CustomError(
+      null,
+      code,
+      errorType,
+      err.message,
+      err.stack
+    );
+    return customError;
+  } else {
+    return err;
+  }
+};
+/**
+ * throwError - to throw custome error
+ */
+export const throwError = (err: any, statusCode?: number, type?: string) => {
+  throw errorMapper(err, statusCode, type);
+};

package/src/common/util/logger.ts

@@ -0,0 +1,215 @@
+import bunyan from 'bunyan';
+import config from '../../config/index';
+import bformat from 'bunyan-format';
+import { getTraceId, getSpanId } from './requestTracer';
+import _ from 'lodash';
+export interface payLoadInterface {
+  statusCode?: number;
+  data?: any;
+}
+
+export interface LoggerInterface {
+  info(message: string, method: string): void;
+  warn(message: string, method: string, payload?: object): void;
+  error(message: string, method: string, payload?: object): void;
+  debug(message: string, method: string, payload?: object): void;
+}
+
+export class LoggerClass implements LoggerInterface {
+  private logger: bunyan;
+  private infoLevel: boolean = false;
+  private debugLevel: boolean = false;
+  private errorLevel: boolean = false;
+  private warnLevel: boolean = false;
+  private blockedKeywords = ['currentPassword', 'clientSecret', 'newPassword'];
+
+  constructor() {
+    this.mapLogLevels();
+    this.logger = bunyan.createLogger({
+      name: config.APP_NAME,
+      level: 'trace', // by default enabling all levels, controlled through env separately
+      stream: bformat({
+        outputMode: config.NODE_ENV === 'development' ? 'short' : 'bunyan',
+        levelInString: true,
+        color: true,
+      }),
+    });
+  }
+  /**
+   * It's written to handle JSON.circular error
+   * @param obj
+   * @returns
+   */
+  public customstringify(obj: any) {
+    let cache: any = [];
+    let str = JSON.stringify(obj, (key, value) => {
+      {
+        if (typeof value === 'object' && value !== null) {
+          if (cache.indexOf(value) !== -1) {
+            // Circular reference found, discard key
+            return;
+          }
+          // Store value in our collection
+          cache.push(value);
+        }
+        return value;
+      }
+    });
+    cache = null; // reset the cache
+    return str;
+  }
+  /**
+   * for info log
+   * @param message
+   * @param payload
+   * @param method
+   * @returns
+   */
+  public info(message: string, method: string) {
+    if (!this.infoLevel) {
+      return;
+    }
+    let loggerParams = {
+      message,
+      method,
+      traceId: getTraceId(),
+    };
+    this.logger.info(` start ${JSON.stringify(loggerParams)} ==end`);
+  }
+  /**
+   * for warn log
+   * @param message
+   * @param payload
+   * @param method
+   * @returns
+   */
+  public warn(message: string, method: string, payload?: any) {
+    if (!this.warnLevel) {
+      return;
+    }
+    let loggerParams = {
+      message,
+      method,
+      traceId: getTraceId(),
+      statusCode: payload?.statusCode,
+    };
+
+    let finalPayload = payload !== undefined ? payload : {};
+    this.logger.warn(
+      ` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(
+        this.sanitizeLog(finalPayload)
+      )}==end`
+    );
+  }
+  /**
+   * for error log
+   * @param message
+   * @param payload
+   * @param method
+   * @returns
+   */
+  public error(message: string, method: string, payload?: any) {
+    if (!this.errorLevel) {
+      return;
+    }
+
+    if (payload instanceof Error) {
+      payload = {
+        message,
+        method,
+        traceId: getTraceId(),
+        stack: payload?.stack,
+      };
+    }
+    let loggerParams = {
+      message,
+      method,
+      traceId: getTraceId(),
+      spanId: getSpanId(),
+      statusCode: payload?.statusCode,
+    };
+    let finalPayload = payload !== undefined ? payload : {};
+    this.logger.error(
+      ` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(
+        this.sanitizeLog(finalPayload)
+      )}==end`
+    );
+  }
+  /**
+   * for debug log
+   * @param message
+   * @param payload
+   * @param method
+   * @returns
+   */
+  public debug(message: string, method: string, payload?: any) {
+    if (!this.debugLevel) {
+      return;
+    }
+
+    let loggerParams = {
+      message,
+      method,
+      traceId: getTraceId(),
+      statusCode: payload?.statusCode,
+    };
+    let finalPayload = payload !== undefined ? payload : {};
+    this.logger.debug(
+      ` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(
+        this.sanitizeLog(finalPayload)
+      )}==end`
+    );
+  }
+  /**
+   * to map log levels and handle from config
+   */
+  private mapLogLevels() {
+    if (config.LOG_LEVELS.length) {
+      config.LOG_LEVELS.forEach((element: string) => {
+        const logLevel = element.trim();
+        if (logLevel === 'info') {
+          this.infoLevel = true;
+        } else if (logLevel === 'debug') {
+          this.debugLevel = true;
+        } else if (logLevel === 'error') {
+          this.errorLevel = true;
+        } else if (logLevel === 'warn') {
+          this.warnLevel = true;
+        }
+      });
+    }
+  }
+  /**
+   * to sanitize logs from unwanted fields to be shown
+   * @param request
+   * @returns
+   */
+  private sanitizeLog(request: any) {
+    try {
+      if (request) {
+        Object.keys(request).forEach((key) => {
+          let value = request[key];
+          if (request[key] === 'options') {
+            delete request.options;
+          } else {
+            if (
+              this.blockedKeywords.find(
+                (blockedKey: any) =>
+                  key.toLowerCase() === blockedKey.toLowerCase()
+              )
+            ) {
+              request[key] = 'XXXXXXXXXX';
+            } else {
+              request[key] = value;
+            }
+          }
+        });
+        return request;
+      }
+    } catch (err: any) {
+      this.error('Logger sanitize error', err);
+    }
+  }
+}
+
+export const Logger = new LoggerClass();

package/src/common/util/requestTracer.ts

@@ -0,0 +1,10 @@
+import cls from 'cls-hooked';
+import { v4 as uuidv4 } from 'uuid';
+
+const nsid = `rtracer:${uuidv4()}`;
+const ns = cls.createNamespace(nsid);
+const traceIdKey = 'traceId';
+const spanIdKey = 'spanId';
+
+  export const getTraceId = () => ns.get(traceIdKey);
+  export const getSpanId = () => ns.get(spanIdKey);