holosphere 2.0.0-alpha2 → 2.0.0-alpha5

package/src/storage/nostr-async.js

@@ -5,10 +5,23 @@
 
 /**
  * Global subscription manager to prevent duplicate subscriptions
- * Maps: pathPrefix -> subscription object
+ * Maps: subscriptionKey -> subscription object
  */
 const globalSubscriptions = new Map();
 
+/**
+ * Single-path subscription manager (for nostrSubscribe)
+ * Maps: subscriptionKey -> { subscription, callbacks: [] }
+ */
+const singlePathSubscriptions = new Map();
+
+/**
+ * Query deduplication for nostrGet - prevents duplicate relay queries
+ * Maps: queryKey -> { promise, timestamp, callbacks: [] }
+ */
+const pendingQueries = new Map();
+const QUERY_DEDUP_WINDOW = 2000; // 2 second window for deduplication
+
 /**
  * Write data as Nostr event (parameterized replaceable event)
  * @param {Object} client - NostrClient instance
@@ -34,6 +47,7 @@ export async function nostrPut(client, path, data, kind = 30000) {
 /**
  * Read data from Nostr (query by d-tag)
  * LOCAL-FIRST: Checks persistent storage first, never blocks on network
+ * Uses query deduplication to prevent duplicate relay queries within a time window
  * @param {Object} client - NostrClient instance
  * @param {string} path - Path identifier
  * @param {number} kind - Event kind (default: 30000)
@@ -77,7 +91,42 @@ export async function nostrGet(client, path, kind = 30000, options = {}) {
     }
   }
 
-  // Fallback to relay query (existing logic)
+  // Query deduplication: Check if same query is already pending
+  const queryKey = `get:${client.publicKey}:${kind}:${path}:${authors.join(',')}`;
+  const pending = pendingQueries.get(queryKey);
+
+  if (pending && Date.now() - pending.timestamp < QUERY_DEDUP_WINDOW) {
+    // Reuse pending query result
+    return pending.promise;
+  }
+
+  // Create new query with deduplication
+  const queryPromise = _executeNostrGet(client, path, kind, authors, timeout, options);
+
+  pendingQueries.set(queryKey, {
+    promise: queryPromise,
+    timestamp: Date.now(),
+  });
+
+  // Clean up after promise resolves
+  queryPromise.finally(() => {
+    // Remove from pending after a short delay to allow coalescing
+    setTimeout(() => {
+      const current = pendingQueries.get(queryKey);
+      if (current && current.promise === queryPromise) {
+        pendingQueries.delete(queryKey);
+      }
+    }, QUERY_DEDUP_WINDOW);
+  });
+
+  return queryPromise;
+}
+
+/**
+ * Internal function to execute nostrGet query
+ * @private
+ */
+async function _executeNostrGet(client, path, kind, authors, timeout, options) {
   const filter = {
     kinds: [kind],
     authors: authors, // Support multiple authors for cross-holosphere queries
@@ -96,13 +145,17 @@ export async function nostrGet(client, path, kind = 30000, options = {}) {
 
   try {
     const data = JSON.parse(event.content);
+    // Skip deleted items
+    if (data._deleted) {
+      return null;
+    }
     // Optionally include author information
     if (options.includeAuthor) {
       data._author = event.pubkey;
     }
     return data;
   } catch (error) {
-    console.error('Failed to parse event content:', error);
+    // Silent - return null for unparseable events
     return null;
   }
 }
@@ -110,6 +163,7 @@ export async function nostrGet(client, path, kind = 30000, options = {}) {
 /**
  * Query all events under a path prefix
  * LOCAL-FIRST: Checks persistent storage first, never blocks on network
+ * Uses query deduplication to prevent duplicate relay queries within a time window
  * @param {Object} client - NostrClient instance
  * @param {string} pathPrefix - Path prefix to match
  * @param {number} kind - Event kind (default: 30000)
@@ -143,8 +197,11 @@ export async function nostrGetAll(client, pathPrefix, kind = 30000, options = {}
           try {
             const data = JSON.parse(event.content);
 
-            // Skip deleted items
-            if (data._deleted) continue;
+            // Handle deleted items - remove from map if this is newer
+            if (data._deleted) {
+              byPath.delete(path);
+              continue;
+            }
 
             // Optionally include author information
             if (options.includeAuthor) {
@@ -167,7 +224,41 @@ export async function nostrGetAll(client, pathPrefix, kind = 30000, options = {}
     }
   }
 
-  // Fallback to relay query (existing logic)
+  // Query deduplication: Check if same query is already pending
+  const queryKey = `getAll:${client.publicKey}:${kind}:${pathPrefix}:${authors.join(',')}`;
+  const pending = pendingQueries.get(queryKey);
+
+  if (pending && Date.now() - pending.timestamp < QUERY_DEDUP_WINDOW) {
+    // Reuse pending query result
+    return pending.promise;
+  }
+
+  // Create new query with deduplication
+  const queryPromise = _executeNostrGetAll(client, pathPrefix, kind, authors, timeout, limit, options);
+
+  pendingQueries.set(queryKey, {
+    promise: queryPromise,
+    timestamp: Date.now(),
+  });
+
+  // Clean up after promise resolves
+  queryPromise.finally(() => {
+    setTimeout(() => {
+      const current = pendingQueries.get(queryKey);
+      if (current && current.promise === queryPromise) {
+        pendingQueries.delete(queryKey);
+      }
+    }, QUERY_DEDUP_WINDOW);
+  });
+
+  return queryPromise;
+}
+
+/**
+ * Internal function to execute nostrGetAll query
+ * @private
+ */
+async function _executeNostrGetAll(client, pathPrefix, kind, authors, timeout, limit, options) {
   const filter = {
     kinds: [kind],
     authors: authors,
@@ -192,8 +283,11 @@ export async function nostrGetAll(client, pathPrefix, kind = 30000, options = {}
       try {
         const data = JSON.parse(event.content);
 
-        // Skip deleted items
-        if (data._deleted) continue;
+        // Handle deleted items - remove from map if this is newer
+        if (data._deleted) {
+          byPath.delete(dTag);
+          continue;
+        }
 
         // Optionally include author information
         if (options.includeAuthor) {
@@ -201,7 +295,7 @@ export async function nostrGetAll(client, pathPrefix, kind = 30000, options = {}
         }
         byPath.set(dTag, { data, created_at: event.created_at });
       } catch (error) {
-        console.error('Failed to parse event content:', error);
+        // Silent - skip unparseable events
       }
     }
   }
@@ -252,13 +346,22 @@ export async function nostrGetAllHybrid(client, pathPrefix, kind = 30000, option
     if (!existing || event.created_at > existing.created_at) {
       try {
         const data = JSON.parse(event.content);
+        // Skip null or non-object content
+        if (data === null || typeof data !== 'object') {
+          continue;
+        }
+        // Handle deleted items - remove from map if this is newer
+        if (data._deleted) {
+          byPath.delete(dTag);
+          continue;
+        }
         // Optionally include author information
         if (options.includeAuthor) {
           data._author = event.pubkey;
         }
         byPath.set(dTag, { data, created_at: event.created_at });
       } catch (error) {
-        console.error('Failed to parse event content:', error);
+        // Silent - skip unparseable events
       }
     }
   }
@@ -319,14 +422,10 @@ export async function nostrDelete(client, path, kind = 30000) {
 
   // Publish deletion event (best effort, don't block on failure)
   try {
-    const publishResult = await client.publish(deletionEvent);
-    console.log(`✅ NIP-09 deletion event published for ${path}:`, {
-      coordinate,
-      relays: publishResult?.relays?.length || 0,
-      successful: publishResult?.successful || []
-    });
+    await client.publish(deletionEvent);
+    // Silent success - deletion queued
   } catch (error) {
-    console.error(`❌ Failed to publish NIP-09 deletion event for ${path}:`, error.message);
+    // Silent - deletion will be retried
   }
 
   return result;
@@ -438,15 +537,10 @@ export async function nostrDeleteAll(client, pathPrefix, kind = 30000) {
       content: '', // Optional deletion reason/note
     };
 
-    const publishResult = await client.publish(deletionEvent);
-    console.log(`✅ NIP-09 bulk deletion event published for ${pathPrefix}:`, {
-      itemsDeleted: matching.length,
-      coordinates: coordinates.length,
-      relays: publishResult?.relays?.length || 0,
-      successful: publishResult?.successful || []
-    });
+    await client.publish(deletionEvent);
+    // Silent success - bulk deletion queued
   } catch (error) {
-    console.error(`❌ Failed to publish NIP-09 bulk deletion event for ${pathPrefix}:`, error.message);
+    // Silent - bulk deletion will be retried
   }
 
   return {
@@ -458,6 +552,7 @@ export async function nostrDeleteAll(client, pathPrefix, kind = 30000) {
 
 /**
  * Subscribe to path changes
+ * Uses subscription deduplication - multiple subscribers to same path share one relay subscription
  * @param {Object} client - NostrClient instance
  * @param {string} path - Path to subscribe to
  * @param {Function} callback - Callback function (data, event) => void
@@ -466,7 +561,42 @@ export async function nostrDeleteAll(client, pathPrefix, kind = 30000) {
  */
 export function nostrSubscribe(client, path, callback, options = {}) {
   const kind = options.kind || 30000;
-  const includeInitial = options.includeInitial !== false;
+
+  // Create unique key for this subscription
+  const subscriptionKey = `single:${client.publicKey}:${kind}:${path}`;
+
+  // Check if we already have an active subscription for this path
+  const existing = singlePathSubscriptions.get(subscriptionKey);
+  if (existing) {
+    // Add callback to existing subscription
+    existing.callbacks.push(callback);
+
+    // Return wrapper that removes only this callback on unsubscribe
+    return {
+      unsubscribe: () => {
+        const idx = existing.callbacks.indexOf(callback);
+        if (idx > -1) {
+          existing.callbacks.splice(idx, 1);
+        }
+
+        // If no more callbacks, unsubscribe the whole thing
+        if (existing.callbacks.length === 0) {
+          existing.subscription.unsubscribe();
+          singlePathSubscriptions.delete(subscriptionKey);
+        }
+      }
+    };
+  }
+
+  // Create new subscription
+  const callbacks = [callback];
+  const subscriptionInfo = {
+    callbacks,
+    subscription: null,
+  };
+
+  // Store before creating subscription to handle race conditions
+  singlePathSubscriptions.set(subscriptionKey, subscriptionInfo);
 
   const filter = {
     kinds: [kind],
@@ -475,36 +605,57 @@ export function nostrSubscribe(client, path, callback, options = {}) {
     limit: 10, // Limit results for single item subscription
   };
 
-  let initialLoadComplete = false;
-
   const subscription = client.subscribe(
     filter,
     (event) => {
       // Verify event is from our public key (relay may not respect author filter)
       if (event.pubkey !== client.publicKey) {
-        console.warn('[nostrSubscribe] Rejecting event from different author:', {
-          expected: client.publicKey,
-          received: event.pubkey,
-          eventId: event.id
-        });
         return;
       }
 
       try {
         const data = JSON.parse(event.content);
-        callback(data, event);
+
+        // Skip deleted items - don't send tombstones to subscribers
+        if (data._deleted) {
+          return;
+        }
+
+        // Dispatch to all registered callbacks
+        for (const cb of callbacks) {
+          try {
+            cb(data, event);
+          } catch (err) {
+            console.error('Subscription callback error:', err);
+          }
+        }
       } catch (error) {
         console.error('Failed to parse event in subscription:', error);
       }
     },
     {
       onEOSE: () => {
-        initialLoadComplete = true;
+        // EOSE received
       },
     }
   );
 
-  return subscription;
+  subscriptionInfo.subscription = subscription;
+
+  return {
+    unsubscribe: () => {
+      const idx = callbacks.indexOf(callback);
+      if (idx > -1) {
+        callbacks.splice(idx, 1);
+      }
+
+      // If no more callbacks, unsubscribe the whole thing
+      if (callbacks.length === 0) {
+        subscription.unsubscribe();
+        singlePathSubscriptions.delete(subscriptionKey);
+      }
+    }
+  };
 }
 
 /**
@@ -589,9 +740,15 @@ export async function nostrSubscribeMany(client, pathPrefix, callback, options =
 
     // Client-side prefix filter
     if (dTag && dTag.startsWith(pathPrefix)) {
-      acceptedCount++;
       try {
         const data = JSON.parse(event.content);
+
+        // Skip deleted items - don't send tombstones to subscribers
+        if (data._deleted) {
+          return;
+        }
+
+        acceptedCount++;
         // Notify all registered callbacks
         for (const cb of callbacks) {
           cb(data, dTag, event);