@crmcom/self-service-sdk 2.1.2

package/eventListener.js

@@ -0,0 +1,41 @@
+import { logger } from './logger';
+let events = {};
+
+try {
+    // Dynamic import for Vite / ES modules
+    const customConfigModule = import("../../../custom.config");
+    events = customConfigModule.events || {};
+} catch (error) {
+    if (error.code === 'MODULE_NOT_FOUND') {
+        events = {};
+    } else {
+        throw error;
+    }
+}
+
+export const eventListener = {
+    handleEvent,
+};
+
+export const eventTypes = {
+    kochava: 'KOCHAVA',
+};
+
+export async function handleEvent({
+    type,       // eg: 'kochava'
+    code,       // event code
+    data,
+    object_type // object type, e.g., string or object
+}) {
+    logger.debug("handleEvent type:", type);
+    logger.debug("handleEvent code:", code);
+    logger.debug("handleEvent object_type:", object_type);
+    logger.debug("handleEvent data:", data);
+
+    if (type === eventTypes.kochava) {
+        const kochava = events?.kochava ?? null;
+        if (kochava?.sendEvent) {
+            await kochava.sendEvent(object_type, code, data);
+        }
+    }
+}

package/httpBackOfficeUtil.js

@@ -0,0 +1,396 @@
+/**
+ * class to handle HTTP Requests and Token refresh
+ */
+
+//import querystring from 'querystring';
+import { initOptionHeader } from '../../utils/common';
+import {jwtDecode} from 'jwt-decode';
+import { logger } from './logger';
+
+export const httpBackOfficeUtil = {
+  setupChannel,
+  put,
+  post,
+  get,
+  sendDelete,
+  is200OK,
+  startSession,
+  getSession,
+  cleanObj,
+  cleanSession,
+  switchSession
+};
+
+
+/** local variables */
+
+let _storeKVFn;
+let _getKVFn;
+let _sessionInvalidCallback;
+let _fetchFn;
+
+let _apiKey;
+let _accessToken;
+let _refreshToken;
+let _host;
+let _sessionData;
+
+let _selfServicePath = 'self-service';
+let _backofficePath = 'backoffice/v1/';
+/**
+ * 
+ * TODO: do we need a call back for no internet connection ?
+ * when no connection refresh token will not be available -> should not kick user out.
+ */
+
+async function setupChannel({
+  storeKVFn,  //function to store key value
+  getKVFn,    //function to get value by key from the storage
+  sessionInvalidCallback, //function to call when api_key or token key is invalid and refresh token if available was failed
+  apiKey,
+  host,
+  fetchFn
+}) {
+  _storeKVFn = storeKVFn;
+  _getKVFn = getKVFn;
+  _sessionInvalidCallback = sessionInvalidCallback;
+  _apiKey = apiKey;
+  _host = host;
+  if (fetchFn)
+    _fetchFn = fetchFn;
+  else
+    _fetchFn = fetch;
+
+  if (_getKVFn) {
+    _accessToken = await _getKVFn('access_token');
+    _refreshToken = await _getKVFn('refresh_token');
+    try {
+      if (_accessToken) 
+        {
+          _sessionData = jwtDecode(_accessToken);
+          await refreshToken();
+        }
+    }catch (e) {
+      logger.warn('Failed to load session data:', e);  
+      _sessionData = undefined;
+    }
+  }
+  //TODO add silent refresh token here
+}
+
+async function refreshToken() {
+  try {
+    // console.log('Session data:', _sessionData);
+    // console.log('_refreshToken:', _refreshToken);
+    let currentTime = Date.now();
+    let tokenLiveInSec = (_sessionData.exp - currentTime/1000);
+    // console.log("tokenLiveInSec:" + tokenLiveInSec);
+    if (tokenLiveInSec > 60*60)
+      return;
+
+  //try to refresh token
+
+    //console.log('API: ', contact)
+    let response = await post({
+        resourcePath: "users/refresh",
+        refreshToken: true,
+        logOutIfSessionInvalid: false,
+    });
+    if (response.code == "OK") {
+        startSession(response.data);
+        return;
+    }
+    
+  } catch (e) {
+      logger.error("Refresh exception:", e);
+      return;
+  }
+}
+
+function startSession({access_token,refresh_token, exp, organisations}) {
+  //TODO handle expiration
+  _accessToken = access_token;
+  _refreshToken = refresh_token;
+  if (_storeKVFn) {
+    _storeKVFn("refresh_token", refresh_token)
+    _storeKVFn("access_token", access_token)
+    //_storeKVFn("organisations", JSON.stringify(organisations));
+    // _storeKVFn("exp", exp)
+    //parse and store session data
+    _sessionData = jwtDecode(_accessToken);
+      // console.log('Session data:', _sessionData);
+  }
+
+}
+
+
+
+function switchSession({access_token,refresh_token, exp},isMerchant) {
+  _sessionData = jwtDecode(access_token);
+  if(isMerchant){
+    var _sessionServiceOwnerData = jwtDecode(_accessToken);
+    _storeKVFn("merchant_id", _sessionData.current_organisation_id);
+    _storeKVFn("service_owner_id", _sessionServiceOwnerData.current_organisation_id)
+  }else{
+    _storeKVFn("merchant_id", null);
+  }
+
+  startSession({access_token,refresh_token, exp})
+}
+
+function cleanSession() {
+  //TODO handle expiration
+  _accessToken = undefined;
+  _refreshToken = undefined;
+  if (_storeKVFn) {
+    _storeKVFn("refresh_token", undefined)
+    _storeKVFn("access_token", undefined)
+    //parse and store session data
+      logger.debug('Session cleared');
+  }
+
+}
+
+function getSession() {
+  logger.debug("getSession called");
+  return _sessionData;
+}
+
+function getURI(isBackend, resourcePath) {
+  if (isBackend == true)
+    return _host + _backofficePath + resourcePath;
+  else
+    return _host + _selfServicePath + resourcePath;
+}
+
+function json2Obj(str) {
+  try {
+    return JSON.parse(str);
+  }catch (e){
+    return null;
+  }
+}
+async function post({
+  resourcePath,
+  body,
+  queryParams,
+  withAccessToken = false,
+  withoutApikey = false,
+  logOutIfSessionInvalid=true,
+  refreshToken
+}) {
+  // let serverConfig = getServerConfig();
+  // let uri = getURI(isBackend, resourcePath);
+  let uri = _host + 'backoffice/v1/' + resourcePath;
+  var options = {};
+  options.headers = initOptionHeader();
+  options.method = "POST";
+  if (withAccessToken == true || logOutIfSessionInvalid==true || refreshToken==true) {
+    if (refreshToken)
+      options.headers['Authorization'] = 'Bearer ' + _refreshToken;
+    else
+      options.headers['Authorization'] = 'Bearer ' + _accessToken;
+  } else if(!withoutApikey)
+    options.headers['api_key'] = _apiKey;
+
+  // if (refreshToken) {
+  //   options.headers['refresh_token'] = refreshToken;
+  // }
+  if (body)
+    options.body = JSON.stringify(body);
+  if (queryParams)
+    uri = _host + '?' + URLSearchParams(queryParams).toString();
+  logger.debug('POST:', uri);
+  let response = await _fetchFn(uri, options);
+  let bodyText = await response.text()
+  logger.debug('Response:', response.status);
+  if (response.status == '200') {
+    return { code: "OK", data: bodyText ? json2Obj(bodyText) : null };
+  } else
+  {
+    validateForceLogout(response,logOutIfSessionInvalid);
+    return { code: response.status, bodyText: bodyText, error: json2Obj(bodyText) };
+  }
+  
+    
+
+  //TODO: add token expire and validation later 
+  // let accessToken;
+  // if (withAccessToken)
+  // {
+  //   //check if token is not expired
+  // }
+
+}
+
+async function validateForceLogout(response,logOutIfSessionInvalid){
+  try {
+    if (logOutIfSessionInvalid == true && _sessionInvalidCallback && response.status == '401'){
+      await _sessionInvalidCallback();
+      cleanSession();
+    }      
+  }catch (e) {
+    logger.error(e);
+  }
+}
+
+async function get({
+  resourcePath,
+  queryParams,
+  withAccessToken = false,
+  isBackend = true,
+  logOutIfSessionInvalid = true,
+  returnText=false
+}) {
+  let uri = getURI(isBackend, resourcePath);
+  // let uri = _host + 'backoffice/v1/' + resourcePath;
+  var options = {};
+  options.headers = initOptionHeader();
+  options.method = "GET";
+  if (withAccessToken == true || logOutIfSessionInvalid==true)
+    options.headers['Authorization'] = 'Bearer ' + _accessToken;
+  else
+    options.headers['api_key'] = _apiKey;
+
+  if (queryParams)
+  {
+      const queryString = new URLSearchParams(
+      Object.fromEntries(
+          Object.entries(cleanObj(queryParams)).map(([k, v]) => [k, String(v)])
+      )
+      ).toString();
+      uri = uri + '?' + queryString;
+  }
+  logger.debug('GET:', uri);
+  let response = await _fetchFn(uri, options);
+  let bodyText = await response.text()
+  logger.debug('Response:', response.status);
+  if (response.status == '200') {
+    if(returnText)
+      return { code: "OK", data: bodyText};
+    return { code: "OK", data: bodyText ? json2Obj(bodyText) : null };
+  } else
+  {
+    validateForceLogout(response,logOutIfSessionInvalid);
+    return { code: response.status, bodyText: bodyText, error: json2Obj(bodyText) };
+  }
+
+  //TODO: add token expire and validation later 
+  // let accessToken;
+  // if (withAccessToken)
+  // {
+  //   //check if token is not expired
+  // }
+
+}
+
+async function sendDelete({
+  resourcePath,
+  queryParams,
+  withAccessToken = false,
+  isBackend = false,
+  logOutIfSessionInvalid = true
+}) {
+  // let uri = getURI(isBackend, resourcePath);
+  let uri = _host + 'backoffice/v1/' + resourcePath;
+  var options = {};
+  options.headers = initOptionHeader();
+  options.method = "DELETE";
+  if (withAccessToken == true || logOutIfSessionInvalid==true)
+    options.headers['Authorization'] = 'Bearer ' + _accessToken;
+  else
+    options.headers['api_key'] = _apiKey;
+
+  if (queryParams)
+  {
+      const queryString = new URLSearchParams(
+      Object.fromEntries(
+          Object.entries(cleanObj(queryParams)).map(([k, v]) => [k, String(v)])
+      )
+      ).toString();
+      uri = uri + '?' + queryString;
+  }
+  logger.debug('GET:', uri);
+  let response = await _fetchFn(uri, options);
+  let bodyText = await response.text()
+  logger.debug('Response:', response.status);
+  if (response.status == '200') {
+    return { code: "OK", data: bodyText ? json2Obj(bodyText) : null };
+  } else
+  {
+    validateForceLogout(response,logOutIfSessionInvalid);
+    return { code: response.status, bodyText: bodyText, error: json2Obj(bodyText) };
+  }
+
+  //TODO: add token expire and validation later 
+  // let accessToken;
+  // if (withAccessToken)
+  // {
+  //   //check if token is not expired
+  // }
+
+}
+
+async function put({
+  resourcePath,
+  body,
+  queryParams,
+  withAccessToken = false,
+  isBackend = false, 
+  logOutIfSessionInvalid = true
+}) {
+  // let uri = getURI(isBackend, resourcePath);
+  let uri = _host + 'backoffice/v1/' + resourcePath;
+  var options = {};
+  options.headers = initOptionHeader();
+  options.method = "PUT";
+  if (withAccessToken == true || logOutIfSessionInvalid==true)
+    options.headers['Authorization'] = 'Bearer ' + _accessToken;
+  else
+    options.headers['api_key'] = _apiKey;
+
+  if (body)
+    options.body = JSON.stringify(body);
+  if (queryParams)
+    uri = uri + '?' + URLSearchParams(queryParams).toString();
+  logger.debug('PUT:', uri);
+  let response = await _fetchFn(uri, options);
+  let bodyText = await response.text()
+  logger.debug('Response:', response.status);
+  if (response.status == '200') {
+    return { code: "OK", data: bodyText ? json2Obj(bodyText) : null };
+  }
+  else
+  {
+    validateForceLogout(response,logOutIfSessionInvalid);
+    return { code: response.status, bodyText: bodyText, error: json2Obj(bodyText) };
+  }
+
+  //TODO: add token expire and validation later 
+  // let accessToken;
+  // if (withAccessToken)
+  // {
+  //   //check if token is not expired
+  // }
+
+}
+
+async function getAccessToken() {
+
+}
+
+function is200OK(result) {
+  if (result && result.status && result.status == '200')
+    return true;
+  else
+    return false;
+}
+
+function cleanObj(obj) {
+  for (var propName in obj) { 
+    if (obj[propName] === null || obj[propName] === undefined) {
+      delete obj[propName];
+    }
+  }
+  return obj;
+}

