holosphere 2.0.0-alpha4 → 2.0.0-alpha6

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
@@ -114,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)
@@ -174,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,
@@ -468,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
@@ -476,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],
@@ -485,18 +605,11 @@ 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;
       }
 
@@ -508,19 +621,41 @@ export function nostrSubscribe(client, path, callback, options = {}) {
           return;
         }
 
-        callback(data, event);
+        // 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);
+      }
+    }
+  };
 }
 
 /**