many jobs

examples/firecomm/client.js

@@ -64,15 +64,15 @@ const testUnaryChat = () => {
 
 // testClientStream();
 
-const newClient = stub.clientStream({meta: 'data'}, [interceptorProvider])
-  .send({message: 'yolo'})
-  .send(firstChat)
-  .on(data => console.log({ data }))
-  .catch(err => console.log({ err }))
+// const newClient = stub.clientStream({meta: 'data'}, [interceptorProvider])
+//   .send({message: 'yolo'})
+//   .send(firstChat)
+//   .on(({message}) => console.log({ message }))
+//   .catch(err => console.log({ err }))
 
-  setInterval(()=>{
-    newClient.send({message:'please'})
-  }, 1000)
+//   setInterval(()=>{
+//     newClient.send({message:'please'})
+//   }, 1000)
 
 const testServerStream = () => {
   const serverStream = stub.serverStream(firstChat);
@@ -84,17 +84,23 @@ const testServerStream = () => {
 };
 // testServerStream();
 
-const testBidiChat = () => {
-  console.log({ stub });
-  console.log("bidichat:", stub.bidiChat);
-  const duplexStream = stub.bidiChat();
-  duplexStream.write({ message: "dickhead from client" });
-  duplexStream.on("data", data => {
-    console.log(data);
-  });
-  duplexStream.on("error", err => {
-    console.log({ err });
-  });
-};
+// const testBidiChat = () => {
+// const duplexStream = stub.bidiChat({meta: 'data'});
+// duplexStream.write({ message: "from client" });
+// duplexStream.on("data", ({message}) => {
+//   console.log(message);
+//   duplexStream.write({ message: "from client" });
+// });
+// duplexStream.on('error',(err => {
+//   console.log({ err });
+// }));
+
+const duplexStream = stub.bidiChat({meta: 'data'}, [interceptorProvider]).send({ message: "from client" }).on(({message}) => {
+  console.log(message);
+  duplexStream.send({ message: "from client2" });
+}).catch((err => {
+  console.log({ err });
+}));
+// };
 
 // testBidiChat();

examples/firecomm/methodHandlers.js

@@ -37,13 +37,9 @@ function bidiChat(context) {
   // console.log('context proto', context.__proto__)
 
   context.on("data", data => {
-    // console.log('data:', data);
+    console.log('data:', data);
     context.write({ message: data.message + " World" });
   });
-  context.throw(new Error("error"));
-  setTimeout(() => {
-    context.end();
-  }, 3000);
 }
 
 module.exports = {

lib/Stub.js

@@ -101,7 +101,10 @@ module.exports = function Stub(serviceDefinition, port, config) {
         };
       } else if (methodType === "Duplex") {
         // console.log({methodName});
-        this[lowerCaseName] = function(metaObject, interceptorArray) {
+        this[lowerCaseName] = function(
+          metaObject, 
+          interceptorArray
+          ) {
           const that = this;
           return duplexCall(that, methodName, metaObject, interceptorArray);
           // const metadata = generateMeta(metaObject);

lib/clientCalls/clientStreamCall.js

@@ -29,7 +29,6 @@ module.exports = function clientStreamCall(that, methodName, first, second) {
       sender.write(message, null, () => {
         // this.sender.write(message)
       });
-      console.log(sender);
       return clientStreamObj;
     },
     $catch: function() {
@@ -39,7 +38,7 @@ module.exports = function clientStreamCall(that, methodName, first, second) {
       },
       catch: function(first) {
         if (typeof first !== "function") {
-          throw new Error("Unary Call: catch takes a callback");
+          throw new Error("Client Stream: catch takes a callback");
         }
         clientStreamObj.$catch = first;
         return clientStreamObj;

lib/clientCalls/duplexCall.js

@@ -2,24 +2,53 @@ const generateMeta = require("../utils/generateMeta");
 
 // metaObject, interceptorArray
 
-module.exports = function duplexCall(that, methodName, ...args) {
-  let interceptors = undefined;
-  let metadata = undefined;
-  args = args.filter(arg => args !== undefined);
-  // while (args[args.length - 1] === undefined && args.length) {
-  //   console.log(args);
-  //   args.pop();
-  // }
-  // console.log(args);
-  for (let i = 0; i < args.length; i++) {
-    if (typeof (args[i] === "object")) {
-      if (Array.isArray(args[i])) {
-        interceptors = { interceptors: args[i] };
+module.exports = function duplexCall(that, methodName, first, second) {
+  let metadata;
+  let interceptors;
+  if (typeof first === "object") {
+    if (Array.isArray(first)) {
+      interceptors = { interceptors: first };
+    } else {
+      metadata = generateMeta(first);
+    }
+  };
+  if (typeof second === "object") {
+    if (Array.isArray(second)) {
+      interceptors = { interceptors: second };
+    } else {
+      metadata = generateMeta(second);
+    }
+  };
+  const duplexObj = {
+    send: function(message) {
+      const sender = that[methodName](metadata, interceptors);
+      sender.write(message, null, () => {
+        // this.sender.write(message)
+      });
+      return duplexObj;
+    },
+    catch: (first) => {
+      if (typeof first !== 'function') {
+        throw new Error('Unary Call: catch takes a callback')
+      }
+      const listener = that[methodName](metadata, interceptors);
+      listener.on('error', first);
+      return duplexObj;
+    },
+    on: (first, second) => {
+      let listenerCallback;
+      if (typeof first !== 'function' && typeof second !== 'function') {
+        throw new Error('Unary Call: on takes a callback')
+      };
+      if (typeof first === 'function') {
+        listenerCallback = first;
       } else {
-        metadata = generateMeta(args[i]);
+        listenerCallback = second;
       }
+      const listener = that[methodName](metadata, interceptors);
+      listener.on('data', listenerCallback);
+      return duplexObj;
     }
   }
-  // console.log(metadata, interceptors);
-  return that[methodName](metadata, interceptors);
+  return duplexObj;
 };

lib/clientCalls/serverStreamCall.js

@@ -53,16 +53,16 @@ module.exports = function serverStreamCall(that, methodName, first /*real*/, sec
       return serverStreamObj;
     },
     on: (first, second) => {
-      let callback;
+      let listenerCallback;
       if (typeof first !== 'function' && typeof second !== 'function') {
         throw new Error('Unary Call: on takes a callback')
       };
       if (typeof first === 'function') {
-        callback = first;
+        listenerCallback = first;
       } else {
-        callback = second;
+        listenerCallback = second;
       }
-      listener.on('data', callback);
+      listener.on('data', listenerCallback);
       return serverStreamObj;
     }
   };