optional method execution configation

README.md

@@ -114,3 +114,25 @@ transport.send({jsonrpc:'2.0', id: 1, method: 'subtract', params: [5, 4]});
 ```
 
 While, websockets, mqtt, and webworkers are common, transports could be built from any form of communication you wish!
+
+
+## Custom Configuration for Method invocations
+
+if you need to pass configuration specific method invocations, you can uses the `methodsExt` property of a rawr instance.
+
+For example, if you want to specify a specific timeout for a method call you can use a configuration object as the last parameter:
+```javascript
+try {
+  const result = await peer.methodsExt.doSomething(a, b, { timeout: 100 });
+} catch(e) {
+  // method took longer than a 100 millseconds
+}
+```
+
+This also works for customizaton of the transport.
+For example, you may want to pass configuration for transferable objects to a webWorker:
+```javascript
+  const result = await peer.methodsExt.processImage({ imageBitmap, stuff }, {
+    postMessageOptions: { transfer: [imageBitmap] }
+  });
+```

dist/bundle.js

@@ -66,40 +66,60 @@ function rawr({ transport, timeout = 0, handlers = {}, methods, idGenerator }) {
     addHandler(m, methods[m]);
   });
 
-  const methodsProxy = new Proxy({}, {
-    get: (target, name) => {
-      return (...args) => {
-        const id = idGenerator ? idGenerator() : ++callId;
-        const msg = {
-          jsonrpc: '2.0',
-          method: name,
-          params: args,
-          id
-        };
+  function sendMessage(method, params, config) {
+    const id = idGenerator ? idGenerator() : ++callId;
+    const msg = {
+      jsonrpc: '2.0',
+      method,
+      params,
+      id
+    };
 
-        let timeoutId;
-        if (timeout) {
-          timeoutId = setTimeout(() => {
-            if (pendingCalls[id]) {
-              const err = new Error('RPC timeout');
-              err.code = 504;
-              pendingCalls[id].reject(err);
-              delete pendingCalls[id];
-            }
-          }, timeout);
+    let timeoutId;
+    if (config.timeout || timeout) {
+      timeoutId = setTimeout(() => {
+        if (pendingCalls[id]) {
+          const err = new Error('RPC timeout');
+          err.code = 504;
+          pendingCalls[id].reject(err);
+          delete pendingCalls[id];
         }
+      }, config.timeout || timeout);
+    }
 
-        const response = new Promise((resolve, reject) => {
-          pendingCalls[id] = { resolve, reject, timeoutId };
-        });
+    const response = new Promise((resolve, reject) => {
+      pendingCalls[id] = { resolve, reject, timeoutId };
+    });
 
-        transport.send(msg);
+    transport.send(msg, config);
 
-        return response;
+    return response;
+  }
+
+  const methodsProxy = new Proxy({}, {
+    get: (target, name) => {
+      return (...args) => {
+        return sendMessage(name, args, {});
       };
     }
   });
 
+  const configurableMethodsProxy = new Proxy({}, {
+    get: (target, name) => {
+      return (...args) => {
+        let config;
+        if (args.length) {
+          const testArg = args.pop();
+          if (testArg && typeof testArg === 'object' && !Array.isArray(testArg)) {
+            config = testArg;
+          }
+        }
+        return sendMessage(name, args, config || {});
+      };
+    }
+  });
+
+
   const notifiers = new Proxy({}, {
     get: (target, name) => {
       return (...args) => {
@@ -125,6 +145,7 @@ function rawr({ transport, timeout = 0, handlers = {}, methods, idGenerator }) {
 
   return {
     methods: methodsProxy,
+    methodsExt: configurableMethodsProxy,
     addHandler,
     notifications,
     notifiers,
@@ -759,8 +780,8 @@ function dom(webWorker) {
       emitter.emit('rpc', data);
     }
   });
-  emitter.send = (msg) => {
-    webWorker.postMessage(msg);
+  emitter.send = (msg, config) => {
+    webWorker.postMessage(msg, config ? config.postMessageOptions : undefined);
   };
   return emitter;
 }
@@ -773,8 +794,8 @@ function worker() {
       emitter.emit('rpc', data);
     }
   };
-  emitter.send = (msg) => {
-    self.postMessage(msg);
+  emitter.send = (msg, config) => {
+    self.postMessage(msg, config ? config.postMessageOptions : undefined);
   };
   return emitter;
 }

index.js

@@ -65,40 +65,60 @@ function rawr({ transport, timeout = 0, handlers = {}, methods, idGenerator }) {
     addHandler(m, methods[m]);
   });
 
-  const methodsProxy = new Proxy({}, {
-    get: (target, name) => {
-      return (...args) => {
-        const id = idGenerator ? idGenerator() : ++callId;
-        const msg = {
-          jsonrpc: '2.0',
-          method: name,
-          params: args,
-          id
-        };
+  function sendMessage(method, params, config) {
+    const id = idGenerator ? idGenerator() : ++callId;
+    const msg = {
+      jsonrpc: '2.0',
+      method,
+      params,
+      id
+    };
 
-        let timeoutId;
-        if (timeout) {
-          timeoutId = setTimeout(() => {
-            if (pendingCalls[id]) {
-              const err = new Error('RPC timeout');
-              err.code = 504;
-              pendingCalls[id].reject(err);
-              delete pendingCalls[id];
-            }
-          }, timeout);
+    let timeoutId;
+    if (config.timeout || timeout) {
+      timeoutId = setTimeout(() => {
+        if (pendingCalls[id]) {
+          const err = new Error('RPC timeout');
+          err.code = 504;
+          pendingCalls[id].reject(err);
+          delete pendingCalls[id];
         }
+      }, config.timeout || timeout);
+    }
 
-        const response = new Promise((resolve, reject) => {
-          pendingCalls[id] = { resolve, reject, timeoutId };
-        });
+    const response = new Promise((resolve, reject) => {
+      pendingCalls[id] = { resolve, reject, timeoutId };
+    });
 
-        transport.send(msg);
+    transport.send(msg, config);
+
+    return response;
+  }
 
-        return response;
+  const methodsProxy = new Proxy({}, {
+    get: (target, name) => {
+      return (...args) => {
+        return sendMessage(name, args, {});
+      };
+    }
+  });
+
+  const configurableMethodsProxy = new Proxy({}, {
+    get: (target, name) => {
+      return (...args) => {
+        let config;
+        if (args.length) {
+          const testArg = args.pop();
+          if (testArg && typeof testArg === 'object' && !Array.isArray(testArg)) {
+            config = testArg;
+          }
+        }
+        return sendMessage(name, args, config || {});
       };
     }
   });
 
+
   const notifiers = new Proxy({}, {
     get: (target, name) => {
       return (...args) => {
@@ -124,6 +144,7 @@ function rawr({ transport, timeout = 0, handlers = {}, methods, idGenerator }) {
 
   return {
     methods: methodsProxy,
+    methodsExt: configurableMethodsProxy,
     addHandler,
     notifications,
     notifiers,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "rawr",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "description": "JSON-RPC over simple event emitters",
   "dependencies": {},
   "devDependencies": {

test/index.js

@@ -48,6 +48,18 @@ function subtract(a, b) {
   return a - b;
 }
 
+function slowFunction() {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve('slow');
+    }, 300);
+  });
+}
+
+function hi() {
+  return 'hi';
+}
+
 describe('rawr', () => {
   it('should make a client', (done) => {
     const client = rawr({ transport: mockTransports().a });
@@ -126,4 +138,29 @@ describe('rawr', () => {
 
     clientB.notifiers.doSomething('testing_notification');
   });
+
+  it('client should fail on a configured timeout', async () => {
+    const { a, b } = mockTransports();
+    const clientA = rawr({ transport: a, handlers: { slowFunction, hi } });
+    const clientB = rawr({ transport: b, handlers: { slowFunction, add } });
+
+    const resultA = await clientA.methodsExt.slowFunction({ timeout: 1000 });
+    resultA.should.equal('slow');
+    const resultA2 = await clientA.methodsExt.add(1, 2, null);
+    resultA2.should.equal(3);
+    try {
+      await clientB.methodsExt.slowFunction({ timeout: 100 });
+
+    } catch (error) {
+      error.code.should.equal(504);
+    }
+    try {
+      await clientB.methodsExt.slowFunction('useless param', { timeout: 100 });
+    } catch (error) {
+      error.code.should.equal(504);
+    }
+    const resultB2 = await clientB.methodsExt.hi();
+    resultB2.should.equal('hi');
+
+  });
 });

transports/worker/index.js

@@ -8,8 +8,8 @@ function dom(webWorker) {
       emitter.emit('rpc', data);
     }
   });
-  emitter.send = (msg) => {
-    webWorker.postMessage(msg);
+  emitter.send = (msg, config) => {
+    webWorker.postMessage(msg, config ? config.postMessageOptions : undefined);
   };
   return emitter;
 }
@@ -22,8 +22,8 @@ function worker() {
       emitter.emit('rpc', data);
     }
   };
-  emitter.send = (msg) => {
-    self.postMessage(msg);
+  emitter.send = (msg, config) => {
+    self.postMessage(msg, config ? config.postMessageOptions : undefined);
   };
   return emitter;
 }