@gofynd/fdk-client-javascript 0.1.35

package/sdk/common/RequestSigner.js

@@ -0,0 +1,306 @@
+"use strict";
+
+const url = require("url");
+const querystring = require("query-string");
+const sha256 = require("crypto-js/sha256");
+const hmacSHA256 = require("crypto-js/hmac-sha256");
+
+function hmac(key, string, encoding) {
+  return hmacSHA256(string, key).toString();
+}
+function hash(string, encoding) {
+  return sha256(string).toString();
+}
+
+// This function assumes the string has already been percent encoded
+function encodeRfc3986(urlEncodedString) {
+  return urlEncodedString.replace(/[!'()*]/g, function (c) {
+    return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+  });
+}
+
+function encodeRfc3986Full(str) {
+  return str;
+  // return encodeRfc3986(encodeURIComponent(str));
+}
+
+const HEADERS_TO_IGNORE = {
+  authorization: true,
+  connection: true,
+  "x-amzn-trace-id": true,
+  "user-agent": true,
+  expect: true,
+  "presigned-expires": true,
+  range: true,
+};
+
+const HEADERS_TO_INCLUDE = ["x-fp-.*", "host"];
+
+// request: { path | body, [host], [method], [headers], [service], [region] }
+class RequestSigner {
+  constructor(request) {
+    if (typeof request === "string") {
+      request = url.parse(request);
+    }
+
+    let headers = (request.headers = request.headers || {});
+    this.request = request;
+
+    if (!request.method && request.body) {
+      request.method = "POST";
+    }
+
+    if (!headers.Host && !headers.host) {
+      headers.Host = request.hostname || request.host;
+
+      // If a port is specified explicitly, use it as is
+      if (request.port) {
+        headers.Host += ":" + request.port;
+      }
+    }
+    if (!request.hostname && !request.host) {
+      request.hostname = headers.Host || headers.host;
+    }
+  }
+
+  prepareRequest() {
+    this.parsePath();
+
+    let request = this.request;
+    let headers = request.headers;
+    let query;
+
+    if (request.signQuery) {
+      this.parsedPath.query = query = this.parsedPath.query || {};
+
+      if (query["x-fp-date"]) {
+        this.datetime = query["x-fp-date"];
+      } else {
+        query["x-fp-date"] = this.getDateTime();
+      }
+    } else {
+      if (!request.doNotModifyHeaders) {
+        if (headers["x-fp-date"]) {
+          this.datetime = headers["x-fp-date"] || headers["x-fp-date"];
+        } else {
+          headers["x-fp-date"] = this.getDateTime();
+        }
+      }
+
+      delete headers["x-fp-signature"];
+      delete headers["X-Fp-Signature"];
+    }
+  }
+
+  sign() {
+    if (!this.parsedPath) {
+      this.prepareRequest();
+    }
+    if (this.request.signQuery) {
+      this.parsedPath.query["x-fp-signature"] = this.signature();
+    } else {
+      this.request.headers["x-fp-signature"] = this.signature();
+    }
+    this.request.path = this.formatPath();
+    return this.request;
+  }
+
+  getDateTime() {
+    if (!this.datetime) {
+      let headers = this.request.headers;
+      let date = new Date(headers.Date || headers.date || new Date());
+
+      this.datetime = date.toISOString().replace(/[:\-]|\.\d{3}/g, "");
+    }
+    return this.datetime;
+  }
+
+  getDate() {
+    return this.getDateTime().substr(0, 8);
+  }
+
+  signature() {
+    let kCredentials = "1234567";
+    let strTosign = this.stringToSign();
+    // console.log(strTosign);
+    return `v1.1:${hmac(kCredentials, strTosign, "hex")}`;
+  }
+
+  stringToSign() {
+    return [this.getDateTime(), hash(this.canonicalString(), "hex")].join("\n");
+  }
+
+  canonicalString() {
+    if (!this.parsedPath) {
+      this.prepareRequest();
+    }
+
+    let pathStr = this.parsedPath.path;
+    let query = this.parsedPath.query;
+    let headers = this.request.headers;
+    let queryStr = "";
+    let normalizePath = true;
+    let decodePath = this.request.doNotEncodePath;
+    let decodeSlashesInPath = false;
+    let firstValOnly = false;
+    let bodyHash = hash(this.request.body || "", "hex");
+    if (query) {
+      let reducedQuery = Object.keys(query).reduce(function (obj, key) {
+        if (!key) {
+          return obj;
+        }
+        obj[encodeRfc3986Full(key)] = !Array.isArray(query[key])
+          ? query[key]
+          : firstValOnly
+          ? query[key][0]
+          : query[key];
+        return obj;
+      }, {});
+      let encodedQueryPieces = [];
+      Object.keys(reducedQuery)
+        .sort()
+        .forEach(function (key) {
+          if (!Array.isArray(reducedQuery[key])) {
+            encodedQueryPieces.push(
+              key + "=" + encodeRfc3986Full(reducedQuery[key])
+            );
+          } else {
+            reducedQuery[key]
+              .map(encodeRfc3986Full)
+              .sort()
+              .forEach(function (val) {
+                encodedQueryPieces.push(key + "=" + val);
+              });
+          }
+        });
+      queryStr = encodedQueryPieces.join("&");
+    }
+    if (pathStr !== "/") {
+      if (normalizePath) {
+        pathStr = pathStr.replace(/\/{2,}/g, "/");
+      }
+      pathStr = pathStr
+        .split("/")
+        .reduce(function (path, piece) {
+          if (normalizePath && piece === "..") {
+            path.pop();
+          } else if (!normalizePath || piece !== ".") {
+            if (decodePath)
+              piece = decodeURIComponent(piece.replace(/\+/g, " "));
+            path.push(encodeRfc3986Full(piece));
+          }
+          return path;
+        }, [])
+        .join("/");
+      if (pathStr[0] !== "/") pathStr = "/" + pathStr;
+      if (decodeSlashesInPath) pathStr = pathStr.replace(/%2F/g, "/");
+    }
+
+    let canonicalReq = [
+      this.request.method || "GET",
+      pathStr,
+      queryStr,
+      this.canonicalHeaders() + "\n",
+      this.signedHeaders(),
+      bodyHash,
+    ].join("\n");
+    return canonicalReq;
+  }
+
+  canonicalHeaders() {
+    let headers = this.request.headers;
+
+    function trimAll(header) {
+      return header.toString().trim().replace(/\s+/g, " ");
+    }
+    return Object.keys(headers)
+      .filter(function (key) {
+        let notInIgnoreHeader = HEADERS_TO_IGNORE[key.toLowerCase()] == null;
+        if (notInIgnoreHeader) {
+          let foundMatch = false;
+          for (let t in HEADERS_TO_INCLUDE) {
+            foundMatch =
+              foundMatch || new RegExp(HEADERS_TO_INCLUDE[t], "ig").test(key);
+          }
+          return foundMatch;
+        } else {
+          return false;
+        }
+      })
+      .sort(function (a, b) {
+        return a.toLowerCase() < b.toLowerCase() ? -1 : 1;
+      })
+      .map(function (key) {
+        return key.toLowerCase() + ":" + trimAll(headers[key]);
+      })
+      .join("\n");
+  }
+
+  signedHeaders() {
+    return Object.keys(this.request.headers)
+      .map(function (key) {
+        return key.toLowerCase();
+      })
+      .filter(function (key) {
+        let notInIgnoreHeader = HEADERS_TO_IGNORE[key.toLowerCase()] == null;
+        if (notInIgnoreHeader) {
+          let foundMatch = false;
+          for (let t in HEADERS_TO_INCLUDE) {
+            foundMatch =
+              foundMatch || new RegExp(HEADERS_TO_INCLUDE[t], "ig").test(key);
+          }
+          return foundMatch;
+        } else {
+          return false;
+        }
+      })
+      .sort()
+      .join(";");
+  }
+
+  parsePath() {
+    let path = this.request.path || "/";
+    let queryIx = path.indexOf("?");
+    let query = null;
+
+    if (queryIx >= 0) {
+      query = querystring.parse(path.slice(queryIx + 1));
+      path = path.slice(0, queryIx);
+    }
+    path = path
+      .split("/")
+      .map((t) => {
+        return encodeURIComponent(decodeURIComponent(t));
+      })
+      .join("/");
+
+    this.parsedPath = {
+      path: path,
+      query: query,
+    };
+  }
+
+  formatPath() {
+    let path = this.parsedPath.path;
+    let query = this.parsedPath.query;
+
+    if (!query) {
+      return path;
+    }
+
+    // Services don't support empty query string keys
+    if (query[""] != null) {
+      delete query[""];
+    }
+
+    return path + "?" + encodeRfc3986(querystring.stringify(query));
+  }
+}
+
+function sign(request) {
+  return new RequestSigner(request).sign();
+}
+
+module.exports = {
+  sign: sign,
+};

