ggez-banking-sdk 0.4.22 → 0.4.24

package/dist/api/service/limited.d.ts

@@ -2,7 +2,9 @@ import { BaseService } from "./base";
 import type { ConfirmUserSecurity, ForgetSecurityData, ValidateLimitedSecurity, VerifyUserSecurity, LimitedServiceParameters } from "../../types";
 declare class LimitedService extends BaseService {
     protected endpoint: string;
+    private authService;
     constructor(data: LimitedServiceParameters);
+    private onLimitedRequest;
     validateSecurityData(data: ValidateLimitedSecurity): Promise<import("../..").ApiResponse<ValidateLimitedSecurity>>;
     verifySecurityData(data: VerifyUserSecurity): Promise<import("../..").ApiResponse<VerifyUserSecurity>>;
     confirmSecurityData(data: ConfirmUserSecurity): Promise<import("../..").ApiResponse<ConfirmUserSecurity>>;

package/dist/api/service/limited.js

@@ -1,10 +1,21 @@
 import { Endpoints, LimitedEndpoints } from "../../constant/constant";
+import { AxiosHelper } from "../../helper/api/axiosHelper";
+import { AuthService } from "./auth";
 import { BaseService } from "./base";
 class LimitedService extends BaseService {
     endpoint = Endpoints.Limited;
+    authService;
     constructor(data) {
         super(data);
+        this.authService = new AuthService(data);
+        this.axiosInstance.interceptors.request.use((req) => this.onLimitedRequest(req));
     }
+    // #region "Interceptors Handlers"
+    async onLimitedRequest(req) {
+        await AxiosHelper.injectLimitedToken(req, this.authService, this.cookiesHelper);
+        return req;
+    }
+    // #endregion
     // #region "POST"
     validateSecurityData(data) {
         const url = this.resolveURL(LimitedEndpoints.SecurityValidate);

package/dist/api/service/user.d.ts

@@ -8,6 +8,7 @@ import type { ValidateUserSecurity } from "../../types/banking/user/validateUser
 import type { VerifyUserSecurity } from "../../types/banking/user/verifyUserSecurity";
 declare class UserService extends BaseService {
     protected endpoint: string;
+    private authService;
     constructor(data: UserServiceParameters);
     private userId;
     getUser(): Promise<import("../..").ApiResponse<UserData>>;

package/dist/api/service/user.js

@@ -1,12 +1,15 @@
 import { Endpoints, UserEndpoints } from "../../constant/constant";
+import { AuthService } from "./auth";
 import { BaseService } from "./base";
 import { IPAddressAndLocationService } from "./ipAddressAndLocation";
 import { AxiosHelper } from "../../helper/api/axiosHelper";
 import { GeoHelper } from "../../helper/geoHelper";
 class UserService extends BaseService {
     endpoint = Endpoints.User;
+    authService;
     constructor(data) {
         super(data);
+        this.authService = new AuthService(data);
         this.axiosInstance.interceptors.request.use(async (req) => {
             const locationService = new IPAddressAndLocationService(data);
             const geoCoordinates = await GeoHelper.getGeoCoordinates(locationService);
@@ -100,9 +103,10 @@ class UserService extends BaseService {
     }
     // #endregion
     // #region "POST"
-    createUser(payload) {
+    async createUser(payload) {
         const url = this.resolveURL();
-        return this.POST(url, payload);
+        const headers = await AxiosHelper.getLimitedAuthHeaders(this.authService, this.cookiesHelper);
+        return this.POST(url, payload, { headers });
     }
     async createPhone(payload) {
         const url = this.resolveURL(`${UserEndpoints.Phone}/${await this.userId()}`);

package/dist/helper/api/axiosHelper.d.ts

@@ -1,12 +1,15 @@
-import type { InjectBaseHeaders, TAddAxiosConfigHeader, TGetAuthAxiosConfig, TGetAxiosConfig, TInjectGeoCoordinates, TInjectLimitedToken, TInjectRequest } from "../../types/helper/api/axiosHelper";
+import type { Bearer, GetLimitedAuthHeaders, GetLimitedToken, InjectBaseHeaders, InjectLimitedToken, TAddAxiosConfigHeader, TGetAuthAxiosConfig, TGetAxiosConfig, TInjectGeoCoordinates, TInjectRequest } from "../../types/helper/api/axiosHelper";
 import type { BaseResult } from "../../types/banking/common/baseresult";
 declare class AxiosHelper {
+    static bearer: Bearer;
     static getAxiosConfig: TGetAxiosConfig;
     static getAuthAxiosConfig: TGetAuthAxiosConfig;
     static addAxiosConfigHeader: TAddAxiosConfigHeader;
     static injectBaseHeaders: InjectBaseHeaders<BaseResult>;
     static injectBaseBodyProperties: TInjectRequest<BaseResult | string>;
+    static getLimitedToken: GetLimitedToken;
+    static getLimitedAuthHeaders: GetLimitedAuthHeaders;
+    static injectLimitedToken: InjectLimitedToken;
     static injectGeoCoordinates: TInjectGeoCoordinates;
-    static injectLimitedToken: TInjectLimitedToken;
 }
 export { AxiosHelper };

package/dist/helper/api/axiosHelper.js

@@ -1,9 +1,9 @@
-import axios from "axios";
 import { generateSourceID } from "../../utils/data/generation";
 import { DateTimeHelper } from "../dateTimeHelper";
 import qs from "qs";
 import { HeaderKeys } from "../../constant/constant";
 class AxiosHelper {
+    static bearer = (token) => `Bearer ${token}`;
     static getAxiosConfig = (token, baseURL, lang, installationId) => {
         const config = {
             headers: {
@@ -18,7 +18,7 @@ class AxiosHelper {
             withCredentials: true,
         };
         if (token && config.headers) {
-            config.headers.Authorization = `Bearer ${token}`;
+            config.headers.Authorization = AxiosHelper.bearer(token);
         }
         return config;
     };
@@ -46,8 +46,9 @@ class AxiosHelper {
         const userId = await cookiesHelper.getUserId();
         const lang = context.getLang();
         const iid = await cookiesHelper.getIID();
-        if (token)
-            req.headers.set(HeaderKeys.Authorization, `Bearer ${token}`);
+        if (token && !req.headers.has(HeaderKeys.Authorization)) {
+            req.headers.set(HeaderKeys.Authorization, AxiosHelper.bearer(token));
+        }
         if (userId)
             req.headers.set(HeaderKeys.SourceID, generateSourceID(userId));
         if (lang)
@@ -82,6 +83,24 @@ class AxiosHelper {
             return req;
         }
     };
+    static getLimitedToken = async (authService, cookiesHelper) => {
+        const installationId = (await cookiesHelper.getIID()) ?? "";
+        const res = await authService.generateLimitedToken({ installationId });
+        return res.data?.data?.access_token ?? null;
+    };
+    static getLimitedAuthHeaders = async (authService, cookiesHelper) => {
+        const token = await AxiosHelper.getLimitedToken(authService, cookiesHelper);
+        return token
+            ? { [HeaderKeys.Authorization]: AxiosHelper.bearer(token) }
+            : undefined;
+    };
+    static injectLimitedToken = async (req, authService, cookiesHelper) => {
+        const headers = await AxiosHelper.getLimitedAuthHeaders(authService, cookiesHelper);
+        if (headers) {
+            req.headers.set(HeaderKeys.Authorization, headers.Authorization);
+        }
+        return req;
+    };
     static injectGeoCoordinates = (req, geoCoordinates) => {
         if (req.data && typeof req.data === "object") {
             const data = req.data;
@@ -89,12 +108,5 @@ class AxiosHelper {
         }
         return req;
     };
-    static injectLimitedToken = async (req, nodeUrl, installationId) => {
-        const tokenRes = await axios.post(`${nodeUrl}/token/limited-token`, {
-            installationId,
-        });
-        req.headers.set("Authorization", `Bearer ${tokenRes.data.data.access_token}`);
-        return req;
-    };
 }
 export { AxiosHelper };

package/dist/helper/api/responseHelper.js

@@ -1,25 +1,20 @@
 import { createDefaultBaseResult, fillResultByError } from "../../api";
 import { HttpStatusCode } from "axios";
 import { ResultHelper } from "./resultHelper";
+import { SystemResponses } from "../../constant";
 class ResponseHelper {
     static onResponse = (res) => {
         const defaultResult = {
-            code: "0000",
+            code: SystemResponses.Approved,
             message: "Operation completed successfully",
             friendly_message: "Operation completed successfully",
             description: "Operation completed successfully",
         };
-        if (typeof res.data !== "object" || res.data === null) {
+        if (!res.data.result) {
             res.data = createDefaultBaseResult({
                 result: defaultResult,
-                value: res.data,
             });
         }
-        else if (!res.data.result) {
-            res.data.result = createDefaultBaseResult({
-                result: defaultResult,
-            }).result;
-        }
         return res;
     };
     static onError = (error) => {

package/dist/types/helper/api/axiosHelper.d.ts

@@ -2,6 +2,7 @@ import { AxiosRequestConfig, InternalAxiosRequestConfig } from "axios";
 import { GeoCoordinates } from "../../banking/common";
 import { ClientContextProvider } from "../..";
 import { CookiesHelper } from "../../..";
+import type { AuthService } from "../../../api/service/auth";
 type TGetAxiosConfig = (token: string, baseURL: string, lang?: string, installationId?: string) => AxiosRequestConfig;
 type TGetAuthAxiosConfig = (baseURL: string, lang: string, installationId: string) => AxiosRequestConfig;
 type TAddAxiosConfigHeader = (config: AxiosRequestConfig, key: string, value: string) => void;
@@ -11,5 +12,10 @@ type InjectBaseHeaders<D> = (req: InternalAxiosRequestConfig, context: ClientCon
 type TInjectGeoCoordinates = <D extends {
     geo_coordinates: GeoCoordinates;
 }>(req: InternalAxiosRequestConfig<D>, geoCoordinates: GeoCoordinates) => InternalAxiosRequestConfig<D>;
-type TInjectLimitedToken = (req: InternalAxiosRequestConfig, nodeUrl: string, installationId?: string) => Promise<InternalAxiosRequestConfig>;
-export { TGetAxiosConfig, TGetAuthAxiosConfig, TAddAxiosConfigHeader, TInjectRequest, InjectBaseHeaders, InjectRequiredHeaders, TInjectGeoCoordinates, TInjectLimitedToken, };
+type InjectLimitedToken = (req: InternalAxiosRequestConfig, authService: AuthService, cookiesHelper: CookiesHelper) => Promise<InternalAxiosRequestConfig>;
+type GetLimitedToken = (authService: AuthService, cookiesHelper: CookiesHelper) => Promise<string | null>;
+type GetLimitedAuthHeaders = (authService: AuthService, cookiesHelper: CookiesHelper) => Promise<{
+    Authorization: string;
+} | undefined>;
+type Bearer = (token: string) => string;
+export { TGetAxiosConfig, TGetAuthAxiosConfig, TAddAxiosConfigHeader, TInjectRequest, InjectBaseHeaders, InjectRequiredHeaders, TInjectGeoCoordinates, InjectLimitedToken, GetLimitedToken, GetLimitedAuthHeaders, Bearer, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ggez-banking-sdk",
-  "version": "0.4.22",
+  "version": "0.4.24",
   "description": "A Node.js package to handle GGEZ Banking API endpoints, Simplify the process of managing CRUD operations with this efficient and easy-to-use package.",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",