Allow options to be proxied to send method

Author: blakeembrey

src/index.spec.ts

@@ -1,6 +1,12 @@
 import * as t from "io-ts";
-import { createServer, parse, createClient, RpcError } from "./index";
 import { isLeft, isRight } from "fp-ts/lib/Either";
+import {
+  createServer,
+  parse,
+  createClient,
+  RpcError,
+  Resolvers
+} from "./index";
 
 describe("json rpc", () => {
   const methods = {
@@ -14,11 +20,12 @@ describe("json rpc", () => {
     }
   };
 
-  const server = createServer(methods, {
+  const resolvers: Resolvers<typeof methods> = {
     hello: _ => "Hello World!",
     echo: ({ arg }) => arg
-  });
+  };
 
+  const server = createServer(methods, resolvers);
   const client = createClient(methods, x => server(x, undefined));
 
   describe("parse", () => {
@@ -271,6 +278,28 @@ describe("json rpc", () => {
           }
         });
       });
+
+      describe("without type checking", () => {
+        const server = createServer(methods, resolvers, {
+          encode: false,
+          decode: false
+        });
+
+        it("should succeed", async () => {
+          const result = await server({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "hello",
+            params: {}
+          });
+
+          expect(result).toEqual({
+            jsonrpc: "2.0",
+            id: 1,
+            result: "Hello World!"
+          });
+        });
+      });
     });
   });
 
@@ -300,42 +329,69 @@ describe("json rpc", () => {
           })
         ).rejects.toBeInstanceOf(RpcError);
       });
+
+      describe("without type checking", () => {
+        const client = createClient(methods, x => server(x), {
+          encode: false,
+          decode: false
+        });
+
+        it("should succeed", async () => {
+          const result = await client({ method: "hello", params: {} });
+
+          expect(result).toEqual("Hello World!");
+        });
+      });
+
+      describe("with send options", () => {
+        const client = createClient(methods, (_, options: string) =>
+          Promise.resolve({ result: options })
+        );
+
+        it("should accept options", async () => {
+          const result = await client({ method: "hello", params: {} }, "Test");
+
+          expect(result).toEqual("Test");
+        });
+      });
     });
 
-    describe("batch", () => {
-      it("should make a batch request", async () => {
-        const result = await client.batch(
+    describe("many", () => {
+      it("should make a many request", async () => {
+        const result = await client.many([
           { method: "hello", params: {} },
           { method: "echo", params: { arg: "test" } }
-        );
+        ]);
 
         expect(result).toEqual(["Hello World!", "test"]);
       });
 
-      it("should make a batch notification request", async () => {
-        const result = await client.batch(
+      it("should make a many notification request", async () => {
+        const result = await client.many([
           { method: "hello", params: {}, async: true },
           { method: "echo", params: { arg: "test" }, async: true }
-        );
+        ]);
 
         expect(result).toEqual([undefined, undefined]);
       });
 
-      it("should handle mixed batch responses", async () => {
-        const result = await client.batch(
+      it("should handle mixed many responses", async () => {
+        const result = await client.many([
           { method: "hello", params: {}, async: true },
           { method: "echo", params: { arg: "test" } },
           { method: "hello", params: {}, async: true }
-        );
+        ]);
 
         expect(result).toEqual([undefined, "test", undefined]);
       });
 
       it("should return rpc errors", async () => {
-        const result = await client.batch({
-          method: "echo",
-          params: {} as any
-        });
+        const result = await client.many([
+          {
+            method: "echo",
+            params: {} as any
+          }
+        ]);
 
         expect(result.length).toEqual(1);
         expect(result[0]).toBeInstanceOf(RpcError);

src/index.ts

@@ -272,10 +272,11 @@ export interface ClientOptions {
 /**
  * Create a JSON RPC request client.
  */
-export function createClient<T extends Methods>(
+export function createClient<T extends Methods, U = void>(
   methods: T,
   send: (
-    rpc: JsonRpcRequest<string, unknown> | JsonRpcRequest<string, unknown>[]
+    data: JsonRpcRequest<string, unknown> | JsonRpcRequest<string, unknown>[],
+    options: U
   ) => Promise<unknown>,
   options: ClientOptions = {}
 ) {
@@ -303,61 +304,59 @@ export function createClient<T extends Methods>(
 
         const { result, error } = body as Record<string, any>;
 
-        if (result) {
-          const output =
-            options.decode === false
-              ? either.right(result)
-              : response.decode(result);
-
-          if (either.isLeft(output)) {
-            return new RpcError(
-              PathReporter.report(output).join("; "),
-              -2,
-              output.left
-            );
-          }
-
-          return output.right;
+        if (result === undefined && error === undefined) {
+          return new RpcError("Invalid response", -1, undefined);
         }
 
-        if (
-          error === null ||
-          typeof error !== "object" ||
-          Array.isArray(error)
-        ) {
-          return new RpcError("Invalid response", -1, undefined);
+        if (error !== undefined) {
+          return new RpcError(
+            String(error?.message || "Error"),
+            Number(error?.code) || 0,
+            error?.data
+          );
+        }
+
+        const output =
+          options.decode === false
+            ? either.right(result)
+            : response.decode(result);
+
+        if (either.isLeft(output)) {
+          return new RpcError(
+            PathReporter.report(output).join("; "),
+            -2,
+            output.left
+          );
         }
 
-        return new RpcError(
-          String(error.message || "Error"),
-          Number(error.code) || 0,
-          error.data
-        );
+        return output.right;
       }
     };
   }
 
-  async function rpcClient<U extends ClientMethods<T>>(
-    payload: U
+  async function rpcClient<P extends ClientMethods<T>>(
+    payload: P,
+    options: U
   ): Promise<
-    U["async"] extends true ? undefined : TypeOf<T[U["method"]]["response"]>
+    P["async"] extends true ? undefined : TypeOf<T[P["method"]]["response"]>
   > {
     const { params, id, method, process } = prepare(payload);
-    const data = await send({ jsonrpc, method, params, id });
+    const data = await send({ jsonrpc, method, params, id }, options);
     const response = process(data) as any;
     if (response instanceof RpcError) throw response; // Throw RPC errors.
     return response;
   }
 
-  rpcClient.many = async <U extends ClientMethods<T>[]>(
-    payload: U
+  rpcClient.many = async <P extends ClientMethods<T>[]>(
+    payload: P,
+    options: U
   ): Promise<
     {
-      [K in keyof U]: U[K] extends ClientMethods<T>
-        ? U[K]["async"] extends true
+      [K in keyof P]: P[K] extends ClientMethods<T>
+        ? P[K]["async"] extends true
           ? undefined
-          : TypeOf<T[U[K]["method"]]["response"]> | RpcError
-        : U[K];
+          : TypeOf<T[P[K]["method"]]["response"]> | RpcError
+        : P[K];
     }
   > => {
     const items = payload.map(prepare);
@@ -370,7 +369,8 @@ export function createClient<T extends Methods>(
           params,
           id
         })
-      )
+      ),
+      options
     );
 
     if (!Array.isArray(data)) {
@@ -382,9 +382,5 @@ export function createClient<T extends Methods>(
     return items.map(item => item.process(lookup.get(item.id))) as any;
   };
 
-  rpcClient.batch = async <U extends ClientMethods<T>[]>(...payload: U) => {
-    return rpcClient.many(payload);
-  };
-
   return rpcClient;
 }