bluera-knowledge 0.14.0 → 0.14.2

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

@@ -1,115 +0,0 @@
-/**
- * @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

@@ -1,127 +0,0 @@
-/**
- * @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

@@ -1,153 +0,0 @@
-/**
- * @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

@@ -1,79 +0,0 @@
-/**
- * @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

@@ -1,55 +0,0 @@
-/**
- * @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

@@ -1,141 +0,0 @@
-/**
- * @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()
-  }
-}