@peers-app/peers-sdk 0.16.4 → 0.16.5

package/dist/context/user-context.js

@@ -238,6 +238,7 @@ class UserContext {
     subscribeToDataChangedAcrossAllGroups(table, handler) {
         const tableName = typeof table === "string" ? table : table.tableName;
         const tableEventPrefix = `${tableName}_DataChanged_`;
+        const unsubscribePrefix = (0, events_1.subscribePrefix)(tableEventPrefix);
         const subscription = (0, events_1.subscribe)((evt) => evt.name.startsWith(tableEventPrefix), async (evt) => {
             const dataContextId = evt.name.endsWith("_") ? this.userId : evt.name.split("_").pop();
             const dataContext = this.getDataContext(dataContextId);
@@ -248,6 +249,11 @@ class UserContext {
                 data: evt.data,
             });
         });
+        const originalUnsubscribe = subscription.unsubscribe;
+        subscription.unsubscribe = () => {
+            unsubscribePrefix();
+            return originalUnsubscribe();
+        };
         return subscription;
     }
     dispose() {

package/dist/data/persistent-vars.js

@@ -58,10 +58,12 @@ class PersistentVarsTable extends table_1.Table {
     }
     async save(persistentVar, opts) {
         if (!persistentVar.persistentVarId) {
-            persistentVar.persistentVarId = (0, utils_1.newid)();
+            persistentVar.persistentVarId = (0, utils_1.deterministicPvarId)(persistentVar.name);
         }
         const dbVar = await this.get(persistentVar.persistentVarId);
-        if (persistentVar.isSecret && persistentVar.value.value !== undefined && (!rpc_types_1.isClient || (0, rpc_types_1.isSingleProcessClient)())) {
+        if (persistentVar.isSecret &&
+            persistentVar.value.value !== undefined &&
+            (!rpc_types_1.isClient || (0, rpc_types_1.isSingleProcessClient)())) {
             if (!dbVar ||
                 dbVar.value.value !== persistentVar.value.value ||
                 dbVar.isSecret !== persistentVar.isSecret) {
@@ -204,6 +206,12 @@ function persistentVarFactory(name, opts) {
                             dbRec = undefined;
                         }
                     }
+                    if (dbRec && !(0, utils_1.isDeterministicPvarId)(dbRec.persistentVarId)) {
+                        const newId = (0, utils_1.deterministicPvarId)(name);
+                        await table.delete(dbRec);
+                        dbRec.persistentVarId = newId;
+                        dbRec = await table.save(dbRec);
+                    }
                     if (!dbRec) {
                         dbRec = {
                             persistentVarId: "",
@@ -271,6 +279,10 @@ function persistentVarFactory(name, opts) {
                 };
                 // subscribe to db changes
                 userContext.subscribeToDataChangedAcrossAllGroups(exports.persistentVarsMetaData.name, async (evt) => {
+                    const dc = getDataContext();
+                    if (dc && evt.dataContext && evt.dataContext.dataContextId !== dc.dataContextId) {
+                        return;
+                    }
                     const dbRec = evt.data.dataObject;
                     const dbName = getVarNameInDb();
                     if (!rec?.persistentVarId && dbRec.name === dbName) {

package/dist/events.d.ts

@@ -4,10 +4,23 @@ export type IEventHandler<T = any> = (eventData: IEventData<T>) => boolean | voi
 export interface ISubscription {
     filter: IEventFilter;
     handler: IEventHandler;
+    /** When set, this subscription matches only events with this exact name (fast-path via Map lookup). */
+    eventName?: string;
 }
 export interface ISubscriptionResult {
     unsubscribe: () => boolean;
 }
+/**
+ * Notify the events system that the client connection is ready.
+ * Flushes any subscriptions that were registered before the connection.
+ */
+export declare function notifyClientConnected(): void;
+/**
+ * Register a prefix-based event subscription with the server.
+ * Events whose name starts with this prefix will be forwarded to the client.
+ * Returns an unsubscribe function that decrements the refcount.
+ */
+export declare function subscribePrefix(prefix: string): () => void;
 export declare function subscribe<T = any>(nameOrFilter: string | IEventFilter, handler: IEventHandler<T>): ISubscriptionResult;
 export declare function subscribeDebounce<T = any>(nameOrFilter: string | IEventFilter, handler: IEventHandler<T>, debounceMs: number): ISubscriptionResult;
 export declare function emit(event: IEventData, dontPropagate?: boolean): Promise<boolean>;

package/dist/events.js

@@ -1,37 +1,195 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Emitter = exports.Event = void 0;
+exports.notifyClientConnected = notifyClientConnected;
+exports.subscribePrefix = subscribePrefix;
 exports.subscribe = subscribe;
 exports.subscribeDebounce = subscribeDebounce;
 exports.emit = emit;
 exports.unionEvents = unionEvents;
 const rpc_types_1 = require("./rpc-types");
 const unitTests = process.env.NODE_ENV === "test";
-const subscriptions = [];
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+// ─── Subscription Storage ────────────────────────────────────────────────────
+/** Subscriptions indexed by exact event name for O(1) dispatch. */
+const nameIndex = new Map();
+/** Subscriptions that use custom filter functions (checked on every emit). */
+const wildcardSubscriptions = new Set();
+function addSubscription(subscription) {
+    if (subscription.eventName) {
+        let bucket = nameIndex.get(subscription.eventName);
+        if (!bucket) {
+            bucket = new Set();
+            nameIndex.set(subscription.eventName, bucket);
+        }
+        bucket.add(subscription);
+    }
+    else {
+        wildcardSubscriptions.add(subscription);
+    }
+}
+function removeSubscription(subscription) {
+    if (subscription.eventName) {
+        const bucket = nameIndex.get(subscription.eventName);
+        if (bucket) {
+            const removed = bucket.delete(subscription);
+            if (bucket.size === 0) {
+                nameIndex.delete(subscription.eventName);
+            }
+            return removed;
+        }
+        return false;
+    }
+    return wildcardSubscriptions.delete(subscription);
+}
+// ─── Client → Server Subscription Registration ──────────────────────────────
+// In multi-process mode (Electron), the client tells the server which event
+// names/prefixes it cares about so the server can skip forwarding unneeded events.
+/** Reference counts for event names registered with the server. */
+const clientNameRefCounts = new Map();
+/** Reference counts for event prefixes registered with the server. */
+const clientPrefixRefCounts = new Map();
+/** Whether the client-server connection is established (for deferred registration). */
+let clientConnected = false;
+/** Names pending registration (accumulated before connection is ready). */
+const pendingNameSubscriptions = new Set();
+/** Prefixes pending registration (accumulated before connection is ready). */
+const pendingPrefixSubscriptions = new Set();
+/**
+ * Notify the events system that the client connection is ready.
+ * Flushes any subscriptions that were registered before the connection.
+ */
+function notifyClientConnected() {
+    clientConnected = true;
+    if (pendingNameSubscriptions.size > 0) {
+        const names = [...pendingNameSubscriptions];
+        pendingNameSubscriptions.clear();
+        rpc_types_1.rpcServerCalls.subscribeEvents(names).catch((err) => {
+            console.error("Failed to register pending event subscriptions with server", err);
+        });
+    }
+    if (pendingPrefixSubscriptions.size > 0) {
+        const prefixes = [...pendingPrefixSubscriptions];
+        pendingPrefixSubscriptions.clear();
+        rpc_types_1.rpcServerCalls.subscribePrefixes(prefixes).catch((err) => {
+            console.error("Failed to register pending prefix subscriptions with server", err);
+        });
+    }
+}
+function clientRegisterName(name) {
+    if (unitTests || (0, rpc_types_1.isSingleProcessClient)())
+        return;
+    const count = clientNameRefCounts.get(name) || 0;
+    clientNameRefCounts.set(name, count + 1);
+    if (count === 0) {
+        if (clientConnected) {
+            rpc_types_1.rpcServerCalls.subscribeEvents([name]).catch((err) => {
+                console.error(`Failed to register event subscription with server: ${name}`, err);
+            });
+        }
+        else {
+            pendingNameSubscriptions.add(name);
+        }
+    }
+}
+function clientUnregisterName(name) {
+    if (unitTests || (0, rpc_types_1.isSingleProcessClient)())
+        return;
+    const count = clientNameRefCounts.get(name) || 0;
+    if (count <= 1) {
+        clientNameRefCounts.delete(name);
+        pendingNameSubscriptions.delete(name);
+        if (clientConnected) {
+            rpc_types_1.rpcServerCalls.unsubscribeEvents([name]).catch((err) => {
+                console.error(`Failed to unregister event subscription with server: ${name}`, err);
+            });
+        }
+    }
+    else {
+        clientNameRefCounts.set(name, count - 1);
+    }
+}
+/**
+ * Register a prefix-based event subscription with the server.
+ * Events whose name starts with this prefix will be forwarded to the client.
+ * Returns an unsubscribe function that decrements the refcount.
+ */
+function subscribePrefix(prefix) {
+    if (!rpc_types_1.isClient || unitTests || (0, rpc_types_1.isSingleProcessClient)()) {
+        return () => { };
+    }
+    const count = clientPrefixRefCounts.get(prefix) || 0;
+    clientPrefixRefCounts.set(prefix, count + 1);
+    if (count === 0) {
+        if (clientConnected) {
+            rpc_types_1.rpcServerCalls.subscribePrefixes([prefix]).catch((err) => {
+                console.error(`Failed to register prefix subscription with server: ${prefix}`, err);
+            });
+        }
+        else {
+            pendingPrefixSubscriptions.add(prefix);
+        }
+    }
+    return () => {
+        const current = clientPrefixRefCounts.get(prefix) || 0;
+        if (current <= 1) {
+            clientPrefixRefCounts.delete(prefix);
+            pendingPrefixSubscriptions.delete(prefix);
+            if (clientConnected) {
+                rpc_types_1.rpcServerCalls.unsubscribePrefixes([prefix]).catch((err) => {
+                    console.error(`Failed to unregister prefix subscription with server: ${prefix}`, err);
+                });
+            }
+        }
+        else {
+            clientPrefixRefCounts.set(prefix, current - 1);
+        }
+    };
+}
+// ─── Server-Side Event Forwarding Gate ───────────────────────────────────────
+// The server uses this to decide whether to forward an event to the client.
+/** Event names the client has subscribed to. Server-side only. */
+const serverClientNames = new Set();
+/** Event prefixes the client has subscribed to. Server-side only. */
+const serverClientPrefixes = new Set();
+/**
+ * Check whether the client wants this event.
+ * Used by the server to gate `rpcClientCalls.emitEvent`.
+ */
+function clientWantsEvent(event) {
+    if (serverClientNames.has(event.name))
+        return true;
+    for (const prefix of serverClientPrefixes) {
+        if (event.name.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
 function subscribe(nameOrFilter, handler) {
+    let eventName;
+    let filter;
     if (typeof nameOrFilter === "string") {
-        const name = nameOrFilter;
-        nameOrFilter = (evt) => evt.name === name;
+        eventName = nameOrFilter;
+        filter = (evt) => evt.name === eventName;
+    }
+    else {
+        filter = nameOrFilter;
+    }
+    const subscription = { filter, handler, eventName };
+    addSubscription(subscription);
+    if (rpc_types_1.isClient && eventName) {
+        clientRegisterName(eventName);
     }
-    const filter = nameOrFilter;
-    const subscription = {
-        filter,
-        handler,
-    };
-    subscriptions.push(subscription);
     return {
         unsubscribe: () => {
-            const iSub = subscriptions.indexOf(subscription);
-            if (iSub >= 0) {
-                subscriptions.splice(iSub, 1);
-                return true;
+            const removed = removeSubscription(subscription);
+            if (removed && rpc_types_1.isClient && eventName) {
+                clientUnregisterName(eventName);
             }
-            return false;
+            return removed;
         },
     };
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function subscribeDebounce(nameOrFilter, handler, debounceMs) {
     let pid = 0;
     const handlerDebounced = (evt) => {
@@ -46,37 +204,64 @@ function subscribeDebounce(nameOrFilter, handler, debounceMs) {
     return subscribe(nameOrFilter, handlerDebounced);
 }
 async function emit(event, dontPropagate) {
-    const matchedHandlerPromises = subscriptions
-        .filter((subscription) => subscription.filter(event))
-        .map(async (subscription) => {
+    const matched = [];
+    const bucket = nameIndex.get(event.name);
+    if (bucket) {
+        for (const sub of bucket) {
+            matched.push(sub);
+        }
+    }
+    for (const sub of wildcardSubscriptions) {
+        if (sub.filter(event)) {
+            matched.push(sub);
+        }
+    }
+    const handlerPromises = matched.map(async (subscription) => {
         try {
             return await subscription.handler(event);
         }
         catch (err) {
-            console.error(`An unhandled error occurred in a handler while processing event: ${JSON.stringify({ event, subscription })}`, err);
+            console.error(`An unhandled error occurred in a handler while processing event: ${JSON.stringify({ event })}`, err);
             return false;
         }
     });
-    // if (!(dontPropagate || unitTests)) {
-    //   matchedHandlerPromises.push(
-    //     isClient
-    //       ? rpcServerCalls.emitEvent(event).catch((err) => { console.error(`Error while propagating event to server`, err); return false; })
-    //       : rpcClientCalls.emitEvent(event).catch((err) => { console.error(`Error while propagating event to client`, err); return false; })
-    //   );
-    // }
     if (!(dontPropagate || unitTests || (0, rpc_types_1.isSingleProcessClient)())) {
-        matchedHandlerPromises.push(rpc_types_1.rpcClientCalls.emitEvent(event).catch((err) => {
-            console.error(`Error while propagating event to client`, err);
-            return false;
-        }));
+        if (clientWantsEvent(event)) {
+            handlerPromises.push(rpc_types_1.rpcClientCalls.emitEvent(event).catch((err) => {
+                console.error(`Error while propagating event to client`, err);
+                return false;
+            }));
+        }
     }
-    const results = await Promise.all(matchedHandlerPromises);
-    // if any handlers returned false (or errored), return false, otherwise return true
+    const results = await Promise.all(handlerPromises);
     return !results.some((r) => r === false);
 }
 if (rpc_types_1.isClient) {
     rpc_types_1.rpcClientCalls.emitEvent = (event) => emit(event, true);
 }
+// Server-side: register RPC handlers for client subscription management
+if (!rpc_types_1.isClient) {
+    rpc_types_1.rpcServerCalls.subscribeEvents = async (names) => {
+        for (const name of names) {
+            serverClientNames.add(name);
+        }
+    };
+    rpc_types_1.rpcServerCalls.unsubscribeEvents = async (names) => {
+        for (const name of names) {
+            serverClientNames.delete(name);
+        }
+    };
+    rpc_types_1.rpcServerCalls.subscribePrefixes = async (prefixes) => {
+        for (const prefix of prefixes) {
+            serverClientPrefixes.add(prefix);
+        }
+    };
+    rpc_types_1.rpcServerCalls.unsubscribePrefixes = async (prefixes) => {
+        for (const prefix of prefixes) {
+            serverClientPrefixes.delete(prefix);
+        }
+    };
+}
 class Event {
     _eventName;
     constructor(_eventName) {
@@ -119,7 +304,6 @@ class Emitter {
     }
 }
 exports.Emitter = Emitter;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function unionEvents(...events) {
     const eventName = events.map((s) => s.eventName()).join("|");
     return {

package/dist/rpc-types.d.ts

@@ -116,6 +116,10 @@ export declare const rpcServerCalls: {
     voiceDisable: () => Promise<void>;
     voiceEnable: () => Promise<void>;
     flushDatabases: () => Promise<void>;
+    subscribeEvents: (names: string[]) => Promise<void>;
+    unsubscribeEvents: (names: string[]) => Promise<void>;
+    subscribePrefixes: (prefixes: string[]) => Promise<void>;
+    unsubscribePrefixes: (prefixes: string[]) => Promise<void>;
 };
 export declare const rpcClientCalls: {
     ping: (msg: string) => Promise<string>;

package/dist/rpc-types.js

@@ -67,10 +67,11 @@ exports.rpcServerCalls = {
     // Flush all in-memory database snapshots to durable storage (IndexedDB in PWA).
     // No-op on Electron where better-sqlite3 writes are synchronous to disk.
     flushDatabases: (async () => { }),
-    // TODO try to get rid of this and rely on the client-side table and server-side table individually emitting events
-    // TODO TODO before deleting this, check if we can stop client-side tables from emitting events and rely solely on server-side tables
-    //           propagating events with rpcClientCalls.emitEvent.  It's very likely we're currently seeing two events for every one write originating from the UI
-    // emitEvent: _na as ((event: IEventData) => Promise<boolean>),
+    // Event subscription management (for selective proxying)
+    subscribeEvents: rpcStub("subscribeEvents"),
+    unsubscribeEvents: rpcStub("unsubscribeEvents"),
+    subscribePrefixes: rpcStub("subscribePrefixes"),
+    unsubscribePrefixes: rpcStub("unsubscribePrefixes"),
 };
 exports.rpcClientCalls = {
     ping: async (msg) => `pong: ${msg}`,

package/dist/utils.d.ts

@@ -31,6 +31,21 @@ export declare function simpleHash(str: string): number;
 export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 /** `simpleHash` of JSON-stable stringification of an object. */
 export declare function simpleObjectHash(obj: any): number;
+/**
+ * Generates a deterministic 25-character peer ID for a persistent variable.
+ * The ID has the fixed prefix `000pvar0` (8 chars) followed by 17 base-36 characters
+ * derived from a SHA-512 hash of the input name. Two calls with the same name always
+ * return the same ID.
+ *
+ * @param name The persistent variable name as stored in the database
+ *   (already includes group suffixes for groupDevice/groupUser scopes)
+ */
+export declare function deterministicPvarId(name: string): string;
+/**
+ * Returns whether a peer ID was generated by {@link deterministicPvarId}
+ * (starts with the `000pvar0` prefix).
+ */
+export declare function isDeterministicPvarId(id: string): boolean;
 /** Resolves after `ms` milliseconds (0 yields a microtask-yield on most runtimes). */
 export declare function sleep(ms?: number): Promise<void>;
 /** Turns `fooBar` into `Foo Bar` for labels (also replaces `_` with space). */

package/dist/utils.js

@@ -9,6 +9,8 @@ exports.idDate = idDate;
 exports.idRandNums = idRandNums;
 exports.simpleHash = simpleHash;
 exports.simpleObjectHash = simpleObjectHash;
+exports.deterministicPvarId = deterministicPvarId;
+exports.isDeterministicPvarId = isDeterministicPvarId;
 exports.sleep = sleep;
 exports.camelCaseToSpaces = camelCaseToSpaces;
 exports.camelCaseToHyphens = camelCaseToHyphens;
@@ -119,6 +121,43 @@ function simpleHash(str) {
 function simpleObjectHash(obj) {
     return simpleHash(stableStringify(obj));
 }
+/** Well-known prefix for deterministic persistent variable IDs. */
+const DETERMINISTIC_PVAR_PREFIX = "000pvar0";
+/**
+ * Converts a byte array to a base-36 string of the requested length, using unbiased modular reduction.
+ * Bytes >= 252 are skipped to avoid bias (same technique as {@link cryptoRandomString}).
+ */
+function bytesToBase36(bytes, length) {
+    let s = "";
+    for (let i = 0; i < bytes.length && s.length < length; i++) {
+        const n = bytes[i];
+        if (n >= 252)
+            continue;
+        s += (n % 36).toString(36);
+    }
+    return s.substring(0, length);
+}
+/**
+ * Generates a deterministic 25-character peer ID for a persistent variable.
+ * The ID has the fixed prefix `000pvar0` (8 chars) followed by 17 base-36 characters
+ * derived from a SHA-512 hash of the input name. Two calls with the same name always
+ * return the same ID.
+ *
+ * @param name The persistent variable name as stored in the database
+ *   (already includes group suffixes for groupDevice/groupUser scopes)
+ */
+function deterministicPvarId(name) {
+    const hashSuffixLength = 25 - DETERMINISTIC_PVAR_PREFIX.length; // 17
+    const hash = nacl.hash(new TextEncoder().encode(name)); // 64-byte SHA-512
+    return DETERMINISTIC_PVAR_PREFIX + bytesToBase36(hash, hashSuffixLength);
+}
+/**
+ * Returns whether a peer ID was generated by {@link deterministicPvarId}
+ * (starts with the `000pvar0` prefix).
+ */
+function isDeterministicPvarId(id) {
+    return id.startsWith(DETERMINISTIC_PVAR_PREFIX);
+}
 /** Resolves after `ms` milliseconds (0 yields a microtask-yield on most runtimes). */
 function sleep(ms = 0) {
     return new Promise((resolve) => setTimeout(resolve, ms));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.16.4",
+  "version": "0.16.5",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"