shogun-core 4.2.3 → 4.2.4

package/dist/gundb/db.js

@@ -82,6 +82,7 @@ class DataBase {
     constructor(gun, appScope = "shogun") {
         this.user = null;
         this.onAuthCallbacks = [];
+        console.log("[DB] Initializing DataBase");
         // Initialize event emitter
         this.eventEmitter = new eventEmitter_1.EventEmitter();
         // Validate Gun instance
@@ -101,31 +102,38 @@ class DataBase {
             throw new Error(`Gun instance is invalid: gun.on is not a function. Received gun.on type: ${typeof gun.on}`);
         }
         this.gun = gun;
+        console.log("[DB] Gun instance validated");
         // Recall only if NOT disabled and there's a "pair" in sessionStorage
         this.user = this.gun.user().recall({ sessionStorage: true });
+        console.log("[DB] User recall completed");
         this.subscribeToAuthEvents();
+        console.log("[DB] Auth events subscribed");
         this.crypto = crypto;
         this.sea = sea_1.default;
         this._rxjs = new rxjs_1.RxJS(this.gun);
         this.node = null;
+        console.log("[DB] DataBase initialization completed");
     }
     /**
      * Initialize the GunInstance asynchronously
      * This method should be called after construction to perform async operations
      */
     initialize(appScope = "shogun") {
+        console.log(`[DB] Initializing with appScope: ${appScope}`);
         try {
             const sessionResult = this.restoreSession();
+            console.log(`[DB] Session restore result: ${sessionResult.success ? "success" : "failed"}`);
             this.node = this.gun.get(appScope);
+            console.log("[DB] App scope node initialized");
             if (sessionResult.success) {
-                // Session automatically restored
+                console.log("[DB] Session automatically restored");
             }
             else {
-                // No previous session to restore
+                console.log("[DB] No previous session to restore");
             }
         }
         catch (error) {
-            console.error("Error during automatic session restoration:", error);
+            console.error("[DB] Error during automatic session restoration:", error);
         }
     }
     subscribeToAuthEvents() {
@@ -148,13 +156,16 @@ class DataBase {
      * @param peer URL of the peer to add
      */
     addPeer(peer) {
+        console.log(`[PEER] Adding peer: ${peer}`);
         this.gun.opt({ peers: [peer] });
+        console.log(`[PEER] Peer added successfully`);
     }
     /**
      * Removes a peer from the network
      * @param peer URL of the peer to remove
      */
     removePeer(peer) {
+        console.log(`[PEER] Removing peer: ${peer}`);
         try {
             // Get current peers from Gun instance
             const gunOpts = this.gun._.opt;
@@ -166,13 +177,14 @@ class DataBase {
                 if (peerConnection && typeof peerConnection.close === "function") {
                     peerConnection.close();
                 }
+                console.log(`[PEER] Peer removed successfully`);
             }
             else {
-                console.error(`Peer not found in current connections: ${peer}`);
+                console.error(`[PEER] Peer not found in current connections: ${peer}`);
             }
         }
         catch (error) {
-            console.error(`Error removing peer ${peer}:`, error);
+            console.error(`[PEER] Error removing peer ${peer}:`, error);
         }
     }
     /**
@@ -383,16 +395,7 @@ class DataBase {
      */
     async put(path, data) {
         const node = this.navigateToPath(this.node, path);
-        return new Promise((resolve, reject) => {
-            node.put(data, (ack) => {
-                if (ack && ack.err) {
-                    reject(new Error(ack.err));
-                }
-                else {
-                    resolve(ack);
-                }
-            });
-        });
+        return await node.put(data).then();
     }
     /**
      * Sets data at the specified path
@@ -402,16 +405,7 @@ class DataBase {
      */
     async set(path, data) {
         const node = this.navigateToPath(this.node, path);
-        return new Promise((resolve, reject) => {
-            node.set(data, (ack) => {
-                if (ack && ack.err) {
-                    reject(new Error(ack.err));
-                }
-                else {
-                    resolve(ack);
-                }
-            });
-        });
+        return await node.set(data).then();
     }
     /**
      * Removes data at the specified path
@@ -420,16 +414,7 @@ class DataBase {
      */
     async remove(path) {
         const node = this.navigateToPath(this.node, path);
-        return new Promise((resolve, reject) => {
-            node.put(null, (ack) => {
-                if (ack && ack.err) {
-                    reject(new Error(ack.err));
-                }
-                else {
-                    resolve(ack);
-                }
-            });
-        });
+        return await node.put(null).then();
     }
     /**
      * Checks if a user is currently logged in
@@ -931,18 +916,20 @@ class DataBase {
         });
     }
     async runPostAuthOnAuthResult(username, userPub, authResult) {
-        // Setting up user profile after authentication
+        console.log(`[POSTAUTH] Starting post-auth setup for user: ${username}, userPub: ${userPub}`);
         try {
+            console.log(`[POSTAUTH] Validating parameters for user: ${username}`);
             // Validate required parameters
             if (!username ||
                 typeof username !== "string" ||
                 username.trim().length === 0) {
+                console.error(`[POSTAUTH] Invalid username provided: ${username}`);
                 throw new Error("Invalid username provided");
             }
             if (!userPub ||
                 typeof userPub !== "string" ||
                 userPub.trim().length === 0) {
-                console.error("Invalid userPub provided:", {
+                console.error("[POSTAUTH] Invalid userPub provided:", {
                     userPub,
                     type: typeof userPub,
                     authResult,
@@ -951,34 +938,38 @@ class DataBase {
             }
             // Additional validation for userPub format
             if (!userPub.includes(".") || userPub.length < 10) {
-                console.error("Invalid userPub format:", userPub);
+                console.error(`[POSTAUTH] Invalid userPub format: ${userPub}`);
                 throw new Error("Invalid userPub format");
             }
+            console.log(`[POSTAUTH] Parameters validated for user: ${username}`);
             // Normalize username to prevent path issues
             const normalizedUsername = username.trim().toLowerCase();
             if (normalizedUsername.length === 0) {
+                console.error(`[POSTAUTH] Normalized username is empty for user: ${username}`);
                 throw new Error("Username cannot be empty");
             }
-            const existingUser = await new Promise((resolve) => {
-                this.gun.get(userPub).once((data) => {
-                    resolve(data);
-                });
-            });
+            console.log(`[POSTAUTH] Normalized username: ${normalizedUsername}`);
+            console.log(`[POSTAUTH] Checking if user exists: ${userPub}`);
+            const existingUser = await this.gun.get(userPub).then();
             const isNewUser = !existingUser || !existingUser.alias;
-            // const isNewUser = true;
+            console.log(`[POSTAUTH] User is ${isNewUser ? "NEW" : "EXISTING"}: ${userPub}`);
             // Get user's encryption public key (epub) for comprehensive tracking
             const userInstance = this.gun.user();
             const userSea = userInstance?._?.sea;
             const epub = userSea?.epub;
+            console.log(`[POSTAUTH] User epub retrieved: ${epub ? "yes" : "no"}`);
             // Enhanced user tracking system
+            console.log(`[POSTAUTH] Setting up comprehensive user tracking for: ${normalizedUsername}`);
             const trackingResult = await this.setupComprehensiveUserTracking(normalizedUsername, userPub, epub);
             if (!trackingResult) {
+                console.error(`[POSTAUTH] Comprehensive user tracking setup failed for: ${normalizedUsername}`);
                 return {
                     success: false,
                     error: "Comprehensive user tracking setup failed",
                 };
             }
-            return {
+            console.log(`[POSTAUTH] User tracking setup completed successfully for: ${normalizedUsername}`);
+            const result = {
                 success: true,
                 userPub: userPub,
                 username: normalizedUsername,
@@ -993,9 +984,11 @@ class DataBase {
                     }
                     : undefined,
             };
+            console.log(`[POSTAUTH] Post-auth setup completed successfully for user: ${username}`);
+            return result;
         }
         catch (error) {
-            console.error(`Error in post-authentication setup: ${error}`);
+            console.error(`[POSTAUTH] Error in post-authentication setup for ${username}:`, error);
             return {
                 success: false,
                 error: `Post-authentication setup failed: ${error}`,
@@ -1007,43 +1000,66 @@ class DataBase {
      * Creates multiple indexes for efficient user discovery
      */
     async setupComprehensiveUserTracking(username, userPub, epub) {
+        console.log(`[TRACKING] Starting comprehensive user tracking setup for: ${username}, userPub: ${userPub}`);
         try {
             // 1. Create alias index: ~@alias -> userPub (for GunDB compatibility)
+            console.log(`[TRACKING] Step 1: Creating alias index for ${username}`);
             const aliasIndexResult = await this.createAliasIndex(username, userPub);
             if (!aliasIndexResult) {
+                console.error(`[TRACKING] Failed to create alias index for ${username}`);
                 return false;
             }
+            console.log(`[TRACKING] Step 1 completed: Alias index created for ${username}`);
             // 2. Create username mapping: usernames/alias -> userPub
+            console.log(`[TRACKING] Step 2: Creating username mapping for ${username}`);
             const usernameMappingResult = await this.createUsernameMapping(username, userPub);
             if (!usernameMappingResult) {
+                console.error(`[TRACKING] Failed to create username mapping for ${username}`);
                 return false;
             }
+            console.log(`[TRACKING] Step 2 completed: Username mapping created for ${username}`);
             // 3. Create user registry: users/userPub -> user data
+            console.log(`[TRACKING] Step 3: Creating user registry for ${username}`);
             const userRegistryResult = await this.createUserRegistry(username, userPub, epub);
             if (!userRegistryResult) {
+                console.error(`[TRACKING] Failed to create user registry for ${username}`);
                 return false;
             }
+            console.log(`[TRACKING] Step 3 completed: User registry created for ${username}`);
             // 4. Create reverse lookup: userPub -> alias
+            console.log(`[TRACKING] Step 4: Creating reverse lookup for ${username}`);
             const reverseLookupResult = await this.createReverseLookup(username, userPub);
             if (!reverseLookupResult) {
+                console.error(`[TRACKING] Failed to create reverse lookup for ${username}`);
                 return false;
             }
+            console.log(`[TRACKING] Step 4 completed: Reverse lookup created for ${username}`);
             // 5. Create epub index: epubKeys/epub -> userPub (for encryption lookups)
             if (epub) {
+                console.log(`[TRACKING] Step 5: Creating epub index for ${username}`);
                 const epubIndexResult = await this.createEpubIndex(epub, userPub);
                 if (!epubIndexResult) {
+                    console.error(`[TRACKING] Failed to create epub index for ${username}`);
                     return false;
                 }
+                console.log(`[TRACKING] Step 5 completed: Epub index created for ${username}`);
+            }
+            else {
+                console.log(`[TRACKING] Step 5 skipped: No epub available for ${username}`);
             }
             // 6. Create user metadata in user's own node
+            console.log(`[TRACKING] Step 6: Creating user metadata for ${username}`);
             const userMetadataResult = await this.createUserMetadata(username, userPub, epub);
             if (!userMetadataResult) {
+                console.error(`[TRACKING] Failed to create user metadata for ${username}`);
                 return false;
             }
+            console.log(`[TRACKING] Step 6 completed: User metadata created for ${username}`);
+            console.log(`[TRACKING] Comprehensive user tracking setup completed successfully for: ${username}`);
             return true;
         }
         catch (error) {
-            console.error(`Error in comprehensive user tracking setup: ${error}`);
+            console.error(`[TRACKING] Error in comprehensive user tracking setup for ${username}:`, error);
             // Don't throw - continue with other operations
             return false;
         }
@@ -1135,20 +1151,18 @@ class DataBase {
      */
     async createReverseLookup(username, userPub) {
         try {
-            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);
-                    }
-                });
-            });
+            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;
+            }
         }
         catch (error) {
             console.error(`Error creating reverse lookup: ${error}`);
@@ -1221,14 +1235,9 @@ class DataBase {
             }
             // Method 1: Try GunDB standard alias lookup (~@alias)
             try {
-                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"];
+                const aliasData = await this.gun.get(`~@${normalizedAlias}`).then();
+                if (aliasData && aliasData["~pubKeyOfUser"]) {
+                    const userPub = aliasData["~pubKeyOfUser"]["#"] || aliasData["~pubKeyOfUser"];
                     if (userPub) {
                         const userData = await this.getUserDataByPub(userPub);
                         if (userData) {
@@ -1242,14 +1251,10 @@ class DataBase {
             }
             // Method 2: Try username mapping (usernames/alias -> userPub)
             try {
-                const userPub = await new Promise((resolve) => {
-                    this.node
-                        .get("usernames")
-                        .get(normalizedAlias)
-                        .once((data) => {
-                        resolve(data);
-                    });
-                });
+                const userPub = await this.node
+                    .get("usernames")
+                    .get(normalizedAlias)
+                    .then();
                 if (userPub) {
                     const userData = await this.getUserDataByPub(userPub);
                     if (userData) {
@@ -1279,14 +1284,7 @@ class DataBase {
             }
             // Method 1: Try user registry (users/userPub -> user data)
             try {
-                const userData = await new Promise((resolve) => {
-                    this.node
-                        .get("users")
-                        .get(userPub)
-                        .once((data) => {
-                        resolve(data);
-                    });
-                });
+                const userData = await this.node.get("users").get(userPub).then();
                 if (userData && userData.username) {
                     return {
                         userPub: userData.userPub || userPub,
@@ -1302,11 +1300,7 @@ class DataBase {
             }
             // Method 2: Try user's own node
             try {
-                const userNodeData = await new Promise((resolve) => {
-                    this.gun.get(userPub).once((data) => {
-                        resolve(data);
-                    });
-                });
+                const userNodeData = await this.gun.get(userPub).then();
                 if (userNodeData && userNodeData.username) {
                     return {
                         userPub: userPub,
@@ -1337,14 +1331,7 @@ class DataBase {
             if (!epub || typeof epub !== "string") {
                 return null;
             }
-            const userPub = await new Promise((resolve) => {
-                this.node
-                    .get("epubKeys")
-                    .get(epub)
-                    .once((data) => {
-                    resolve(data);
-                });
-            });
+            const userPub = await this.node.get("epubKeys").get(epub).then();
             return userPub || null;
         }
         catch (error) {
@@ -1362,14 +1349,7 @@ class DataBase {
             if (!userPub || typeof userPub !== "string") {
                 return null;
             }
-            const alias = await new Promise((resolve) => {
-                this.node
-                    .get("userAliases")
-                    .get(userPub)
-                    .once((data) => {
-                    resolve(data);
-                });
-            });
+            const alias = await this.node.get("userAliases").get(userPub).then();
             return alias || null;
         }
         catch (error) {
@@ -1408,39 +1388,19 @@ class DataBase {
             const timestamp = Date.now();
             // Update in user registry
             try {
-                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();
-                        }
-                    });
-                });
+                await this.node
+                    .get("users")
+                    .get(userPub)
+                    .get("lastSeen")
+                    .put(timestamp)
+                    .then();
             }
             catch (error) {
                 console.error(`Failed to update lastSeen in user registry:`, error);
             }
             // Update in user's own node
             try {
-                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();
-                        }
-                    });
-                });
+                await this.gun.get(userPub).get("lastSeen").put(timestamp).then();
             }
             catch (error) {
                 console.error(`Failed to update lastSeen in user node:`, error);
@@ -1691,19 +1651,10 @@ class DataBase {
                 questions: JSON.stringify(securityQuestions),
                 hint: encryptedHint,
             };
-            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);
-                    }
-                });
-            });
+            const ack = await this.node.get(userPub)
+                .get("security")
+                .put(securityPayload)
+                .then();
             if (ack.err) {
                 console.error("Error saving security data to public graph:", ack.err);
                 throw new Error(ack.err);
@@ -1726,26 +1677,15 @@ class DataBase {
         try {
             // Find the user's data using direct lookup
             const normalizedUsername = username.trim().toLowerCase();
-            const userPub = await new Promise((resolve) => {
-                this.node
-                    .get("usernames")
-                    .get(normalizedUsername)
-                    .once((data) => {
-                    resolve(data);
-                });
-            });
+            const userPub = (await this.node.get("usernames").get(normalizedUsername).then()) ||
+                null;
             if (!userPub) {
                 return { success: false, error: "User not found" };
             }
             // Access the user's security data directly from their public key node
-            const securityData = await new Promise((resolve) => {
-                this.node
-                    .get(userPub)
-                    .get("security")
-                    .once((data) => {
-                    resolve(data);
-                });
-            });
+            const securityData = await this.node.get(userPub)
+                .get("security")
+                .then();
             if (!securityData || !securityData.hint) {
                 return {
                     success: false,

package/package.json

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