@novasamatech/host-substrate-chain-connection 0.9.2 → 0.9.4

package/README.md

@@ -86,6 +86,7 @@ function createChainConnection<C extends ChainConfig, T = PolkadotClient>(
 |---|---|---|
 | `createProvider` | `(chain: C, onStatusChanged: (status: ConnectionStatus) => void) => JsonRpcProvider` | Factory for the underlying JSON-RPC transport. Called once per chain. Use `onStatusChanged` to feed connection status back into the pool. |
 | `clientOptions` | `(chain: C) => ClientOptions` | Optional. Returns [polkadot-api client options](https://papi.how/) - typically metadata cache hooks (`getMetadata` / `setMetadata`). |
+| `createClient` | `typeof createClient` | Optional. Overrides polkadot-api's `createClient`. Defaults to it; an injection point for tests and for wrapping client construction. |
 | `resolve` | `(chain: C, client: PolkadotClient) => Promise<T>` | Optional. Transforms the raw `PolkadotClient` into your app's API type. The result is cached per chain. If omitted, `T` defaults to `PolkadotClient`. |
 | `destroyDelay` | `number` | Optional. Milliseconds to wait before destroying a connection after the last caller releases. Defaults to `0` (destroy immediately). Useful to avoid reconnect churn when callers release and re-acquire in quick succession. |
 

package/dist/connectionPool.d.ts

@@ -4,6 +4,8 @@ import type { ChainConfig, ConnectionStatus } from './types.js';
 export type ChainConnectionConfig<C extends ChainConfig, T = PolkadotClient> = {
     createProvider(chain: C, onStatusChanged: (status: ConnectionStatus) => void): JsonRpcProvider;
     clientOptions?(chain: C): Parameters<typeof createClient>[1];
+    /** Defaults to polkadot-api's `createClient`. An injection point for tests and for wrapping client construction — polkadot-api is imported either way. */
+    createClient?: typeof createClient;
     resolve?(chain: C, client: PolkadotClient): Promise<T>;
     destroyDelay?: number;
 };
@@ -24,4 +26,4 @@ export type ChainConnection<C extends ChainConfig, T = PolkadotClient> = {
     pauseAll(): void;
     resumeAll(): void;
 };
-export declare const createChainConnection: <C extends ChainConfig, T = PolkadotClient>({ resolve, clientOptions, createProvider, destroyDelay, }: ChainConnectionConfig<C, T>) => ChainConnection<C, T>;
+export declare const createChainConnection: <C extends ChainConfig, T = PolkadotClient>({ resolve, clientOptions, createProvider, createClient: makeClient, destroyDelay, }: ChainConnectionConfig<C, T>) => ChainConnection<C, T>;

package/dist/connectionPool.js

@@ -4,7 +4,7 @@ import { createBranchedProvider } from './branchedProvider.js';
 import { createConnectionManager } from './connectionManager.js';
 import { createRefCounter } from './refCounter.js';
 import { isPausable } from './wsProvider.js';
-export const createChainConnection = ({ resolve, clientOptions, createProvider, destroyDelay = 0, }) => {
+export const createChainConnection = ({ resolve, clientOptions, createProvider, createClient: makeClient = createClient, destroyDelay = 0, }) => {
     const connections = createConnectionManager();
     const refCounter = createRefCounter();
     const existingClients = new Map();
@@ -25,7 +25,7 @@ export const createChainConnection = ({ resolve, clientOptions, createProvider,
             return existing;
         const rootProvider = createProvider(chain, status => connections.update(chain.genesisHash, status));
         const branchedProvider = createBranchedProvider(rootProvider);
-        const client = createClient(branchedProvider.branch(), clientOptions?.(chain));
+        const client = makeClient(branchedProvider.branch(), clientOptions?.(chain));
         const pooled = { client, provider: branchedProvider, rootProvider };
         existingClients.set(chain.genesisHash, pooled);
         return pooled;

package/dist/connectionPool.spec.js

@@ -1,9 +1,16 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { createChainConnection } from './connectionPool.js';
-vi.mock('polkadot-api', () => ({
-    createClient: vi.fn((_provider, _options) => createMockClient()),
-}));
-const createMockClient = () => ({ destroy: vi.fn() });
+// An in-memory stand-in for polkadot-api's `createClient`: one client object per
+// call, each counting its own `destroy()`.
+const createClientFactory = () => {
+    const clients = [];
+    const factory = ((_provider, _options) => {
+        const client = { destroyed: 0 };
+        clients.push(client);
+        return { destroy: () => client.destroyed++ };
+    });
+    return { createClient: factory, last: () => clients[clients.length - 1] };
+};
 const createMockProvider = () => {
     const send = vi.fn();
     const disconnect = vi.fn();
@@ -20,11 +27,13 @@ const createMockProvider = () => {
 const testChain = (id) => ({ genesisHash: id });
 const createTestConnection = (overrides) => {
     const mockProvider = createMockProvider();
+    const clientFactory = createClientFactory();
     const connection = createChainConnection({
         createProvider: () => mockProvider.provider,
+        createClient: clientFactory.createClient,
         ...overrides,
     });
-    return { connection, mockProvider };
+    return { connection, mockProvider, clients: clientFactory };
 };
 describe('createChainConnection', () => {
     describe('lockApi', () => {
@@ -141,30 +150,20 @@ describe('createChainConnection', () => {
     });
     describe('lockApi — connection lifecycle', () => {
         it('destroys client synchronously when last lock is released (no destroyDelay)', async () => {
-            const destroyFn = vi.fn();
-            vi.mocked(await import('polkadot-api')).createClient.mockReturnValueOnce({
-                getBestBlocks: vi.fn().mockResolvedValue([]),
-                destroy: destroyFn,
-            });
-            const { connection } = createTestConnection();
+            const { connection, clients } = createTestConnection();
             const { unlock } = await connection.lockApi(testChain('a'));
             unlock();
-            expect(destroyFn).toHaveBeenCalledOnce();
+            expect(clients.last().destroyed).toBe(1);
         });
         it('does not destroy while any lock is still held', async () => {
-            const destroyFn = vi.fn();
-            vi.mocked(await import('polkadot-api')).createClient.mockReturnValueOnce({
-                getBestBlocks: vi.fn().mockResolvedValue([]),
-                destroy: destroyFn,
-            });
-            const { connection } = createTestConnection();
+            const { connection, clients } = createTestConnection();
             const chain = testChain('a');
             const { unlock: u1 } = await connection.lockApi(chain);
             const { unlock: u2 } = await connection.lockApi(chain);
             u1();
-            expect(destroyFn).not.toHaveBeenCalled();
+            expect(clients.last().destroyed).toBe(0);
             u2();
-            expect(destroyFn).toHaveBeenCalledOnce();
+            expect(clients.last().destroyed).toBe(1);
         });
         describe('with destroyDelay', () => {
             beforeEach(() => {
@@ -174,32 +173,22 @@ describe('createChainConnection', () => {
                 vi.useRealTimers();
             });
             it('defers destruction by destroyDelay ms', async () => {
-                const destroyFn = vi.fn();
-                vi.mocked(await import('polkadot-api')).createClient.mockReturnValueOnce({
-                    getBestBlocks: vi.fn().mockResolvedValue([]),
-                    destroy: destroyFn,
-                });
-                const { connection } = createTestConnection({ destroyDelay: 1000 });
+                const { connection, clients } = createTestConnection({ destroyDelay: 1000 });
                 const { unlock } = await connection.lockApi(testChain('a'));
                 unlock();
-                expect(destroyFn).not.toHaveBeenCalled();
+                expect(clients.last().destroyed).toBe(0);
                 vi.advanceTimersByTime(1000);
-                expect(destroyFn).toHaveBeenCalledOnce();
+                expect(clients.last().destroyed).toBe(1);
             });
             it('cancels destruction timer when connection is re-acquired before delay elapses', async () => {
-                const destroyFn = vi.fn();
-                vi.mocked(await import('polkadot-api')).createClient.mockReturnValueOnce({
-                    getBestBlocks: vi.fn().mockResolvedValue([]),
-                    destroy: destroyFn,
-                });
-                const { connection } = createTestConnection({ destroyDelay: 1000 });
+                const { connection, clients } = createTestConnection({ destroyDelay: 1000 });
                 const chain = testChain('a');
                 const { api: api1, unlock: u1 } = await connection.lockApi(chain);
                 u1();
                 // Re-acquire before timer fires — same client must be returned, no destruction
                 const { api: api2, unlock: u2 } = await connection.lockApi(chain);
                 vi.advanceTimersByTime(1000);
-                expect(destroyFn).not.toHaveBeenCalled();
+                expect(clients.last().destroyed).toBe(0);
                 expect(api1).toBe(api2);
                 u2();
             });
@@ -221,6 +210,7 @@ describe('createChainConnection', () => {
             const providerByChain = { a: chainA.provider, b: chainB.provider };
             const connection = createChainConnection({
                 createProvider: chain => providerByChain[chain.genesisHash],
+                createClient: createClientFactory().createClient,
             });
             const { unlock: u1 } = await connection.lockApi(testChain('a'));
             const { unlock: u2 } = await connection.lockApi(testChain('b'));
@@ -232,7 +222,10 @@ describe('createChainConnection', () => {
         });
         it('calls resume on every pausable provider', async () => {
             const chainA = createPausableMockProvider();
-            const connection = createChainConnection({ createProvider: () => chainA.provider });
+            const connection = createChainConnection({
+                createProvider: () => chainA.provider,
+                createClient: createClientFactory().createClient,
+            });
             const { unlock } = await connection.lockApi(testChain('a'));
             connection.pauseAll();
             connection.resumeAll();
@@ -245,6 +238,7 @@ describe('createChainConnection', () => {
             const pausable = createPausableMockProvider();
             const connection = createChainConnection({
                 createProvider: c => (c.genesisHash === 'b' ? pausable.provider : createMockProvider().provider),
+                createClient: createClientFactory().createClient,
             });
             await connection.lockApi(testChain('a'));
             await connection.lockApi(testChain('b'));
@@ -257,6 +251,7 @@ describe('createChainConnection', () => {
             const chainA = createPausableMockProvider();
             const connection = createChainConnection({
                 createProvider: () => chainA.provider,
+                createClient: createClientFactory().createClient,
                 destroyDelay: 0,
             });
             const { unlock } = await connection.lockApi(testChain('a'));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-substrate-chain-connection",
   "type": "module",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "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.9.2",
+    "@novasamatech/storage-adapter": "0.9.4",
     "@polkadot-api/ws-provider": "^0.9.0",
     "@polkadot-api/json-rpc-provider": "^0.2.0",
     "@polkadot-api/json-rpc-provider-proxy": "^0.4.0",