@gofynd/fdk-client-javascript 1.0.4 → 1.1.1

package/sdk/common/BaseOAuthClient.d.ts

@@ -0,0 +1,17 @@
+export = BaseOAuthClient;
+declare class BaseOAuthClient {
+    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;
+    renewAccessToken(): Promise<void>;
+}

package/sdk/common/BaseOAuthClient.js

@@ -0,0 +1,67 @@
+const { Logger } = require("./Logger");
+
+class BaseOAuthClient {
+  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.token_expires_at = token.expires_at || this.token_expires_at;
+    this.refreshToken = token.refresh_token ? token.refresh_token : null;
+    if (this.refreshToken && this.useAutoRenewTimer) {
+      this.retryOAuthToken(token.expires_in);
+    }
+  }
+
+  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);
+    }
+  }
+
+  async renewAccessToken() {
+    // Impementation to renew Access Token
+  }
+}
+
+module.exports = BaseOAuthClient;

package/sdk/common/Constant.d.ts

@@ -20,8 +20,6 @@ export namespace AVAILABLE_PAGE_TYPE {
     const PAGE: string;
     const POLICY: string;
     const PRODUCT: string;
-    const PRODUCT_REVIEWS: string;
-    const ADD_PRODUCT_REVIEW: string;
     const PRODUCT_REQUEST: string;
     const PRODUCTS: string;
     const PROFILE: string;
@@ -168,22 +166,6 @@ export const NAVIGATORS: {
             required: boolean;
         }[];
     };
-    "product-reviews": {
-        name: string;
-        link: string;
-        params: {
-            key: string;
-            required: boolean;
-        }[];
-    };
-    "add-product-review": {
-        name: string;
-        link: string;
-        params: {
-            key: string;
-            required: boolean;
-        }[];
-    };
     "product-request": {
         name: string;
         link: string;

package/sdk/common/Constant.js

@@ -20,8 +20,6 @@ const AVAILABLE_PAGE_TYPE = {
   PAGE: "page",
   POLICY: "policy",
   PRODUCT: "product",
-  PRODUCT_REVIEWS: "product-reviews",
-  ADD_PRODUCT_REVIEW: "add-product-review",
   PRODUCT_REQUEST: "product-request",
   PRODUCTS: "products",
   PROFILE: "profile",
@@ -189,26 +187,6 @@ const NAVIGATORS = {
       },
     ],
   },
