shogun-core 4.2.2 → 4.2.4

package/dist/browser/shogun-core.js

@@ -133841,6 +133841,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
@@ -133860,31 +133861,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() {
@@ -133907,13 +133915,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;
@@ -133925,13 +133936,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);
         }
     }
     /**
@@ -134664,18 +134676,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,
@@ -134684,30 +134698,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");
             }
+            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,
@@ -134722,9 +134744,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}`,
@@ -134736,43 +134760,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;
         }