add tentative handle() api and spec

electron · nornagon · May 31, 2019 · May 24, 2019 · May 24, 2019 · May 28, 2019
commit 1a7f77f234b8198e7bf143c4e8a248e6dfd37bb7
diff --git a/docs/api/structures/ipc-main-event.md b/docs/api/structures/ipc-main-event.md
@@ -5,4 +5,5 @@
 * `sender` WebContents - Returns the `webContents` that sent the message
 * `reply` Function - A function that will send an IPC message to the renderer frame that sent the original message that you are currently handling.  You should use this method to "reply" to the sent message in order to guaruntee the reply will go to the correct process and frame.
   * `...args` any[]
+* `throw` Function - (only for 'invoke' events) Reject the waiting promise on the caller's end with the given string
 IpcRenderer
diff --git a/lib/browser/api/ipc-main.ts b/lib/browser/api/ipc-main.ts
@@ -1,8 +1,23 @@
 import { EventEmitter } from 'events'
 
-const emitter = new EventEmitter()
+class IpcMain extends EventEmitter {
+  handle (method: string, fn: Function) {
+    if (this.listenerCount(method) !== 0) {
+      throw new Error(`Attempted to register a second handler for '${method}'`)
+    }
+    this.on(method, async (e, ...args) => {
+      try {
+        e.reply(await Promise.resolve(fn(...args)))
+      } catch (err) {
+        e.throw(err)
+      }
+    })
+  }
+}
+
+const ipcMain = new IpcMain()
 
 // Do not throw exception when channel name is "error".
-emitter.on('error', () => {})
+ipcMain.on('error', () => {})
 
-export default emitter
+export default ipcMain
diff --git a/lib/browser/api/web-contents.js b/lib/browser/api/web-contents.js
@@ -327,7 +327,8 @@ WebContents.prototype._init = function () {
   })
 
   this.on('-ipc-invoke', function (event, channel, args) {
-    event.reply = event.sendReply
+    event.reply = (result) => event.sendReply({ result })
+    event.throw = (error) => event.sendReply({ error: error.toString() })
     this.emit('ipc-invoke', event, channel, ...args)
     ipcMain.emit(channel, event, ...args)
   })

diff --git a/lib/renderer/api/ipc-renderer.js b/lib/renderer/api/ipc-renderer.js
@@ -28,7 +28,10 @@ ipcRenderer.sendToAll = function (webContentsId, channel, ...args) {
 }
 
 ipcRenderer.invoke = function (channel, ...args) {
-  return ipc.invoke(channel, args)
+  return ipc.invoke(channel, args).then(({ error, result }) => {
+    if (error) { throw new Error(`Error invoking remote method '${channel}': ${error}`) }
+    return result
+  })
 }
 
 module.exports = ipcRenderer
diff --git a/spec-main/api-ipc-spec.ts b/spec-main/api-ipc-spec.ts
@@ -0,0 +1,136 @@
+import * as chai from 'chai'
+import * as chaiAsPromised from 'chai-as-promised'
+import { BrowserWindow, ipcMain } from 'electron'
+
+const { expect } = chai
+
+chai.use(chaiAsPromised)
+
+describe('ipc module', () => {
+  describe('invoke', () => {
+    async function rendererInvoke(...args: any[]) {
+      const {ipcRenderer} = require('electron')
+      try {
+        const result = await ipcRenderer.invoke('test', ...args)
+        ipcRenderer.send('result', {result})
+      } catch (e) {
+        ipcRenderer.send('result', {error: e.message})
+      }
+    }
+
+    it('receives responses', async () => {
+      ipcMain.once('test', (e, arg) => {
+        expect(arg).to.equal(123)
+        e.reply('456')
+      })
+      const done = new Promise(resolve => {
+        ipcMain.once('result', (e, arg) => {
+          expect(arg).to.deep.equal({result: '456'})
+          resolve()
+        })
+      })
+      const w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true } })
+      try {
+        await w.loadURL(`data:text/html,<script>(${rendererInvoke})(123)</script>`)
+        await done
+      } finally {
+        w.destroy()
+      }
+    })
+
+    it('receives errors', async () => {
+      ipcMain.once('test', (e) => {
+        e.throw('some error')
+      })
+      const done = new Promise(resolve => {
+        ipcMain.once('result', (e, arg) => {
+          expect(arg.error).to.match(/some error/)
+          resolve()
+        })
+      })
+      const w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true } })
+      try {
+        await w.loadURL(`data:text/html,<script>(${rendererInvoke})()</script>`)
+        await done
+      } finally {
+        w.destroy()
+      }
+    })
+
+    it('registers a synchronous handler', async () => {
+      (ipcMain as any).handle('test', (arg: number) => {
+        ipcMain.removeAllListeners('test')
+        expect(arg).to.equal(123)
+        return 3
+      })
+      const done = new Promise(resolve => ipcMain.once('result', (e, arg) => {
+        expect(arg).to.deep.equal({result: 3})
+        resolve()
+      }))
+      const w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true } })
+      try {
+        await w.loadURL(`data:text/html,<script>(${rendererInvoke})(123)</script>`)
+        await done
+      } finally {
+        w.destroy()
+      }
+    })
+
+    it('registers an asynchronous handler', async () => {
+      (ipcMain as any).handle('test', async (arg: number) => {
+        ipcMain.removeAllListeners('test')
+        expect(arg).to.equal(123)
+        await new Promise(resolve => setImmediate(resolve))
+        return 3
+      })
+      const done = new Promise(resolve => ipcMain.once('result', (e, arg) => {
+        expect(arg).to.deep.equal({result: 3})
+        resolve()
+      }))
+      const w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true } })
+      try {
+        await w.loadURL(`data:text/html,<script>(${rendererInvoke})(123)</script>`)
+        await done
+      } finally {
+        w.destroy()
+      }
+    })
+
+    it('receives an error from a synchronous handler', async () => {
+      (ipcMain as any).handle('test', () => {
+        ipcMain.removeAllListeners('test')
+        throw new Error('some error')
+      })
+      const done = new Promise(resolve => ipcMain.once('result', (e, arg) => {
+        expect(arg.error).to.match(/some error/)
+        resolve()
+      }))
+      const w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true } })
+      try {
+        await w.loadURL(`data:text/html,<script>(${rendererInvoke})()</script>`)
+        await done
+      } finally {
+        w.destroy()
+      }
+    })
+
+    it('receives an error from an asynchronous handler', async () => {
+      (ipcMain as any).handle('test', async () => {
+        ipcMain.removeAllListeners('test')
+        await new Promise(resolve => setImmediate(resolve))
+        throw new Error('some error')
+      })
+      const done = new Promise(resolve => ipcMain.once('result', (e, arg) => {
+        expect(arg.error).to.match(/some error/)
+        resolve()
+      }))
+      const w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true } })
+      try {
+        await w.loadURL(`data:text/html,<script>(${rendererInvoke})()</script>`)
+        await done
+      } finally {
+        w.destroy()
+      }
+    })
+  })
+})