@kabacorp/kaba-electron-rpc 7.1.2 → 8.1.0

package/.nvmrc

@@ -0,0 +1 @@
+14.21.3

package/README.md

@@ -135,4 +135,4 @@ var rpcClient = rpc.importAPI('error-api', manifest, {
   errors: {MyCustomError} // pass in custom error constructors
 })
 rpcClient.testThrow().catch(console.log) // => MyCustomError
-```
+```

package/index.js

@@ -1,2 +1,2 @@
 module.exports.exportAPI = require('./lib/export-api')
-module.exports.importAPI = require('./lib/import-api')
+module.exports.importAPI = require('./lib/import-api')

package/lib/export-api.js

@@ -6,12 +6,8 @@ const {
   isRenderer,
 } = require("./util");
 
-function removeCircular(ref) {
-  for (let i in ref) {
-    if (ref[i] === ref) delete ref[i];
-    else if (typeof ref[i] == "Object") removeCircular(ref[i]);
-  }
-}
+// Persistent map to avoid leaking cleanup functions
+const cleanupRoutines = new Map();
 
 module.exports = function (
   channelName,
@@ -19,54 +15,72 @@ module.exports = function (
   methods,
   globalPermissionCheck
 ) {
-  var api = new EventEmitter();
-  var webcontentsStreams = {};
+  const api = new EventEmitter();
+  const webcontentsStreams = {};
+
+  // Internal Debugging helper
+  const debug = (...args) => {
+    if (process.env.RPC_DEBUG) {
+      console.log(`[RPC-EXPORT:${channelName}]`, ...args);
+    }
+  };
 
-  var channel;
+  let channel;
   if (isNodeProcess()) {
-    var mockedSender = new EventEmitter();
+    const mockedSender = new EventEmitter();
     mockedSender.id = "main-process";
+    mockedSender.isDestroyed = () => false;
     mockedSender.send = (channelName, msgType, requestId, ...args) => {
-      // console.log('export-api#send', {channelName, msgType, requestId, args})
+      debug("send (node-process)", { msgType, requestId });
       process.send({ channelName, msgType, requestId, args });
     };
     channel = {
       onMessage(cb) {
         process.on("message", (msg) => {
-          if (msg.channelName !== channelName) return;
-          let mockedEvent = { sender: mockedSender };
-          // console.log('export-api#onMessage', msg)
-          cb(mockedEvent, msg.methodName, msg.requestId, ...msg.args);
+          if (msg && msg.channelName === channelName) {
+            debug("onMessage (node-process)", msg.methodName, msg.requestId);
+            const mockedEvent = { sender: mockedSender };
+            cb(mockedEvent, msg.methodName, msg.requestId, ...msg.args);
+          }
         });
       },
     };
   } else if (isRenderer()) {
-    var { ipcRenderer } = require("electron");
+    const { ipcRenderer } = require("electron");
     channel = {
       onMessage(cb) {
-        ipcRenderer.on(channelName, cb);
+        ipcRenderer.on(channelName, (event, methodName, requestId, ...args) => {
+          debug("onMessage (renderer)", methodName, requestId);
+          cb(event, methodName, requestId, ...args);
+        });
       },
     };
   } else {
-    var { ipcMain } = require("electron");
+    const { ipcMain } = require("electron");
     channel = {
       onMessage(cb) {
-        ipcMain.on(channelName, cb);
+        ipcMain.on(channelName, (event, methodName, requestId, ...args) => {
+          debug("onMessage (main)", methodName, requestId);
+          cb(event, methodName, requestId, ...args);
+        });
       },
     };
   }
 
   // wire up handler
   channel.onMessage(async function (event, methodName, requestId, ...args) {
-    // console.log('received', channelName, methodName, requestId, ...args)
     args = args.map(IPCValueToValue);
 
     // watch for a navigation event
-    var hasNavigated = false;
-    function onDidNavigate() {
+    let hasNavigated = false;
+    const onDidNavigate = () => {
+      debug("navigation detected", { requestId, methodName });
       hasNavigated = true;
+    };
+
+    if (event.sender && !event.sender.isDestroyed()) {
+      event.sender.once("did-navigate", onDidNavigate);
     }
-    event.sender.on("did-navigate", onDidNavigate);
 
     // helper to send
     const send = function (
@@ -75,48 +89,84 @@ module.exports = function (
       value,
       keepListeningForDidNavigate = false
     ) {
-      if (event.sender.isDestroyed && event.sender.isDestroyed()) return; // dont send response if destroyed
-      if (!keepListeningForDidNavigate)
+      if (
+        !event.sender ||
+        (event.sender.isDestroyed && event.sender.isDestroyed())
+      ) {
+        debug("send aborted: sender destroyed", { requestId, msgType });
+        return;
+      }
+
+      if (!keepListeningForDidNavigate) {
         event.sender.removeListener("did-navigate", onDidNavigate);
-      if (hasNavigated) return; // dont send response if the page changed
+      }
 
-      if (!value) {
-        console.log("sending", channelName, msgType, requestId, err, value);
-        value = err;
-      } else {
-        // console.log("sending", channelName, msgType, requestId, err, value);
+      if (hasNavigated) {
+        debug("send aborted: navigated away", { requestId, msgType });
+        return;
       }
-      //
-      if (event.reply) {
-        event.reply(channelName, msgType, requestId, err, value);
-      } else if (event.sender && event.sender.send) {
-        event.sender.send(channelName, msgType, requestId, err, value);
+
+      const target = event.reply ? event : event.sender;
+
+      try {
+        target.send(channelName, msgType, requestId, err, value);
+      } catch (serializationError) {
+        debug("serialization failed, attempting sanitization", {
+          requestId,
+          methodName,
+        });
+
+        let sanitizedValue = value;
+        if (value && typeof value === "object") {
+          if (typeof value.toJSON === "function") {
+            sanitizedValue = value.toJSON();
+          } else {
+            try {
+              sanitizedValue = JSON.parse(JSON.stringify(value));
+            } catch (e) {
+              console.error(
+                `[RPC ERROR] Circular/Complex object at "${methodName}":`,
+                e
+              );
+              sanitizedValue = {
+                id: value.id,
+                error:
+                  "Object too complex to serialize: " +
+                  serializationError.message,
+                stack: serializationError.stack,
+              };
+            }
+          }
+        }
+        target.send(channelName, msgType, requestId, err, sanitizedValue);
       }
     };
 
     // handle special methods
-    if (methodName == "stream-request-write") {
+    if (methodName === "stream-request-write") {
       event.returnValue = true;
       return streamRequestWrite(event.sender.id, requestId, args);
     }
-    if (methodName == "stream-request-end") {
+    if (methodName === "stream-request-end") {
       event.returnValue = true;
       return streamRequestEnd(event.sender.id, requestId, args);
     }
-    if (methodName == "stream-request-close") {
+    if (methodName === "stream-request-close") {
       event.returnValue = true;
       return streamRequestClose(event.sender.id, requestId, args);
     }
 
     // look up the method called
-    var type = manifest[methodName];
-    var method = methods[methodName];
+    const type = manifest[methodName];
+    const method = methods[methodName];
+
     if (!type || !method) {
-      api.emit(
-        "error",
-        new Error(`Method not found: "${methodName}"`),
-        arguments
-      );
+      const err = new Error(`Method not found: "${methodName}"`);
+      debug("error: method not found", methodName);
+      api.emit("error", err, { methodName, requestId, args });
+      // If async/promise, we should probably let the caller know
+      if (type === "async" || type === "promise")
+        send("async-reply", errorObject(err));
       return;
     }
 
@@ -125,8 +175,8 @@ module.exports = function (
       globalPermissionCheck &&
       !globalPermissionCheck(event, methodName, args)
     ) {
-      // repond according to method type
-      if (type == "async" || type == "promise") {
+      debug("permission denied", methodName);
+      if (type === "async" || type === "promise") {
         send("async-reply", "Method Access Denied");
       } else {
         event.returnValue = { error: "Method Access Denied" };
@@ -135,49 +185,55 @@ module.exports = function (
     }
 
     // run method by type
-    if (type == "sync") {
-      // call sync
+    if (type === "sync") {
       try {
         event.returnValue = {
           success: valueToIPCValue(method.apply(event, args)),
         };
       } catch (e) {
+        debug("sync method error", methodName, e.message);
         event.returnValue = { error: e.message };
       }
       return;
     }
-    if (type == "async") {
-      // create a reply cb
+
+    if (type === "async") {
       const replyCb = (err, value) => {
         if (err) err = errorObject(err);
         send("async-reply", err, valueToIPCValue(value));
       };
       args.push(replyCb);
-
-      // call async
-      method.apply(event, args);
+      try {
+        method.apply(event, args);
+      } catch (e) {
+        debug("async method throw", methodName, e.message);
+        send("async-reply", errorObject(e));
+      }
       return;
     }
-    if (type == "promise") {
-      // call promise
+
+    if (type === "promise") {
       let p;
       try {
         p = method.apply(event, args);
-        if (typeof p === "undefined") p = Promise.resolve();
-        if (typeof p.then === "undefined") p = Promise.resolve(p);
+        if (!(p instanceof Promise) && (!p || typeof p.then !== "function")) {
+          p = Promise.resolve(p);
+        }
       } catch (e) {
-        p = Promise.reject(errorObject(e));
+        p = Promise.reject(e);
       }
 
-      // handle response
       p.then(
         (value) => send("async-reply", null, valueToIPCValue(value)),
-        (error) => send("async-reply", errorObject(error))
+        (error) => {
+          debug("promise rejected", methodName, error?.message);
+          send("async-reply", errorObject(error));
+        }
       );
       return;
     }
 
-    var streamTypes = {
+    const streamTypes = {
       readable: createReadableEvents,
       writable: createWritableEvents,
       duplex: createDuplexEvents,
@@ -194,11 +250,11 @@ module.exports = function (
       );
     }
 
-    api.emit(
-      "error",
-      new Error(`Invalid method type "${type}" for "${methodName}"`),
-      arguments
+    const typeErr = new Error(
+      `Invalid method type "${type}" for "${methodName}"`
     );
+    debug("error: invalid type", type);
+    api.emit("error", typeErr, { methodName, type, requestId });
   });
 
   async function handleStream(
@@ -209,45 +265,32 @@ module.exports = function (
     createStreamEvents,
     send
   ) {
-    // call duplex
     let stream;
-    let error;
     try {
       stream = method.apply(event, args);
+      if (stream && typeof stream.then === "function") stream = await stream;
       if (!stream) {
-        send("stream-error", "Empty stream response");
-        return;
+        debug("stream-error: method returned null", requestId);
+        return send("stream-error", "Empty stream response");
       }
     } catch (e) {
-      send("stream-error", "" + e);
-      return;
-    }
-
-    // handle promises
-    if (stream.then) {
-      try {
-        stream = await stream; // wait for it
-      } catch (e) {
-        send("stream-error", "" + e);
-        return;
-      }
+      debug("stream instantiation error", e.message);
+      return send("stream-error", "" + e);
     }
 
     trackWebcontentsStreams(event.sender, requestId, stream);
-    var events = createStreamEvents(event, stream, requestId, send);
+    const events = createStreamEvents(event, stream, requestId, send);
     hookUpEventsAndUnregister(stream, events);
 
-    // done
     event.returnValue = { success: true };
-    return;
   }
 
   function hookUpEventsAndUnregister(stream, events) {
     Object.keys(events).forEach((key) => stream.on(key, events[key]));
     stream.unregisterEvents = () => {
-      Object.keys(events).forEach((key) =>
-        stream.removeListener(key, events[key])
-      );
+      Object.keys(events).forEach((key) => {
+        stream.removeListener(key, events[key]);
+      });
     };
   }
 
@@ -255,15 +298,22 @@ module.exports = function (
     return {
       data: (chunk) =>
         send("stream-data", valueToIPCValue(chunk), undefined, true),
-      close: () => send("stream-close"),
+      close: () => {
+        debug("stream-close (readable)", requestId);
+        stream.unregisterEvents();
+        send("stream-close");
+      },
       error: (err) => {
+        debug("stream-error (readable)", requestId, err?.message);
         stream.unregisterEvents();
-        send("stream-error", err ? err.message : "");
+        send("stream-error", err ? err.message : "Unknown stream error");
       },
       end: () => {
-        stream.unregisterEvents(); // TODO does calling this in 'end' mean that 'close' will never be sent?
+        debug("stream-end (readable)", requestId);
         send("stream-end");
-        webcontentsStreams[event.sender.id][requestId] = null;
+        if (webcontentsStreams[event.sender.id]) {
+          webcontentsStreams[event.sender.id][requestId] = null;
+        }
       },
     };
   }
@@ -271,87 +321,93 @@ module.exports = function (
   function createWritableEvents(event, stream, requestId, send) {
     return {
       drain: () => send("stream-drain", undefined, undefined, true),
-      close: () => send("stream-close"),
+      close: () => {
+        debug("stream-close (writable)", requestId);
+        stream.unregisterEvents();
+        send("stream-close");
+      },
       error: (err) => {
+        debug("stream-error (writable)", requestId, err?.message);
         stream.unregisterEvents();
-        send("stream-error", err ? err.message : "");
+        send("stream-error", err ? err.message : "Unknown stream error");
       },
       finish: () => {
-        stream.unregisterEvents();
+        debug("stream-finish (writable)", requestId);
         send("stream-finish");
-        webcontentsStreams[event.sender.id][requestId] = null;
+        if (webcontentsStreams[event.sender.id]) {
+          webcontentsStreams[event.sender.id][requestId] = null;
+        }
       },
     };
   }
 
   function createDuplexEvents(event, stream, requestId, send) {
+    // Note: unregisterEvents will be shared, which is correct
     return Object.assign(
       createWritableEvents(event, stream, requestId, send),
       createReadableEvents(event, stream, requestId, send)
     );
   }
 
-  // special methods
   function trackWebcontentsStreams(webcontents, requestId, stream) {
-    // track vs. sender's lifecycle
-    if (!webcontentsStreams[webcontents.id]) {
-      webcontentsStreams[webcontents.id] = {};
-      // listen for webcontent close event
-      webcontents.once(
-        "did-navigate",
-        closeAllWebcontentsStreams(webcontents.id)
-      );
-      webcontents.once("destroyed", closeAllWebcontentsStreams(webcontents.id));
+    const wcId = webcontents.id;
+    if (!webcontentsStreams[wcId]) {
+      webcontentsStreams[wcId] = {};
+
+      const cleanup = () => {
+        debug("cleaning up all streams for webcontents", wcId);
+        if (!webcontentsStreams[wcId]) return;
+        for (let rid in webcontentsStreams[wcId]) {
+          if (webcontentsStreams[wcId][rid]) {
+            const s = webcontentsStreams[wcId][rid];
+            if (s.unregisterEvents) s.unregisterEvents();
+            streamRequestClose(wcId, rid, []);
+          }
+        }
+        delete webcontentsStreams[wcId];
+        cleanupRoutines.delete(wcId);
+      };
+
+      cleanupRoutines.set(wcId, cleanup);
+      webcontents.once("did-navigate", cleanup);
+      webcontents.once("destroyed", cleanup);
     }
-    webcontentsStreams[webcontents.id][requestId] = stream;
+    webcontentsStreams[wcId][requestId] = stream;
   }
 
   function streamRequestWrite(webcontentsId, requestId, args) {
-    var stream = webcontentsStreams[webcontentsId][requestId];
-
-    if (stream && typeof stream.write == "function") {
+    const stream = (webcontentsStreams[webcontentsId] || {})[requestId];
+    if (stream && typeof stream.write === "function") {
       stream.write(...args);
+    } else {
+      debug("write failed: stream not found or not writable", requestId);
     }
   }
+
   function streamRequestEnd(webcontentsId, requestId, args) {
-    var stream = webcontentsStreams[webcontentsId][requestId];
-    if (stream && typeof stream.end == "function") stream.end(...args);
+    const stream = (webcontentsStreams[webcontentsId] || {})[requestId];
+    if (stream && typeof stream.end === "function") {
+      stream.end(...args);
+    }
   }
+
   function streamRequestClose(webcontentsId, requestId, args) {
-    var stream = webcontentsStreams[webcontentsId][requestId];
+    const stream = (webcontentsStreams[webcontentsId] || {})[requestId];
     if (!stream) return;
-    // try .close
-    if (typeof stream.close == "function") stream.close(...args);
-    // hmm, try .destroy
-    else if (typeof stream.destroy == "function") stream.destroy(...args);
-    // oye, last shot: end()
-    else if (typeof stream.end == "function") stream.end(...args);
-  }
-
-  // helpers
-  function closeAllWebcontentsStreams(webcontentsId) {
-    return (e) => {
-      if (!webcontentsStreams[webcontentsId]) return;
-
-      // close all of the open streams
-      for (var requestId in webcontentsStreams[webcontentsId]) {
-        if (webcontentsStreams[webcontentsId][requestId]) {
-          webcontentsStreams[webcontentsId][requestId].unregisterEvents();
-          streamRequestClose(webcontentsId, requestId, []);
-        }
-      }
-
-      // stop tracking
-      delete webcontentsStreams[webcontentsId];
-    };
+    debug("force closing stream", requestId);
+    if (typeof stream.close === "function") stream.close(...args);
+    else if (typeof stream.destroy === "function") stream.destroy(...args);
+    else if (typeof stream.end === "function") stream.end(...args);
   }
 
   return api;
 };
 
 function errorObject(error) {
-  var copy = Object.assign({}, error);
+  if (!error) return { message: "Unknown Error" };
+  const copy = Object.assign({}, error);
   copy.message = error.message || error.toString();
   if (error.name) copy.name = error.name;
+  if (error.stack) copy.stack = error.stack; // Added for better loggic
   return copy;
 }