Function createRatelimitMiddleware

packages/ratelimit/src/middleware.ts:51–98

(
  { dedupe = true, ...options }: CreateRatelimitMiddlewareOptions<TInContext, TInput, TMeta>,
)

 * @see {@link https://orpc.dev/docs/helpers/ratelimit#createratelimitmiddleware Ratelimit middleware}
 */
export function createRatelimitMiddleware<
  TInContext extends Context,
  TInput = unknown,
  TMeta extends Meta = Record<never, never>,
>(
  { dedupe = true, ...options }: CreateRatelimitMiddlewareOptions<TInContext, TInput, TMeta>,
): Middleware<TInContext, Record<never, never>, TInput, any, any, TMeta> {
  return async function ratelimit(middlewareOptions, input) {
    const [limiter, key] = await Promise.all([
      value(options.limiter, middlewareOptions, input),
      value(options.key, middlewareOptions, input),
    ])

    const middlewareContext = (middlewareOptions.context as RatelimiterMiddlewareContext)[RATELIMIT_MIDDLEWARE_CONTEXT_SYMBOL]
    if (dedupe && middlewareContext?.limits.some(l => l.key === key && l.limiter === limiter)) {
      return middlewareOptions.next()
    }

    const result = await limiter.limit(key)

    const pluginContext = (middlewareOptions.context as RatelimitHandlerPluginContext)[RATELIMIT_HANDLER_CONTEXT_SYMBOL]
    if (pluginContext) {
      pluginContext.ratelimitResult = result
    }

    if (!result.success) {
      throw new ORPCError('TOO_MANY_REQUESTS', {
        data: {
          limit: result.limit,
          remaining: result.remaining,
          reset: result.reset,
        },
      })
    }

    return middlewareOptions.next({
      context: {
        [RATELIMIT_MIDDLEWARE_CONTEXT_SYMBOL]: {
          ...middlewareContext,
          limits: [
            ...toArray(middlewareContext?.limits),
            { limiter, key },
          ],
        },
      },
    })
  }
}