@novasamatech/host-api 0.6.6-0 → 0.6.6

package/dist/logger.d.ts

@@ -1,2 +1,2 @@
 import type { Logger } from './types.js';
-export declare function createDefaultLogger(): Logger;
+export declare function createDefaultLogger(msgPrefix?: string): Logger;

package/dist/logger.js

@@ -1,8 +1,10 @@
-export function createDefaultLogger() {
+export function createDefaultLogger(msgPrefix) {
+    const prefix = msgPrefix ? `[${msgPrefix}]` : '';
     return {
-        info: (...args) => console.info(...args),
-        error: (...args) => console.error(...args),
-        warn: (...args) => console.warn(...args),
-        log: (...args) => console.log(...args),
+        info: (...args) => console.info(prefix, ...args),
+        error: (...args) => console.error(prefix, ...args),
+        warn: (...args) => console.warn(prefix, ...args),
+        log: (...args) => console.log(prefix, ...args),
+        withPrefix: (newPrefix) => createDefaultLogger(newPrefix),
     };
 }

package/dist/protocol/v1/jsonRpc.d.ts

@@ -1,5 +1,5 @@
 export declare const JsonRpcMessageSendV1_request: import("scale-ts").Codec<[`0x${string}`, string]>;
-export declare const JsonRpcMessageSendV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("packages/scale/dist/err.js").CodecError<{
+export declare const JsonRpcMessageSendV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("packages/scale/src/err.js").CodecError<{
     reason: string;
 }, "GenericError">>>;
 export declare const JsonRpcMessageSubscribeV1_start: import("scale-ts").Codec<`0x${string}`>;

package/dist/protocol/v1/notification.d.ts

@@ -6,6 +6,6 @@ export declare const PushNotificationV1_request: import("scale-ts").Codec<{
     text: string;
     deeplink: string | undefined;
 }>;
-export declare const PushNotificationV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("packages/scale/dist/err.js").CodecError<{
+export declare const PushNotificationV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("packages/scale/src/err.js").CodecError<{
     reason: string;
 }, "GenericError">>>;

package/dist/provider.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from './types.js';
 export type Provider = {
-    logger: Logger;
+    readonly logger: Logger;
     isCorrectEnvironment(): boolean;
     postMessage(message: Uint8Array): void;
     subscribe(callback: (message: Uint8Array) => void): () => void;

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 unsubscribeListener() {
+                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: unsubscribeListener,
             };
-            const startPayload = enumValue(startAction, payload);
-            transport.postMessage(requestId, startPayload);
-            return {
-                unsubscribe() {
-                    stopSubscription();
-                    const stopPayload = enumValue(stopAction, undefined);
-                    transport.postMessage(requestId, stopPayload);
-                },
+            const publicSubscription = {
+                unsubscribe: unsubscribeListener,
                 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/dist/types.d.ts

@@ -2,7 +2,9 @@ import type { HostApiProtocol } from './protocol/impl.js';
 import type { ComposeMessageAction, MessageAction, MessagePayloadSchema, PickMessagePayload, PickMessagePayloadValue } from './protocol/messageCodec.js';
 import type { Provider } from './provider.js';
 export type HostApiMethod = keyof HostApiProtocol;
-export type Logger = Record<'info' | 'warn' | 'error' | 'log', (...args: unknown[]) => void>;
+export type Logger = Record<'info' | 'warn' | 'error' | 'log', (...args: unknown[]) => void> & {
+    withPrefix(prefix: string): Logger;
+};
 export type ConnectionStatus = 'connecting' | 'connected' | 'disconnected';
 export type RequestHandler<Method extends string> = (message: PickMessagePayloadValue<ComposeMessageAction<Method, 'request'>>) => PromiseLike<PickMessagePayloadValue<ComposeMessageAction<Method, 'response'>>>;
 export type SubscriptionHandler<Method extends string> = (params: PickMessagePayloadValue<ComposeMessageAction<Method, 'start'>>, send: (value: PickMessagePayloadValue<ComposeMessageAction<Method, 'receive'>>) => void, interrupt: () => void) => VoidFunction;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api",
   "type": "module",
-  "version": "0.6.6-0",
+  "version": "0.6.6",
   "description": "Host API: transport implementation for host - product integration.",
   "license": "Apache-2.0",
   "repository": {
@@ -12,6 +12,7 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
+      "#/source": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
@@ -21,10 +22,10 @@
     "README.md"
   ],
   "dependencies": {
-    "@novasamatech/scale": "0.6.6-0",
+    "@novasamatech/scale": "0.6.6",
     "@polkadot-api/utils": "^0.2.0",
     "nanoevents": "9.1.0",
-    "nanoid": "5.1.6",
+    "nanoid": "5.1.7",
     "neverthrow": "^8.2.0",
     "scale-ts": "1.6.1"
   },