Remove io-ts from package

Author: blakeembrey

README.md

@@ -5,15 +5,14 @@
 [![Build status][travis-image]][travis-url]
 [![Test coverage][coveralls-image]][coveralls-url]
 
-> Tiny, type-safe [JSON-RPC 2.0](https://www.jsonrpc.org/specification) implementation.
+> Tiny, mostly compliant [JSON-RPC 2.0](https://www.jsonrpc.org/specification) implementation.
+
+This package intentionally doesn't implement the "arguments" form of request parameters. This is when the input `params` can be an object or an ordered array representing the object. Instead, you can pass _any_ JSON params over the wire.
 
 ## Installation
 
 ```sh
 npm install @borderlesslabs/json-rpc --save
-
-# Peer dependencies.
-npm install io-ts fp-ts --save
 ```
 
 ## Usage
@@ -22,33 +21,27 @@ This package makes no assumptions about the transportation layer, for client or
 
 ### Methods
 
-The methods definition uses [`io-ts`](https://github.com/gcanti/io-ts) to encode and decode requests or responses.
-
 ```ts
-import * as t from "io-ts";
-
-const methods = {
+type Methods = {
   hello: {
-    // `request` is required, even when empty.
-    request: t.type({}),
-    response: t.string
-  },
+    request: {};
+    response: string;
+  };
   echo: {
-    // Specify `request` parameters as keys of the object.
-    request: t.type({ arg: t.string }),
-    response: t.string
-  }
+    request: { arg: string };
+    response: string;
+  };
 };
 ```
 
 ### Server
 
-The server takes the methods and a dictionary of matching resolvers.
+The server accepts a dictionary of resolvers.
 
 ```ts
 import { createClient } from "@borderlesslabs/json-rpc";
 
-const server = createServer(methods, {
+const server = createServer<Methods>({
   hello: _ => "Hello World!",
   echo: ({ arg }) => arg
 });
@@ -62,15 +55,15 @@ const res = await server({
 
 ### Client
 
-The client takes the methods and a function to `send` the JSON-RPC request.
+The client accepts a function to `send` the JSON-RPC request.
 
 ```ts
 import { createClient } from "@borderlesslabs/json-rpc";
 
-const client = createClient(methods, async x => {
+const client = createClient(async payload => {
   const res = await fetch("...", {
     method: "POST",
-    body: JSON.stringify(x),
+    body: JSON.stringify(payload),
     headers: {
       "Content-Type": "application/json"
     }

package-lock.json

@@ -79,19 +79,13 @@
     "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",
     "rimraf": "^3.0.0",
     "ts-expect": "^1.1.0",
     "ts-jest": "^25.2.1",
     "typescript": "^3.7.4"
-  },
-  "peerDependencies": {
-    "io-ts": "^2.0.4",
-    "fp-ts": "^2.4.0"
   }
 }

package.json

@@ -1,62 +1,48 @@
-import * as t from "io-ts";
-import { isLeft, isRight } from "fp-ts/lib/Either";
 import { expectType, TypeEqual } from "ts-expect";
 import {
   createServer,
-  parse,
+  parseJSON,
   createClient,
   RpcError,
   Resolvers,
-  ClientRequests,
+  ClientRequest,
   ClientResponse
 } from "./index";
 
 describe("json rpc", () => {
-  const methods = {
+  type Methods = {
     hello: {
-      request: t.undefined,
-      response: t.string
-    },
+      request: undefined;
+      response: string;
+    };
     echo: {
-      request: t.type({ arg: t.string }),
-      response: t.string
-    }
+      request: { arg: string };
+      response: string;
+    };
   };
 
-  const resolvers: Resolvers<typeof methods> = {
+  const resolvers: Resolvers<Methods> = {
     hello: _ => "Hello World!",
     echo: ({ arg }) => arg
   };
 
-  const server = createServer(methods, resolvers);
-  const client = createClient(methods, x => server(x, undefined));
+  const server = createServer(resolvers);
+  const client = createClient(x => server(x, undefined));
 
   describe("types", () => {
-    type Requests = ClientRequests<typeof methods>;
-    type Responses = ClientResponse<typeof methods, Requests>;
+    type Requests = ClientRequest<Methods>;
+    type Responses = ClientResponse<Methods, Requests>;
 
     expectType<TypeEqual<Responses, string>>(true);
   });
 
   describe("parse", () => {
     it("should parse json", () => {
-      const result = parse("{}");
-
-      expect(isRight(result)).toEqual(true);
-
-      if (isRight(result)) {
-        expect(result.right).toEqual({});
-      }
+      expect(() => parseJSON("{}")).not.toThrow();
     });
 
     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(() => parseJSON("[")).toThrow(RpcError);
     });
   });
 
@@ -219,63 +205,6 @@ describe("json rpc", () => {
           }
         });
       });
-
-      it("should fail on missing parameters", async () => {
-        const res = await server({
-          jsonrpc: "2.0",
-          id: "test",
-          method: "echo"
-        });
-
-        expect(res).toEqual({
-          jsonrpc: "2.0",
-          id: "test",
-          error: {
-            code: -32602,
-            message: "Invalid value undefined supplied to : { arg: string }"
-          }
-        });
-      });
-
-      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: -32602,
-            message: 'Invalid value "test" supplied to : { arg: string }'
-          }
-        });
-      });
-
-      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!"
-          });
-        });
-      });
     });
   });
 
@@ -306,23 +235,10 @@ 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: undefined });
-
-          expect(result).toEqual("Hello World!");
-        });
-      });
-
-      describe("with send options", () => {
-        const client = createClient(methods, (_, options: string) =>
-          Promise.resolve({ result: options })
-        );
+      describe("with send context", () => {
+        const client = createClient(async (_, context: string) => ({
+          result: context
+        }));
 
         it("should accept options", async () => {
           const result = await client(
@@ -377,40 +293,4 @@ describe("json rpc", () => {
       });
     });
   });
-
-  describe("intersection types", () => {
-    const methods = {
-      test: {
-        request: t.intersection([
-          t.type({ url: t.string }),
-          t.partial({ accept: t.string })
-        ]),
-        response: t.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`);
-    });
-  });
 });