Expose helper types for working with client types

Author: blakeembrey

package-lock.json

@@ -89,6 +89,7 @@
     "lint-staged": "^9.2.0",
     "prettier": "^1.19.1",
     "rimraf": "^3.0.0",
+    "ts-expect": "^1.1.0",
     "ts-jest": "^24.0.2",
     "typescript": "^3.7.4"
   },

package.json

@@ -1,11 +1,14 @@
 import * as t from "io-ts";
 import { isLeft, isRight } from "fp-ts/lib/Either";
+import { expectType, TypeEqual } from "ts-expect";
 import {
   createServer,
   parse,
   createClient,
   RpcError,
-  Resolvers
+  Resolvers,
+  ClientRequests,
+  ClientResponse
 } from "./index";
 
 describe("json rpc", () => {
@@ -28,6 +31,13 @@ describe("json rpc", () => {
   const server = createServer(methods, resolvers);
   const client = createClient(methods, x => server(x, undefined));
 
+  describe("types", () => {
+    type Requests = ClientRequests<typeof methods>;
+    type Responses = ClientResponse<typeof methods, Requests>;
+
+    expectType<TypeEqual<Responses, string>>(true);
+  });
+
   describe("parse", () => {
     it("should parse json", () => {
       const result = parse("{}");

src/index.spec.ts

@@ -253,14 +253,22 @@ export function createServer<T extends Methods, C = void>(
 /**
  * Map methods to valid client methods.
  */
-type ClientMethods<T extends Methods> = {
+export type ClientRequests<T extends Methods> = {
   [K in keyof T]: {
     method: K;
     params: TypeOf<T[K]["request"]>;
     async?: boolean;
   };
 }[keyof T & string];
 
+/**
+ * Map client requests to response types.
+ */
+export type ClientResponse<
+  T extends Methods,
+  P extends ClientRequests<T>
+> = P["async"] extends true ? undefined : TypeOf<T[P["method"]]["response"]>;
+
 /**
  * Configure client options.
  */
@@ -283,7 +291,7 @@ export function createClient<T extends Methods, U = void>(
   let counter = 0;
   const jsonrpc = "2.0";
 
-  function prepare<U extends ClientMethods<T>>(payload: U) {
+  function prepare<U extends ClientRequests<T>>(payload: U) {
     const { method, params, async } = payload;
     const { request, response } = methods[method];
 
@@ -334,28 +342,24 @@ export function createClient<T extends Methods, U = void>(
     };
   }
 
-  async function rpcClient<P extends ClientMethods<T>>(
+  async function rpcClient<P extends ClientRequests<T>>(
     payload: P,
     options: U
-  ): Promise<
-    P["async"] extends true ? undefined : TypeOf<T[P["method"]]["response"]>
-  > {
+  ): Promise<ClientResponse<T, P>> {
     const { params, id, method, process } = prepare(payload);
     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 <P extends ClientMethods<T>[]>(
+  rpcClient.many = async <P extends ClientRequests<T>[]>(
     payload: P,
     options: U
   ): Promise<
     {
-      [K in keyof P]: P[K] extends ClientMethods<T>
-        ? P[K]["async"] extends true
-          ? undefined
-          : TypeOf<T[P[K]["method"]]["response"]> | RpcError
+      [K in keyof P]: K extends number
+        ? ClientResponse<T, P[K]> | RpcError
         : P[K];
     }
   > => {