package/httpJCCUtil.js

@@ -0,0 +1,61 @@
+import { parseString, processors } from 'xml2js';
+import { logger } from './logger';
+
+// var jccServer = 'https://test-apis.jccsecure.com/JCCLoyaltyService/JCCLoyaltyService?wsdl';
+// var jccServer ='https://test-apis.crm.com/JCCLoyaltyService/JCCLoyaltyService?wsdl'   //uat
+export const jccServer = 'https://apis.jccsecure.com/JCCLoyaltyService/JCCLoyaltyService?wsdl'; // live
+
+export const httpJCCUtil = {
+    post
+};
+
+function createPostOption(payload) {
+    return {
+        headers: {
+            'Content-Type': 'text/xml',
+            strictSSL: true,
+            rejectUnauthorized: false,
+        },
+        body: payload,
+        method: 'POST',
+    };
+}
+
+export async function post(path, payload, urlEndPoint) {
+    const options = createPostOption(payload);
+    options.NODE_TLS_REJECT_UNAUTHORIZED = 0;
+
+    let response;
+    try {
+        response = await fetch(urlEndPoint, options);
+        logger.debug("Response received");
+    } catch (ex) {
+        logger.error("Fetch exception:", ex);
+        return { code: "NETWORK_ISSUE", data: {} };
+    }
+
+    let body;
+    try {
+        body = await response.text();
+        logger.debug("Response body received");
+    } catch (ex) {
+        logger.error("Server unexpected response:", ex);
+        return { code: 'SERVER_UNEXPECTED_ISSUE', data: ex };
+    }
+
+    try {
+        let bodyData = null;
+        parseString(
+            body,
+            { tagNameProcessors: [processors.stripPrefix] },
+            (err, result) => {
+                if (err) throw err;
+                bodyData = result;
+            }
+        );
+        return { code: 'OK', data: bodyData };
+    } catch (ex) {
+        logger.error('XML parse error:', ex);
+        return { code: "CLIENT_UNEXPECTED_ISSUE", data: {} };
+    }
+}