Function createTypedHandler

src/ipc/handlers/base.ts:45–99

(
  contract: IpcContract<TChannel, TInput, TOutput>,
  handler: (
    event: IpcMainInvokeEvent,
    input: z.infer<TInput>,
  ) => Promise<z.infer<TOutput>>,
)

 * });
 */
export function createTypedHandler<
  TChannel extends string,
  TInput extends z.ZodType,
  TOutput extends z.ZodType,
>(
  contract: IpcContract<TChannel, TInput, TOutput>,
  handler: (
    event: IpcMainInvokeEvent,
    input: z.infer<TInput>,
  ) => Promise<z.infer<TOutput>>,
): void {
  registeredHandlers.set(contract.channel, handler);
  // Optional chaining: ipcMain is undefined in unit tests (no electron runtime).
  ipcMain?.handle(
    contract.channel,
    async (event: IpcMainInvokeEvent, rawInput: unknown) => {
      // Runtime validation of input
      const parsed = contract.input.safeParse(rawInput);
      if (!parsed.success) {
        const errorMessage = parsed.error.issues
          .map((e) => `${e.path.join(".")}: ${e.message}`)
          .join("; ");
        return createIpcErrorEnvelope(
          new DyadError(
            `[${contract.channel}] Invalid input: ${errorMessage}`,
            DyadErrorKind.Validation,
          ),
        );
      }

      let result: z.infer<TOutput>;
      try {
        result = await handler(event, parsed.data);
      } catch (err) {
        sendTelemetryException(err, { ipc_channel: contract.channel });
        return createIpcErrorEnvelope(err);
      }

      // Validate output in development mode only (catches handler bugs without prod overhead)
      if (process.env.NODE_ENV === "development") {
        const outputParsed = contract.output.safeParse(result);
        if (!outputParsed.success) {
          const errorMessage = outputParsed.error.issues
            .map((e) => `${e.path.join(".")}: ${e.message}`)
            .join("; ");
          console.error(
            `[${contract.channel}] Output validation warning: ${errorMessage}`,
          );
        }
      }

      return createIpcSuccessEnvelope(result);
    },
  );
}

/**
 * Creates a typed IPC handler with logging support.