@novasamatech/host-substrate-chain-connection 0.7.7 → 0.7.8-0

package/dist/connectionPool.spec.js

@@ -239,14 +239,19 @@ describe('createChainConnection', () => {
             expect(chainA.resume).toHaveBeenCalledTimes(1);
             unlock();
         });
-        it('skips providers that do not expose pause/resume', async () => {
-            const { connection } = createTestConnection();
-            const { unlock } = await connection.lockApi(testChain('a'));
-            expect(() => {
-                connection.pauseAll();
-                connection.resumeAll();
-            }).not.toThrow();
-            unlock();
+        it('skips non-pausable providers without preventing pause on the rest', async () => {
+            // Mixed pool: 'a' is non-pausable, 'b' is pausable. The pausable one must
+            // still receive pause/resume even though the other is silently skipped.
+            const pausable = createPausableMockProvider();
+            const connection = createChainConnection({
+                createProvider: c => (c.genesisHash === 'b' ? pausable.provider : createMockProvider().provider),
+            });
+            await connection.lockApi(testChain('a'));
+            await connection.lockApi(testChain('b'));
+            connection.pauseAll();
+            connection.resumeAll();
+            expect(pausable.pause).toHaveBeenCalledTimes(1);
+            expect(pausable.resume).toHaveBeenCalledTimes(1);
         });
         it('does not call pause on providers for chains that have been destroyed', async () => {
             const chainA = createPausableMockProvider();

package/dist/pauseControllerIntegration.spec.d.ts

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

package/dist/pauseControllerIntegration.spec.js

@@ -0,0 +1,106 @@
+import { getSyncProvider } from '@polkadot-api/json-rpc-provider-proxy';
+import { describe, expect, it, vi } from 'vitest';
+import { createPauseController } from './pauseController.js';
+const flushMicroAndTimers = async () => {
+    await vi.advanceTimersByTimeAsync(0);
+};
+const req = (id, method, params = []) => ({
+    jsonrpc: '2.0',
+    id,
+    method,
+    params,
+});
+const followNotif = (subscription, result) => ({
+    jsonrpc: '2.0',
+    method: 'chainHead_v1_followEvent',
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    params: { subscription, result },
+});
+describe('pauseController × getSyncProvider integration', () => {
+    it('routes follow events to the new listener after pause+resume+refollow (best blocks must keep flowing)', async () => {
+        vi.useFakeTimers();
+        try {
+            const invocations = [];
+            const base = (onMessage, onHalt) => {
+                const send = vi.fn();
+                const disconnect = vi.fn();
+                invocations.push({
+                    onMessage: onMessage,
+                    onHalt: onHalt,
+                    send,
+                    disconnect,
+                });
+                return { send, disconnect };
+            };
+            const pc = createPauseController();
+            const inner = pc.middleware(base);
+            // Wrap the pausable inner in getSyncProvider so we get the same proxy /
+            // synthetic-Stop machinery the WS provider gets via getWsProvider.
+            const provider = getSyncProvider(onReady => {
+                onReady((onMsg, onHalt) => inner(onMsg, onHalt));
+                return () => {
+                    /* no teardown for the scheduling step */
+                };
+            });
+            const events = [];
+            const conn = provider(msg => events.push(msg));
+            // getSyncProvider schedules input via setTimeout(0); flush it so the
+            // base receives onMessage/onHalt and the proxy reaches Connected.
+            await flushMicroAndTimers();
+            expect(invocations).toHaveLength(1);
+            // Initial follow: consumer sends chainHead_v1_follow, the base "chain"
+            // assigns sub-id-1, and a bestBlockChanged event arrives.
+            conn.send(req(1, 'chainHead_v1_follow', [true]));
+            expect(invocations[0].send).toHaveBeenCalledWith(req(1, 'chainHead_v1_follow', [true]));
+            invocations[0].onMessage({ jsonrpc: '2.0', id: 1, result: 'sub-id-1' });
+            invocations[0].onMessage(followNotif('sub-id-1', { event: 'bestBlockChanged', bestBlockHash: '0xaa' }));
+            expect(events).toContainEqual({ jsonrpc: '2.0', id: 1, result: 'sub-id-1' });
+            expect(events).toContainEqual(followNotif('sub-id-1', { event: 'bestBlockChanged', bestBlockHash: '0xaa' }));
+            // === pause ===
+            // pauseController.pause() disconnects the live socket and manually fires
+            // onHalt({type:'paused'}). The proxy reacts by synthesizing a stop
+            // notification for every active chainHead — which is what surfaces to
+            // the consumer as "the follow died, please refollow".
+            events.length = 0;
+            pc.pause();
+            const syntheticStop = events.find(m => 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            m.method === 'chainHead_v1_follow' &&
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                m.params?.subscription === 'sub-id-1' &&
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                m.params?.result?.event === 'stop');
+            expect(syntheticStop).toBeDefined();
+            expect(invocations[0].disconnect).toHaveBeenCalledTimes(1);
+            // Consumer's substrate-client refollows synchronously inside the stop
+            // handler. The new chainHead_v1_follow goes into the proxy's pending
+            // queue while the base is paused.
+            conn.send(req(2, 'chainHead_v1_follow', [true]));
+            expect(invocations[0].send).not.toHaveBeenCalledWith(req(2, 'chainHead_v1_follow', [true]));
+            // === resume ===
+            pc.resume();
+            // After resume, the base is re-invoked (new "connection") and the
+            // queued send is flushed. proxy.start() has its own setTimeout backoff;
+            // flush all timers so the new connection is established.
+            await vi.advanceTimersByTimeAsync(10_000);
+            expect(invocations.length).toBeGreaterThanOrEqual(2);
+            const fresh = invocations[invocations.length - 1];
+            // The buffered chainHead_v1_follow must hit the fresh base.
+            expect(fresh.send).toHaveBeenCalledWith(req(2, 'chainHead_v1_follow', [true]));
+            // Server assigns a NEW subId on the new connection.
+            fresh.onMessage({ jsonrpc: '2.0', id: 2, result: 'sub-id-2' });
+            // bestBlockChanged on sub-id-2 must reach the consumer — this is the
+            // assertion that fails if pause/resume drops best-block flow.
+            events.length = 0;
+            fresh.onMessage(followNotif('sub-id-2', { event: 'bestBlockChanged', bestBlockHash: '0xcc' }));
+            expect(events).toContainEqual(followNotif('sub-id-2', { event: 'bestBlockChanged', bestBlockHash: '0xcc' }));
+            // And no stale sub-id-1 events should have leaked through after refollow.
+            expect(events.some(m => 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            m.method === 'chainHead_v1_follow' && m.params?.subscription === 'sub-id-1')).toBe(false);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-substrate-chain-connection",
   "type": "module",
-  "version": "0.7.7",
+  "version": "0.7.8-0",
   "description": "Chain connection pool with ref counting and provider branching for Polkadot API",
   "license": "Apache-2.0",
   "repository": {
@@ -25,7 +25,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@novasamatech/storage-adapter": "0.7.7",
+    "@novasamatech/storage-adapter": "0.7.8-0",
     "@polkadot-api/ws-provider": "^0.9.0",
     "@polkadot-api/json-rpc-provider": "^0.2.0",
     "@polkadot-api/json-rpc-provider-proxy": "^0.4.0",