@gofynd/fdk-client-javascript 0.1.35

package/sdk/platform/OAuthClient.js

@@ -0,0 +1,221 @@
+const querystring = require("query-string");
+const { fdkAxios } = require("../common/AxiosHelper");
+const { sign } = require("../common/RequestSigner");
+const { FDKTokenIssueError, FDKOAuthCodeError } = require("../common/FDKError");
+const { Logger } = require("../common/Logger");
+
+const refreshTokenRequestCache = {};
+class OAuthClient {
+  constructor(config) {
+    this.config = config;
+    this.token = null;
+    this.refreshToken = null;
+    this.retryOAuthTokenTimer = null;
+    this.raw_token = null;
+    this.token_expires_in = null;
+    this.token_expires_at = 0;
+    this.useAutoRenewTimer =
+      config.useAutoRenewTimer !== undefined ? config.useAutoRenewTimer : true;
+  }
+
+  async getAccessToken() {
+    if (
+      !this.useAutoRenewTimer &&
+      this.refreshToken &&
+      this.isTokenExpired(120)
+    ) {
+      // Check if token is about to expire in less than 2 mins.
+      // Renew if to be expired and auto renew timer is not enabled.
+      await this.renewAccessToken();
+    }
+    return this.token;
+  }
+
+  // default TTL checked 0 seconds
+  isTokenExpired(ttl = 0) {
+    const currentTimestamp = new Date().getTime();
+    // Check if token is about to expire in less than 2 mins
+    if ((this.token_expires_at - currentTimestamp) / 1000 < ttl) {
+      return true;
+    }
+    return false;
+  }
+
+  setToken(token) {
+    this.raw_token = token;
+    this.token_expires_in = token.expires_in;
+    this.token = token.access_token;
+    this.refreshToken = token.refresh_token ? token.refresh_token : null;
+    if (this.refreshToken && this.useAutoRenewTimer) {
+      this.retryOAuthToken(token.expires_in);
+    }
+    Logger({ type: "INFO", message: "Token set." });
+  }
+
+  retryOAuthToken(expires_in) {
+    Logger({ type: "INFO", message: "Retrying OAuth Token..." });
+    if (this.retryOAuthTokenTimer) {
+      clearTimeout(this.retryOAuthTokenTimer);
+    }
+    if (expires_in > 60) {
+      this.retryOAuthTokenTimer = setTimeout(() => {
+        this.renewAccessToken();
+      }, (expires_in - 60) * 1000);
+    }
+  }
+
+  startAuthorization(options) {
+    Logger({ type: "INFO", message: "Starting Authorization..." });
+    let query = {
+      client_id: this.config.apiKey,
+      scope: options.scope.join(","),
+      redirect_uri: options.redirectUri,
+      state: options.state,
+      access_mode: options.access_mode,
+      response_type: "code",
+    };
+    const queryString = querystring.stringify(query);
+
+    let reqPath = `/service/panel/authentication/v1.0/company/${this.config.companyId}/oauth/authorize?${queryString}`;
+    let signingOptions = {
+      method: "GET",
+      host: new URL(this.config.domain).host,
+      path: reqPath,
+      body: null,
+      headers: {},
+      signQuery: true,
+    };
+    signingOptions = sign(signingOptions);
+    Logger({ type: "INFO", message: "Authorization successful.!" });
+
+    return `${this.config.domain}${signingOptions.path}`;
+  }
+
+  async verifyCallback(query) {
+    if (query.error) {
+      throw new FDKOAuthCodeError(query.error_description, {
+        error: query.error,
+      });
+    }
+
+    try {
+      let res = await this.getAccesstokenObj({
+        grant_type: "authorization_code",
+        code: query.code,
+      });
+      this.setToken(res);
+      this.token_expires_at =
+        new Date().getTime() + this.token_expires_in * 1000;
+    } catch (error) {
+      if (error.isAxiosError) {
+        throw new FDKTokenIssueError(error.message);
+      }
+      throw error;
+    }
+  }
+
+  async renewAccessToken(isOfflineToken = false) {
+    try {
+      Logger({ type: "INFO", message: "Renewing Access token..." });
+      let res;
+      if (isOfflineToken) {
+        let requestCacheKey = `${this.config.apiKey}:${this.config.companyId}`;
+        if (!refreshTokenRequestCache[requestCacheKey]) {
+          refreshTokenRequestCache[requestCacheKey] = this.getAccesstokenObj({
+            grant_type: "refresh_token",
+            refresh_token: this.refreshToken,
+          });
+        }
+        res = await refreshTokenRequestCache[requestCacheKey].finally(() => {
+          delete refreshTokenRequestCache[requestCacheKey];
+        });
+      } else {
+        res = await this.getAccesstokenObj({
+          grant_type: "refresh_token",
+          refresh_token: this.refreshToken,
+        });
+      }
+      this.setToken(res);
+      this.token_expires_at =
+        new Date().getTime() + this.token_expires_in * 1000;
+      Logger({ type: "INFO", message: "Done." });
+      return res;
+    } catch (error) {
+      if (error.isAxiosError) {
+        throw new FDKTokenIssueError(error.message);
+      }
+      throw error;
+    }
+  }
+
+  async getAccesstokenObj({ grant_type, refresh_token, code }) {
+    Logger({ type: "INFO", message: "Processing Access token object..." });
+    let reqData = {
+      grant_type: grant_type,
+    };
+    if (grant_type === "refresh_token") {
+      reqData = { ...reqData, refresh_token };
+    } else if (grant_type === "authorization_code") {
+      reqData = { ...reqData, code };
+    }
+
+    const token = Buffer.from(
+      `${this.config.apiKey}:${this.config.apiSecret}`,
+      "utf8"
+    ).toString("base64");
+    let url = `${this.config.domain}/service/panel/authentication/v1.0/company/${this.config.companyId}/oauth/token`;
+    const rawRequest = {
+      method: "post",
+      url: url,
+      data: querystring.stringify(reqData),
+      headers: {
+        Authorization: `Basic ${token}`,
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+    };
+    Logger({ type: "INFO", message: "Done." });
+    return fdkAxios.request(rawRequest);
+  }
+
+  async getOfflineAccessToken(scopes, code) {
+    try {
+      let res = await this.getOfflineAccessTokenObj(scopes, code);
+      this.setToken(res);
+      this.token_expires_at =
+        new Date().getTime() + this.token_expires_in * 1000;
+      return res;
+    } catch (error) {
+      if (error.isAxiosError) {
+        throw new FDKTokenIssueError(error.message);
+      }
+      throw error;
+    }
+  }
+
+  async getOfflineAccessTokenObj(scopes, code) {
+    let url = `${this.config.domain}/service/panel/authentication/v1.0/company/${this.config.companyId}/oauth/offline-token`;
+    let data = {
+      client_id: this.config.apiKey,
+      client_secret: this.config.apiSecret,
+      grant_type: "authorization_code",
+      scope: scopes,
+      code: code,
+    };
+    const token = Buffer.from(
+      `${this.config.apiKey}:${this.config.apiSecret}`,
+      "utf8"
+    ).toString("base64");
+    const rawRequest = {
+      method: "post",
+      url: url,
+      data: data,
+      headers: {
+        Authorization: `Basic ${token}`,
+        "Content-Type": "application/json",
+      },
+    };
+    return fdkAxios.request(rawRequest);
+  }
+}
+
+module.exports = OAuthClient;

package/sdk/platform/PlatformAPIClient.d.ts

@@ -0,0 +1,12 @@
+export = APIClient;
+declare class APIClient {
+    /**
+     * @param {object} conf
+     * @param {string} method
+     * @param {string} url
+     * @param {object} query
+     * @param {object} body
+     */
+    static execute(conf: object, method: string, url: string, query: object, body: object, xHeaders: any): Promise<any>;
+    get(url: any, config: any): Promise<any>;
+}

package/sdk/platform/PlatformAPIClient.js

@@ -0,0 +1,43 @@
+const { fdkAxios } = require("../common/AxiosHelper");
+
+class APIClient {
+  /**
+   * @param {object} conf
+   * @param {string} method
+   * @param {string} url
+   * @param {object} query
+   * @param {object} body
+   */
+  static async execute(conf, method, url, query, body, xHeaders) {
+    const token = await conf.oauthClient.getAccessToken();
+
+    const extraHeaders = conf.extraHeaders.reduce((acc, curr) => {
+      acc = { ...acc, ...curr };
+      return acc;
+    }, {});
+
+    const rawRequest = {
+      baseURL: conf.domain,
+      method: method,
+      url: url,
+      params: query,
+      data: body,
+      headers: {
+        Authorization: "Bearer " + token,
+        ...extraHeaders,
+        ...xHeaders,
+      },
+    };
+
+    return fdkAxios.request(rawRequest);
+  }
+
+  async get(url, config) {
+    let access_token = await this.configuration.getAccessToken();
+    config = config || {};
+    config.headers = config.headers || {};
+    config.headers.Authorization = "Bearer " + access_token;
+    return axios.get(url);
+  }
+}
+module.exports = APIClient;