execute code after response was sent

@trpc/server

a while ago, i asked @Alex / KATT 🐱 if i could code something which executes after a response was sent. the goal was to dispatch messages to a message queue after the response was delivered (notably for chat purpose but not only). this led to writing this helper:

export function withCallbacks<T extends AnyFunction>(
  fn: T,
  opts: {
    onError?: (opts: Parameters<T>[0] & { error: TRPCError }) => void | Promise<void>
    onSuccess?: (
      opts: Parameters<T>[0] & { output: Awaited<ReturnType<T>> },
    ) => void | Promise<void>
  },
) {
  return async function withCallbacksWrapper(...args: Parameters<T>) {
    try {
      const output = await fn(...args)
      opts.onSuccess?.({ ...args[0], output })?.catch()

      return output
    } catch (cause) {
      await opts.onError?.({ ...args[0], error: getTRPCErrorFromUnknown(cause) })

      throw cause
    }
  } as T
}

export function withCallbacks<T extends AnyFunction>(
  fn: T,
  opts: {
    onError?: (opts: Parameters<T>[0] & { error: TRPCError }) => void | Promise<void>
    onSuccess?: (
      opts: Parameters<T>[0] & { output: Awaited<ReturnType<T>> },
    ) => void | Promise<void>
  },
) {
  return async function withCallbacksWrapper(...args: Parameters<T>) {
    try {
      const output = await fn(...args)
      opts.onSuccess?.({ ...args[0], output })?.catch()

      return output
    } catch (cause) {
      await opts.onError?.({ ...args[0], error: getTRPCErrorFromUnknown(cause) })

      throw cause
    }
  } as T
}

but after testing extensively, it seems that the order of delivery cannot be guaranteed. if in

onSuccess

onSuccess

there's code which leads to a delivery of message via useSubscription, it could happen that it gets to the client faster than the response.

aside from adding the response object to the context and having a

on('finish', () => {})

on('finish', () => {})

i don't see how to end this race condition. is there a different path than this? this looks like it could be a problem for multiplexing and such and i'd rather not do that. just that i need to execute code after the message was delivered (and that, regardless of the actual example usecase).

(cc @Nick bc i adviced you this function as worth advertising in the docs but it apparently most sneaky than stable)

execute code after response was sent

@trpc/server

export function withCallbacks<T extends AnyFunction>(
  fn: T,
  opts: {
    onError?: (opts: Parameters<T>[0] & { error: TRPCError }) => void | Promise<void>
    onSuccess?: (
      opts: Parameters<T>[0] & { output: Awaited<ReturnType<T>> },
    ) => void | Promise<void>
  },
) {
  return async function withCallbacksWrapper(...args: Parameters<T>) {
    try {
      const output = await fn(...args)
      opts.onSuccess?.({ ...args[0], output })?.catch()

      return output
    } catch (cause) {
      await opts.onError?.({ ...args[0], error: getTRPCErrorFromUnknown(cause) })

      throw cause
    }
  } as T
}

export function withCallbacks<T extends AnyFunction>(
  fn: T,
  opts: {
    onError?: (opts: Parameters<T>[0] & { error: TRPCError }) => void | Promise<void>
    onSuccess?: (
      opts: Parameters<T>[0] & { output: Awaited<ReturnType<T>> },
    ) => void | Promise<void>
  },
) {
  return async function withCallbacksWrapper(...args: Parameters<T>) {
    try {
      const output = await fn(...args)
      opts.onSuccess?.({ ...args[0], output })?.catch()

      return output
    } catch (cause) {
      await opts.onError?.({ ...args[0], error: getTRPCErrorFromUnknown(cause) })

      throw cause
    }
  } as T
}

but after testing extensively, it seems that the order of delivery cannot be guaranteed. if in

onSuccess

onSuccess

on('finish', () => {})

on('finish', () => {})

execute code after response was sent

execute code after response was sent

Continue the conversation

tRPC

Continue the conversation

tRPC

Similar Threads