bluera-knowledge 0.9.21

package/tests/fixtures/corpus/oss-repos/hono/src/middleware/body-limit/index.ts

@@ -0,0 +1,115 @@
+/**
+ * @module
+ * Body Limit Middleware for Hono.
+ */
+
+import type { Context } from '../../context'
+import { HTTPException } from '../../http-exception'
+import type { MiddlewareHandler } from '../../types'
+
+const ERROR_MESSAGE = 'Payload Too Large'
+
+type OnError = (c: Context) => Response | Promise<Response>
+type BodyLimitOptions = {
+  maxSize: number
+  onError?: OnError
+}
+
+class BodyLimitError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'BodyLimitError'
+  }
+}
+
+/**
+ * Body Limit Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/body-limit}
+ *
+ * @param {BodyLimitOptions} options - The options for the body limit middleware.
+ * @param {number} options.maxSize - The maximum body size allowed.
+ * @param {OnError} [options.onError] - The error handler to be invoked if the specified body size is exceeded.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.post(
+ *   '/upload',
+ *   bodyLimit({
+ *     maxSize: 50 * 1024, // 50kb
+ *     onError: (c) => {
+ *       return c.text('overflow :(', 413)
+ *     },
+ *   }),
+ *   async (c) => {
+ *     const body = await c.req.parseBody()
+ *     if (body['file'] instanceof File) {
+ *       console.log(`Got file sized: ${body['file'].size}`)
+ *     }
+ *     return c.text('pass :)')
+ *   }
+ * )
+ * ```
+ */
+export const bodyLimit = (options: BodyLimitOptions): MiddlewareHandler => {
+  const onError: OnError =
+    options.onError ||
+    (() => {
+      const res = new Response(ERROR_MESSAGE, {
+        status: 413,
+      })
+      throw new HTTPException(413, { res })
+    })
+  const maxSize = options.maxSize
+
+  return async function bodyLimit(c, next) {
+    if (!c.req.raw.body) {
+      // maybe GET or HEAD request
+      return next()
+    }
+
+    if (c.req.raw.headers.has('content-length')) {
+      // we can trust content-length header because it's already validated by server
+      const contentLength = parseInt(c.req.raw.headers.get('content-length') || '0', 10)
+      return contentLength > maxSize ? onError(c) : next()
+    }
+
+    // maybe chunked transfer encoding
+
+    let size = 0
+    const rawReader = c.req.raw.body.getReader()
+    const reader = new ReadableStream({
+      async start(controller) {
+        try {
+          for (;;) {
+            const { done, value } = await rawReader.read()
+            if (done) {
+              break
+            }
+            size += value.length
+            if (size > maxSize) {
+              controller.error(new BodyLimitError(ERROR_MESSAGE))
+              break
+            }
+
+            controller.enqueue(value)
+          }
+        } finally {
+          controller.close()
+        }
+      },
+    })
+
+    const requestInit: RequestInit & { duplex: 'half' } = { body: reader, duplex: 'half' }
+    c.req.raw = new Request(c.req.raw, requestInit as RequestInit)
+
+    await next()
+
+    if (c.error instanceof BodyLimitError) {
+      c.res = await onError(c)
+    }
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/middleware/cache/index.ts

@@ -0,0 +1,127 @@
+/**
+ * @module
+ * Cache Middleware for Hono.
+ */
+
+import type { Context } from '../../context'
+import type { MiddlewareHandler } from '../../types'
+
+/**
+ * Cache Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/cache}
+ *
+ * @param {Object} options - The options for the cache middleware.
+ * @param {string | Function} options.cacheName - The name of the cache. Can be used to store multiple caches with different identifiers.
+ * @param {boolean} [options.wait=false] - A boolean indicating if Hono should wait for the Promise of the `cache.put` function to resolve before continuing with the request. Required to be true for the Deno environment.
+ * @param {string} [options.cacheControl] - A string of directives for the `Cache-Control` header.
+ * @param {string | string[]} [options.vary] - Sets the `Vary` header in the response. If the original response header already contains a `Vary` header, the values are merged, removing any duplicates.
+ * @param {Function} [options.keyGenerator] - Generates keys for every request in the `cacheName` store. This can be used to cache data based on request parameters or context parameters.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ * @throws {Error} If the `vary` option includes "*".
+ *
+ * @example
+ * ```ts
+ * app.get(
+ *   '*',
+ *   cache({
+ *     cacheName: 'my-app',
+ *     cacheControl: 'max-age=3600',
+ *   })
+ * )
+ * ```
+ */
+export const cache = (options: {
+  cacheName: string | ((c: Context) => Promise<string> | string)
+  wait?: boolean
+  cacheControl?: string
+  vary?: string | string[]
+  keyGenerator?: (c: Context) => Promise<string> | string
+}): MiddlewareHandler => {
+  if (!globalThis.caches) {
+    console.log('Cache Middleware is not enabled because caches is not defined.')
+    return async (_c, next) => await next()
+  }
+
+  if (options.wait === undefined) {
+    options.wait = false
+  }
+
+  const cacheControlDirectives = options.cacheControl
+    ?.split(',')
+    .map((directive) => directive.toLowerCase())
+  const varyDirectives = Array.isArray(options.vary)
+    ? options.vary
+    : options.vary?.split(',').map((directive) => directive.trim())
+  // RFC 7231 Section 7.1.4 specifies that "*" is not allowed in Vary header.
+  // See: https://datatracker.ietf.org/doc/html/rfc7231#section-7.1.4
+  if (options.vary?.includes('*')) {
+    throw new Error(
+      'Middleware vary configuration cannot include "*", as it disallows effective caching.'
+    )
+  }
+
+  const addHeader = (c: Context) => {
+    if (cacheControlDirectives) {
+      const existingDirectives =
+        c.res.headers
+          .get('Cache-Control')
+          ?.split(',')
+          .map((d) => d.trim().split('=', 1)[0]) ?? []
+      for (const directive of cacheControlDirectives) {
+        let [name, value] = directive.trim().split('=', 2)
+        name = name.toLowerCase()
+        if (!existingDirectives.includes(name)) {
+          c.header('Cache-Control', `${name}${value ? `=${value}` : ''}`, { append: true })
+        }
+      }
+    }
+
+    if (varyDirectives) {
+      const existingDirectives =
+        c.res.headers
+          .get('Vary')
+          ?.split(',')
+          .map((d) => d.trim()) ?? []
+
+      const vary = Array.from(
+        new Set(
+          [...existingDirectives, ...varyDirectives].map((directive) => directive.toLowerCase())
+        )
+      ).sort()
+
+      if (vary.includes('*')) {
+        c.header('Vary', '*')
+      } else {
+        c.header('Vary', vary.join(', '))
+      }
+    }
+  }
+
+  return async function cache(c, next) {
+    let key = c.req.url
+    if (options.keyGenerator) {
+      key = await options.keyGenerator(c)
+    }
+
+    const cacheName =
+      typeof options.cacheName === 'function' ? await options.cacheName(c) : options.cacheName
+    const cache = await caches.open(cacheName)
+    const response = await cache.match(key)
+    if (response) {
+      return new Response(response.body, response)
+    }
+
+    await next()
+    if (!c.res.ok) {
+      return
+    }
+    addHeader(c)
+    const res = c.res.clone()
+    if (options.wait) {
+      await cache.put(key, res)
+    } else {
+      c.executionCtx.waitUntil(cache.put(key, res))
+    }
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/middleware/combine/index.ts

@@ -0,0 +1,153 @@
+/**
+ * @module
+ * Combine Middleware for Hono.
+ */
+
+import type { Context } from '../../context'
+import type { MiddlewareHandler, Next } from '../../types'
+import { TrieRouter } from '../../router/trie-router'
+import { METHOD_NAME_ALL } from '../../router'
+import { compose } from '../../compose'
+
+type Condition = (c: Context) => boolean
+
+/**
+ * Create a composed middleware that runs the first middleware that returns true.
+ *
+ * @param middleware - An array of MiddlewareHandler or Condition functions.
+ * Middleware is applied in the order it is passed, and if any middleware exits without returning
+ * an exception first, subsequent middleware will not be executed.
+ * You can also pass a condition function that returns a boolean value. If returns true
+ * the evaluation will be halted, and rest of the middleware will not be executed.
+ * @returns A composed middleware.
+ *
+ * @example
+ * ```ts
+ * import { some } from 'hono/combine'
+ * import { bearerAuth } from 'hono/bearer-auth'
+ * import { myRateLimit } from '@/rate-limit'
+ *
+ * // If client has a valid token, then skip rate limiting.
+ * // Otherwise, apply rate limiting.
+ * app.use('/api/*', some(
+ *   bearerAuth({ token }),
+ *   myRateLimit({ limit: 100 }),
+ * ));
+ * ```
+ */
+export const some = (...middleware: (MiddlewareHandler | Condition)[]): MiddlewareHandler => {
+  return async function some(c, next) {
+    let lastError: unknown
+    for (const handler of middleware) {
+      try {
+        const result = await handler(c, next)
+        if (result === true && !c.finalized) {
+          await next()
+        } else if (result === false) {
+          lastError = new Error('No successful middleware found')
+          continue
+        }
+        lastError = undefined
+        break
+      } catch (error) {
+        lastError = error
+        continue
+      }
+    }
+    if (lastError) {
+      throw lastError
+    }
+  }
+}
+
+/**
+ * Create a composed middleware that runs all middleware and throws an error if any of them fail.
+ *
+ * @param middleware - An array of MiddlewareHandler or Condition functions.
+ * Middleware is applied in the order it is passed, and if any middleware throws an error,
+ * subsequent middleware will not be executed.
+ * You can also pass a condition function that returns a boolean value. If returns false
+ * the evaluation will be halted, and rest of the middleware will not be executed.
+ * @returns A composed middleware.
+ *
+ * @example
+ * ```ts
+ * import { some, every } from 'hono/combine'
+ * import { bearerAuth } from 'hono/bearer-auth'
+ * import { myCheckLocalNetwork } from '@/check-local-network'
+ * import { myRateLimit } from '@/rate-limit'
+ *
+ * // If client is in local network, then skip authentication and rate limiting.
+ * // Otherwise, apply authentication and rate limiting.
+ * app.use('/api/*', some(
+ *   myCheckLocalNetwork(),
+ *   every(
+ *     bearerAuth({ token }),
+ *     myRateLimit({ limit: 100 }),
+ *   ),
+ * ));
+ * ```
+ */
+export const every = (...middleware: (MiddlewareHandler | Condition)[]): MiddlewareHandler => {
+  const wrappedMiddleware = middleware.map((m) => async (c: Context, next: Next) => {
+    const res = await m(c, next)
+    if (res === false) {
+      throw new Error('Unmet condition')
+    }
+  })
+
+  const handler = async (c: Context, next: Next) =>
+    compose<Context>(wrappedMiddleware.map((m) => [[m, undefined], c.req.param()]))(c, next)
+
+  return async function every(c, next) {
+    await handler(c, next)
+  }
+}
+
+/**
+ * Create a composed middleware that runs all middleware except when the condition is met.
+ *
+ * @param condition - A string or Condition function.
+ * If there are multiple targets to match any of them, they can be passed as an array.
+ * If a string is passed, it will be treated as a path pattern to match.
+ * If a Condition function is passed, it will be evaluated against the request context.
+ * @param middleware - A composed middleware
+ *
+ * @example
+ * ```ts
+ * import { except } from 'hono/combine'
+ * import { bearerAuth } from 'hono/bearer-auth
+ *
+ * // If client is accessing public API, then skip authentication.
+ * // Otherwise, require a valid token.
+ * app.use('/api/*', except(
+ *   '/api/public/*',
+ *   bearerAuth({ token }),
+ * ));
+ * ```
+ */
+export const except = (
+  condition: string | Condition | (string | Condition)[],
+  ...middleware: MiddlewareHandler[]
+): MiddlewareHandler => {
+  let router: TrieRouter<true> | undefined = undefined
+  const conditions = (Array.isArray(condition) ? condition : [condition])
+    .map((condition) => {
+      if (typeof condition === 'string') {
+        router ||= new TrieRouter()
+        router.add(METHOD_NAME_ALL, condition, true)
+      } else {
+        return condition
+      }
+    })
+    .filter(Boolean) as Condition[]
+
+  if (router) {
+    conditions.unshift((c: Context) => !!router?.match(METHOD_NAME_ALL, c.req.path)?.[0]?.[0]?.[0])
+  }
+
+  const handler = some((c: Context) => conditions.some((cond) => cond(c)), every(...middleware))
+  return async function except(c, next) {
+    await handler(c, next)
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/middleware/compress/index.ts

@@ -0,0 +1,79 @@
+/**
+ * @module
+ * Compress Middleware for Hono.
+ */
+
+import type { MiddlewareHandler } from '../../types'
+
+const ENCODING_TYPES = ['gzip', 'deflate'] as const
+const cacheControlNoTransformRegExp = /(?:^|,)\s*?no-transform\s*?(?:,|$)/i
+const compressibleContentTypeRegExp =
+  /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i
+
+interface CompressionOptions {
+  encoding?: (typeof ENCODING_TYPES)[number]
+  threshold?: number
+}
+
+/**
+ * Compress Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/compress}
+ *
+ * @param {CompressionOptions} [options] - The options for the compress middleware.
+ * @param {'gzip' | 'deflate'} [options.encoding] - The compression scheme to allow for response compression. Either 'gzip' or 'deflate'. If not defined, both are allowed and will be used based on the Accept-Encoding header. 'gzip' is prioritized if this option is not provided and the client provides both in the Accept-Encoding header.
+ * @param {number} [options.threshold=1024] - The minimum size in bytes to compress. Defaults to 1024 bytes.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(compress())
+ * ```
+ */
+export const compress = (options?: CompressionOptions): MiddlewareHandler => {
+  const threshold = options?.threshold ?? 1024
+
+  return async function compress(ctx, next) {
+    await next()
+
+    const contentLength = ctx.res.headers.get('Content-Length')
+
+    // Check if response should be compressed
+    if (
+      ctx.res.headers.has('Content-Encoding') || // already encoded
+      ctx.req.method === 'HEAD' || // HEAD request
+      (contentLength && Number(contentLength) < threshold) || // content-length below threshold
+      !shouldCompress(ctx.res) || // not compressible type
+      !shouldTransform(ctx.res) // cache-control: no-transform
+    ) {
+      return
+    }
+
+    const accepted = ctx.req.header('Accept-Encoding')
+    const encoding =
+      options?.encoding ?? ENCODING_TYPES.find((encoding) => accepted?.includes(encoding))
+    if (!encoding || !ctx.res.body) {
+      return
+    }
+
+    // Compress the response
+    const stream = new CompressionStream(encoding)
+    ctx.res = new Response(ctx.res.body.pipeThrough(stream), ctx.res)
+    ctx.res.headers.delete('Content-Length')
+    ctx.res.headers.set('Content-Encoding', encoding)
+  }
+}
+
+const shouldCompress = (res: Response) => {
+  const type = res.headers.get('Content-Type')
+  return type && compressibleContentTypeRegExp.test(type)
+}
+
+const shouldTransform = (res: Response) => {
+  const cacheControl = res.headers.get('Cache-Control')
+  // Don't compress for Cache-Control: no-transform
+  // https://tools.ietf.org/html/rfc7234#section-5.2.2.4
+  return !cacheControl || !cacheControlNoTransformRegExp.test(cacheControl)
+}

package/tests/fixtures/corpus/oss-repos/hono/src/middleware/context-storage/index.ts

@@ -0,0 +1,55 @@
+/**
+ * @module
+ * Context Storage Middleware for Hono.
+ */
+
+import type { Context } from '../../context'
+import type { Env, MiddlewareHandler } from '../../types'
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+const asyncLocalStorage = new AsyncLocalStorage<Context>()
+
+/**
+ * Context Storage Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/context-storage}
+ *
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * type Env = {
+ *   Variables: {
+ *     message: string
+ *   }
+ * }
+ *
+ * const app = new Hono<Env>()
+ *
+ * app.use(contextStorage())
+ *
+ * app.use(async (c, next) => {
+ *   c.set('message', 'Hono is cool!!)
+ *   await next()
+ * })
+ *
+ * app.get('/', async (c) => { c.text(getMessage()) })
+ *
+ * const getMessage = () => {
+ *   return getContext<Env>().var.message
+ * }
+ * ```
+ */
+export const contextStorage = (): MiddlewareHandler => {
+  return async function contextStorage(c, next) {
+    await asyncLocalStorage.run(c, next)
+  }
+}
+
+export const getContext = <E extends Env = Env>(): Context<E> => {
+  const context = asyncLocalStorage.getStore()
+  if (!context) {
+    throw new Error('Context is not available')
+  }
+  return context
+}

package/tests/fixtures/corpus/oss-repos/hono/src/middleware/cors/index.ts

@@ -0,0 +1,141 @@
+/**
+ * @module
+ * CORS Middleware for Hono.
+ */
+
+import type { Context } from '../../context'
+import type { MiddlewareHandler } from '../../types'
+
+type CORSOptions = {
+  origin: string | string[] | ((origin: string, c: Context) => string | undefined | null)
+  allowMethods?: string[]
+  allowHeaders?: string[]
+  maxAge?: number
+  credentials?: boolean
+  exposeHeaders?: string[]
+}
+
+/**
+ * CORS Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/cors}
+ *
+ * @param {CORSOptions} [options] - The options for the CORS middleware.
+ * @param {string | string[] | ((origin: string, c: Context) => string | undefined | null)} [options.origin='*'] - The value of "Access-Control-Allow-Origin" CORS header.
+ * @param {string[]} [options.allowMethods=['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH']] - The value of "Access-Control-Allow-Methods" CORS header.
+ * @param {string[]} [options.allowHeaders=[]] - The value of "Access-Control-Allow-Headers" CORS header.
+ * @param {number} [options.maxAge] - The value of "Access-Control-Max-Age" CORS header.
+ * @param {boolean} [options.credentials] - The value of "Access-Control-Allow-Credentials" CORS header.
+ * @param {string[]} [options.exposeHeaders=[]] - The value of "Access-Control-Expose-Headers" CORS header.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use('/api/*', cors())
+ * app.use(
+ *   '/api2/*',
+ *   cors({
+ *     origin: 'http://example.com',
+ *     allowHeaders: ['X-Custom-Header', 'Upgrade-Insecure-Requests'],
+ *     allowMethods: ['POST', 'GET', 'OPTIONS'],
+ *     exposeHeaders: ['Content-Length', 'X-Kuma-Revision'],
+ *     maxAge: 600,
+ *     credentials: true,
+ *   })
+ * )
+ *
+ * app.all('/api/abc', (c) => {
+ *   return c.json({ success: true })
+ * })
+ * app.all('/api2/abc', (c) => {
+ *   return c.json({ success: true })
+ * })
+ * ```
+ */
+export const cors = (options?: CORSOptions): MiddlewareHandler => {
+  const defaults: CORSOptions = {
+    origin: '*',
+    allowMethods: ['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH'],
+    allowHeaders: [],
+    exposeHeaders: [],
+  }
+  const opts = {
+    ...defaults,
+    ...options,
+  }
+
+  const findAllowOrigin = ((optsOrigin) => {
+    if (typeof optsOrigin === 'string') {
+      return () => optsOrigin
+    } else if (typeof optsOrigin === 'function') {
+      return optsOrigin
+    } else {
+      return (origin: string) => (optsOrigin.includes(origin) ? origin : optsOrigin[0])
+    }
+  })(opts.origin)
+
+  return async function cors(c, next) {
+    function set(key: string, value: string) {
+      c.res.headers.set(key, value)
+    }
+
+    const allowOrigin = findAllowOrigin(c.req.header('origin') || '', c)
+    if (allowOrigin) {
+      set('Access-Control-Allow-Origin', allowOrigin)
+    }
+
+    // Suppose the server sends a response with an Access-Control-Allow-Origin value with an explicit origin (rather than the "*" wildcard).
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin
+    if (opts.origin !== '*') {
+      const existingVary = c.req.header('Vary')
+
+      if (existingVary) {
+        set('Vary', existingVary)
+      } else {
+        set('Vary', 'Origin')
+      }
+    }
+
+    if (opts.credentials) {
+      set('Access-Control-Allow-Credentials', 'true')
+    }
+
+    if (opts.exposeHeaders?.length) {
+      set('Access-Control-Expose-Headers', opts.exposeHeaders.join(','))
+    }
+
+    if (c.req.method === 'OPTIONS') {
+      if (opts.maxAge != null) {
+        set('Access-Control-Max-Age', opts.maxAge.toString())
+      }
+
+      if (opts.allowMethods?.length) {
+        set('Access-Control-Allow-Methods', opts.allowMethods.join(','))
+      }
+
+      let headers = opts.allowHeaders
+      if (!headers?.length) {
+        const requestHeaders = c.req.header('Access-Control-Request-Headers')
+        if (requestHeaders) {
+          headers = requestHeaders.split(/\s*,\s*/)
+        }
+      }
+      if (headers?.length) {
+        set('Access-Control-Allow-Headers', headers.join(','))
+        c.res.headers.append('Vary', 'Access-Control-Request-Headers')
+      }
+
+      c.res.headers.delete('Content-Length')
+      c.res.headers.delete('Content-Type')
+
+      return new Response(null, {
+        headers: c.res.headers,
+        status: 204,
+        statusText: c.res.statusText,
+      })
+    }
+    await next()
+  }
+}