package/sdk/common/Utility.d.ts

@@ -0,0 +1,9 @@
+export function convertActionToUrl(action: any): any;
+export function convertUrlToAction(url: any): {
+    type: string;
+    page: {
+        type: any;
+        query: {};
+        params: {};
+    };
+};

package/sdk/common/Utility.js

@@ -0,0 +1,86 @@
+const utils = require("./utils");
+const Constant = require("./Constant");
+
+function convertUrlToAction(url) {
+  if (url) {
+    const path = utils.trimChar(url);
+    const query = utils.getQuery(path);
+    const pathname = utils.validURL(path)
+      ? new URL(path).pathname
+      : path.split("?")[0];
+    const allNavigations = Object.assign({}, Constant.NAVIGATORS);
+    const typeLink = {};
+    for (nav in allNavigations) {
+      let { link, params } = allNavigations[nav];
+      typeLink[link] = nav;
+      if (params) {
+        params.forEach((param) => {
+          if (param.required == false) {
+            let modifiedLink = link.slice(0, link.indexOf(param.key) - 1);
+            typeLink[modifiedLink] = nav;
+          }
+        });
+      }
+    }
+    const allLinks = Object.keys(typeLink);
+    allLinks.sort(function (a, b) {
+      return b.length - a.length;
+    });
+    const bestMatchingLink = utils.findBestMatchingLink(allLinks, pathname);
+    const closestMatchingNavLink = Object.keys(typeLink).find((pageType) => {
+      return utils.trimChar(pageType) === bestMatchingLink.value;
+    });
+    const closestMatchingNavKey = typeLink[closestMatchingNavLink];
+    if (!closestMatchingNavKey) {
+      closestMatchingNavKey = "home";
+    }
+    return {
+      type: "page",
+      page: {
+        type: closestMatchingNavKey,
+        query: query,
+        params: bestMatchingLink.params,
+      },
+    };
+  } else {
+    return {
+      type: "page",
+      page: {
+        type: "home",
+        query: {},
+        params: {},
+      },
+    };
+  }
+}
+
+function convertActionToUrl(action) {
+  if (action && action.page && action.page.type) {
+    switch (action.type) {
+      case utils.NAV_TYPE.PAGE: {
+        const item = Object.assign({}, Constant.NAVIGATORS[action.page.type]);
+        if (item) {
+          //get param
+          item.link = utils.generateUrlWithParams(item, action.page.params);
+          //get query
+          if (action.page.query && Object.keys(action.page.query).length > 0) {
+            item.link +=
+              "/?" + utils.transformRequestOptions(action.page.query);
+          }
+          return item.link;
+        }
+        return "";
+      }
+      case utils.NAV_TYPE.POPUP: {
+        break;
+      }
+    }
+  } else {
+    return "";
+  }
+}
+
+module.exports = {
+  convertActionToUrl,
+  convertUrlToAction,
+};

