ggez-banking-sdk 0.1.178 → 0.1.179

package/dist/api/data/result.js

@@ -30,9 +30,9 @@ const FillResult = (responseData) => {
 const FillResultByError = (error) => {
     const result = {
         code: HttpStatusCode.BadRequest.toString(),
-        message: error.data?.error || error.message || error,
-        friendly_message: error.data?.error || error.message || error,
-        description: error.data?.error || error.message || error,
+        message: error.data?.error || error.message || error.toString(),
+        friendly_message: error.data?.error || error.message || error.toString(),
+        description: error.data?.error || error.message || error.toString(),
     };
     return result;
 };

package/dist/api/services/account.d.ts

@@ -3,7 +3,7 @@ import type { AccountData, AccountServiceParameters } from "../../types";
 declare class AccountService extends BaseService {
     userId: number;
     endpoint: string;
-    constructor(data: AccountServiceParameters);
+    constructor(data: AccountServiceParameters, errorHandler: (error: any) => void);
     get(accountId: number): Promise<import("axios").AxiosResponse<AccountData, any, {}>>;
     getLimits(accountId: number): Promise<import("axios").AxiosResponse<AccountData, any, {}>>;
 }

package/dist/api/services/account.js

@@ -6,29 +6,27 @@ import { AxiosHelper } from "../../helper";
 class AccountService extends BaseService {
     userId;
     endpoint = Endpoints.Account;
-    constructor(data) {
-        super(data);
+    constructor(data, errorHandler) {
+        super(data, errorHandler);
         this.userId = data.userId;
         this.axiosInstance.interceptors.request.use(async (req) => {
             const locationService = new IPAddressAndLocationService({
                 config: data.config,
                 userId: this.userId,
-            });
+            }, this.errorHandler);
             const geoCoordinates = await GeoHelper.GetGeoCoordinates(locationService);
             AxiosHelper.InjectGeoCoordinates(req, geoCoordinates);
             return req;
         });
     }
     // #region "GET"
-    async get(accountId) {
+    get(accountId) {
         const url = this.resolveURL(`/${accountId}`);
-        const response = await this.GET(url);
-        return response;
+        return this.GET(url);
     }
-    async getLimits(accountId) {
+    getLimits(accountId) {
         const url = this.resolveURL(`/${AccountEndpoints.Limits}/${accountId}`);
-        const response = await this.GET(url);
-        return response;
+        return this.GET(url);
     }
 }
 export { AccountService };

package/dist/api/services/auth.d.ts

@@ -4,7 +4,7 @@ declare class AuthService extends BaseService {
     nodeUrl: string;
     userId: number;
     endpoint: string;
-    constructor(data: AuthServiceParameters);
+    constructor(data: AuthServiceParameters, errorHandler: (error: any) => void);
     login(data: string): Promise<import("axios").AxiosResponse<TokenData, any, {}>>;
     generateLimitedToken(data: IGenerateLimitedTokenData): Promise<import("axios").AxiosResponse<TokenData, any, {}>>;
 }

package/dist/api/services/auth.js

@@ -4,17 +4,17 @@ class AuthService extends BaseService {
     nodeUrl;
     userId;
     endpoint = Endpoints.Auth;
-    constructor(data) {
-        super(data);
+    constructor(data, errorHandler) {
+        super(data, errorHandler);
         this.nodeUrl = data.nodeUrl;
         this.userId = data.userId;
     }
     // #region "POST"
-    async login(data) {
+    login(data) {
         const url = this.resolveURL();
         return this.POST(url, data);
     }
-    async generateLimitedToken(data) {
+    generateLimitedToken(data) {
         return this.POST(`${this.nodeUrl}/v1/limited-token`, data);
     }
 }

package/dist/api/services/base.d.ts

@@ -4,7 +4,8 @@ declare abstract class BaseService {
     protected abstract userId: number;
     protected abstract endpoint: string;
     protected axiosInstance: AxiosInstance;
-    constructor(data: BaseServiceParameters);
+    protected errorHandler: (error: any) => void;
+    constructor(data: BaseServiceParameters, errorHandler: (error: any) => void);
     protected GET<T>(url: string, params?: any, config?: AxiosRequestConfig): Promise<AxiosResponse<T, any, {}>>;
     protected POST<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<AxiosResponse<T, any, {}>>;
     protected PUT<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<AxiosResponse<T, any, {}>>;

package/dist/api/services/base.js

@@ -2,7 +2,9 @@ import axios from "axios";
 import { AxiosHelper } from "../../helper";
 class BaseService {
     axiosInstance;
-    constructor(data) {
+    errorHandler;
+    constructor(data, errorHandler) {
+        this.errorHandler = errorHandler;
         this.axiosInstance = axios.create(data.config);
         this.axiosInstance.interceptors.request.use((req) => {
             AxiosHelper.InjectRequiredHeaders(req, this.userId);
@@ -10,46 +12,42 @@ class BaseService {
             return req;
         });
     }
-    async GET(url, params, config) {
+    GET(url, params, config) {
         try {
             return this.axiosInstance.get(url, {
                 ...config,
                 params,
             });
         }
-        catch (ex) {
-            console.error(ex);
-            // onErrorHandler(ex);
+        catch (error) {
+            this.errorHandler(error);
         }
     }
-    async POST(url, data, config) {
+    POST(url, data, config) {
         try {
             return this.axiosInstance.post(url, data, config);
         }
-        catch (ex) {
-            console.error(ex);
-            // onErrorHandler(ex);
+        catch (error) {
+            this.errorHandler(error);
         }
     }
-    async PUT(url, data, config) {
+    PUT(url, data, config) {
         try {
             return this.axiosInstance.put(url, data, config);
         }
-        catch (ex) {
-            console.error(ex);
-            // onErrorHandler(ex);
+        catch (error) {
+            this.errorHandler(error);
         }
     }
-    async DELETE(url, data, config) {
+    DELETE(url, data, config) {
         try {
             return this.axiosInstance.delete(url, {
                 ...config,
                 data,
             });
         }
-        catch (ex) {
-            console.error(ex);
-            // onErrorHandler(ex);
+        catch (error) {
+            this.errorHandler(error);
         }
     }
     resolveURL(path = "") {

package/dist/api/services/blockchain.d.ts

@@ -1,9 +1,9 @@
 import { BaseService } from "./base";
-import type { BlockchainData, BlockchainServiceParameters } from "../../types";
+import type { BlockchainData, BlockchainServiceParameters, ErrorHandler } from "../../types";
 declare class BlockchainService extends BaseService {
     userId: number;
     endpoint: string;
-    constructor(data: BlockchainServiceParameters);
+    constructor(data: BlockchainServiceParameters, errorHandler: ErrorHandler);
     send(payload: BlockchainData): Promise<import("axios").AxiosResponse<BlockchainData, any, {}>>;
     multiSend(payload: BlockchainData): Promise<import("axios").AxiosResponse<BlockchainData, any, {}>>;
     delegate(payload: BlockchainData): Promise<import("axios").AxiosResponse<BlockchainData, any, {}>>;

package/dist/api/services/blockchain.js

@@ -3,24 +3,24 @@ import { BaseService } from "./base";
 class BlockchainService extends BaseService {
     userId;
     endpoint = Endpoints.Blockchain;
-    constructor(data) {
-        super(data);
+    constructor(data, errorHandler) {
+        super(data, errorHandler);
         this.userId = data.userId;
     }
     // #region "POST"
-    async send(payload) {
+    send(payload) {
         const url = this.resolveURL(BlockchainEndpoints.Send);
         return this.POST(url, payload);
     }
-    async multiSend(payload) {
+    multiSend(payload) {
         const url = this.resolveURL(BlockchainEndpoints.MultiSend);
         return this.POST(url, payload);
     }
-    async delegate(payload) {
+    delegate(payload) {
         const url = this.resolveURL(BlockchainEndpoints.Delegate);
         return this.POST(url, payload);
     }
-    async undelegate(payload) {
+    undelegate(payload) {
         const url = this.resolveURL(BlockchainEndpoints.Undelegate);
         return this.POST(url, payload);
     }

package/dist/api/services/ipAddressAndLocation.d.ts

@@ -3,7 +3,7 @@ import type { IPAddressAndLocationServiceParameters } from "../../types";
 declare class IPAddressAndLocationService extends BaseService {
     userId: number;
     endpoint: string;
-    constructor(data: IPAddressAndLocationServiceParameters);
+    constructor(data: IPAddressAndLocationServiceParameters, errorHandler: (error: any) => void);
     getIPAddressAndLocation: () => Promise<import("axios").AxiosResponse<string, any, {}>>;
 }
 export { IPAddressAndLocationService };

package/dist/api/services/ipAddressAndLocation.js

@@ -3,8 +3,8 @@ import { Endpoints } from "../../constants";
 class IPAddressAndLocationService extends BaseService {
     userId;
     endpoint = Endpoints.IPAddress;
-    constructor(data) {
-        super(data);
+    constructor(data, errorHandler) {
+        super(data, errorHandler);
         this.userId = data.userId;
     }
     // #region "GET"
@@ -13,7 +13,7 @@ class IPAddressAndLocationService extends BaseService {
             return this.GET(this.endpoint);
         }
         catch (error) {
-            // console.error(error);
+            this.errorHandler(error);
         }
     };
 }

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

@@ -4,7 +4,7 @@ declare class LimitedService extends BaseService {
     endpoint: string;
     private nodeUrl;
     userId: number;
-    constructor(data: LimitedServiceParameters);
+    constructor(data: LimitedServiceParameters, errorHandler: (error: any) => void);
     validateForgetSecurityData(data: ForgetSecurityData): Promise<import("axios").AxiosResponse<ForgetSecurityData, any, {}>>;
     confirmForgetSecurityData(data: ForgetSecurityData): Promise<import("axios").AxiosResponse<ForgetSecurityData, any, {}>>;
     validateSecurityData(data: ValidateLimitedSecurity): Promise<import("axios").AxiosResponse<ValidateLimitedSecurity, any, {}>>;

package/dist/api/services/limited.js

@@ -6,8 +6,8 @@ class LimitedService extends BaseService {
     endpoint = Endpoints.Limited;
     nodeUrl;
     userId;
-    constructor(data) {
-        super(data);
+    constructor(data, errorHandler) {
+        super(data, errorHandler);
         this.nodeUrl = data.nodeUrl;
         this.userId = data.userId;
         this.axiosInstance.interceptors.request.use(async (req) => {
@@ -16,7 +16,7 @@ class LimitedService extends BaseService {
                 config: authConfig,
                 nodeUrl: this.nodeUrl,
                 userId: this.userId,
-            });
+            }, this.errorHandler);
             const { data } = await authService.generateLimitedToken({
                 installationId: "",
             });
@@ -28,25 +28,25 @@ class LimitedService extends BaseService {
         });
     }
     // #region "POST"
-    async validateForgetSecurityData(data) {
+    validateForgetSecurityData(data) {
         const url = this.resolveURL(LimitedEndpoints.SecurityForgetValidate);
-        return await this.POST(url, data);
+        return this.POST(url, data);
     }
-    async confirmForgetSecurityData(data) {
+    confirmForgetSecurityData(data) {
         const url = this.resolveURL(LimitedEndpoints.SecurityForgetConfirm);
-        return await this.POST(url, data);
+        return this.POST(url, data);
     }
-    async validateSecurityData(data) {
+    validateSecurityData(data) {
         const url = this.resolveURL(LimitedEndpoints.SecurityValidate);
-        return await this.POST(url, data);
+        return this.POST(url, data);
     }
-    async verifySecurityData(data) {
+    verifySecurityData(data) {
         const url = this.resolveURL(LimitedEndpoints.SecurityVerify);
-        return await this.POST(url, data);
+        return this.POST(url, data);
     }
-    async confirmSecurityData(data) {
+    confirmSecurityData(data) {
         const url = this.resolveURL(LimitedEndpoints.SecurityConfirm);
-        return await this.POST(url, data);
+        return this.POST(url, data);
     }
 }
 export { LimitedService };

package/dist/api/services/order.d.ts

@@ -1,9 +1,9 @@
 import { BaseService } from "./base";
-import type { OrderData, OrderServiceParameters } from "../../types";
+import type { ErrorHandler, OrderData, OrderServiceParameters } from "../../types";
 declare class OrderService extends BaseService {
     userId: number;
     endpoint: string;
-    constructor(data: OrderServiceParameters);
+    constructor(data: OrderServiceParameters, errorHandler: ErrorHandler);
     create(data: OrderData): Promise<import("axios").AxiosResponse<OrderData, any, {}>>;
 }
 export { OrderService };

package/dist/api/services/order.js

@@ -6,21 +6,21 @@ import { AxiosHelper } from "../../helper";
 class OrderService extends BaseService {
     userId;
     endpoint = Endpoints.Order;
-    constructor(data) {
-        super(data);
+    constructor(data, errorHandler) {
+        super(data, errorHandler);
         this.userId = data.userId;
         this.axiosInstance.interceptors.request.use(async (req) => {
             const locationService = new IPAddressAndLocationService({
                 config: data.config,
                 userId: this.userId,
-            });
+            }, this.errorHandler);
             const geoCoordinates = await GeoHelper.GetGeoCoordinates(locationService);
             AxiosHelper.InjectGeoCoordinates(req, geoCoordinates);
             return req;
         });
     }
     // #region "POST"
-    async create(data) {
+    create(data) {
         const url = this.resolveURL();
         return this.POST(url, data);
     }

package/dist/api/services/organization.d.ts

@@ -1,10 +1,10 @@
 import { BaseService } from "./base";
-import type { DocumentData, OrganizationData, OrganizationServiceParameters } from "../../types";
+import type { DocumentData, ErrorHandler, OrganizationData, OrganizationServiceParameters } from "../../types";
 declare class OrganizationService extends BaseService {
     url: string;
     userId: number;
     endpoint: string;
-    constructor(data: OrganizationServiceParameters);
+    constructor(data: OrganizationServiceParameters, errorHandler: ErrorHandler);
     create(data: OrganizationData): Promise<import("axios").AxiosResponse<OrganizationData, any, {}>>;
     createDocument(id: number, data: DocumentData): Promise<import("axios").AxiosResponse<DocumentData, any, {}>>;
     update(id: number, data: OrganizationData): Promise<import("axios").AxiosResponse<OrganizationData, any, {}>>;

package/dist/api/services/organization.js

@@ -7,37 +7,37 @@ class OrganizationService extends BaseService {
     url;
     userId;
     endpoint = Endpoints.Organization;
-    constructor(data) {
-        super(data);
+    constructor(data, errorHandler) {
+        super(data, errorHandler);
         this.userId = data.userId;
         this.axiosInstance.interceptors.request.use(async (req) => {
             const locationService = new IPAddressAndLocationService({
                 config: data.config,
                 userId: this.userId,
-            });
+            }, this.errorHandler);
             const geoCoordinates = await GeoHelper.GetGeoCoordinates(locationService);
             AxiosHelper.InjectGeoCoordinates(req, geoCoordinates);
             return req;
         });
     }
     // #region "POST"
-    async create(data) {
+    create(data) {
         const url = this.resolveURL();
         return this.POST(url, data);
     }
-    async createDocument(id, data) {
+    createDocument(id, data) {
         const url = this.resolveURL(`${OrganizationEndpoints.Document}/${id}`);
         return this.POST(url, data);
     }
     // #endregion
     // #region "PUT"
-    async update(id, data) {
+    update(id, data) {
         const url = this.resolveURL(id);
         return this.PUT(url, data);
     }
     // #endregion
     // #region "DELETE"
-    async delete(id) {
+    delete(id) {
         const url = this.resolveURL(id);
         return this.DELETE(url);
     }

package/dist/api/services/promotion.d.ts

@@ -1,9 +1,9 @@
 import { BaseService } from "./base";
-import type { GGEZGiftRewards, PromotionDetails, PromotionServiceParameters } from "../../types";
+import type { ErrorHandler, GGEZGiftRewards, PromotionDetails, PromotionServiceParameters } from "../../types";
 declare class PromotionService extends BaseService {
     userId: number;
     endpoint: string;
-    constructor(data: PromotionServiceParameters);
+    constructor(data: PromotionServiceParameters, errorHandler: ErrorHandler);
     getPromotionByCode(promotionCode: string): Promise<import("axios").AxiosResponse<PromotionDetails, any, {}>>;
     getTwitterSpotlightPostIds(): Promise<import("axios").AxiosResponse<string[], any, {}>>;
     incrementPromotionParticipants(data: GGEZGiftRewards): Promise<import("axios").AxiosResponse<{

package/dist/api/services/promotion.js

@@ -3,22 +3,22 @@ import { BaseService } from "./base";
 class PromotionService extends BaseService {
     userId;
     endpoint = Endpoints.Promotion;
-    constructor(data) {
-        super(data);
+    constructor(data, errorHandler) {
+        super(data, errorHandler);
         this.userId = data.userId;
     }
     // #region "GET"
-    async getPromotionByCode(promotionCode) {
+    getPromotionByCode(promotionCode) {
         const url = this.resolveURL(`/${promotionCode}`);
         return this.GET(url);
     }
-    async getTwitterSpotlightPostIds() {
+    getTwitterSpotlightPostIds() {
         const url = this.resolveURL("/spotlight/twitter");
         return this.GET(url);
     }
     // #endregion
     // #region "PUT"
-    async incrementPromotionParticipants(data) {
+    incrementPromotionParticipants(data) {
         const url = this.resolveURL();
         return this.PUT(url, data);
     }

package/dist/api/services/transaction.d.ts

@@ -1,9 +1,9 @@
 import { BaseService } from "./base";
-import type { TransactionData, TransactionInquiry, TransactionResultInquiry, TransactionServiceParameters } from "../../types";
+import type { ErrorHandler, TransactionData, TransactionInquiry, TransactionResultInquiry, TransactionServiceParameters } from "../../types";
 declare class TransactionService extends BaseService {
     userId: number;
     endpoint: string;
-    constructor(data: TransactionServiceParameters);
+    constructor(data: TransactionServiceParameters, errorHandler: ErrorHandler);
     inquiry(payload: TransactionInquiry): Promise<import("axios").AxiosResponse<TransactionResultInquiry, any, {}>>;
     create(payload: TransactionData): Promise<import("axios").AxiosResponse<TransactionData, any, {}>>;
 }

package/dist/api/services/transaction.js

@@ -6,27 +6,27 @@ import { AxiosHelper } from "../../helper";
 class TransactionService extends BaseService {
     userId;
     endpoint = Endpoints.Transaction;
-    constructor(data) {
-        super(data);
+    constructor(data, errorHandler) {
+        super(data, errorHandler);
         this.userId = data.userId;
         this.axiosInstance.interceptors.request.use(async (req) => {
             const locationService = new IPAddressAndLocationService({
                 config: data.config,
                 userId: this.userId,
-            });
+            }, this.errorHandler);
             const geoCoordinates = await GeoHelper.GetGeoCoordinates(locationService);
             AxiosHelper.InjectGeoCoordinates(req, geoCoordinates);
             return req;
         });
     }
     // #region "GET"
-    async inquiry(payload) {
+    inquiry(payload) {
         const url = this.resolveURL(TransactionEndpoints.Inquiry);
         return this.GET(url, payload);
     }
     // #endregion
     // #region "POST"
-    async create(payload) {
+    create(payload) {
         const url = this.resolveURL();
         return this.POST(url, payload);
     }

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

@@ -1,11 +1,11 @@
 import { AxiosRequestConfig } from "axios";
 import { BaseService } from "./base";
-import type { ConfirmUserSecurity, DocumentData, ResetUserSecurity, UserData, UserServiceParameters, ValidateUserSecurity, VerifyUserSecurity } from "../../types";
+import type { ConfirmUserSecurity, DocumentData, ErrorHandler, ResetUserSecurity, UserData, UserServiceParameters, ValidateUserSecurity, VerifyUserSecurity } from "../../types";
 declare class UserService extends BaseService {
     url: string;
     userId: number;
     endpoint: string;
-    constructor(data: UserServiceParameters);
+    constructor(data: UserServiceParameters, errorHandler: ErrorHandler);
     getUser(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
     getTermsAndConditions(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;
     getSecurity(userId: number): Promise<import("axios").AxiosResponse<UserData, any, {}>>;