open-rpc
diff --git a/‎src/RequestManager.test.ts‎
Lines changed: 36 additions & 1 deletion b/‎src/RequestManager.test.ts‎
Lines changed: 36 additions & 1 deletion
diff --git a/‎src/RequestManager.ts‎
Lines changed: 34 additions & 4 deletions b/‎src/RequestManager.ts‎
Lines changed: 34 additions & 4 deletions
diff --git a/‎src/index.ts‎
Lines changed: 6 additions & 15 deletions b/‎src/index.ts‎
Lines changed: 6 additions & 15 deletions
@@ -39,7 +39,42 @@ describe("client-js", () => {
     c.request("foo", []);
   });
 
-  it("can send a request and error", () => {
+  it("can batch a request", async () => {
+    const transport = new EventEmitterTransport("foo://unique-uri");
+    transport.sendData = (data) => {
+      const result = JSON.stringify([
+        {
+          jsonrpc: "2.0",
+          id: 3,
+          result: "foo",
+        },
+        {
+          jsonrpc: "2.0",
+          id: 4,
+          result: "bar",
+        },
+      ]);
+      transport.connection.emit("message", result);
+    };
+
+    const c = new RequestManager([transport]);
+    return c.connect().then(() => {
+      c.startBatch();
+      const requests = [
+        c.request("foo", []),
+        c.request("foo", []),
+      ];
+      c.endBatch();
+      return Promise.all(requests).then((results) => {
+        expect(results[0]).toEqual("foo");
+        expect(results[1]).toEqual("bar");
+        c.close();
+      });
+
+    });
+  });
+
+  it("can send a request and error", async () => {
     const transport = new EventEmitterTransport("foo://unique-uri");
     const c = new RequestManager([transport]);
     transport.onData = (fn) => {
 
@@ -1,4 +1,5 @@
 import ITransport from "./transports/Transport";
+
 let id = 1;
 
 interface IJSONRPCRequest {
@@ -7,6 +8,24 @@ interface IJSONRPCRequest {
   method: string;
   params: any[] | object;
 }
+interface IJSONRPCError {
+  code: number;
+  message: string;
+  data: any;
+}
+
+interface IJSONRPCResponse {
+  jsonrpc: "2.0";
+  id: number;
+  result?: any;
+  error?: IJSONRPCError;
+}
+
+interface IJSONRPCNotification {
+  jsonrpc: "2.0";
+  method: string;
+  params: any[] | object;
+}
 
 /*
 ** Naive Request Manager, only use 1st transport.
@@ -15,8 +34,8 @@ interface IJSONRPCRequest {
  */
 class RequestManager {
   public transports: ITransport[];
+  public connectPromise: Promise<any>;
   private requests: any;
-  private connectPromise: Promise<any>;
   private batchStarted: boolean = false;
   private batch: IJSONRPCRequest[] = [];
 
@@ -40,7 +59,6 @@ class RequestManager {
   }
 
   public async request(method: string, params: any): Promise<any> {
-    await this.connectPromise;
     return new Promise((resolve, reject) => {
       const i = id++;
       // naively grab first transport and use it
@@ -56,7 +74,7 @@ class RequestManager {
         params,
       };
       if (this.batchStarted) {
-        this.batch.push(payload); // could dedupe
+        this.batch.push(payload);
       } else {
         transport.sendData(JSON.stringify(payload));
       }
@@ -95,7 +113,19 @@ class RequestManager {
   }
 
   private onData(data: string): void {
-    const parsedData = JSON.parse(data);
+    const parsedData: IJSONRPCResponse[] | IJSONRPCResponse = JSON.parse(data);
+    if (Array.isArray(parsedData)) {
+      parsedData.forEach((response) => {
+        if (this.requests[response.id]) {
+          if (response.error) {
+            this.requests[response.id].reject(new Error(response.error.message));
+          } else {
+            this.requests[response.id].resolve(response.result);
+          }
+        }
+      });
+      return;
+    }
     if (typeof parsedData.result === "undefined" && typeof parsedData.error === "undefined") {
       return;
     }
 
@@ -29,26 +29,16 @@ class Client implements IClient {
   }
 
   /**
-   * A JSON-RPC call is represented by sending a Request object to a Server.
-   *
-   * @param method A String containing the name of the method to be invoked.
-   * Method names that begin with the word rpc followed by a
-   * period character (U+002E or ASCII 46) are reserved for rpc-internal
-   * methods and extensions and MUST NOT be used for anything else.
-   * @param params A Structured value that holds the parameter values to be used during the invocation of the method.
+   * Starts a JSON-RPC Batch call. The client will batch following requests.
+   * This method REQUIRES endBatch be called when finished calling requests.
    */
   public startBatch(): void {
     return this.requestManager.startBatch();
   }
 
   /**
-   * A JSON-RPC call is represented by sending a Request object to a Server. See [[RequestManager#endBatch]]
-   *
-   * @param method A String containing the name of the method to be invoked.
-   * Method names that begin with the word rpc followed by a
-   * period character (U+002E or ASCII 46) are reserved for rpc-internal
-   * methods and extensions and MUST NOT be used for anything else.
-   * @param params A Structured value that holds the parameter values to be used during the invocation of the method.
+   * Ends a JSON-RPC Batch call. This client will batch requests from when startBatch
+   * was called until endBatch. This REQUIRES startBatch to be called first.
    */
   public endBatch(): void {
     return this.requestManager.endBatch();
@@ -62,7 +52,8 @@ class Client implements IClient {
    * methods and extensions and MUST NOT be used for anything else.
    * @param params A Structured value that holds the parameter values to be used during the invocation of the method.
    */
-  public request(method: string, params: any) {
+  public async request(method: string, params: any) {
+    await this.requestManager.connectPromise;
     return this.requestManager.request(method, params);
   }
 }