package/sdk/common/utils.d.ts

@@ -0,0 +1,14 @@
+export function transformRequestOptions(params: any): string;
+export function getParamsFromItem(params: any): string;
+export function getQuery(path: any): {};
+export function trimChar(string?: string, charToRemove?: string): string;
+export function generateUrlWithParams(item: {}, params: any): string;
+export function findBestMatchingLink(allLinks?: any[], pathname?: string): {
+    value: string;
+    params: {};
+};
+export function validURL(str: any): boolean;
+export namespace NAV_TYPE {
+    const PAGE: string;
+    const POPUP: string;
+}

package/sdk/common/utils.js

@@ -0,0 +1,165 @@
+const SLUG_DELIMETER = ":::";
+const transformRequestOptions = (params) => {
+  let options = "";
+
+  for (const key in params) {
+    if (typeof params[key] !== "object" && params[key]) {
+      const encodeVal = encodeURIComponent(params[key]);
+      options += `${key}=${encodeVal}&`;
+    } else if (Array.isArray(params[key])) {
+      params[key].forEach((el) => {
+        const encodeVal = encodeURIComponent(el);
+        options += `${key}=${encodeVal}&`;
+      });
+    } else if (typeof params[key] === "object" && params[key]) {
+      options += transformRequestOptions(params[key]);
+    }
+  }
+  return options ? options.slice(0, -1) : options;
+};
+
+const getParamsFromItem = (params) => {
+  let strParam = "";
+  for (let key in params) {
+    if (Array.isArray(params[key])) {
+      for (let index = 0; index < params[key].length; index++) {
+        strParam +=
+          index === params[key].length - 1
+            ? params[key][index]
+            : params[key][index] + SLUG_DELIMETER;
+      }
+      return strParam;
+    }
+  }
+  return strParam;
+};
+const generateUrlWithParams = (item = {}, params) => {
+  if (!item || !item.link) return "";
+  if (!params) return `/${trimChar(item.link.split(":")[0])}`;
+  const joinedParamsObj = {};
+  for (let key in params) {
+    if (Array.isArray(params[key])) {
+      let joinedParams = "";
+      for (let index = 0; index < params[key].length; index++) {
+        joinedParams +=
+          index === params[key].length - 1
+            ? params[key][index]
+            : params[key][index] + SLUG_DELIMETER;
+      }
+      joinedParamsObj[key] = joinedParams;
+    }
+  }
+  item.link = trimChar(item.link);
+
+  let linkArr = item.link.split("/");
+  let url = "";
+  for (let linkSubString of linkArr) {
+    if (linkSubString.startsWith(":")) {
+      linkSubString = linkSubString.slice(1);
+      url += `${joinedParamsObj[linkSubString]}`;
+    } else url += `${linkSubString}`;
+    url += "/";
+  }
+  url = trimChar(url);
+  return `/${url}`;
+};
+const getQuery = (path) => {
+  let parseUrl = path.split("?");
+  if (parseUrl.length > 1) {
+    const searchParams = new URLSearchParams(parseUrl[1]);
+    let queryResult = {};
+    for (let item of searchParams) {
+      let key = item[0],
+        value = item[1];
+
+      queryResult[key] = queryResult[key]
+        ? [...queryResult[key], value]
+        : [value];
+    }
+    return queryResult;
+  }
+  return {};
+};
+const trimChar = (string = "", charToRemove = "/") => {
+  while (string.charAt(0) == charToRemove) {
+    string = string.substring(1);
+  }
+
+  while (string.charAt(string.length - 1) == charToRemove) {
+    string = string.substring(0, string.length - 1);
+  }
+
+  return string;
+};
+
+function validURL(str) {
+  var pattern = new RegExp(
+    "^(https?:\\/\\/)?" + // protocol
+      "((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|" + // domain name
+      "((\\d{1,3}\\.){3}\\d{1,3}))" + // OR ip (v4) address
+      "(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*" + // port and path
+      "(\\?[;&a-z\\d%_.~+=-]*)?" + // query string
+      "(\\#[-a-z\\d_]*)?$",
+    "i"
+  ); // fragment locator
+  return !!pattern.test(str);
+}
+
+const findBestMatchingLink = (allLinks = [], pathname = "/") => {
+  let bestMatch = { value: "", params: {} };
+  pathname = trimChar(pathname); // -> product/test-product-tag/reviews
+  for (let i = 0; i < allLinks.length; i++) {
+    let link = trimChar(allLinks[i]); // -> product/:slug/add-reviews
+    if (new RegExp(`^${trimChar(link)}`).test(pathname)) {
+      bestMatch.value = link;
+      break;
+    }
+    const linkArr = link.split("/"); // -> [ 'product', ':slug', 'add-reviews' ]
+    const pathArr = pathname.split("/"); // -> [ 'product', 'test-product-tag', 'reviews' ]
+    if (linkArr.length === pathArr.length) {
+      // some match
+      let j;
+      bestMatch = { value: "", params: {} };
+      for (j = 0; j < linkArr.length; ++j) {
+        if (linkArr[j].startsWith(":")) {
+          // this will be :slug & test-slug
+          let arrParams = [];
+          if (pathArr[j].includes(SLUG_DELIMETER)) {
+            // if link container multiple path params eg test-slug--test-slug-123
+            arrParams = pathArr[j].split(SLUG_DELIMETER); // split it into array
+          } else arrParams = [pathArr[j]]; // else assign
+          if (bestMatch.params[linkArr[j].slice(1)]) {
+            // if params is already present in best match object spread new params
+            arrParams = [
+              ...bestMatch.params[linkArr[j].slice(1)],
+              ...arrParams,
+            ];
+          }
+          bestMatch.params[linkArr[j].slice(1)] = arrParams; // else assign
+        } else if (linkArr[j] !== pathArr[j]) break; // if path and link params not match and are not :slug type break and move to next link
+      }
+      if (j === linkArr.length) {
+        // if all paths match and j is not 0 coz 'about-us' & 'notification' have same length and in that case j will be 0. This type of matching is handled in Regex on line #100
+        bestMatch.value = link;
+        break;
+      }
+    }
+  }
+  return bestMatch;
+};
+
+const NAV_TYPE = {
+  PAGE: "page",
+  POPUP: "popup",
+};
+
+module.exports = {
+  transformRequestOptions,
+  getParamsFromItem,
+  getQuery,
+  trimChar,
+  generateUrlWithParams,
+  findBestMatchingLink,
+  validURL,
+  NAV_TYPE,
+};

package/sdk/platform/OAuthClient.d.ts

@@ -0,0 +1,26 @@
+export = OAuthClient;
+declare class OAuthClient {
+    constructor(config: any);
+    config: any;
+    token: any;
+    refreshToken: any;
+    retryOAuthTokenTimer: NodeJS.Timeout;
+    raw_token: any;
+    token_expires_in: any;
+    token_expires_at: number;
+    useAutoRenewTimer: any;
+    getAccessToken(): Promise<any>;
+    isTokenExpired(ttl?: number): boolean;
+    setToken(token: any): void;
+    retryOAuthToken(expires_in: any): void;
+    startAuthorization(options: any): string;
+    verifyCallback(query: any): Promise<void>;
+    renewAccessToken(isOfflineToken?: boolean): Promise<any>;
+    getAccesstokenObj({ grant_type, refresh_token, code }: {
+        grant_type: any;
+        refresh_token: any;
+        code: any;
+    }): Promise<any>;
+    getOfflineAccessToken(scopes: any, code: any): Promise<any>;
+    getOfflineAccessTokenObj(scopes: any, code: any): Promise<any>;
+}