Testing and Dev Tools

Copyexport const testClient = <T extends Hono<any, Schema, string>>(
  app: T,
  Env?: ExtractEnv<T>['Bindings'] | {},
  executionCtx?: ExecutionContext,
  options?: Omit<ClientRequestOptions, 'fetch'>
): UnionToIntersection<Client<T, 'http://localhost'>> => {
  const customFetch = (input: RequestInfo | URL, init?: RequestInit) => {
    return app.request(input, init, Env, executionCtx)
  }
 
  return hc<typeof app, 'http://localhost'>('http://localhost', { ...options, fetch: customFetch })

Copyfetch = async (
  args?: ValidationTargets<FormValue> & {
    param?: Record<string, string>
  },
  opt?: ClientRequestOptions
) => {
  if (args) {
    if (args.query) {
      this.queryParams = this.buildSearchParams(args.query)
    }
 
    if (args.form) {
      const form = new FormData()
      for (const [k, v] of Object.entries(args.form)) {
        if (v === undefined) {
          continue
        }
        if (Array.isArray(v)) {
          for (const v2 of v) {
            form.append(k, v2)
          }
        } else {
          form.append(k, v)
        }
      }
      this.rBody = form
    }
 
    if (args.json) {
      this.rBody = JSON.stringify(args.json)
      this.cType = 'application/json'
    }
 
    if (args.param) {
      this.pathParams = args.param
    }
  }
 
  let methodUpperCase = this.method.toUpperCase()
 
  const headerValues: Record<string, string> = {
    ...args?.header,
    ...(typeof opt?.headers === 'function' ? await opt.headers() : opt?.headers),
  }
 
  if (args?.cookie) {
    const cookies: string[] = []
    for (const [key, value] of Object.entries(args.cookie)) {
      cookies.push(serialize(key, value, { path: '/' }))
    }
    headerValues['Cookie'] = cookies.join(',')
  }
 
  if (this.cType) {
    headerValues['Content-Type'] = this.cType
  }
 
  const headers = new Headers(headerValues ?? undefined)
  let url = this.url
 
  url = removeIndexString(url)
  url = replaceUrlParam(url, this.pathParams)
 
  if (this.queryParams) {
    url = url + '?' + this.queryParams.toString()
  }
  methodUpperCase = this.method.toUpperCase()
  const setBody = !(methodUpperCase === 'GET' || methodUpperCase === 'HEAD')
 
  // Pass URL string to 1st arg for testing with MSW and node-fetch
  return (opt?.fetch || fetch)(url, {
    body: setBody ? this.rBody : undefined,
    method: methodUpperCase,
    headers: headers,
    ...opt?.init,
  })
}

Copyexport const inspectRoutes = <E extends Env>(hono: Hono<E>): RouteData[] => {
  return hono.routes.map(({ path, method, handler }: RouterRoute) => {
    const targetHandler = findTargetHandler(handler)
    return {
      path,
      method,
      name: handlerName(targetHandler),
      isMiddleware: isMiddleware(targetHandler),
    }
  })
}

Copyinterface RouteData {
  path: string
  method: string
  name: string
  isMiddleware: boolean
}
 
const handlerName = (handler: Function): string => {
  return handler.name || (isMiddleware(handler) ? '[middleware]' : '[handler]')
}

Copyexport const testClient = <T extends Hono<any, Schema, string>>(
  app: T,
  Env?: ExtractEnv<T>['Bindings'] | {},
  executionCtx?: ExecutionContext,
  options?: Omit<ClientRequestOptions, 'fetch'>
): UnionToIntersection<Client<T, 'http://localhost'>> => {
  const customFetch = (input: RequestInfo | URL, init?: RequestInit) => {
    return app.request(input, init, Env, executionCtx)
  }

Copy#dispatch(
  request: Request,
  executionCtx: ExecutionContext | FetchEventLike | undefined,
  env: E['Bindings'],
  method: string
): Response | Promise<Response> {
  // Handle HEAD method
  if (method === 'HEAD') {
    return (async () =>
      new Response(null, await this.#dispatch(request, executionCtx, env, 'GET')))()
  }
 
  const path = this.getPath(request, { env })
  const matchResult = this.router.match(method, path)
 
  const c = new Context(request, {
    path,
    matchResult,
    env,
    executionCtx,
    notFoundHandler: this.#notFoundHandler,
  })

Copyexport const timing = (config?: TimingOptions): MiddlewareHandler => {
  const options: TimingOptions = {
    total: true,
    enabled: true,
    totalDescription: 'Total Response Time',
    autoEnd: true,
    crossOrigin: false,
    ...config,
  }
  return async function timing(c, next) {
    const headers: string[] = []
    const timers = new Map<string, Timer>()
 
    if (c.get('metric')) {
      return await next()
    }
 
    c.set('metric', { headers, timers })
 
    if (options.total) {
      startTime(c, 'total', options.totalDescription)
    }
    await next()
 
    if (options.total) {
      endTime(c, 'total')
    }
 
    if (options.autoEnd) {
      timers.forEach((_, key) => {
        endTime(c, key)
      })
    }
 
    const enabled = typeof options.enabled === 'function' ? options.enabled(c) : options.enabled
 
    if (enabled) {
      c.res.headers.append('Server-Timing', headers.join(','))
 
      const crossOrigin =
        typeof options.crossOrigin === 'function' ? options.crossOrigin(c) : options.crossOrigin
 
      if (crossOrigin) {
        c.res.headers.append(
          'Timing-Allow-Origin',
          typeof crossOrigin === 'string' ? crossOrigin : '*'
        )
      }
    }
  }
}

Copyexport const startTime = (c: Context, name: string, description?: string) => {
  const metrics = c.get('metric')
  if (!metrics) {
    console.warn('Metrics not initialized! Please add the `timing()` middleware to this route!')
    return
  }
  metrics.timers.set(name, { description, start: getTime() })
}
 
/**
 * End a timer for the timing middleware.
 *
 * @param {Context} c - The context of the request.
 * @param {string} name - The name of the timer.
 * @param {number} [precision] - The precision of the timer value.
 *
 * @example
 * ```ts
 * endTime(c, 'db')
 * ```
 */
export const endTime = (c: Context, name: string, precision?: number) => {
  const metrics = c.get('metric')
  if (!metrics) {
    console.warn('Metrics not initialized! Please add the `timing()` middleware to this route!')
    return
  }
  const timer = metrics.timers.get(name)
  if (!timer) {
    console.warn(`Timer "${name}" does not exist!`)
    return
  }
  const { description, start } = timer
 
  const duration = getTime() - start
 
  setMetric(c, name, duration, description, precision)
  metrics.timers.delete(name)
}
 
/**
 * Wrap a Promise to capture its duration.
 * @param {Context} c - The context of the request.
 * @param {string} name - The name of the timer.
 * @param {Promise<T>} callable - The Promise to time.
 * @param {string} [description] - The description of the timer.
 * @param {number} [precision] - The precision of the timer value.
 *
 * @example
 * ```ts
 *   // Instead of this:
 *   const data = await db.findMany(...);
 *
 *   // do this:
 *   const data = await wrapTime(c, 'query', db.findMany(...));
 * ```
 * */
export async function wrapTime<T>(
  c: Context,
  name: string,
  callable: Promise<T>,
  description?: string,
  precision?: number
): Promise<T> {
  startTime(c, name, description)
  try {
    return await callable
  } finally {
    endTime(c, name, precision)
  }