ggez-banking-sdk 0.1.169 → 0.1.170

package/dist/helper/storage/cookiesHelper.d.ts

@@ -1,32 +1,44 @@
-import { USR } from "../../types";
+import { CredentialsCookies, USR } from "../../types";
 declare class CookiesHelper {
+    private key;
+    private eventHandlers;
     private domain;
     private programId;
+    private Cookies;
     constructor(programId: string);
-    GetIID(): string;
-    SetIID(): string;
-    ValidateIID(IID: string): string;
-    isIIDValid(IID: string): boolean;
-    GetDEK(): string;
-    SetDEK(deviceEncryptionKey: string, USR: USR): void;
-    ValidateDEK(DEK: string): string;
-    GetUSR(): USR;
-    SetUSR(deviceId: string, userId: string): void;
-    ValidateUSR(USR: string): string;
-    GetDeviceSecurityCode(): string;
-    GetAccessToken(): string;
-    SetAccessToken(accessToken: string, expires: Date): void;
-    ValidateAccessToken(accessToken: string): string;
-    GetJWTToken(): string;
+    GetIID(): Promise<string>;
+    SetIID(): Promise<string>;
+    ValidateIID(IID: string): Promise<string>;
+    isIIDValid(IID: string): Promise<boolean>;
+    GetDEK(): Promise<string>;
+    SetDEK(deviceEncryptionKey: string, USR: USR): Promise<void>;
+    ValidateDEK(DEK: string): Promise<string>;
+    GetUSR(): Promise<USR>;
+    SetUSR(deviceId: string, userId: string): Promise<void>;
+    ValidateUSR(USR: string): Promise<string>;
+    GetDeviceSecurityCode(): Promise<string>;
+    GetAccessToken(): Promise<string>;
+    SetAccessToken(accessToken: string, expires: number): Promise<void>;
+    ValidateAccessToken(accessToken: string): Promise<string>;
+    GetJWTToken(): Promise<string>;
     SetJWTToken(jwtToken: string): void;
-    ValidateJWTToken(jwtToken: string): string;
-    GET(key: string): string | undefined;
-    SET(key: string, value: string, expires?: Date): void;
-    REMOVE(key: string): void;
-    cookieEventHandler(e: CookieChangeEvent, callback: () => void): void;
-    onChangeHandler(changed: CookieInit[], callback: () => void): Promise<void>;
-    onDeleteHandler(deleted: CookieInit[], callback: () => void): Promise<void>;
-    addOnChangeEventListener(callback: () => void): void;
-    removeOnChangeEventListener(callback: () => void): void;
+    GET(key: string): Promise<string>;
+    SET(key: string, value: string, expires?: number): Promise<void>;
+    REMOVE(key: string): Promise<void>;
+    cookieEventHandler(e: CookieChangeEvent, params: ChangeEventParameters): Promise<void>;
+    onChangeHandler(changed: CookieInit[], params: ChangeEventParameters): Promise<void>;
+    onDeleteHandler(deleted: CookieInit[], params: ChangeEventParameters): Promise<void>;
+    addOnChangeEventListener(params: ChangeEventParameters): void;
+    removeOnChangeEventListener(): void;
+    IsAuthenticated(): Promise<boolean>;
+    GetCredentialsCookies(): Promise<CredentialsCookies>;
 }
+type ChangeEventParameters = {
+    IID: EventCallback;
+    USR: EventCallback;
+    DEK: EventCallback;
+    accessToken: EventCallback;
+    jwtToken: EventCallback;
+};
+type EventCallback = (eventType: "change" | "delete") => void;
 export { CookiesHelper };

package/dist/helper/storage/cookiesHelper.js

@@ -1,23 +1,27 @@
 import { v4 } from "uuid";
