Replace io-ts with zod, remove array params

Author: blakeembrey

package-lock.json

@@ -82,9 +82,7 @@
     "eslint": "^6.8.0",
     "eslint-config-prettier": "^6.9.0",
     "eslint-plugin-prettier": "^3.1.2",
-    "fp-ts": "^2.4.0",
     "husky": "^3.0.0",
-    "io-ts": "^2.0.4",
     "jest": "^24.9.0",
     "lint-staged": "^9.2.0",
     "prettier": "^1.19.1",
@@ -93,11 +91,7 @@
     "ts-jest": "^24.0.2",
     "typescript": "^3.7.4"
   },
-  "peerDependencies": {
-    "io-ts": "^2.0.4",
-    "fp-ts": "^2.4.0"
-  },
   "dependencies": {
-    "make-error": "^1.3.5"
+    "zod": "^1.0.9"
   }
 }

package.json

@@ -1,7 +1,6 @@
-import * as t from "io-ts";
-import { isLeft, isRight } from "fp-ts/lib/Either";
 import { expectType, TypeEqual } from "ts-expect";
 import {
+  schema,
   createServer,
   parse,
   createClient,
@@ -14,12 +13,12 @@ import {
 describe("json rpc", () => {
   const methods = {
     hello: {
-      request: t.type({}),
-      response: t.string
+      request: schema.object({}),
+      response: schema.string()
     },
     echo: {
-      request: t.type({ arg: t.string }),
-      response: t.string
+      request: schema.object({ arg: schema.string() }),
+      response: schema.string()
     }
   };
 
@@ -29,7 +28,7 @@ describe("json rpc", () => {
   };
 
   const server = createServer(methods, resolvers);
-  const client = createClient(methods, x => server(x, undefined));
+  const client = createClient(methods, server);
 
   describe("types", () => {
     type Requests = ClientRequests<typeof methods>;
@@ -40,23 +39,11 @@ describe("json rpc", () => {
 
   describe("parse", () => {
     it("should parse json", () => {
-      const result = parse("{}");
-
-      expect(isRight(result)).toEqual(true);
-
-      if (isRight(result)) {
-        expect(result.right).toEqual({});
-      }
+      expect(parse("{}")).toEqual({});
     });
 
     it("should fail to parse malformed json", () => {
-      const result = parse("[");
-
-      expect(isLeft(result)).toEqual(true);
-
-      if (isLeft(result)) {
-        expect(result.left).toEqual({ code: -32700, message: "Parse error" });
-      }
+      expect(() => parse("[")).toThrow(SyntaxError);
     });
   });
 
@@ -85,21 +72,6 @@ describe("json rpc", () => {
         expect(res).toEqual(undefined);
       });
 
-      it("should accept an array of parameters", async () => {
-        const res = await server({
-          jsonrpc: "2.0",
-          id: "test",
-          method: "echo",
-          params: ["test"]
-        });
-
-        expect(res).toEqual({
-          jsonrpc: "2.0",
-          id: "test",
-          result: "test"
-        });
-      });
-
       it("should accept an object of parameters", async () => {
         const res = await server({
           jsonrpc: "2.0",
@@ -247,8 +219,7 @@ describe("json rpc", () => {
           id: "test",
           error: {
             code: -32602,
-            message:
-              "Invalid value undefined supplied to : { arg: string }/arg: string"
+            message: "arg: Non-string type: undefined"
           }
         });
       });
@@ -331,13 +302,13 @@ describe("json rpc", () => {
         expect(result).toEqual(undefined);
       });
 
-      it("should throw rpc errors", async () => {
+      it("should throw on invalid argument", async () => {
         await expect(
           client({
             method: "echo",
             params: {} as any
           })
-        ).rejects.toBeInstanceOf(RpcError);
+        ).rejects.toBeInstanceOf(Error);
       });
 
       describe("without type checking", () => {
@@ -395,17 +366,52 @@ describe("json rpc", () => {
         expect(result).toEqual([undefined, "test", undefined]);
       });
 
-      it("should return rpc errors", async () => {
-        const result = await client.many([
-          {
-            method: "echo",
-            params: {} as any
-          }
-        ]);
+      it("should throw on invalid argument", async () => {
+        expect(
+          client.many([
+            {
+              method: "echo",
+              params: {} as any
+            }
+          ])
+        ).rejects.toBeInstanceOf(Error);
+      });
+    });
+  });
 
-        expect(result.length).toEqual(1);
-        expect(result[0]).toBeInstanceOf(RpcError);
+  describe("intersection types", () => {
+    const methods = {
+      test: {
+        request: schema.intersection(
+          schema.object({ url: schema.string() }),
+          schema.object({ accept: schema.string().optional() })
+        ),
+        response: schema.string()
+      }
+    };
+
+    const server = createServer(methods, {
+      test: ({ url, accept }) => `${url}#${accept}`
+    });
+
+    const client = createClient(methods, server);
+
+    it("should support intersection types", async () => {
+      const result = await client({
+        method: "test",
+        params: { url: "http://example.com", accept: "json" }
       });
+
+      expect(result).toEqual(`http://example.com#json`);
+    });
+
+    it("should support intersection type with optional key", async () => {
+      const result = await client({
+        method: "test",
+        params: { url: "http://example.com" }
+      });
+
+      expect(result).toEqual(`http://example.com#undefined`);
     });
   });
 });

src/index.spec.ts

@@ -1,14 +1,14 @@
-import { BaseError } from "make-error";
-import { TypeOf, Any, TypeC } from "io-ts";
-import { PathReporter } from "io-ts/lib/PathReporter";
-import { either } from "fp-ts";
+import { TypeOf, ZodAny } from "zod";
+import * as schema from "zod";
 
-export interface Method<T extends TypeC<any>, U extends Any> {
+export { schema };
+
+export interface Method<T extends ZodAny, U extends ZodAny> {
   request: T;
   response: U;
 }
 
-export type Methods = Record<string, Method<TypeC<any>, Any>>;
+export type Methods = Record<string, Method<ZodAny, ZodAny>>;
 
 /**
  * Metadata for JSON-RPC requests.
@@ -87,19 +87,23 @@ export interface JsonRpcFailure<T> extends JsonRpcResponse {
 // Define commonly used failure messages.
 const INVALID_REQUEST = { code: -32600, message: "Invalid request" };
 const METHOD_NOT_FOUND = { code: -32601, message: "Method not found" };
-const PARSE_ERROR = { code: -32700, message: "Parse error" };
 
 /**
  * Parse raw input into JSON.
  */
-export function parse(input: string): either.Either<JsonRpcError, unknown> {
-  return either.parseJSON(input, () => PARSE_ERROR);
+export function parse(input: string): unknown {
+  try {
+    return JSON.parse(input);
+  } catch (err) {
+    err.code = -32700;
+    throw err;
+  }
 }
 
 /**
  * Create a custom RPC error to report issues.
  */
-export class RpcError<T = void> extends BaseError {
+export class RpcError<T = void> extends Error {
   constructor(public message: string, public code = -32603, public data: T) {
     super(message);
   }
@@ -166,25 +170,21 @@ async function processRequest<T extends Methods, C = void>(
   let data = undefined;
   const { request, response } = methods[method];
 
-  if (Array.isArray(params)) {
-    data = Object.keys(request.props).reduce<any>((obj, key, index) => {
-      obj[key] = params[index];
-      return obj;
-    }, {});
-  } else if (params === undefined || typeof params === "object") {
+  if (params === undefined || typeof params === "object") {
     data = params ?? {};
   } else {
     return failure(INVALID_REQUEST, id);
   }
 
-  const input =
-    options.decode === false ? either.right(data) : request.decode(data);
+  let input: unknown;
 
-  if (either.isLeft(input)) {
+  try {
+    input = options.decode === false ? data : request.parse(data);
+  } catch (err) {
     return failure(
       {
         code: -32602,
-        message: PathReporter.report(input).join("; ")
+        message: err.message
       },
       id
     );
@@ -194,9 +194,9 @@ async function processRequest<T extends Methods, C = void>(
   const metadata: Metadata = { id, isNotification };
 
   try {
-    const data = await resolvers[method](input.right, context, metadata);
+    const data = await resolvers[method](input, context, metadata);
     if (isNotification) return; // Do not encode response for notifications.
-    return success(options.encode === false ? data : response.encode(data), id);
+    return success(options.encode === false ? data : response.parse(data), id);
   } catch (err) {
     return failure(
       {
@@ -297,7 +297,7 @@ export function createClient<T extends Methods, U = void>(
 
     return {
       method,
-      params: options.encode === false ? params : request.encode(params),
+      params: options.encode === false ? params : request.parse(params),
       id: async ? undefined : counter++,
       process: (body: unknown): unknown => {
         if (body === undefined) {
@@ -324,20 +324,11 @@ export function createClient<T extends Methods, U = void>(
           );
         }
 
-        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
-          );
+        try {
+          return response.parse(result);
+        } catch (err) {
+          return new RpcError(err.message, -2, { result });
         }
-
-        return output.right;
       }
     };
   }