unary stub call updated to new API

firecomm · Aug 5, 2019 · 5707e30 · 5707e30
1 parent a1a5a3e
commit 5707e30
Show file tree

Hide file tree

Showing 2 changed files with 62 additions and 65 deletions.
diff --git a/lib/Stub.js b/lib/Stub.js
@@ -44,51 +44,20 @@ module.exports = function Stub(serviceDefinition, port, config) {
         methodName[0].toLowerCase() + methodName.substring(1);
 
       if (methodType === "Unary") {
-        // 'message' could be *any* kind of data that fits the *.proto file
+        // 'message' will always be an object with *any* kind of data as properties that fit the .proto file
         // configuation
         this[lowerCaseName] = function(
-          message,
-          interceptorArray,
           metaObject,
-          callback
+          interceptorArray,
         ) {
           const that = this;
           return unaryCall(
+            metaObject,
+            interceptorArray,
             that,
             methodName,
-            message,
-            interceptorArray,
-            metaObject,
-            callback
           );
         };
-        //   let metadata = undefined;
-        //   let interceptors = undefined;
-        //   if (typeof message !== "object") {
-        //     throw new Error(
-        //       "First parameter required and must be of type: Message."
-        //     );
-        //   }
-        //   //ultimately needs to get message, metadata, interceptors...
-        //   //and callback
-        //   if (callback === undefined) {
-        //     return new Promise((resolve, reject) => {
-        //       that[methodName](
-        //         message,
-        //         metadata,
-        //         interceptors,
-        //         (err, response) => {
-        //           if (err) {
-        //             reject(err);
-        //           }
-        //           resolve(response);
-        //         }
-        //       );
-        //     });
-        //   } else {
-        //     that[methodName](message, metadata, interceptors, callback);
-        //   }
-        // };
       } else if (methodType === "ClientStream") {
         this[lowerCaseName] = function(metaObject, interceptorArray, callback) {
           const that = this;

diff --git a/lib/clientCalls/unaryCall.js b/lib/clientCalls/unaryCall.js
@@ -24,41 +24,69 @@ const generateMeta = require("../utils/generateMeta");
 
 //throw which will console.log(no throw on unary calls...)
 
-module.exports = function unaryCall(that, methodName, ...args) {
-  if (typeof args[0] !== "object") {
-    throw new Error("First parameter required and must be of type: Message.");
+module.exports = function unaryCall(that, methodName, first /*real*/, second /*real*/,) {
+  let message;
+  let metadata;
+  let interceptors;
+  let callback = function(err, res) => {
+    if(err) this.$catch(err);
+    return this.$on(res);
   }
-  let message = args[0];
-  let interceptors = undefined;
-  let metadata = undefined;
-  let callback = undefined;
-  let promise = true;
-  args = args.filter(arg => args !== undefined);
-  for (let i = 1; i < args.length; i++) {
-    if (typeof args[i] === "function") {
-      callback = args[i];
-      promise = false;
+  if (typeof first === "object") {
+    if (Array.isArray(first)) {
+      interceptors = { interceptors: first };
     } else {
-      if (typeof (args[i] === "object")) {
-        if (Array.isArray(args[i])) {
-          interceptors = { interceptors: args[i] };
-        } else {
-          metadata = generateMeta(args[i]);
-        }
+      metadata = generateMeta(first);
+    }
+  };
+  if (typeof second === "object") {
+    if (Array.isArray(second)) {
+      interceptors = { interceptors: second };
+    } else {
+      metadata = generateMeta(second);
+    }
+  };
+  return {
+    send: (message) => {
+      that[methodName](message, metadata, interceptors, callback);
+    },
+    catch: (first) => {
+      if (typeof first !== 'function') {
+        throw new Error('Unary Call: catch takes a callback')
+      }
+      this.$catch = first;
+    },
+    on: (first, second) => {
+      let callback;
+      if (typeof first !== 'function' && typeof second !== 'function') {
+        throw new Error('Unary Call: on takes a callback')
       }
+      if (typeof first === 'function') {
+        callback = first;
+      } else {
+        callback = second;
+      }
+      this.$on = callback;
+    }
     }
   }
-  if (promise) {
-    return new Promise((resolve, reject) => {
-      that[methodName](message, metadata, interceptors, (err, res) => {
-        if (err) reject(err);
-        resolve(res);
-      });
-    });
-  } else {
-    return that[methodName](message, metadata, interceptors, callback);
-  }
-};
+}
+
+// function unaryInner(that, methodName, ...args) {
+//   if (typeof args[0] !== "object") {
+//     throw new Error("First parameter required and must be of type: Message.");
+//   }
+//   let message = args[0];
+//   let interceptors = undefined;
+//   let metadata = undefined;
+//   let callback = undefined;
+//   args = args.filter(arg => args !== undefined);
+//   for (let i = 1; i < args.length; i++) {
+//     }
+//   } else {
+//     return that[methodName](message, metadata, interceptors, callback);
+//   }
+// };
 // message interceptors
 
 // []