Revert to io-ts

Author: blakeembrey

package-lock.json

@@ -79,7 +79,9 @@
     "eslint": "^6.8.0",
     "eslint-config-prettier": "^6.9.0",
     "eslint-plugin-prettier": "^3.1.2",
+    "fp-ts": "^2.4.0",
     "husky": "^4.2.3",
+    "io-ts": "^2.0.4",
     "jest": "^25.1.0",
     "lint-staged": "^10.0.8",
     "prettier": "^1.19.1",
@@ -88,7 +90,8 @@
     "ts-jest": "^25.2.1",
     "typescript": "^3.7.4"
   },
-  "dependencies": {
-    "zod": "^1.0.9"
+  "peerDependencies": {
+    "io-ts": "^2.0.4",
+    "fp-ts": "^2.4.0"
   }
 }

package.json

@@ -1,6 +1,7 @@
+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,
@@ -13,12 +14,12 @@ import {
 describe("json rpc", () => {
   const methods = {
     hello: {
-      request: schema.object({}),
-      response: schema.string()
+      request: t.undefined,
+      response: t.string
     },
     echo: {
-      request: schema.object({ arg: schema.string() }),
-      response: schema.string()
+      request: t.type({ arg: t.string }),
+      response: t.string
     }
   };
 
@@ -28,7 +29,7 @@ describe("json rpc", () => {
   };
 
   const server = createServer(methods, resolvers);
-  const client = createClient(methods, server);
+  const client = createClient(methods, x => server(x, undefined));
 
   describe("types", () => {
     type Requests = ClientRequests<typeof methods>;
@@ -39,11 +40,23 @@ describe("json rpc", () => {
 
   describe("parse", () => {
     it("should parse json", () => {
-      expect(parse("{}")).toEqual({});
+      const result = parse("{}");
+
+      expect(isRight(result)).toEqual(true);
+
+      if (isRight(result)) {
+        expect(result.right).toEqual({});
+      }
     });
 
     it("should fail to parse malformed json", () => {
-      expect(() => parse("[")).toThrow(SyntaxError);
+      const result = parse("[");
+
+      expect(isLeft(result)).toEqual(true);
+
+      if (isLeft(result)) {
+        expect(result.left).toEqual({ code: -32700, message: "Parse error" });
+      }
     });
   });
 
@@ -219,25 +232,7 @@ describe("json rpc", () => {
           id: "test",
           error: {
             code: -32602,
-            message: "arg: Non-string type: undefined"
-          }
-        });
-      });
-
-      it("should fail on invalid parameters", async () => {
-        const res = await server({
-          jsonrpc: "2.0",
-          id: "test",
-          method: "echo",
-          params: "test"
-        });
-
-        expect(res).toEqual({
-          jsonrpc: "2.0",
-          id: "test",
-          error: {
-            code: -32600,
-            message: "Invalid request"
+            message: "Invalid value undefined supplied to : { arg: string }"
           }
         });
       });
@@ -254,8 +249,8 @@ describe("json rpc", () => {
           jsonrpc: "2.0",
           id: "test",
           error: {
-            code: -32600,
-            message: "Invalid request"
+            code: -32602,
+            message: 'Invalid value "test" supplied to : { arg: string }'
           }
         });
       });
@@ -287,28 +282,28 @@ describe("json rpc", () => {
   describe("client", () => {
     describe("request", () => {
       it("should make a request", async () => {
-        const result = await client({ method: "hello", params: {} });
+        const result = await client({ method: "hello", params: undefined });
 
         expect(result).toEqual("Hello World!");
       });
 
       it("should make a notification request", async () => {
         const result = await client({
           method: "hello",
-          params: {},
+          params: undefined,
           async: true
         });
 
         expect(result).toEqual(undefined);
       });
 
-      it("should throw on invalid argument", async () => {
+      it("should throw rpc errors", async () => {
         await expect(
           client({
             method: "echo",
             params: {} as any
           })
-        ).rejects.toBeInstanceOf(Error);
+        ).rejects.toBeInstanceOf(RpcError);
       });
 
       describe("without type checking", () => {
@@ -318,7 +313,7 @@ describe("json rpc", () => {
         });
 
         it("should succeed", async () => {
-          const result = await client({ method: "hello", params: {} });
+          const result = await client({ method: "hello", params: undefined });
 
           expect(result).toEqual("Hello World!");
         });
@@ -330,7 +325,10 @@ describe("json rpc", () => {
         );
 
         it("should accept options", async () => {
-          const result = await client({ method: "hello", params: {} }, "Test");
+          const result = await client(
+            { method: "hello", params: undefined },
+            "Test"
+          );
 
           expect(result).toEqual("Test");
         });
@@ -340,7 +338,7 @@ describe("json rpc", () => {
     describe("many", () => {
       it("should make a many request", async () => {
         const result = await client.many([
-          { method: "hello", params: {} },
+          { method: "hello", params: undefined },
           { method: "echo", params: { arg: "test" } }
         ]);
 
@@ -349,7 +347,7 @@ describe("json rpc", () => {
 
       it("should make a many notification request", async () => {
         const result = await client.many([
-          { method: "hello", params: {}, async: true },
+          { method: "hello", params: undefined, async: true },
           { method: "echo", params: { arg: "test" }, async: true }
         ]);
 
@@ -358,35 +356,36 @@ describe("json rpc", () => {
 
       it("should handle mixed many responses", async () => {
         const result = await client.many([
-          { method: "hello", params: {}, async: true },
+          { method: "hello", params: undefined, async: true },
           { method: "echo", params: { arg: "test" } },
-          { method: "hello", params: {}, async: true }
+          { method: "hello", params: undefined, async: true }
         ]);
 
         expect(result).toEqual([undefined, "test", undefined]);
       });
 
-      it("should throw on invalid argument", async () => {
-        expect(
-          client.many([
-            {
-              method: "echo",
-              params: {} as any
-            }
-          ])
-        ).rejects.toBeInstanceOf(Error);
+      it("should return rpc errors", async () => {
+        const result = await client.many([
+          {
+            method: "echo",
+            params: {} as any
+          }
+        ]);
+
+        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()
+        request: t.intersection([
+          t.type({ url: t.string }),
+          t.partial({ accept: t.string })
+        ]),
+        response: t.string
       }
     };