custom-code.patch

diff --git a/src/authentication/core/AuthenticationHeader.ts b/src/authentication/core/AuthenticationHeader.ts
new file mode 100644
index 00000000..fcbd8581
--- /dev/null
+++ b/src/authentication/core/AuthenticationHeader.ts
@@ -0,0 +1,178 @@
+import type { Logger as WinstonLogger } from 'winston';
+import MerchantConfig from './MerchantConfig';
+import type { MerchantConfigOptions, Stringable } from './MerchantConfig';
+import * as Constants from '../util/Constants';
+import * as Logger from '../logging/Logger';
+import * as Authorization from './Authorization';
+import * as PayloadDigest from '../payloadDigest/DigestGenerator';
+import * as querystring from 'querystring';
+
+// Code added by Infosys dev team
+
+export class AuthenticationHeader {
+  merchantConfig: MerchantConfig;
+  constants = Constants;
+  basePath: string;
+  logger: WinstonLogger;
+
+  /**
+   * This method will set the merchantConfig object global
+   * @param configObject merchantConfiguration properties.
+   */
+  setConfiguration(configObject: MerchantConfigOptions) {
+    this.merchantConfig = new MerchantConfig(configObject);
+    this.constants = Constants;
+    if (this.merchantConfig.getIntermediateHost()) {
+      if (
+        this.merchantConfig
+          .getIntermediateHost()
+          .startsWith(this.constants.HTTP_URL_PREFIX) ||
+        this.merchantConfig.getIntermediateHost().startsWith('http://')
+      ) {
+        this.basePath = this.merchantConfig.getIntermediateHost();
+      } else {
+        this.basePath =
+          this.constants.HTTP_URL_PREFIX +
+          this.merchantConfig.getIntermediateHost();
+      }
+    } else {
+      this.basePath =
+        this.constants.HTTP_URL_PREFIX + this.merchantConfig.getRequestHost();
+    }
+    this.logger = Logger.getLogger(this.merchantConfig, 'ApiClient');
+  }
+
+  /**
+   * This method is to generate headers for http and jwt authentication.
+   */
+  callAuthenticationHeader(
+    httpMethod: string,
+    requestTarget: string,
+    requestBody: string,
+    headerParams,
+  ) {
+    this.merchantConfig.setRequestTarget(requestTarget);
+    this.merchantConfig.setRequestType(httpMethod);
+    this.merchantConfig.setRequestJsonData(requestBody);
+
+    this.logger.info(
+      'Authentication Type : ' + this.merchantConfig.getAuthenticationType(),
+    );
+    this.logger.info(
+      this.constants.REQUEST_TYPE + ' : ' + httpMethod.toUpperCase(),
+    );
+
+    var token = Authorization.getToken(this.merchantConfig, this.logger);
+
+    if (
+      this.merchantConfig.getAuthenticationType()?.toLowerCase() ===
+      this.constants.JWT
+    ) {
+      token = 'Bearer ' + token;
+      headerParams['Authorization'] = token;
+      this.logger.info(this.constants.AUTHORIZATION + ' : ' + token);
+    } else if (
+      this.merchantConfig.getAuthenticationType()?.toLowerCase() ===
+      this.constants.HTTP
+    ) {
+      var date = new Date(Date.now()).toUTCString();
+
+      if (
+        httpMethod.toLowerCase() === this.constants.POST ||
+        httpMethod.toLowerCase() === this.constants.PATCH ||
+        httpMethod.toLowerCase() === this.constants.PUT
+      ) {
+        var digest = PayloadDigest.generateDigest(
+          this.merchantConfig,
+          this.logger,
+        );
+        digest = this.constants.SIGNATURE_ALGORITHAM + digest;
+        this.logger.info(this.constants.DIGEST + ' : ' + digest);
+        headerParams['digest'] = digest;
+      }
+
+      headerParams['v-c-merchant-id'] = this.merchantConfig.getMerchantID();
+      headerParams['date'] = date;
+      headerParams['host'] = this.merchantConfig.getRequestHost();
+      headerParams['signature'] = token;
+      headerParams['User-Agent'] = this.constants.USER_AGENT_VALUE;
+
+      this.logger.info(
+        'v-c-merchant-id : ' + this.merchantConfig.getMerchantID(),
+      );
+      this.logger.info('date : ' + date);
+      this.logger.info('host : ' + this.merchantConfig.getRequestHost());
+      this.logger.info('signature : ' + token);
+      this.logger.info('User-Agent : ' + headerParams['User-Agent']);
+      this.logger.info(this.constants.END_TRANSACTION);
+    } else if (
+      this.merchantConfig.getAuthenticationType()?.toLowerCase() ===
+      this.constants.OAUTH
+    ) {
+      token = 'Bearer ' + token;
+      headerParams['Authorization'] = token;
+      // this.logger.info(this.constants.AUTHORIZATION + ' : ' + token);
+    }
+
+    return headerParams;
+  }
+
+  /**
+   * Build request target required for the signature generation
+   */
+  buildRequestTarget(
+    path: string,
+    pathParams: Record<string, string | null>,
+    queryParams: Record<string, string | null>,
+  ) {
+    if (!path.match(/^\//)) {
+      path = '/' + path;
+    }
+
+    var _this = this;
+    var requestTarget = path.replace(
+      /\{([\w-]+)\}/g,
+      function (fullMatch, key) {
+        var value;
+        if (pathParams.hasOwnProperty(key)) {
+          value = _this.paramToString(pathParams[key]);
+        } else {
+          value = fullMatch;
+        }
+        return encodeURIComponent(value);
+      },
+    );
+
+    // added by infosys team, to generate requestTarget with queryParams
+    if (Object.keys(queryParams).length !== 0) {
+      var queryFlag = false;
+      var queryArray: Record<string, string | null> = {};
+      Object.keys(queryParams).forEach(function (prop) {
+        var val = queryParams[prop];
+
+        if (val !== undefined) {
+          queryArray[prop] = val;
+          queryFlag = true;
+        }
+      });
+      if (queryFlag)
+        requestTarget = requestTarget + '?' + querystring.stringify(queryArray);
+    }
+    return requestTarget;
+  }
+
+  /**
+   * Returns a string representation for an actual parameter.
+   * @param param The actual parameter.
+   * @returns The string representation of <code>param</code>.
+   */
+  paramToString(param: null | undefined | Date | Stringable): string {
+    if (param == undefined || param == null) {
+      return '';
+    }
+    if (param instanceof Date) {
+      return param.toJSON();
+    }
+    return param.toString();
+  }
+}
diff --git a/src/authentication/core/MerchantConfig.d.ts b/src/authentication/core/MerchantConfig.d.ts
new file mode 100644
index 00000000..106ec08b
--- /dev/null
+++ b/src/authentication/core/MerchantConfig.d.ts
@@ -0,0 +1,270 @@
+import * as LogConfiguration from '../logging/LogConfiguration';
+import { Logger } from 'winston';
+
+export interface Stringable {
+  toString(): string;
+}
+
+export type MerchantConfigOptions = Partial<
+  Pick<
+    MerchantConfig,
+    | 'authenticationType'
+    | 'requestJsonPath'
+    | 'merchantID'
+    | 'keysDirectory'
+    | 'keyAlias'
+    | 'keyPass'
+    | 'keyFilename'
+    | 'useProxy'
+    | 'proxyAddress'
+    | 'proxyPort'
+    | 'proxyUser'
+    | 'proxyPassword'
+    | 'merchantKeyId'
+    | 'merchantsecretKey'
+    | 'useMetaKey'
+    | 'portfolioID'
+    | 'enableClientCert'
+    | 'clientCertDir'
+    | 'sslClientCert'
+    | 'privateKey'
+    | 'clientId'
+    | 'clientSecret'
+    | 'accessToken'
+    | 'refreshToken'
+    | 'runEnvironment'
+    | 'intermediateHost'
+    | 'solutionId'
+    | 'logConfiguration'
+    | 'defaultHeaders'
+  > & {
+    /** @deprecated use `keyFilename` instead */
+    keyFileName: MerchantConfig['keyFilename'];
+  }
+>;
+
+export = class MerchantConfig {
+  /*Common Parameters*/
+  authenticationType?: string;
+  url;
+  requestHost;
+  requestJsonPath;
+  merchantID?: string | Stringable;
+  requestType;
+  requestTarget;
+  requestJsonData;
+
+  /* JWT Parameters*/
+  keysDirectory?: string;
+  keyAlias?: string | Stringable;
+  keyPass?: string | Stringable;
+  keyType?;
+  keyFilename?: string | Stringable;
+  useHttpClient: boolean;
+
+  /* proxy Parameters*/
+  useProxy: boolean;
+  proxyAddress?: string;
+  proxyPort?: string | number;
+  proxyUser?: string;
+  proxyPassword?: string;
+
+  /*HTTP Parameters*/
+  merchantKeyId?: string | Stringable;
+  merchantsecretKey?: string | Stringable;
+
+  /* MetaKey Parameters */
+  useMetaKey: boolean;
+  portfolioID?: string;
+
+  /* MutualAuth Parameters */
+  enableClientCert: boolean;
+  clientCertDir?: string;
+  sslClientCert?: string | Stringable;
+  privateKey?: string | Stringable;
+
+  /* OAuth Parameters */
+  clientId?: string | Stringable;
+  clientSecret?: string | Stringable;
+  accessToken?: string | Stringable;
+  refreshToken?: string | Stringable;
+
+  runEnvironment?: string | Stringable;
+
+  /* Intermediate Host */
+  intermediateHost;
+
+  solutionId;
+
+  logConfiguration: LogConfiguration;
+
+  /* Default Custom Headers */
+  defaultHeaders;
+
+  constructor(result: MerchantConfigOptions);
+
+  getAuthenticationType(): MerchantConfig['authenticationType'];
+
+  setAuthenticationType(authType: MerchantConfig['authenticationType']): void;
+
+  setMerchantID(merchantID: MerchantConfig['merchantID']): void;
+
+  setRequestHost(requestHost: MerchantConfig['requestHost']): void;
+
+  setKeyAlias(keyAlias: MerchantConfig['keyAlias']): void;
+
+  setKeyPass(keyPass: MerchantConfig['keyPass']): void;
+
+  setKeysDirectory(keysDirectory: MerchantConfig['keysDirectory']): void;
+
+  setMerchantKeyID(merchantKeyId: MerchantConfig['merchantKeyId']): void;
+
+  setMerchantsecretKey(
+    merchantsecretKey: MerchantConfig['merchantsecretKey'],
+  ): void;
+
+  setUseMetaKey(useMetaKey: MerchantConfig['useMetaKey']): void;
+
+  setPortfolioID(portfolioID: MerchantConfig['portfolioID']): void;
+
+  setEnableClientCert(
+    enableClientCert: MerchantConfig['enableClientCert'],
+  ): void;
+
+  setClientCertDir(clientCertDir: MerchantConfig['clientCertDir']): void;
+
+  setSSLClientCert(sslClientCert: MerchantConfig['sslClientCert']): void;
+
+  setPrivateKey(privateKey: MerchantConfig['privateKey']): void;
+
+  setClientId(clientId: MerchantConfig['clientId']): void;
+
+  setClientSecret(clientSecret: MerchantConfig['clientSecret']): void;
+
+  setAccessToken(accessToken: MerchantConfig['accessToken']): void;
+
+  setRefreshToken(refreshToken: MerchantConfig['refreshToken']): void;
+
+  setSolutionId(solutionId: MerchantConfig['solutionId']): void;
+
+  setURL(url: MerchantConfig['url']): void;
+
+  getMerchantID(): MerchantConfig['merchantID'];
+
+  getRequestHost(): MerchantConfig['requestHost'];
+
+  getKeyAlias(): MerchantConfig['keyAlias'];
+
+  getKeyPass(): MerchantConfig['keyPass'];
+
+  getUseMetaKey(): MerchantConfig['useMetaKey'];
+
+  getPortfolioID(): MerchantConfig['portfolioID'];
+
+  getEnableClientCert(): MerchantConfig['enableClientCert'];
+
+  getClientCertDir(): MerchantConfig['clientCertDir'];
+
+  getSSLClientCert(): MerchantConfig['sslClientCert'];
+
+  getPrivateKey(): MerchantConfig['privateKey'];
+
+  getClientId(): MerchantConfig['clientId'];
+
+  getClientSecret(): MerchantConfig['clientSecret'];
+
+  getAccessToken(): MerchantConfig['accessToken'];
+
+  getRefreshToken(): MerchantConfig['refreshToken'];
+
+  getKeysDirectory(): MerchantConfig['keysDirectory'];
+
+  getMerchantKeyID(): MerchantConfig['merchantKeyId'];
+
+  getMerchantsecretKey(): MerchantConfig['merchantsecretKey'];
+
+  getSolutionId(): MerchantConfig['solutionId'];
+
+  getURL(): MerchantConfig['url'];
+
+  getRequestTarget(): MerchantConfig['requestTarget'];
+
+  setRequestJsonData(requestJsonData: MerchantConfig['requestJsonData']): void;
+
+  getRequestJsonData(): MerchantConfig['requestJsonData'];
+
+  setRequestTarget(requestTarget: MerchantConfig['requestTarget']): void;
+
+  getRequestJsonPath(): MerchantConfig['requestJsonPath'];
+
+  setRequestJsonPath(requestJsonPath: MerchantConfig['requestJsonPath']): void;
+
+  getRequestType(): MerchantConfig['requestType'];
+
+  setRequestType(requestType: MerchantConfig['requestType']): void;
+
+  getRunEnvironment(): MerchantConfig['runEnvironment'];
+
+  setRunEnvironment(runEnvironment: MerchantConfig['runEnvironment']): void;
+
+  getIntermediateHost(): MerchantConfig['intermediateHost'];
+
+  setIntermediateHost(
+    intermediateHost: MerchantConfig['intermediateHost'],
+  ): void;
+
+  getProxyAddress(): MerchantConfig['proxyAddress'];
+
+  setProxyAddress(proxyAddress: MerchantConfig['proxyAddress']);
+
+  getProxyPort(): MerchantConfig['proxyPort'];
+
+  setProxyPort(proxyPort: MerchantConfig['proxyPort']);
+
+  getUseProxy(): MerchantConfig['useProxy'];
+
+  setUseProxy(useProxy): MerchantConfig['useProxy'];
+
+  getProxyUser(): MerchantConfig['proxyUser'];
+
+  setProxyUser(proxyUser: MerchantConfig['proxyUser']): void;
+
+  getProxyPassword(): MerchantConfig['proxyPassword'];
+
+  setProxyPassword(proxyPassword: MerchantConfig['proxyPassword']): void;
+
+  getKeyFileName(): MerchantConfig['keyFilename'];
+
+  setKeyFileName(keyFilename: MerchantConfig['keyFilename']): void;
+
+  getLogConfiguration(): MerchantConfig['logConfiguration'];
+
+  setLogConfiguration(logConfig: MerchantConfig['logConfiguration']): void;
+
+  getDefaultHeaders(): MerchantConfig['defaultHeaders'];
+
+  setDefaultHeaders(defaultHeaders: MerchantConfig['defaultHeaders']): void;
+
+  runEnvironmentCheck(logger: Logger): void;
+
+  //This method is for fallback
+  defaultPropValues(): void;
+
+  /**
+   * This method is to log all merchantConfig properties
+   * excluding HideMerchantConfigProperties defined in Constants
+   *
+   * @param {*} merchantConfig
+   */
+  getAllProperties(
+    merchantConfig,
+  ): Exclude<
+    MerchantConfig,
+    | 'merchantID'
+    | 'merchantsecretKey'
+    | 'merchantKeyId'
+    | 'keyAlias'
+    | 'keyPass'
+    | 'requestJsonData'
+  >;
+};
diff --git a/src/authentication/logging/ExternalLoggerWrapper.d.ts b/src/authentication/logging/ExternalLoggerWrapper.d.ts
new file mode 100644
index 00000000..2d17b9f8
--- /dev/null
+++ b/src/authentication/logging/ExternalLoggerWrapper.d.ts
@@ -0,0 +1,14 @@
+import type { Logger } from 'winston';
+
+export = class ExternalLoggerWrapper {
+  private extLogger: Pick<
+    Logger,
+    'error' | 'warn' | 'info' | 'debug' | 'verbose' | 'silly'
+  >;
+
+  constructor(extLogger: ExternalLoggerWrapper['extLogger']);
+
+  getLogger(): ExternalLoggerWrapper['extLogger'];
+
+  isLoggerEmpty(): boolean;
+};
diff --git a/src/authentication/logging/LogConfiguration.d.ts b/src/authentication/logging/LogConfiguration.d.ts
new file mode 100644
index 00000000..0440c860
--- /dev/null
+++ b/src/authentication/logging/LogConfiguration.d.ts
@@ -0,0 +1,71 @@
+import ExternalLoggerWrapper from './ExternalLoggerWrapper';
+
+export interface LogConfigurationOptions {
+  enableLog?: boolean;
+  logDirectory?: string;
+  logFileName?: string;
+  logFileMaxSize?: string;
+  loggingLevel?: string;
+  maxLogFiles?: string;
+  enableMasking?: boolean;
+  hasExternalLogger?: boolean;
+  externalLogger?: ExternalLoggerWrapper;
+}
+
+export = class LogConfiguration {
+  enableLog: boolean;
+  logDirectory: string;
+  logFileName: string;
+  logFileMaxSize: string;
+  loggingLevel: string;
+  maxLogFiles: string;
+  enableMasking: boolean;
+  hasExternalLogger: boolean;
+  externalLogger?: ExternalLoggerWrapper;
+
+  constructor(logConfig?: LogConfigurationOptions);
+
+  isLogEnabled(): LogConfiguration['enableLog'];
+
+  setLogEnable(enableLogValue: LogConfiguration['enableLog']): void;
+
+  isMaskingEnabled(): LogConfiguration['isMaskingEnabled'];
+
+  setMaskingEnabled(
+    enableMaskingValue: LogConfiguration['isMaskingEnabled'],
+  ): void;
+
+  setHasExternalLogger(
+    hasExternalLogger: LogConfiguration['hasExternalLogger'],
+  ): void;
+
+  isExternalLoggerSet(): LogConfiguration['hasExternalLogger'];
+
+  setExternalLogger(externalLogger: LogConfiguration['externalLogger']): void;
+
+  getExternalLogger(): LogConfiguration['externalLogger'];
+
+  getLogDirectory(): LogConfiguration['logDirectory'];
+
+  setLogDirectory(logDirectoryValue: LogConfiguration['logDirectory']): void;
+
+  getLogFileName(): LogConfiguration['logFileName'];
+
+  setLogFileName(logFileNameValue: LogConfiguration['logFileName']): void;
+
+  getLogFileMaxSize(): LogConfiguration['logFileMaxSize'];
+
+  setLogFileMaxSize(
+    logFileMaxSizeValue: LogConfiguration['logFileMaxSize'],
+  ): void;
+
+  getLoggingLevel(): LogConfiguration['loggingLevel'];
+
+  setLoggingLevel(loggingLevelValue: LogConfiguration['loggingLevel']): void;
+
+  getMaxLogFiles(): LogConfiguration['maxLogFiles'];
+
+  setMaxLogFiles(maxLogFilesValue: LogConfiguration['maxLogFiles']): void;
+
+  getDefaultLoggingProperties(warningMessage: string): void;
+};
diff --git a/src/authentication/logging/LogConfiguration.js b/src/authentication/logging/LogConfiguration.js
index a79968ca..77051d63 100644
--- a/src/authentication/logging/LogConfiguration.js
+++ b/src/authentication/logging/LogConfiguration.js
@@ -16,15 +16,15 @@ class LogConfiguration {
     externalLogger;
 
     constructor(logConfig) {
-        this.setLogEnable(logConfig.enableLog);
-        this.setLogDirectory(logConfig.logDirectory);
-        this.setLogFileName(logConfig.logFileName);
-        this.setLogFileMaxSize(logConfig.logFileMaxSize);
-        this.setLoggingLevel(logConfig.loggingLevel);
-        this.setMaxLogFiles(logConfig.maxLogFiles);
-        this.setMaskingEnabled(logConfig.enableMasking);
-        this.setHasExternalLogger(logConfig.hasExternalLogger);
-        this.setExternalLogger(logConfig.externalLogger);
+        this.setLogEnable(logConfig?.enableLog);
+        this.setLogDirectory(logConfig?.logDirectory);
+        this.setLogFileName(logConfig?.logFileName);
+        this.setLogFileMaxSize(logConfig?.logFileMaxSize);
+        this.setLoggingLevel(logConfig?.loggingLevel);
+        this.setMaxLogFiles(logConfig?.maxLogFiles);
+        this.setMaskingEnabled(logConfig?.enableMasking);
+        this.setHasExternalLogger(logConfig?.hasExternalLogger);
+        this.setExternalLogger(logConfig?.externalLogger);
     }
 
     isLogEnabled() {
diff --git a/src/authentication/logging/Logger.d.ts b/src/authentication/logging/Logger.d.ts
new file mode 100644
index 00000000..aedef29b
--- /dev/null
+++ b/src/authentication/logging/Logger.d.ts
@@ -0,0 +1,8 @@
+import MerchantConfig from '../core/MerchantConfig';
+import { Logger } from 'winston';
+import { LiteralUnion } from 'type-fest';
+
+export function getLogger(
+  merchantConfig: MerchantConfig,
+  loggerCategory: LiteralUnion<string, 'UnknownCategoryLogger'>,
+): Logger;
diff --git a/src/authentication/logging/Logger.js b/src/authentication/logging/Logger.js
index 0b7679b9..55366224 100644
--- a/src/authentication/logging/Logger.js
+++ b/src/authentication/logging/Logger.js
@@ -23,9 +23,6 @@ exports.getLogger = function (merchantConfig, loggerCategory = 'UnknownCategoryL
   }
   var enableLog = merchantConfig.getLogConfiguration().isLogEnabled();
   var enableMasking = merchantConfig.getLogConfiguration().isMaskingEnabled();
-  var loggerCategoryRandomiser = Math.floor(Math.random() * (1000000000 - 100 + 1)) + 100;
-
-  loggerCategory = loggerCategory + loggerCategoryRandomiser;
 
   var newLogger;
 
diff --git a/src/authentication/util/PropertiesUtil.js b/src/authentication/util/PropertiesUtil.js
index 86d6ae93..622c8cee 100644
--- a/src/authentication/util/PropertiesUtil.js
+++ b/src/authentication/util/PropertiesUtil.js
@@ -2,7 +2,6 @@
 
 var fs = require('fs');
 var Constants = require('./Constants');
-var Promise = require('promise');
 var path = require('path');
 
 /*Method for reading json config file */
diff --git a/src/authentication/util/Utility.js b/src/authentication/util/Utility.js
index 7f7b0f43..f1d7512d 100644
--- a/src/authentication/util/Utility.js
+++ b/src/authentication/util/Utility.js
@@ -2,6 +2,10 @@
 
 var Constants = require('./Constants')
 
+/**
+ * @param {string | { toString: () => any; }} responseCode
+ * @returns {string}
+ */
 exports.getResponseCodeMessage = function (responseCode) {
 
     var tempResponseCode = responseCode.toString();