@mr-zwets/bchn-api-wrapper 1.0.1 → 1.0.2

package/test/restClient.test.ts

@@ -1,32 +1,34 @@
-import { BchnRestClient } from '../src/index.js';
-
-describe('BchnRestClient URL validation tests', () => {
-  it('should create an instance with a valid URL', () => {
-    const client = new BchnRestClient({url: 'http://localhost:8332'});
-    expect(client).toBeInstanceOf(BchnRestClient);
-  });
-
-  it('should throw an error for an invalid URL', () => {
-    expect(() => new BchnRestClient({url: 'invalid-url'})).toThrow('Invalid URL');
-  });
-
-  it('should throw an error if the URL is missing', () => {
-    expect(() => new BchnRestClient({url: ''})).toThrow('URL is required');
-  });
-});
-
-describe('BchnRestClient Timeout Handling', () => {
-  const config = {
-    url: 'http://localhost:8332',
-    timeoutMs: 1000, // 1 second timeout
-  };
-  const restClient = new BchnRestClient(config);
-
-  it('should throw a timeout error if the request exceeds the timeout limit', async () => {
-    await expect(restClient.getChainInfo()).rejects.toThrow('Request timed out');
-  });
-
-  it('should not return a timeout error if the request completes in time', async () => {
-    await expect(restClient.getMempoolInfo()).resolves.toEqual({});
-  });
+import { BchnRestClient } from '../src/index.js';
+
+const localhostUrl = 'http://localhost:8332';
+
+describe('BchnRestClient URL validation tests', () => {
+  it('should create an instance with a valid URL', () => {
+    const client = new BchnRestClient({url: localhostUrl});
+    expect(client).toBeInstanceOf(BchnRestClient);
+  });
+
+  it('should throw an error for an invalid URL', () => {
+    expect(() => new BchnRestClient({url: 'invalid-url'})).toThrow('Invalid URL');
+  });
+
+  it('should throw an error if the URL is missing', () => {
+    expect(() => new BchnRestClient({url: ''})).toThrow('URL is required');
+  });
+});
+
+describe('BchnRestClient Timeout Handling', () => {
+  const config = {
+    url: localhostUrl,
+    timeoutMs: 1000, // 1 second timeout
+  };
+  const restClient = new BchnRestClient(config);
+
+  it('should throw a timeout error if the request exceeds the timeout limit', async () => {
+    await expect(restClient.getChainInfo()).rejects.toThrow('Request timed out');
+  });
+
+  it('should not return a timeout error if the request completes in time', async () => {
+    await expect(restClient.getMempoolInfo()).resolves.toEqual({});
+  });
 });

package/test/rpcClient.test.ts

@@ -1,115 +1,119 @@
-import { BchnRpcClient, type GetBestBlockHash, type GetBlockCount, type GetBlockHash, type RpcClientConfig } from '../src/index.js';
-
-describe('BchnRpcClient should have the correct constructor arguments', () => {
-  it('should create an instance with a valid URL', () => {
-    const config = {
-      url: 'http://localhost:8332',
-      rpcUser: 'rpcUser',
-      rpcPassword: 'rpcPassword'
-    }
-    const client = new BchnRpcClient(config);
-    expect(client).toBeInstanceOf(BchnRpcClient);
-  });
-
-  it('should throw an error for an invalid URL', () => {
-    const config = {
-      url: 'invalid-url',
-      rpcUser: 'rpcUser',
-      rpcPassword: 'rpcPassword'
-    }
-    expect(() => new BchnRpcClient(config)).toThrow('Invalid URL');
-  });
-
-  it('should throw an error if the URL is empty', () => {
-    const config = {
-      url: '',
-      rpcUser: 'rpcUser',
-      rpcPassword: 'rpcPassword'
-    }
-    expect(() => new BchnRpcClient(config)).toThrow('URL is required');
-  });
-
-  it('should throw an error if the URL is missing', () => {
-    const config = {
-      rpcUser: 'rpcUser',
-      rpcPassword: 'rpcPassword'
-    } as RpcClientConfig
-    expect(() => new BchnRpcClient(config)).toThrow('Invalid configuration: Either provide the url or protocol/host/port');
-  });
-
-  it('should throw an error if rpcUser is missing', () => {
-    const config = {
-      url: 'http://localhost:8332',
-      rpcPassword: 'rpcPassword'
-    } as RpcClientConfig
-    expect(() => new BchnRpcClient(config)).toThrow('Need to provide rpcUser in config');
-  });
-
-  it('should throw an error if rpcPassword is missing', () => {
-    const config = {
-      url: 'http://localhost:8332',
-      rpcUser: 'rpcUser'
-    } as RpcClientConfig
-    expect(() => new BchnRpcClient(config)).toThrow('Need to provide rpcPassword in config');
-  });
-});
-
-describe('BchnRpcClient Timeout and Retry Handling', () => {
-  it('should throw a timeout error if the request exceeds the timeout limit', async () => {
-    const config = {
-      url: 'http://localhost:8332',
-      rpcUser: 'rpcUser',
-      rpcPassword: 'rpcPassword',
-      timeoutMs: 1000,
-    }
-    const rpcClient = new BchnRpcClient(config);
-
-    await expect(rpcClient.request("getbestblockhash")).rejects.toThrow('Request failed after 1 attempts: The operation was aborted due to timeout');
-  });
-
-  it('should not return a timeout error if the request completes in time', async () => {
-    const config = {
-      url: 'http://localhost:8332',
-      rpcUser: 'rpcUser',
-      rpcPassword: 'rpcPassword',
-      timeoutMs: 1000,
-    }
-    const rpcClient = new BchnRpcClient(config);
-
-    await expect(rpcClient.request<GetBlockCount>("getblockcount")).resolves.toEqual({});
-  });
-
-  it('should return an RetryLimitExceededError if all retries fail', async () => {
-    const config = {
-      url: 'http://localhost:8332',
-      rpcUser: 'rpcUser',
-      rpcPassword: 'rpcPassword',
-      maxRetries: 3,
-      timeoutMs: 1000,
-    }
-    const rpcClient = new BchnRpcClient(config);
-    await expect(rpcClient.request<GetBestBlockHash>("getbestblockhash")).rejects.toThrow("Request failed after 4 attempts: The operation was aborted due to timeout");
-  });
-});
-
-describe('BchnRpcClient Handling of Parameters', () => {
-  it('should error with incorrect number of params', async () => {
-    const config = {
-      url: 'http://localhost:8332',
-      rpcUser: 'rpcUser',
-      rpcPassword: 'rpcPassword',
-    }
-    const rpcClient = new BchnRpcClient(config);
-    await expect(rpcClient.request("getblockhash")).rejects.toThrow("Request failed after 1 attempts: Error: Invalid Request");
-  })
-
-  it('should not error with correct number of params', async () => {
-    const config = {
-      url: 'http://localhost:8332',
-      rpcUser: 'rpcUser',
-      rpcPassword: 'rpcPassword',
-    }
-    const rpcClient = new BchnRpcClient(config);
-    await expect(rpcClient.request<GetBlockHash>("getblockhash", 5)).resolves.toEqual({});
-  })
-})
+import { BchnRpcClient, type GetBestBlockHash, type GetBlockCount, type GetBlockHash, type RpcClientConfig } from '../src/index.js';
+
+const localhostUrl = 'http://localhost:8332';
+const testRpcUser = 'rpcUser';
+const testRpcPassword = 'rpcPassword';
+
+describe('BchnRpcClient should have the correct constructor arguments', () => {
+  it('should create an instance with a valid URL', () => {
+    const config = {
+      url: localhostUrl,
+      rpcUser: testRpcUser,
+      rpcPassword: testRpcPassword
+    }
+    const client = new BchnRpcClient(config);
+    expect(client).toBeInstanceOf(BchnRpcClient);
+  });
+
+  it('should throw an error for an invalid URL', () => {
+    const config = {
+      url: 'invalid-url',
+      rpcUser: testRpcUser,
+      rpcPassword: testRpcPassword
+    }
+    expect(() => new BchnRpcClient(config)).toThrow('Invalid URL');
+  });
+
+  it('should throw an error if the URL is empty', () => {
+    const config = {
+      url: '',
+      rpcUser: testRpcUser,
+      rpcPassword: testRpcPassword
+    }
+    expect(() => new BchnRpcClient(config)).toThrow('URL is required');
+  });
+
+  it('should throw an error if the URL is missing', () => {
+    const config = {
+      rpcUser: testRpcUser,
+      rpcPassword: testRpcPassword
+    } as RpcClientConfig
+    expect(() => new BchnRpcClient(config)).toThrow('Invalid configuration: Either provide the url or protocol/host/port');
+  });
+
+  it('should throw an error if rpcUser is missing', () => {
+    const config = {
+      url: localhostUrl,
+      rpcPassword: testRpcPassword
+    } as RpcClientConfig
+    expect(() => new BchnRpcClient(config)).toThrow('Need to provide rpcUser in config');
+  });
+
+  it('should throw an error if rpcPassword is missing', () => {
+    const config = {
+      url: localhostUrl,
+      rpcUser: testRpcUser
+    } as RpcClientConfig
+    expect(() => new BchnRpcClient(config)).toThrow('Need to provide rpcPassword in config');
+  });
+});
+
+describe('BchnRpcClient Timeout and Retry Handling', () => {
+  it('should throw a timeout error if the request exceeds the timeout limit', async () => {
+    const config = {
+      url: localhostUrl,
+      rpcUser: testRpcUser,
+      rpcPassword: testRpcPassword,
+      timeoutMs: 1000,
+    }
+    const rpcClient = new BchnRpcClient(config);
+
+    await expect(rpcClient.request("getbestblockhash")).rejects.toThrow('Request failed after 1 attempts: The operation was aborted due to timeout');
+  });
+
+  it('should not return a timeout error if the request completes in time', async () => {
+    const config = {
+      url: localhostUrl,
+      rpcUser: testRpcUser,
+      rpcPassword: testRpcPassword,
+      timeoutMs: 1000,
+    }
+    const rpcClient = new BchnRpcClient(config);
+
+    await expect(rpcClient.request<GetBlockCount>("getblockcount")).resolves.toEqual({});
+  });
+
+  it('should return an RetryLimitExceededError if all retries fail', async () => {
+    const config = {
+      url: localhostUrl,
+      rpcUser: testRpcUser,
+      rpcPassword: testRpcPassword,
+      maxRetries: 3,
+      timeoutMs: 1000,
+    }
+    const rpcClient = new BchnRpcClient(config);
+    await expect(rpcClient.request<GetBestBlockHash>("getbestblockhash")).rejects.toThrow("Request failed after 4 attempts: The operation was aborted due to timeout");
+  });
+});
+
+describe('BchnRpcClient Handling of Parameters', () => {
+  it('should error with incorrect number of params', async () => {
+    const config = {
+      url: localhostUrl,
+      rpcUser: testRpcUser,
+      rpcPassword: testRpcPassword,
+    }
+    const rpcClient = new BchnRpcClient(config);
+    await expect(rpcClient.request("getblockhash")).rejects.toThrow("Request failed after 1 attempts: Error: Invalid Request");
+  })
+
+  it('should not error with correct number of params', async () => {
+    const config = {
+      url: localhostUrl,
+      rpcUser: testRpcUser,
+      rpcPassword: testRpcPassword,
+    }
+    const rpcClient = new BchnRpcClient(config);
+    await expect(rpcClient.request<GetBlockHash>("getblockhash", 5)).resolves.toEqual({});
+  })
+})

package/test/setupTests.ts

@@ -1,54 +1,56 @@
-import { http, delay, HttpResponse } from 'msw';
-import { setupServer, SetupServerApi } from 'msw/node';
-
-type jsonResult = { method: string; params?: unknown[] } | null | undefined
-
-const server: SetupServerApi = setupServer(
-  // Mock endpoint with a delay to simulate timeout
-  http.get('http://localhost:8332/rest/chaininfo.json', async() => {
-    // Introduce a delay longer than the timeout setting to simulate a timeout scenario
-    await delay(3000)
-    return HttpResponse.json({})
-  }),
-
-  http.get('http://localhost:8332/rest/mempool/info.json', async() => {
-    // Mock normally working REST endpoint
-    await delay(500)
-    return HttpResponse.json({})
-  }),
-
-  http.post('http://localhost:8332', async ({ request }) => {
-    const json = await request.json() as jsonResult;
-
-    if (json === null || json === undefined) {
-      throw new Error('Invalid JSON response');
-    }    
-
-    // Introduce a delay longer than the timeout setting to simulate a timeout scenario
-    if (json.method === 'getbestblockhash') {
-      await delay(3000)
-      return HttpResponse.json({"jsonrpc": "2.0", "result": {}, "id": 4})
-    }
-
-    if (json.method === 'getblockcount') {
-      // Mock normally working RPC command
-      await delay(500)
-      return HttpResponse.json({"jsonrpc": "2.0", "result": {}, "id": 5})
-    }
-
-    if (json.method === 'getblockhash') {
-      // Mock normally working RPC command
-      await delay(500)
-      if (json.params?.[0]) {
-        return HttpResponse.json({"jsonrpc": "2.0", "result": {}, "id": 6})
-      } else {
-        return HttpResponse.json({"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": 7})
-      }
-    }
-  })
-);
-
-// Start the server before tests and reset handlers after each test
-beforeAll(() => server.listen());
-afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
+import { http, delay, HttpResponse } from 'msw';
+import { setupServer, SetupServerApi } from 'msw/node';
+
+type jsonResult = { method: string; params?: unknown[] } | null | undefined
+
+const localhostUrl = 'http://localhost:8332';
+
+const server: SetupServerApi = setupServer(
+  // Mock endpoint with a delay to simulate timeout
+  http.get(`${localhostUrl}/rest/chaininfo.json`, async() => {
+    // Introduce a delay longer than the timeout setting to simulate a timeout scenario
+    await delay(3000)
+    return HttpResponse.json({})
+  }),
+
+  http.get(`${localhostUrl}/rest/mempool/info.json`, async() => {
+    // Mock normally working REST endpoint
+    await delay(500)
+    return HttpResponse.json({})
+  }),
+
+  http.post(`${localhostUrl}`, async ({ request }) => {
+    const json = await request.json() as jsonResult;
+
+    if (json === null || json === undefined) {
+      throw new Error('Invalid JSON response');
+    }    
+
+    // Introduce a delay longer than the timeout setting to simulate a timeout scenario
+    if (json.method === 'getbestblockhash') {
+      await delay(3000)
+      return HttpResponse.json({"jsonrpc": "2.0", "result": {}, "id": 4})
+    }
+
+    if (json.method === 'getblockcount') {
+      // Mock normally working RPC command
+      await delay(500)
+      return HttpResponse.json({"jsonrpc": "2.0", "result": {}, "id": 5})
+    }
+
+    if (json.method === 'getblockhash') {
+      // Mock normally working RPC command
+      await delay(500)
+      if (json.params?.[0]) {
+        return HttpResponse.json({"jsonrpc": "2.0", "result": {}, "id": 6})
+      } else {
+        return HttpResponse.json({"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": 7})
+      }
+    }
+  })
+);
+
+// Start the server before tests and reset handlers after each test
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());

package/test/tsconfig.json

@@ -1,4 +1,4 @@
-{
-  "extends": "../tsconfig.json",
-  "include": ["**/*"],
-}
+{
+  "extends": "../tsconfig.json",
+  "include": ["**/*"],
+}

package/tsconfig.json

@@ -1,13 +1,13 @@
-{
-  "compilerOptions": {
-    "module": "NodeNext",
-    "verbatimModuleSyntax": true,
-    "moduleResolution": "NodeNext",
-    "target": "ES6",
-    "strict": true,
-    "outDir": "./dist",
-    "declaration": true,
-    "types": ["vitest/globals"],
-  },
-  "include": ["src"]
-}
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "verbatimModuleSyntax": true,
+    "moduleResolution": "NodeNext",
+    "target": "ES6",
+    "strict": true,
+    "outDir": "./dist",
+    "declaration": true,
+    "types": ["vitest/globals", "node"],
+  },
+  "include": ["src"]
+}

package/vitest.config.ts

@@ -1,9 +1,9 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    setupFiles: ['./test/setupTests.ts']
-  },
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    setupFiles: ['./test/setupTests.ts']
+  },
 })

package/CHANGELOG.md

@@ -1,7 +0,0 @@
-## v1.0.1
-
-❗️ Fix for huge list of unneeded dependencies accidentally introduced by `nmp@9.5.1` on `npm init`
-
-## v1.0.0
-
-First Release 🥳