-import Cookies from "js-cookie";
-import { CipherHelper } from "..";
+import { CipherHelper } from "../cipherHelper";
 class CookiesHelper {
     // #region "Properties"
+    key;
+    eventHandlers = new Map();
     domain = "";
     programId = "0";
+    Cookies = window.cookieStore;
     // #endregion
     // #region "Constructor"
     constructor(programId) {
         this.domain = window.location.hostname;
         this.programId = programId;
+        this.Cookies = window.cookieStore;
+        this.key = v4();
     }
     // #endregion
     // #region "IID"
-    GetIID() {
+    async GetIID() {
         try {
-            const IID = this.GET("IID");
+            const IID = await this.GET("IID");
             if (!IID) {
-                return this.SetIID();
+                return await this.SetIID();
             }
             const { key, iv } = CipherHelper.GenerateByProgramID(this.programId);
             const decryptedIID = CipherHelper.Decrypt(IID, key, iv);
@@ -25,9 +29,10 @@ class CookiesHelper {
         }
         catch (error) {
             console.error(error);
+            return "";
         }
     }
-    SetIID() {
+    async SetIID() {
         try {
             const IID = v4();
             const { key, iv } = CipherHelper.GenerateByProgramID(this.programId);
@@ -37,9 +42,10 @@ class CookiesHelper {
         }
         catch (error) {
             console.error(error);
+            return "";
         }
     }
-    ValidateIID(IID) {
+    async ValidateIID(IID) {
         try {
             const { key, iv } = CipherHelper.GenerateByProgramID(this.programId);
             const decryptedIID = CipherHelper.Decrypt(IID, key, iv);
@@ -49,11 +55,12 @@ class CookiesHelper {
             console.error(error);
         }
     }
-    isIIDValid(IID) {
+    async isIIDValid(IID) {
         try {
             const { key, iv } = CipherHelper.GenerateByProgramID(this.programId);
             const decryptedIID = CipherHelper.Decrypt(IID, key, iv);
-            return decryptedIID == this.GetIID();
+            const currentIID = await this.GetIID();
+            return decryptedIID == currentIID;
         }
         catch (error) {
             console.error(error);
@@ -61,12 +68,12 @@ class CookiesHelper {
     }
     // #endregion
     // #region "DEK"
-    GetDEK() {
+    async GetDEK() {
         try {
-            const IID = this.GetIID();
-            const DEK = this.GET("DEK");
-            const USR = this.GetUSR();
-            if (!DEK || !USR) {
+            const IID = await this.GetIID();
+            const DEK = await this.GET("DEK");
+            const USR = await this.GetUSR();
+            if (!DEK || !USR || !IID) {
                 return "";
             }
             const { key, iv } = CipherHelper.GenerateByUSRAndIID(USR, IID);
@@ -78,27 +85,29 @@ class CookiesHelper {
             console.error(error);
         }
     }
-    SetDEK(deviceEncryptionKey, USR) {
+    async SetDEK(deviceEncryptionKey, USR) {
         try {
-            const IID = this.GetIID();
+            const IID = await this.GetIID();
+            if (!USR || !IID)
+                return;
             const { user_id } = USR;
             const { key, iv } = CipherHelper.GenerateByUSRAndIID(USR, IID);
             if (deviceEncryptionKey) {
                 const cipherKeys = CipherHelper.GenerateByUserID(user_id);
                 const encryptionKey = CipherHelper.Decrypt(deviceEncryptionKey, cipherKeys.key, cipherKeys.iv);
                 const DEK = CipherHelper.Encrypt(encryptionKey, key, iv);
-                this.SET("DEK", DEK);
+                await this.SET("DEK", DEK);
             }
         }
         catch (error) {
             console.error(error);
         }
     }
-    ValidateDEK(DEK) {
+    async ValidateDEK(DEK) {
         try {
-            const IID = this.GetIID();
-            const USR = this.GetUSR();
-            if (!DEK || !USR)
+            const IID = await this.GetIID();
+            const USR = await this.GetUSR();
+            if (!DEK || !USR || !IID)
                 return null;
             const { key, iv } = CipherHelper.GenerateByUSRAndIID(USR, IID);
             const decryptedDEK = CipherHelper.Decrypt(DEK, key, iv);
@@ -110,38 +119,41 @@ class CookiesHelper {
     }
     // #endregion
     // #region "USR"
-    GetUSR() {
+    async GetUSR() {
         try {
-            const IID = this.GetIID();
-            const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
-            const USR = this.GET("USR");
-            if (!USR)
+            const IID = await this.GetIID();
+            const USR = await this.GET("USR");
+            if (!IID || !USR)
                 return null;
+            const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
             const decryptedUSR = CipherHelper.Decrypt(USR, key, iv);
             return JSON.parse(decryptedUSR);
         }
         catch (error) {
             console.error(error);
+            return null;
         }
     }
-    SetUSR(deviceId, userId) {
+    async SetUSR(deviceId, userId) {
         try {
-            const IID = this.GetIID();
+            const IID = await this.GetIID();
+            if (!IID)
+                return;
             const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
             const USR = JSON.stringify({
                 device_id: deviceId,
                 user_id: userId,
             });
             const encryptedUSR = CipherHelper.Encrypt(USR, key, iv);
-            this.SET("USR", encryptedUSR);
+            await this.SET("USR", encryptedUSR);
         }
         catch (error) {
             console.error(error);
         }
     }
-    ValidateUSR(USR) {
+    async ValidateUSR(USR) {
         try {
-            const IID = this.GetIID();
+            const IID = await this.GetIID();
             if (!IID)
                 return null;
             const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
@@ -154,11 +166,11 @@ class CookiesHelper {
     }
     // #endregion
     // #region "Device Security Code"
-    GetDeviceSecurityCode() {
+    async GetDeviceSecurityCode() {
         try {
-            const IID = this.GetIID();
-            const DEK = this.GetDEK();
-            const USR = this.GetUSR();
+            const IID = await this.GetIID();
+            const DEK = await this.GetDEK();
+            const USR = await this.GetUSR();
             if (!DEK || !USR) {
                 return "";
             }
@@ -169,17 +181,18 @@ class CookiesHelper {
         }
         catch (error) {
             console.error(error);
+            return "";
         }
     }
     // #endregion
     // #region "Access Token"
-    GetAccessToken() {
+    async GetAccessToken() {
         try {
-            const IID = this.GetIID();
-            const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
-            const accessToken = this.GET("access_token");
-            if (!accessToken)
+            const IID = await this.GetIID();
+            const accessToken = await this.GET("access_token");
+            if (!accessToken || !IID)
                 return "";
+            const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
             const decryptedAccessToken = CipherHelper.Decrypt(accessToken, key, iv);
             return decryptedAccessToken;
         }
@@ -187,20 +200,22 @@ class CookiesHelper {
             console.error(error);
         }
     }
-    SetAccessToken(accessToken, expires) {
+    async SetAccessToken(accessToken, expires) {
         try {
-            const IID = this.GetIID();
+            const IID = await this.GetIID();
+            if (!IID)
+                return;
             const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
             const encryptedAccessToken = CipherHelper.Encrypt(accessToken, key, iv);
-            this.SET("access_token", encryptedAccessToken, expires);
+            await this.SET("access_token", encryptedAccessToken, expires);
         }
         catch (error) {
             console.error(error);
         }
     }
-    ValidateAccessToken(accessToken) {
+    async ValidateAccessToken(accessToken) {
         try {
-            const IID = this.GetIID();
+            const IID = await this.GetIID();
             if (!IID)
                 return null;
             const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
@@ -215,13 +230,7 @@ class CookiesHelper {
     // #region "JWT Token"
     GetJWTToken() {
         try {
-            const IID = this.GetIID();
-            const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
-            const jwtToken = this.GET("jwt_token");
-            if (!jwtToken)
-                return "";
-            const decryptedAccessToken = CipherHelper.Decrypt(jwtToken, key, iv);
-            return decryptedAccessToken;
+            return this.GET("jwt_token");
         }
         catch (error) {
             console.error(error);
@@ -229,23 +238,7 @@ class CookiesHelper {
     }
     SetJWTToken(jwtToken) {
         try {
-            const IID = this.GetIID();
-            const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
-            const encryptedAccessToken = CipherHelper.Encrypt(jwtToken, key, iv);
-            this.SET("jwt_token", encryptedAccessToken);
-        }
-        catch (error) {
-            console.error(error);
-        }
-    }
-    ValidateJWTToken(jwtToken) {
-        try {
-            const IID = this.GetIID();
-            if (!IID)
-                return null;
-            const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
-            const decryptedAccessToken = CipherHelper.Decrypt(jwtToken, key, iv);
-            return decryptedAccessToken;
+            this.SET("jwt_token", jwtToken);
         }
         catch (error) {
             console.error(error);
@@ -253,85 +246,152 @@ class CookiesHelper {
     }
     // #endregion
     // #region "Getters & Setters"
-    GET(key) {
-        return Cookies.get(key);
+    async GET(key) {
+        const cookie = await this.Cookies.get(key);
+        return cookie?.value || "";
     }
-    SET(key, value, expires) {
-        const defaultExpireDate = new Date(Date.now() + 1000 * 60 * 60 * 24 * 365);
-        Cookies.set(key, value, {
+    async SET(key, value, expires) {
+        const defaultExpireDate = Date.now() + 1000 * 60 * 60 * 24 * 365;
+        await this.Cookies.set({
+            name: key,
+            value: value,
+            domain: this.domain,
+            expires: expires || defaultExpireDate,
             path: "/",
             sameSite: "lax",
-            domain: this.domain || "ggez.one",
-            expires: expires || defaultExpireDate,
         });
     }
-    REMOVE(key) {
-        Cookies.remove(key);
+    async REMOVE(key) {
+        await this.Cookies.delete(key);
     }
     // #endregion
     // #region "Cookie Change Event Listener"
-    cookieEventHandler(e, callback) {
+    async cookieEventHandler(e, params) {
         if (e.changed.length > 0) {
-            this.onChangeHandler(e.changed, callback);
+            await this.onChangeHandler(e.changed, params);
         }
         if (e.deleted.length > 0) {
-            this.onDeleteHandler(e.deleted, callback);
+            await this.onDeleteHandler(e.deleted, params);
         }
     }
-    async onChangeHandler(changed, callback) {
+    async onChangeHandler(changed, params) {
+        const eventType = "change";
         const changedCookie = changed[0];
         switch (changedCookie.name) {
             case "IID":
-                const IID = this.GetIID();
-                const changedIID = this.ValidateIID(changedCookie.value);
+                const IID = await this.GetIID();
+                const changedIID = await this.ValidateIID(changedCookie.value);
                 if (IID != changedIID) {
-                    callback();
+                    params.IID(eventType);
                 }
                 break;
             case "USR":
-                const USR = this.GetUSR();
-                const changedUSR = this.ValidateUSR(changedCookie.value);
-                if (USR.toString() != changedUSR) {
-                    callback();
+                const USR = await this.GetUSR();
+                const changedUSR = await this.ValidateUSR(changedCookie.value);
+                if (JSON.stringify(USR) != changedUSR) {
+                    params.USR(eventType);
                 }
                 break;
             case "DEK":
-                const DEK = this.GetDEK();
-                const changedDEK = this.ValidateDEK(changedCookie.value);
+                const DEK = await this.GetDEK();
+                const changedDEK = await this.ValidateDEK(changedCookie.value);
                 if (DEK != changedDEK) {
-                    callback();
+                    params.DEK(eventType);
                 }
                 break;
             case "access_token":
-                const accessToken = this.GetAccessToken();
-                const changedAccessToken = this.ValidateAccessToken(changedCookie.value);
+                const accessToken = await this.GetAccessToken();
+                console.log("🚀 ~ CookiesHelper ~ onChangeHandler ~ accessToken:", accessToken);
+                const changedAccessToken = await this.ValidateAccessToken(changedCookie.value);
+                console.log("🚀 ~ CookiesHelper ~ onChangeHandler ~ changedAccessToken:", changedAccessToken);
                 if (accessToken != changedAccessToken) {
-                    callback();
+                    params.accessToken(eventType);
                 }
                 break;
             case "jwt_token":
-                const jwtToken = this.GetJWTToken();
-                const changedJWTToken = this.ValidateJWTToken(changedCookie.value);
+                const jwtToken = await this.GetJWTToken();
+                const changedJWTToken = changedCookie.value;
                 if (jwtToken != changedJWTToken) {
-                    callback();
+                    params.jwtToken(eventType);
                 }
                 break;
         }
     }
-    async onDeleteHandler(deleted, callback) {
+    async onDeleteHandler(deleted, params) {
+        const eventType = "delete";
         const deletedCookie = deleted[0];
-        if (["DEK", "USR", "IID", "access_token", "jwt_token"].includes(deletedCookie.name)) {
-            callback();
+        switch (deletedCookie.name) {
+            case "IID":
+                params.IID(eventType);
+                break;
+            case "USR":
+                params.USR(eventType);
+                break;
+            case "DEK":
+                params.DEK(eventType);
+                break;
+            case "access_token":
+                params.accessToken(eventType);
+                break;
+            case "jwt_token":
+                params.jwtToken(eventType);
+                break;
         }
-        if (deletedCookie.name == "IID") {
-            this.SetIID();
+    }
+    addOnChangeEventListener(params) {
+        const handler = (e) => this.cookieEventHandler(e, params);
+        this.eventHandlers.set(this.key, handler);
+        this.Cookies.addEventListener("change", handler);
+    }
+    removeOnChangeEventListener() {
+        const handler = this.eventHandlers.get(this.key);
+        if (handler) {
+            this.Cookies.removeEventListener("change", handler);
+            this.eventHandlers.delete(this.key);
         }
     }
-    addOnChangeEventListener(callback) {
-        window.cookieStore.addEventListener("change", (e) => this.cookieEventHandler(e, callback));
+    // #endregion
+    // #region "Checkers"
+    async IsAuthenticated() {
+        try {
+            const IID = await this.GetIID();
+            const USR = await this.GetUSR();
+            const DEK = await this.GetDEK();
+            const accessToken = await this.GetAccessToken();
+            const jwtToken = await this.GetJWTToken();
+            return !!IID && !!USR && !!DEK && !!accessToken && !!jwtToken;
+        }
+        catch (error) {
+            console.error(error);
+            return false;
+        }
     }
-    removeOnChangeEventListener(callback) {
-        window.cookieStore.removeEventListener("change", (e) => this.cookieEventHandler(e, callback));
+    async GetCredentialsCookies() {
+        try {
+            const IID = await this.GetIID();
+            const USR = await this.GetUSR();
+            const DEK = await this.GetDEK();
+            const accessToken = await this.GetAccessToken();
+            const jwtToken = await this.GetJWTToken();
+            const credentials = {
+                IID: IID || "",
+                USR: USR || { user_id: "0", device_id: "0" },
+                DEK: DEK || "",
+                access_token: accessToken || "",
+                jwt_token: jwtToken || "",
+            };
+            return credentials;
+        }
+        catch (error) {
+            console.error(error);
+            return {
+                IID: "",
+                USR: { user_id: "0", device_id: "0" },
+                DEK: "",
+                access_token: "",
+                jwt_token: "",
+            };
+        }
     }
 }
 export { CookiesHelper };

package/dist/helper/storage/localStorageHelper.d.ts

@@ -2,11 +2,9 @@ import { UserData } from "../../types";
 import { CookiesHelper } from "./cookiesHelper";
 declare class LocalStorageHelper {
     cookiesHelper: CookiesHelper;
-    programId: string;
-    domain: string;
     constructor(programId: string);
-    GetUserData(): UserData;
-    SetUserData(userData: UserData): void;
+    GetUserData(): Promise<UserData>;
+    SetUserData(userData: UserData): Promise<void>;
     GET(key: string): string;
     SET(key: string, value: string): void;
     REMOVE(key: string): void;

package/dist/helper/storage/localStorageHelper.js

@@ -2,22 +2,24 @@ import { CipherHelper } from "../cipherHelper";
 import { CookiesHelper } from "./cookiesHelper";
 class LocalStorageHelper {
     cookiesHelper;
-    programId;
-    domain;
     // #region "Constructor"
     constructor(programId) {
         this.cookiesHelper = new CookiesHelper(programId);
     }
     // #endregion
     // #region "User Data"
-    GetUserData() {
+    async GetUserData() {
         try {
-            const IID = this.cookiesHelper.GetIID();
+            const IID = await this.cookiesHelper.GetIID();
+            if (!IID)
+                return null;
             const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
             const userData = this.GET("CUD");
-            const decryptedUserData = CipherHelper.Decrypt(userData, key, iv);
-            if (decryptedUserData) {
-                return JSON.parse(decryptedUserData);
+            if (userData) {
+                const decryptedUserData = CipherHelper.Decrypt(userData, key, iv);
+                if (decryptedUserData) {
+                    return JSON.parse(decryptedUserData);
+                }
             }
             return null;
         }
@@ -25,9 +27,11 @@ class LocalStorageHelper {
             console.error(error);
         }
     }
-    SetUserData(userData) {
+    async SetUserData(userData) {
         try {
-            const IID = this.cookiesHelper.GetIID();
+            const IID = await this.cookiesHelper.GetIID();
+            if (!IID)
+                return;
             const { key, iv } = CipherHelper.GenerateByInstallationID(IID);
             const data = JSON.stringify(userData);
             const encryptedUserData = CipherHelper.Encrypt(data, key, iv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ggez-banking-sdk",
-  "version": "0.1.169",
+  "version": "0.1.170",
   "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",