shogun-core 4.2.1 → 4.2.3

package/dist/gundb/db.js

@@ -383,7 +383,16 @@ class DataBase {
      */
     async put(path, data) {
         const node = this.navigateToPath(this.node, path);
-        return await node.put(data).then();
+        return new Promise((resolve, reject) => {
+            node.put(data, (ack) => {
+                if (ack && ack.err) {
+                    reject(new Error(ack.err));
+                }
+                else {
+                    resolve(ack);
+                }
+            });
+        });
     }
     /**
      * Sets data at the specified path
@@ -393,7 +402,16 @@ class DataBase {
      */
     async set(path, data) {
         const node = this.navigateToPath(this.node, path);
-        return await node.set(data).then();
+        return new Promise((resolve, reject) => {
+            node.set(data, (ack) => {
+                if (ack && ack.err) {
+                    reject(new Error(ack.err));
+                }
+                else {
+                    resolve(ack);
+                }
+            });
+        });
     }
     /**
      * Removes data at the specified path
@@ -402,7 +420,16 @@ class DataBase {
      */
     async remove(path) {
         const node = this.navigateToPath(this.node, path);
-        return await node.put(null).then();
+        return new Promise((resolve, reject) => {
+            node.put(null, (ack) => {
+                if (ack && ack.err) {
+                    reject(new Error(ack.err));
+                }
+                else {
+                    resolve(ack);
+                }
+            });
+        });
     }
     /**
      * Checks if a user is currently logged in
@@ -932,7 +959,11 @@ class DataBase {
             if (normalizedUsername.length === 0) {
                 throw new Error("Username cannot be empty");
             }
-            const existingUser = await this.gun.get(userPub).then();
+            const existingUser = await new Promise((resolve) => {
+                this.gun.get(userPub).once((data) => {
+                    resolve(data);
+                });
+            });
             const isNewUser = !existingUser || !existingUser.alias;
             // const isNewUser = true;
             // Get user's encryption public key (epub) for comprehensive tracking
@@ -1025,14 +1056,17 @@ class DataBase {
             const aliasNode = this.gun.get(`~@${username}`);
             // For Gun.js alias validation to pass, the data must be exactly equal to the key
             // The key is `~@${username}`, so we store that as the data
-            const ack = await aliasNode.put(`~@${username}`).then();
-            if (ack.err) {
-                console.error(`Error creating alias index: ${ack.err}`);
-                return false;
-            }
-            else {
-                return true;
-            }
+            return new Promise((resolve) => {
+                aliasNode.put(`~@${username}`, (ack) => {
+                    if (ack && ack.err) {
+                        console.error(`Error creating alias index: ${ack.err}`);
+                        resolve(false);
+                    }
+                    else {
+                        resolve(true);
+                    }
+                });
+            });
         }
         catch (error) {
             console.error(`Error creating alias index: ${error}`);
@@ -1044,18 +1078,20 @@ class DataBase {
      */
     async createUsernameMapping(username, userPub) {
         try {
-            const ack = await this.node
-                .get("usernames")
-                .get(username)
-                .put(userPub)
-                .then();
-            if (ack.err) {
-                console.error(`Error creating username mapping: ${ack.err}`);
-                return false;
-            }
-            else {
-                return true;
-            }
+            return new Promise((resolve) => {
+                this.node
+                    .get("usernames")
+                    .get(username)
+                    .put(userPub, (ack) => {
+                    if (ack && ack.err) {
+                        console.error(`Error creating username mapping: ${ack.err}`);
+                        resolve(false);
+                    }
+                    else {
+                        resolve(true);
+                    }
+                });
+            });
         }
         catch (error) {
             console.error(`Error creating username mapping: ${error}`);
@@ -1074,18 +1110,20 @@ class DataBase {
                 registeredAt: Date.now().toString(),
                 lastSeen: Date.now().toString(),
             };
-            const ack = await this.node
-                .get("users")
-                .get(userPub)
-                .put(userData)
-                .then();
-            if (ack.err) {
-                console.error(`Error creating user registry: ${ack.err}`);
-                return false;
-            }
-            else {
-                return true;
-            }
+            return new Promise((resolve) => {
+                this.node
+                    .get("users")
+                    .get(userPub)
+                    .put(userData, (ack) => {
+                    if (ack && ack.err) {
+                        console.error(`Error creating user registry: ${ack.err}`);
+                        resolve(false);
+                    }
+                    else {
+                        resolve(true);
+                    }
+                });
+            });
         }
         catch (error) {
             console.error(`Error creating user registry: ${error}`);
@@ -1097,18 +1135,20 @@ class DataBase {
      */
     async createReverseLookup(username, userPub) {
         try {
-            const ack = await this.node
-                .get("userAliases")
-                .get(userPub)
-                .put(username)
-                .then();
-            if (ack.err) {
-                console.error(`Error creating reverse lookup: ${ack.err}`);
-                return false;
-            }
-            else {
-                return true;
-            }
+            return new Promise((resolve) => {
+                this.node
+                    .get("userAliases")
+                    .get(userPub)
+                    .put(username, (ack) => {
+                    if (ack && ack.err) {
+                        console.error(`Error creating reverse lookup: ${ack.err}`);
+                        resolve(false);
+                    }
+                    else {
+                        resolve(true);
+                    }
+                });
+            });
         }
         catch (error) {
             console.error(`Error creating reverse lookup: ${error}`);
@@ -1120,14 +1160,20 @@ class DataBase {
      */
     async createEpubIndex(epub, userPub) {
         try {
-            const ack = await this.node.get("epubKeys").get(epub).put(userPub).then();
-            if (ack.err) {
-                console.error(`Error creating epub index: ${ack.err}`);
-                return false;
-            }
-            else {
-                return true;
-            }
+            return new Promise((resolve) => {
+                this.node
+                    .get("epubKeys")
+                    .get(epub)
+                    .put(userPub, (ack) => {
+                    if (ack && ack.err) {
+                        console.error(`Error creating epub index: ${ack.err}`);
+                        resolve(false);
+                    }
+                    else {
+                        resolve(true);
+                    }
+                });
+            });
         }
         catch (error) {
             console.error(`Error creating epub index: ${error}`);
@@ -1145,14 +1191,17 @@ class DataBase {
                 registeredAt: Date.now(),
                 lastSeen: Date.now(),
             };
-            const ack = await this.gun.get(userPub).put(userMetadata).then();
-            if (ack.err) {
-                console.error(`Error creating user metadata: ${ack.err}`);
-                return false;
-            }
-            else {
-                return true;
-            }
+            return new Promise((resolve) => {
+                this.gun.get(userPub).put(userMetadata, (ack) => {
+                    if (ack && ack.err) {
+                        console.error(`Error creating user metadata: ${ack.err}`);
+                        resolve(false);
+                    }
+                    else {
+                        resolve(true);
+                    }
+                });
+            });
         }
         catch (error) {
             console.error(`Error creating user metadata: ${error}`);
@@ -1172,9 +1221,14 @@ class DataBase {
             }
             // Method 1: Try GunDB standard alias lookup (~@alias)
             try {
-                const aliasData = await this.gun.get(`~@${normalizedAlias}`).then();
-                if (aliasData && aliasData["~pubKeyOfUser"]) {
-                    const userPub = aliasData["~pubKeyOfUser"]["#"] || aliasData["~pubKeyOfUser"];
+                const aliasData = this.gun.get(`~@${normalizedAlias}`);
+                const aliasDataObj = await new Promise((resolve) => {
+                    aliasData.once((data) => {
+                        resolve(data);
+                    });
+                });
+                if (aliasDataObj && aliasDataObj["~pubKeyOfUser"]) {
+                    const userPub = aliasDataObj["~pubKeyOfUser"]["#"] || aliasDataObj["~pubKeyOfUser"];
                     if (userPub) {
                         const userData = await this.getUserDataByPub(userPub);
                         if (userData) {
@@ -1188,10 +1242,14 @@ class DataBase {
             }
             // Method 2: Try username mapping (usernames/alias -> userPub)
             try {
-                const userPub = await this.node
-                    .get("usernames")
-                    .get(normalizedAlias)
-                    .then();
+                const userPub = await new Promise((resolve) => {
+                    this.node
+                        .get("usernames")
+                        .get(normalizedAlias)
+                        .once((data) => {
+                        resolve(data);
+                    });
+                });
                 if (userPub) {
                     const userData = await this.getUserDataByPub(userPub);
                     if (userData) {
@@ -1221,7 +1279,14 @@ class DataBase {
             }
             // Method 1: Try user registry (users/userPub -> user data)
             try {
-                const userData = await this.node.get("users").get(userPub).then();
+                const userData = await new Promise((resolve) => {
+                    this.node
+                        .get("users")
+                        .get(userPub)
+                        .once((data) => {
+                        resolve(data);
+                    });
+                });
                 if (userData && userData.username) {
                     return {
                         userPub: userData.userPub || userPub,
@@ -1237,7 +1302,11 @@ class DataBase {
             }
             // Method 2: Try user's own node
             try {
-                const userNodeData = await this.gun.get(userPub).then();
+                const userNodeData = await new Promise((resolve) => {
+                    this.gun.get(userPub).once((data) => {
+                        resolve(data);
+                    });
+                });
                 if (userNodeData && userNodeData.username) {
                     return {
                         userPub: userPub,
@@ -1268,7 +1337,14 @@ class DataBase {
             if (!epub || typeof epub !== "string") {
                 return null;
             }
-            const userPub = await this.node.get("epubKeys").get(epub).then();
+            const userPub = await new Promise((resolve) => {
+                this.node
+                    .get("epubKeys")
+                    .get(epub)
+                    .once((data) => {
+                    resolve(data);
+                });
+            });
             return userPub || null;
         }
         catch (error) {
@@ -1286,7 +1362,14 @@ class DataBase {
             if (!userPub || typeof userPub !== "string") {
                 return null;
             }
-            const alias = await this.node.get("userAliases").get(userPub).then();
+            const alias = await new Promise((resolve) => {
+                this.node
+                    .get("userAliases")
+                    .get(userPub)
+                    .once((data) => {
+                    resolve(data);
+                });
+            });
             return alias || null;
         }
         catch (error) {
@@ -1325,19 +1408,39 @@ class DataBase {
             const timestamp = Date.now();
             // Update in user registry
             try {
-                await this.node
-                    .get("users")
-                    .get(userPub)
-                    .get("lastSeen")
-                    .put(timestamp)
-                    .then();
+                await new Promise((resolve, reject) => {
+                    this.node
+                        .get("users")
+                        .get(userPub)
+                        .get("lastSeen")
+                        .put(timestamp, (ack) => {
+                        if (ack && ack.err) {
+                            reject(new Error(ack.err));
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
             }
             catch (error) {
                 console.error(`Failed to update lastSeen in user registry:`, error);
             }
             // Update in user's own node
             try {
-                await this.gun.get(userPub).get("lastSeen").put(timestamp).then();
+                await new Promise((resolve, reject) => {
+                    this.gun
+                        .get(userPub)
+                        .get("lastSeen")
+                        .put(timestamp, (ack) => {
+                        if (ack && ack.err) {
+                            reject(new Error(ack.err));
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
             }
             catch (error) {
                 console.error(`Failed to update lastSeen in user node:`, error);
@@ -1588,10 +1691,19 @@ class DataBase {
                 questions: JSON.stringify(securityQuestions),
                 hint: encryptedHint,
             };
-            const ack = await this.node.get(userPub)
-                .get("security")
-                .put(securityPayload)
-                .then();
+            const ack = await new Promise((resolve, reject) => {
+                this.node
+                    .get(userPub)
+                    .get("security")
+                    .put(securityPayload, (ack) => {
+                    if (ack && ack.err) {
+                        reject(new Error(ack.err));
+                    }
+                    else {
+                        resolve(ack);
+                    }
+                });
+            });
             if (ack.err) {
                 console.error("Error saving security data to public graph:", ack.err);
                 throw new Error(ack.err);
@@ -1614,15 +1726,26 @@ class DataBase {
         try {
             // Find the user's data using direct lookup
             const normalizedUsername = username.trim().toLowerCase();
-            const userPub = (await this.node.get("usernames").get(normalizedUsername).then()) ||
-                null;
+            const userPub = await new Promise((resolve) => {
+                this.node
+                    .get("usernames")
+                    .get(normalizedUsername)
+                    .once((data) => {
+                    resolve(data);
+                });
+            });
             if (!userPub) {
                 return { success: false, error: "User not found" };
             }
             // Access the user's security data directly from their public key node
-            const securityData = await this.node.get(userPub)
-                .get("security")
-                .then();
+            const securityData = await new Promise((resolve) => {
+                this.node
+                    .get(userPub)
+                    .get("security")
+                    .once((data) => {
+                    resolve(data);
+                });
+            });
             if (!securityData || !securityData.hint) {
                 return {
                     success: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shogun-core",
-  "version": "4.2.1",
+  "version": "4.2.3",
   "description": "SHOGUN CORE - Core library for Shogun Ecosystem",
   "main": "./dist/index.js",
   "module": "./dist/index.js",