@kumiai/hub-server 0.8.0 → 0.9.0

package/lib/handlers.js

@@ -286,7 +286,9 @@ export function createHandlers(params) {
                 // retry returns `deduped`, and the block below is gated on `!deduped`.
                 let subscribers;
                 try {
-                    subscribers = await store.getSubscribers(topicID);
+                    subscribers = await store.getSubscribers({
+                        topicID
+                    });
                 } catch (error) {
                     storeErrorReporter({
                         method: 'getSubscribers',
@@ -419,7 +421,10 @@ export function createHandlers(params) {
                 });
             }
             try {
-                await store.unsubscribe(clientDID, topicID);
+                await store.unsubscribe({
+                    subscriberDID: clientDID,
+                    topicID
+                });
             } catch (error) {
                 rethrowAsHandlerError(error);
             }
@@ -684,9 +689,16 @@ export function createHandlers(params) {
             // The last-resort path has no cap to cross: the slot is one entry, replaced in place.
             try {
                 if (lastResortPackage != null) {
-                    await store.storeLastResortKeyPackage(clientDID, lastResortPackage);
+                    await store.storeLastResortKeyPackage({
+                        ownerDID: clientDID,
+                        keyPackage: lastResortPackage
+                    });
                 } else {
-                    await Promise.all(keyPackages.map((kp)=>store.storeKeyPackage(clientDID, kp, notAfter)));
+                    await Promise.all(keyPackages.map((kp)=>store.storeKeyPackage({
+                            ownerDID: clientDID,
+                            keyPackage: kp,
+                            notAfter
+                        })));
                 }
             } catch (error) {
                 rethrowAsHandlerError(error);
@@ -745,7 +757,9 @@ export function createHandlers(params) {
                 let lastResort = null;
                 let readFailure;
                 try {
-                    lastResort = await store.fetchLastResortKeyPackage(targetDID);
+                    lastResort = await store.fetchLastResortKeyPackage({
+                        ownerDID: targetDID
+                    });
                 } catch (error) {
                     readFailure = error;
                 }
@@ -778,7 +792,10 @@ export function createHandlers(params) {
             // the request when nothing has been consumed and there is therefore nothing to lose.
             let consumed;
             try {
-                consumed = await store.fetchKeyPackages(targetDID, cappedCount);
+                consumed = await store.fetchKeyPackages({
+                    ownerDID: targetDID,
+                    count: cappedCount
+                });
             } catch (error) {
                 rethrowAsHandlerError(error);
             }
@@ -787,7 +804,9 @@ export function createHandlers(params) {
             };
             let lastResort = null;
             try {
-                lastResort = await store.fetchLastResortKeyPackage(targetDID);
+                lastResort = await store.fetchLastResortKeyPackage({
+                    ownerDID: targetDID
+                });
             } catch (error) {
                 // Nothing consumed, so nothing is lost by surfacing it. Otherwise the top-up was a bonus
                 // the caller never paid for: hand back what the store has already given up.
@@ -834,8 +853,12 @@ export function createHandlers(params) {
                 // Two independent reads for one owner: concurrent, since neither informs the other.
                 ;
                 [count, stored] = await Promise.all([
-                    store.countKeyPackages(clientDID),
-                    store.fetchLastResortKeyPackage(clientDID)
+                    store.countKeyPackages({
+                        ownerDID: clientDID
+                    }),
+                    store.fetchLastResortKeyPackage({
+                        ownerDID: clientDID
+                    })
                 ]);
             } catch (error) {
                 rethrowAsHandlerError(error);

package/lib/memoryStore.js

@@ -360,7 +360,7 @@ function isLive(entry, nowSeconds) {
             }
             ownTopics.add(params.topicID);
         },
-        async unsubscribe (subscriberDID, topicID) {
+        async unsubscribe ({ subscriberDID, topicID }) {
             const subscribers = subscriptions.get(topicID);
             if (subscribers != null) {
                 subscribers.delete(subscriberDID);
@@ -386,13 +386,13 @@ function isLive(entry, nowSeconds) {
                 }
             }
         },
-        async getSubscribers (topicID) {
+        async getSubscribers ({ topicID }) {
             const subscribers = subscriptions.get(topicID);
             return subscribers == null ? [] : [
                 ...subscribers.keys()
             ];
         },
-        async storeKeyPackage (ownerDID, keyPackage, notAfter) {
+        async storeKeyPackage ({ ownerDID, keyPackage, notAfter }) {
             let packages = keyPackages.get(ownerDID);
             if (packages == null) {
                 packages = [];
@@ -417,7 +417,7 @@ function isLive(entry, nowSeconds) {
                 } : {}
             });
         },
-        async fetchKeyPackages (ownerDID, count) {
+        async fetchKeyPackages ({ ownerDID, count }) {
             const packages = keyPackages.get(ownerDID);
             if (packages == null || packages.length === 0) return [];
             const nowSeconds = Math.floor(Date.now() / 1000);
@@ -432,16 +432,16 @@ function isLive(entry, nowSeconds) {
             }
             return served;
         },
-        async countKeyPackages (ownerDID) {
+        async countKeyPackages ({ ownerDID }) {
             const packages = keyPackages.get(ownerDID);
             if (packages == null) return 0;
             const nowSeconds = Math.floor(Date.now() / 1000);
             return packages.filter((entry)=>isLive(entry, nowSeconds)).length;
         },
-        async storeLastResortKeyPackage (ownerDID, keyPackage) {
+        async storeLastResortKeyPackage ({ ownerDID, keyPackage }) {
             lastResortKeyPackages.set(ownerDID, keyPackage);
         },
-        async fetchLastResortKeyPackage (ownerDID) {
+        async fetchLastResortKeyPackage ({ ownerDID }) {
             // No splice, ever. Reuse is the point here — this package is marked last-resort in MLS, so
             // serving it again is by design rather than the init-key reuse `fetchKeyPackages` avoids.
             return lastResortKeyPackages.get(ownerDID) ?? null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumiai/hub-server",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Hub server for Enkaku E2EE group message routing",
   "keywords": [
     "hub",
@@ -25,19 +25,19 @@
     "lib/*"
   ],
   "dependencies": {
-    "@enkaku/protocol": "^0.21.0",
+    "@enkaku/protocol": "^0.21.1",
     "@enkaku/server": "^0.21.2",
     "@kokuin/token": "^0.5.0",
-    "@kumiai/hub-protocol": "^0.8.0",
+    "@kumiai/hub-protocol": "^0.9.0",
     "@sozai/codec": "^0.4.0",
     "@sozai/event": "^0.1.3",
     "@sozai/log": "^0.3.1"
   },
   "devDependencies": {
-    "@enkaku/client": "^0.21.1",
+    "@enkaku/client": "^0.21.2",
     "@enkaku/transport": "^0.21.0",
-    "@kumiai/hub-conformance": "^0.8.0",
-    "@kumiai/hub-wake": "^0.8.0"
+    "@kumiai/hub-conformance": "^0.9.0",
+    "@kumiai/hub-wake": "^0.9.0"
   },
   "publishConfig": {
     "access": "public"