@gofynd/fdk-client-javascript 0.1.35

package/sdk/application/models/UserValidator.js

@@ -0,0 +1,233 @@
+const Joi = require("joi");
+const { Validator } = require("../ApplicationModels");
+class UserValidator {
+  static loginWithFacebook() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.OAuthRequestSchema().required(),
+    }).required();
+  }
+
+  static loginWithGoogle() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.OAuthRequestSchema().required(),
+    }).required();
+  }
+
+  static loginWithGoogleAndroid() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.OAuthRequestSchema().required(),
+    }).required();
+  }
+
+  static loginWithGoogleIOS() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.OAuthRequestSchema().required(),
+    }).required();
+  }
+
+  static loginWithAppleIOS() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.OAuthRequestAppleSchema().required(),
+    }).required();
+  }
+
+  static loginWithOTP() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.SendOtpRequestSchema().required(),
+    }).required();
+  }
+
+  static loginWithEmailAndPassword() {
+    return Joi.object({
+      body: Validator.PasswordLoginRequestSchema().required(),
+    }).required();
+  }
+
+  static sendResetPasswordEmail() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.SendResetPasswordEmailRequestSchema().required(),
+    }).required();
+  }
+
+  static sendResetPasswordMobile() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.SendResetPasswordMobileRequestSchema().required(),
+    }).required();
+  }
+
+  static forgotPassword() {
+    return Joi.object({
+      body: Validator.ForgotPasswordRequestSchema().required(),
+    }).required();
+  }
+
+  static sendResetToken() {
+    return Joi.object({
+      body: Validator.CodeRequestBodySchema().required(),
+    }).required();
+  }
+
+  static loginWithToken() {
+    return Joi.object({
+      body: Validator.TokenRequestBodySchema().required(),
+    }).required();
+  }
+
+  static registerWithForm() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.FormRegisterRequestSchema().required(),
+    }).required();
+  }
+
+  static verifyEmail() {
+    return Joi.object({
+      body: Validator.CodeRequestBodySchema().required(),
+    }).required();
+  }
+
+  static verifyMobile() {
+    return Joi.object({
+      body: Validator.CodeRequestBodySchema().required(),
+    }).required();
+  }
+
+  static hasPassword() {
+    return Joi.object({});
+  }
+
+  static updatePassword() {
+    return Joi.object({
+      body: Validator.UpdatePasswordRequestSchema().required(),
+    }).required();
+  }
+
+  static deleteUser() {
+    return Joi.object({
+      body: Validator.DeleteApplicationUserRequestSchema().required(),
+    }).required();
+  }
+
+  static logout() {
+    return Joi.object({});
+  }
+
+  static sendOTPOnMobile() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.SendMobileOtpRequestSchema().required(),
+    }).required();
+  }
+
+  static verifyMobileOTP() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.VerifyOtpRequestSchema().required(),
+    }).required();
+  }
+
+  static sendOTPOnEmail() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.SendEmailOtpRequestSchema().required(),
+    }).required();
+  }
+
+  static verifyEmailOTP() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.VerifyEmailOtpRequestSchema().required(),
+    }).required();
+  }
+
+  static getLoggedInUser() {
+    return Joi.object({});
+  }
+
+  static getListOfActiveSessions() {
+    return Joi.object({});
+  }
+
+  static getPlatformConfig() {
+    return Joi.object({
+      name: Joi.string().allow(""),
+    });
+  }
+
+  static updateProfile() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.EditProfileRequestSchema().required(),
+    }).required();
+  }
+
+  static addMobileNumber() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.EditMobileRequestSchema().required(),
+    }).required();
+  }
+
+  static deleteMobileNumber() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      active: Joi.boolean().required(),
+      primary: Joi.boolean().required(),
+      verified: Joi.boolean().required(),
+      countryCode: Joi.string().allow("").required(),
+      phone: Joi.string().allow("").required(),
+    }).required();
+  }
+
+  static setMobileNumberAsPrimary() {
+    return Joi.object({
+      body: Validator.SendVerificationLinkMobileRequestSchema().required(),
+    }).required();
+  }
+
+  static sendVerificationLinkToMobile() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.SendVerificationLinkMobileRequestSchema().required(),
+    }).required();
+  }
+
+  static addEmail() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.EditEmailRequestSchema().required(),
+    }).required();
+  }
+
+  static deleteEmail() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      active: Joi.boolean().required(),
+      primary: Joi.boolean().required(),
+      verified: Joi.boolean().required(),
+      email: Joi.string().allow("").required(),
+    }).required();
+  }
+
+  static setEmailAsPrimary() {
+    return Joi.object({
+      body: Validator.EditEmailRequestSchema().required(),
+    }).required();
+  }
+
+  static sendVerificationLinkToEmail() {
+    return Joi.object({
+      platform: Joi.string().allow(""),
+      body: Validator.EditEmailRequestSchema().required(),
+    }).required();
+  }
+}
+module.exports = UserValidator;