-  "product-reviews": {
-    name: "Product Reviews",
-    link: "/product/:slug/reviews",
-    params: [
-      {
-        key: "slug",
-        required: true,
-      },
-    ],
-  },
-  "add-product-review": {
-    name: "Add Product review",
-    link: "/product/:slug/add-review",
-    params: [
-      {
-        key: "slug",
-        required: true,
-      },
-    ],
-  },
   "product-request": {
     name: "Product Request",
     link: "/product-request/",

package/sdk/common/RequestSigner.js

@@ -1,6 +1,5 @@
 "use strict";
 
-const url = require("url");
 const querystring = require("query-string");
 const sha256 = require("crypto-js/sha256");
 const hmacSHA256 = require("crypto-js/hmac-sha256");
@@ -39,10 +38,6 @@ 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;
 

package/sdk/partner/OAuthClient.d.ts

@@ -0,0 +1,14 @@
+export = OAuthClient;
+declare class OAuthClient extends BaseOAuthClient {
+    startAuthorization(options: any): string;
+    verifyCallback(query: any): Promise<void>;
+    renewAccessToken(isOfflineToken?: boolean): Promise<any>;
+    getNewAccessToken(): Promise<any>;
+    getAccesstokenObj({ grant_type, client_id, client_secret, scope }: {
+        grant_type: any;
+        client_id: any;
+        client_secret: any;
+        scope: any;
+    }): Promise<any>;
+}
+import BaseOAuthClient = require("../common/BaseOAuthClient");

package/sdk/partner/OAuthClient.js

@@ -0,0 +1,112 @@
+const { fdkAxios } = require("../common/AxiosHelper");
+const { FDKTokenIssueError } = require("../common/FDKError");
+const { Logger } = require("../common/Logger");
+const BaseOAuthClient = require("../common/BaseOAuthClient");
+const querystring = require("querystring");
+const { sign } = require("../common/RequestSigner");
+
+class OAuthClient extends BaseOAuthClient {
+  constructor(config) {
+    super(config);
+  }
+
+  startAuthorization(options) {
+    Logger({ type: "DEBUG", 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",
+      extension_id: this.config.extensionId,
+    };
+    const queryString = querystring.stringify(query);
+
+    let reqPath = `/service/panel/authentication/v1.0/organization/${this.config.organizationId}/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: "DEBUG", 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,
+      });
+      res.expires_at =
+        res.expires_at || new Date().getTime() + res.expires_in * 1000;
+      this.setToken(res);
+    } catch (error) {
+      if (error.isAxiosError) {
+        throw new FDKTokenIssueError(error.message);
+      }
+      throw error;
+    }
+  }
+
+  async renewAccessToken(isOfflineToken = true) {
+    if (isOfflineToken) {
+      await this.getNewAccessToken();
+    } else {
+      res = await this.getAccesstokenObj({
+        grant_type: "refresh_token",
+        refresh_token: this.refreshToken,
+      });
+      res.expires_at =
+        res.expires_at || new Date().getTime() + res.expires_in * 1000;
+      this.setToken(res);
+      return res;
+    }
+  }
+
+  async getNewAccessToken() {
+    try {
+      let res = await this.getAccesstokenObj({
+        grant_type: "client_credentials",
+        client_id: this.config.apiKey,
+        client_secret: this.config.apiSecret,
+        scope: this.config.scope,
+      });
+      res.expires_at =
+        res.expires_at || new Date().getTime() + res.expires_in * 1000;
+      this.setToken(res);
+      return this.token;
+    } catch (error) {
+      if (error.isAxiosError) {
+        throw new FDKTokenIssueError(error.message);
+      }
+      throw error;
+    }
+  }
+
+  async getAccesstokenObj({ grant_type, client_id, client_secret, scope }) {
+    Logger({ type: "DEBUG", message: "Processing Access token object..." });
+    let reqData = {
+      grant_type: grant_type,
+      client_id,
+      client_secret,
+      scope,
+    };
+    let url = `${this.config.domain}/service/panel/authentication/v1.0/organization/${this.config.organizationId}/oauth/token`;
+    return fdkAxios.post(url, reqData);
+  }
+}
+
+module.exports = OAuthClient;

package/sdk/{APIClient.d.ts → partner/PartnerAPIClient.d.ts}

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

package/sdk/{APIClient.js → partner/PartnerAPIClient.js}

@@ -8,9 +8,8 @@ class APIClient {
    * @param {object} query
    * @param {object} body
    */
-
-  static execute(conf, method, url, query, body, xHeaders) {
-    let headers = {};
+  static async execute(conf, method, url, query, body) {
+    const token = await conf.oauthClient.getNewAccessToken();
 
     const extraHeaders = conf.extraHeaders.reduce((acc, curr) => {
       acc = { ...acc, ...curr };
@@ -18,18 +17,26 @@ class APIClient {
     }, {});
 
     const rawRequest = {
+      baseURL: conf.domain,
       method: method,
       url: url,
       params: query,
       data: body,
       headers: {
-        ...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;

package/sdk/{Client.d.ts → partner/PartnerClient.d.ts}

@@ -1,5 +1,5 @@
-export = Client;
-declare class Client {
+export = PartnerClient;
+declare class PartnerClient {
     constructor(config: any);
     config: any;
     setExtraHeaders(header: any): void;

package/sdk/{Client.js → partner/PartnerClient.js}

@@ -1,6 +1,6 @@
 const { FDKClientValidationError } = require("../common/FDKError");
 
-class Client {
+class PartnerClient {
   constructor(config) {
     this.config = config;
   }
@@ -14,4 +14,4 @@ class Client {
   }
 }
 
-module.exports = Client;
+module.exports = PartnerClient;

package/sdk/partner/PartnerConfig.d.ts

@@ -0,0 +1,30 @@
+export = PartnerConfig;
+declare class PartnerConfig {
+    /**
+     * @param {Object} config
+     * @param {string} config.companyId
+     * @param {string} config.domain
+     * @param {string} config.apiKey
+     * @param {string} config.apiSecret
+     * @param {boolean} config.useAutoRenewTimer
+     */
+    constructor(config: {
+        companyId: string;
+        domain: string;
+        apiKey: string;
+        apiSecret: string;
+        useAutoRenewTimer: boolean;
+    });
+    organizationId: any;
+    domain: string;
+    apiKey: string;
+    apiSecret: string;
+    scope: any;
+    useAutoRenewTimer: boolean;
+    oauthClient: OauthClient;
+    logLevel: any;
+    extraHeaders: any[];
+    setLogLevel(level: any): void;
+    getAccessToken(): Promise<any>;
+}
+import OauthClient = require("./OAuthClient");

package/sdk/partner/PartnerConfig.js

@@ -0,0 +1,39 @@
+const OauthClient = require("./OAuthClient");
+const { setLoggerLevel } = require("../common/Logger");
+
+class PartnerConfig {
+  /**
+   * @param {Object} config
+   * @param {string} config.companyId
+   * @param {string} config.domain
+   * @param {string} config.apiKey
+   * @param {string} config.apiSecret
+   * @param {boolean} config.useAutoRenewTimer
+   */
+  constructor(config) {
+    this.organizationId = config.organizationId;
+    this.domain = config.domain || "https://api.fynd.com";
+    this.apiKey = config.apiKey;
+    this.apiSecret = config.apiSecret;
+    (this.scope = config.scope),
+      (this.useAutoRenewTimer =
+        config.useAutoRenewTimer !== undefined
+          ? config.useAutoRenewTimer
+          : true);
+    this.oauthClient = new OauthClient(this);
+    this.logLevel = config.logLevel || "ERROR";
+    this.setLogLevel(this.logLevel);
+    this.extraHeaders = [];
+  }
+
+  setLogLevel(level) {
+    setLoggerLevel(level);
+  }
+
+  async getAccessToken() {
+    let token = await this.oauthClient.getAccessToken();
+    return token.access_token;
+  }
+}
+
+module.exports = PartnerConfig;

package/sdk/partner/index.d.ts

@@ -0,0 +1,3 @@
+export const PartnerConfig: typeof import("./PartnerConfig");
+export const PartnerClient: typeof import("./PartnerClient");
+export const PartnerModel: {};

package/sdk/partner/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  PartnerConfig: require("./PartnerConfig"),
+  PartnerClient: require("./PartnerClient"),
+  PartnerModel: {},
+};

package/sdk/platform/Billing/BillingPlatformClient.d.ts

@@ -46,6 +46,18 @@ declare class Billing {
         plan: string;
         couponCode: string;
     }): Promise<CheckValidityResponse>;
+    /**
+     * @param {Object} arg - Arg object.
+     * @param {string} arg.extensionId - Extension _id
+     * @param {CreateOneTimeCharge} arg.body
+     * @returns {Promise<CreateOneTimeChargeResponse>} - Success response
+     * @summary: Create one time subscription charge
+     * @description: Register one time subscription charge for a seller of your extension.
+     */
+    createOneTimeCharge({ extensionId, body }?: {
+        extensionId: string;
+        body: CreateOneTimeCharge;
+    }): Promise<CreateOneTimeChargeResponse>;
     /**
      * @param {Object} arg - Arg object.
      * @param {string} arg.extensionId - Extension _id
@@ -58,6 +70,18 @@ declare class Billing {
         extensionId: string;
         body: CreateSubscriptionCharge;
     }): Promise<CreateSubscriptionResponse>;
+    /**
+     * @param {Object} arg - Arg object.
+     * @param {string} arg.extensionId - Extension _id
+     * @param {string} arg.chargeId - Standalone charge _id
+     * @returns {Promise<OneTimeChargeEntity>} - Success response
+     * @summary: Get subscription charge details
+     * @description: Get created subscription charge details
+     */
+    getChargeDetails({ extensionId, chargeId }?: {
+        extensionId: string;
+        chargeId: string;
+    }): Promise<OneTimeChargeEntity>;
     /**
      * @param {Object} arg - Arg object.
      * @returns {Promise<SubscriptionCustomer>} - Success response

package/sdk/platform/Billing/BillingPlatformClient.js

@@ -281,6 +281,73 @@ class Billing {
     return response;
   }
 
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {string} arg.extensionId - Extension _id
+   * @param {CreateOneTimeCharge} arg.body
+   * @returns {Promise<CreateOneTimeChargeResponse>} - Success response
+   * @summary: Create one time subscription charge
+   * @description: Register one time subscription charge for a seller of your extension.
+   */
+  async createOneTimeCharge({ extensionId, body } = {}) {
+    const { error } = BillingValidator.createOneTimeCharge().validate(
+      {
+        extensionId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = BillingValidator.createOneTimeCharge().validate(
+      {
+        extensionId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createOneTimeCharge",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const xHeaders = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "post",
+      `/service/platform/billing/v1.0/company/${this.config.companyId}/extension/${extensionId}/one_time_charge`,
+      query_params,
+      body,
+      xHeaders
+    );
+
+    const {
+      error: res_error,
+    } = BillingModel.CreateOneTimeChargeResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createOneTimeCharge",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.extensionId - Extension _id
@@ -350,6 +417,73 @@ class Billing {
     return response;
   }
 
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {string} arg.extensionId - Extension _id
+   * @param {string} arg.chargeId - Standalone charge _id
+   * @returns {Promise<OneTimeChargeEntity>} - Success response
+   * @summary: Get subscription charge details
+   * @description: Get created subscription charge details
+   */
+  async getChargeDetails({ extensionId, chargeId } = {}) {
+    const { error } = BillingValidator.getChargeDetails().validate(
+      {
+        extensionId,
+        chargeId,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = BillingValidator.getChargeDetails().validate(
+      {
+        extensionId,
+        chargeId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getChargeDetails",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const xHeaders = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/billing/v1.0/company/${this.config.companyId}/extension/${extensionId}/charge/${chargeId}`,
+      query_params,
+      undefined,
+      xHeaders
+    );
+
+    const {
+      error: res_error,
+    } = BillingModel.OneTimeChargeEntity().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getChargeDetails",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
   /**
    * @param {Object} arg - Arg object.
    * @returns {Promise<SubscriptionCustomer>} - Success response

package/sdk/platform/Billing/BillingPlatformModel.d.ts

@@ -5,6 +5,8 @@ declare class BillingModel {
     static CancelSubscriptionRes(): any;
     static ChargeLineItem(): any;
     static CheckValidityResponse(): any;
+    static CreateOneTimeCharge(): any;
+    static CreateOneTimeChargeResponse(): any;
     static CreateSubscriptionCharge(): any;
     static CreateSubscriptionResponse(): any;
     static CurrentPeriod(): any;
@@ -34,6 +36,8 @@ declare class BillingModel {
     static InvoicesDataClient(): any;
     static InvoicesDataPaymentMethod(): any;
     static InvoicesDataPeriod(): any;
+    static OneTimeChargeEntity(): any;
+    static OneTimeChargeItem(): any;
     static Page(): any;
     static Phone(): any;
     static Plan(): any;