@novasamatech/host-api 0.6.6-0 → 0.6.6-1

package/dist/transport.js

@@ -1,10 +1,15 @@
-import { enumValue, isEnumVariant, resultErr, resultOk } from '@novasamatech/scale';
+import { enumValue, isEnumVariant, resultErr, resultOk, toHex } from '@novasamatech/scale';
 import { createNanoEvents } from 'nanoevents';
 import { HANDSHAKE_INTERVAL, HANDSHAKE_TIMEOUT, JAM_CODEC_PROTOCOL_ID } from './constants.js';
 import { composeAction, createRequestId, delay, promiseWithResolvers } from './helpers.js';
-import { Message } from './protocol/messageCodec.js';
+import { Message, MessagePayload } from './protocol/messageCodec.js';
 import { HandshakeErr } from './protocol/v1/handshake.js';
-const isConnected = (status) => status === 'connected';
+function isConnected(status) {
+    return status === 'connected';
+}
+function getSubscriptionKey(method, payload) {
+    return `${method}_${toHex(MessagePayload.enc(payload))}`;
+}
 export function createTransport(provider) {
     let codecVersion = JAM_CODEC_PROTOCOL_ID;
     const handshakeAbortController = new AbortController();
@@ -39,6 +44,8 @@ export function createTransport(provider) {
         throwIfIncorrectEnvironment();
         throwIfInvalidCodecVersion();
     }
+    // subscriptions management (multiplexing)
+    const activeSubscriptions = new Map();
     const transport = {
         provider,
         isCorrectEnvironment() {
@@ -137,39 +144,77 @@ export function createTransport(provider) {
         subscribe(method, payload, callback) {
             checks();
             const events = createNanoEvents();
-            const requestId = createRequestId();
             const startAction = composeAction(method, 'start');
-            const stopAction = composeAction(method, 'stop');
-            const interruptAction = composeAction(method, 'interrupt');
-            const receiveAction = composeAction(method, 'receive');
-            const unsubscribeReceive = transport.listenMessages(receiveAction, (receivedId, data) => {
-                if (receivedId === requestId) {
-                    callback(data.value);
-                }
-            });
-            const unsubscribeInterrupt = transport.listenMessages(interruptAction, receivedId => {
-                if (receivedId === requestId) {
-                    events.emit('interrupt');
-                    stopSubscription();
+            const startPayload = enumValue(startAction, payload);
+            const subscriptionKey = getSubscriptionKey(method, startPayload);
+            let subscription = activeSubscriptions.get(subscriptionKey);
+            function unsub() {
+                const subscription = activeSubscriptions.get(subscriptionKey);
+                if (subscription) {
+                    const newListeners = subscription.listeners.filter(listener => listener.call !== callback);
+                    if (newListeners.length === 0) {
+                        activeSubscriptions.delete(subscriptionKey);
+                        subscription.kill();
+                    }
+                    else {
+                        subscription.listeners = newListeners;
+                    }
                 }
-            });
-            const stopSubscription = () => {
-                unsubscribeReceive();
-                unsubscribeInterrupt();
-                events.events = {};
+            }
+            const listener = {
+                call: callback,
+                unsubscribe: unsub,
             };
-            const startPayload = enumValue(startAction, payload);
-            transport.postMessage(requestId, startPayload);
-            return {
-                unsubscribe() {
-                    stopSubscription();
-                    const stopPayload = enumValue(stopAction, undefined);
-                    transport.postMessage(requestId, stopPayload);
-                },
+            const publicSubscription = {
+                unsubscribe: unsub,
                 onInterrupt(callback) {
                     return events.on('interrupt', callback);
                 },
             };
+            // wiring up a real subscription
+            if (!subscription) {
+                const requestId = createRequestId();
+                const stopAction = composeAction(method, 'stop');
+                const interruptAction = composeAction(method, 'interrupt');
+                const receiveAction = composeAction(method, 'receive');
+                const unsubscribeReceive = transport.listenMessages(receiveAction, (receivedId, data) => {
+                    if (receivedId === requestId) {
+                        const subscription = activeSubscriptions.get(subscriptionKey);
+                        if (subscription) {
+                            for (const listener of subscription.listeners) {
+                                listener.call(data.value);
+                            }
+                        }
+                    }
+                });
+                const unsubscribeInterrupt = transport.listenMessages(interruptAction, receivedId => {
+                    if (receivedId === requestId) {
+                        events.emit('interrupt');
+                        stopSubscription();
+                    }
+                });
+                const stopSubscription = () => {
+                    unsubscribeReceive();
+                    unsubscribeInterrupt();
+                    events.events = {};
+                };
+                // creating subscription
+                subscription = {
+                    requestId,
+                    kill: () => {
+                        stopSubscription();
+                        const stopPayload = enumValue(stopAction, undefined);
+                        transport.postMessage(requestId, stopPayload);
+                    },
+                    listeners: [listener],
+                };
+                activeSubscriptions.set(subscriptionKey, subscription);
+                transport.postMessage(requestId, startPayload);
+            }
+            else {
+                subscription.listeners.push(listener);
+            }
+            return publicSubscription;
         },
         handleSubscription(method, handler) {
             checks();

package/dist/transport.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transport.spec.js

@@ -0,0 +1,58 @@
+import { createNanoEvents } from 'nanoevents';
+import { describe, expect, it, vi } from 'vitest';
+import { createDefaultLogger } from './logger.js';
+import { createTransport } from './transport.js';
+function createProviders() {
+    const bus = createNanoEvents();
+    function createProvider(listenTo, postTo) {
+        return {
+            logger: createDefaultLogger(),
+            isCorrectEnvironment: () => true,
+            dispose: () => delete bus.events[listenTo],
+            subscribe: callback => bus.on(listenTo, callback),
+            postMessage: message => bus.emit(postTo, message),
+        };
+    }
+    return {
+        host: createProvider('toHost', 'toSdk'),
+        sdk: createProvider('toSdk', 'toHost'),
+    };
+}
+describe('transport', () => {
+    describe('subscription', () => {
+        it('should multiplex subscriptions', () => {
+            const providers = createProviders();
+            const events = createNanoEvents();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            const hostUnsubscribe = vi.fn();
+            const containerHandler = vi.fn((_, send) => {
+                const unsub = events.on('push', () => {
+                    send({ tag: 'v1', value: 'connected' });
+                });
+                return () => {
+                    unsub();
+                    hostUnsubscribe();
+                };
+            });
+            host.handleSubscription('host_account_connection_status_subscribe', containerHandler);
+            const s1Handler = vi.fn();
+            const s1 = sdk.subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, s1Handler);
+            const s2Handler = vi.fn();
+            const s2 = sdk.subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, s2Handler);
+            events.emit('push');
+            expect(s1Handler).toHaveBeenCalledTimes(1);
+            expect(s2Handler).toHaveBeenCalledTimes(1);
+            s1.unsubscribe();
+            expect(hostUnsubscribe).not.toBeCalled();
+            events.emit('push');
+            expect(s1Handler).toHaveBeenCalledTimes(1);
+            expect(s2Handler).toHaveBeenCalledTimes(2);
+            s2.unsubscribe();
+            expect(hostUnsubscribe).toHaveBeenCalledTimes(1);
+            events.emit('push');
+            expect(s1Handler).toHaveBeenCalledTimes(1);
+            expect(s2Handler).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api",
   "type": "module",
-  "version": "0.6.6-0",
+  "version": "0.6.6-1",
   "description": "Host API: transport implementation for host - product integration.",
   "license": "Apache-2.0",
   "repository": {
@@ -21,7 +21,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@novasamatech/scale": "0.6.6-0",
+    "@novasamatech/scale": "0.6.6-1",
     "@polkadot-api/utils": "^0.2.0",
     "nanoevents": "9.1.0",
     "nanoid": "5.1.6",