package/sdk/common/AxiosHelper.d.ts

@@ -0,0 +1 @@
+export const fdkAxios: any;

package/sdk/common/AxiosHelper.js

@@ -0,0 +1,141 @@
+const combineURLs = require("axios/lib/helpers/combineURLs");
+const isAbsoluteURL = require("axios/lib/helpers/isAbsoluteURL");
+const axios = require("axios");
+const querystring = require("query-string");
+const { sign } = require("./RequestSigner");
+const { FDKServerResponseError } = require("./FDKError");
+const { Logger } = require("./Logger");
+axios.defaults.withCredentials = true;
+
+function getTransformer(config) {
+  const { transformRequest } = config;
+
+  if (transformRequest) {
+    if (typeof transformRequest === "function") {
+      return transformRequest;
+    } else if (transformRequest.length) {
+      return transformRequest[0];
+    }
+  }
+
+  throw new Error(
+    "Could not get default transformRequest function from Axios defaults"
+  );
+}
+
+function requestInterceptorFn() {
+  return (config) => {
+    if (!config.url) {
+      throw new Error(
+        "No URL present in request config, unable to sign request"
+      );
+    }
+
+    let url = config.url;
+    if (config.baseURL && !isAbsoluteURL(config.url)) {
+      url = combineURLs(config.baseURL, config.url);
+    }
+    const { host, pathname, search } = new URL(url);
+    const { data, headers, method, params } = config;
+    headers["x-fp-sdk-version"] = "0.1.35";
+    let querySearchObj = querystring.parse(search);
+    querySearchObj = { ...querySearchObj, ...params };
+    let queryParam = "";
+    if (querySearchObj && Object.keys(querySearchObj).length) {
+      if (querystring.stringify(querySearchObj).trim() !== "") {
+        queryParam = `?${querystring.stringify(querySearchObj)}`;
+      }
+    }
+    let transformedData;
+    if (method != "get") {
+      const transformRequest = getTransformer(config);
+      transformedData = transformRequest(data, headers);
+    }
+
+    // Remove all the default Axios headers
+    const {
+      common,
+      delete: _delete, // 'delete' is a reserved word
+      get,
+      head,
+      post,
+      put,
+      patch,
+      ...headersToSign
+    } = headers;
+
+    const signingOptions = {
+      method: method && method.toUpperCase(),
+      host: host,
+      path: pathname + search + queryParam,
+      body: transformedData,
+      headers: headersToSign,
+    };
+    sign(signingOptions);
+
+    config.headers["x-fp-date"] = signingOptions.headers["x-fp-date"];
+    config.headers["x-fp-signature"] = signingOptions.headers["x-fp-signature"];
+    // config.headers["fp-sdk-version"] = version;
+    Logger({
+      level: "DEBUG",
+      type: "REQUEST",
+      message: config,
+      url: config.url,
+      headers: config.headers,
+      body: signingOptions.body,
+    });
+    return config;
+  };
+}
+const fdkAxios = axios.create({
+  paramsSerializer: (params) => {
+    return querystring.stringify(params);
+  },
+});
+
+fdkAxios.interceptors.request.use(requestInterceptorFn());
+fdkAxios.interceptors.response.use(
+  function (response) {
+    if (response.config.method == "head") {
+      return response.headers;
+    }
+    Logger({
+      level: "DEBUG",
+      type: "RESPONSE",
+      message: response.config,
+      url: response.config.url,
+      response: response.data,
+    });
+    return response.data; // IF 2XX then return response.data only
+  },
+  function (error) {
+    if (error.response) {
+      // Request made and server responded
+      Logger({ level: "ERROR", message: error });
+      throw new FDKServerResponseError(
+        error.response.data.message || error.message,
+        error.response.data.stack || error.stack,
+        error.response.statusText,
+        error.response.status,
+        error.response.data
+      );
+    } else if (error.request) {
+      // The request was made but no error.response was received
+      Logger({ level: "ERROR", message: error });
+      throw new FDKServerResponseError(
+        error.message,
+        error.stack,
+        error.code,
+        error.code
+      );
+    } else {
+      // Something happened in setting up the request that triggered an Error
+      Logger({ level: "ERROR", message: error });
+      throw new FDKServerResponseError(error.message, error.stack);
+    }
+  }
+);
+
+module.exports = {
+  fdkAxios,
+};

