send response back to the webcontents which send the request

packages/electron-trpc/src/main/createIPCHandler.ts

@@ -16,18 +16,22 @@ class IPCHandler<TRouter extends AnyRouter> {
     router,
     windows = [],
   }: {
-    createContext?: () => Awaitable<inferRouterContext<TRouter>>;
+    createContext?: (event: IpcMainInvokeEvent) => Awaitable<inferRouterContext<TRouter>>;
     router: TRouter;
     windows?: BrowserWindow[];
   }) {
     this.#windows = windows;
 
-    ipcMain.on(ELECTRON_TRPC_CHANNEL, (_event: IpcMainInvokeEvent, args: Operation) => {
+    ipcMain.on(ELECTRON_TRPC_CHANNEL, (event: IpcMainInvokeEvent, args: Operation) => {
       handleIPCOperation({
         router,
         createContext,
+        event,
         operation: args,
-        respond: (response) => this.#sendToAllWindows(response),
+        respond: (response) => {
+          if(!event.sender.isDestroyed()) return;
+          event.sender.send(ELECTRON_TRPC_CHANNEL, response);
+        },
       });
     });
   }

packages/electron-trpc/src/main/handleIPCOperation.ts

@@ -1,6 +1,7 @@
 import { callProcedure, TRPCError } from '@trpc/server';
 import type { AnyRouter, inferRouterContext } from '@trpc/server';
 import type { TRPCResponseMessage } from '@trpc/server/rpc';
+import type { IpcMainInvokeEvent } from 'electron';
 import { isObservable } from '@trpc/server/observable';
 import { Operation } from '@trpc/client';
 import { getTRPCErrorFromUnknown, transformTRPCResponseItem } from './utils';
@@ -10,19 +11,21 @@ export async function handleIPCOperation<TRouter extends AnyRouter>({
   createContext,
   operation,
   respond,
+  event
 }: {
   router: TRouter;
-  createContext?: () => Promise<inferRouterContext<TRouter>>;
+  createContext?: (event: IpcMainInvokeEvent) => Promise<inferRouterContext<TRouter>>;
   operation: Operation;
   respond: (response: TRPCResponseMessage) => void;
+  event: IpcMainInvokeEvent;
 }) {
   const { type, input: serializedInput, id, path } = operation;
   const input = router._def._config.transformer.input.deserialize(serializedInput);
 
   // type TSuccessResponse = TRPCSuccessResponse<inferRouterContext<TRouter>>;
   // type TErrorResponse = TRPCErrorResponse<inferRouterError<TRouter>>;
 
-  const ctx = (await createContext?.()) ?? {};
+  const ctx = (await createContext?.(event)) ?? {};
 
   try {
     const result = await callProcedure({
@@ -88,7 +91,7 @@ export async function handleIPCOperation<TRouter extends AnyRouter>({
       },
     });
 
-    void subscription;
+    event.sender.on("destroyed", () => subscription.unsubscribe());
   } catch (cause) {
     const error: TRPCError = getTRPCErrorFromUnknown(cause);
 
@@ -102,6 +105,6 @@ export async function handleIPCOperation<TRouter extends AnyRouter>({
       }),
     });
 
-    return { response };
+    return respond({id, ...response});
   }
 }