package/sdk/common/Constant.d.ts

@@ -0,0 +1,294 @@
+export namespace AVAILABLE_PAGE_TYPE {
+    const ABOUT_US: string;
+    const ADDRESSES: string;
+    const BLOG: string;
+    const BRANDS: string;
+    const CARDS: string;
+    const CART: string;
+    const CATEGORIES: string;
+    const BRAND: string;
+    const CATEGORY: string;
+    const COLLECTION: string;
+    const COLLECTIONS: string;
+    const CONTACT_US: string;
+    const EXTERNAL: string;
+    const FAQ: string;
+    const FRESHCHAT: string;
+    const HOME: string;
+    const NOTIFICATION_SETTINGS: string;
+    const ORDERS: string;
+    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;
+    const PROFILE_BASIC: string;
+    const PROFILE_COMPANY: string;
+    const PROFILE_EMAILS: string;
+    const PROFILE_PHONES: string;
+    const RATE_US: string;
+    const REFER_EARN: string;
+    const SETTINGS: string;
+    const SHARED_CART: string;
+    const TNC: string;
+    const TRACK_ORDER: string;
+    const WISHLIST: string;
+    const SECTIONS: string;
+    const FORM: string;
+    const CART_DELIVERY: string;
+    const CART_PAYMENT: string;
+    const CART_REVIEW: string;
+    const LOGIN: string;
+    const REGISTER: string;
+    const SHIPPING_POLICY: string;
+    const RETURN_POLICY: string;
+}
+export const NAVIGATORS: {
+    "about-us": {
+        name: string;
+        link: string;
+    };
+    addresses: {
+        name: string;
+        link: string;
+    };
+    blog: {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    brands: {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    cards: {
+        name: string;
+        link: string;
+    };
+    cart: {
+        name: string;
+        link: string;
+    };
+    categories: {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    brand: {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    category: {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    collection: {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    collections: {
+        name: string;
+        link: string;
+    };
+    "contact-us": {
+        name: string;
+        link: string;
+    };
+    external: {
+        name: string;
+        link: string;
+        query: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    faq: {
+        name: string;
+        link: string;
+    };
+    freshchat: {
+        name: string;
+        link: string;
+    };
+    home: {
+        name: string;
+        link: string;
+    };
+    "notification-settings": {
+        name: string;
+        link: string;
+    };
+    orders: {
+        name: string;
+        link: string;
+    };
+    page: {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    policy: {
+        name: string;
+        link: string;
+    };
+    product: {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            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;
+    };
+    products: {
+        name: string;
+        link: string;
+    };
+    profile: {
+        name: string;
+        link: string;
+    };
+    "profile-basic": {
+        name: string;
+        link: string;
+    };
+    "profile-company": {
+        name: string;
+        link: string;
+    };
+    "profile-emails": {
+        name: string;
+        link: string;
+    };
+    "profile-phones": {
+        name: string;
+        link: string;
+    };
+    "rate-us": {
+        name: string;
+        link: string;
+    };
+    "refer-earn": {
+        name: string;
+        link: string;
+    };
+    settings: {
+        name: string;
+        link: string;
+    };
+    "shared-cart": {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    tnc: {
+        name: string;
+        link: string;
+    };
+    "track-order": {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    wishlist: {
+        name: string;
+        link: string;
+    };
+    sections: {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    form: {
+        name: string;
+        link: string;
+        params: {
+            key: string;
+            required: boolean;
+        }[];
+    };
+    "cart-delivery": {
+        name: string;
+        link: string;
+    };
+    "cart-payment": {
+        name: string;
+        link: string;
+    };
+    "cart-review": {
+        name: string;
+        link: string;
+    };
+    login: {
+        name: string;
+        link: string;
+    };
+    register: {
+        name: string;
+        link: string;
+    };
+    "shipping-policy": {
+        name: string;
+        link: string;
+    };
+    "return-policy": {
+        name: string;
+        link: string;
+    };
+};