bluera-knowledge 0.14.0 → 0.14.2

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

@@ -1,90 +0,0 @@
-/**
- * @module
- * CSRF Protection Middleware for Hono.
- */
-
-import type { Context } from '../../context'
-import { HTTPException } from '../../http-exception'
-import type { MiddlewareHandler } from '../../types'
-
-type IsAllowedOriginHandler = (origin: string, context: Context) => boolean
-interface CSRFOptions {
-  origin?: string | string[] | IsAllowedOriginHandler
-}
-
-const isSafeMethodRe = /^(GET|HEAD)$/
-const isRequestedByFormElementRe =
-  /^\b(application\/x-www-form-urlencoded|multipart\/form-data|text\/plain)\b/i
-
-/**
- * CSRF Protection Middleware for Hono.
- *
- * @see {@link https://hono.dev/docs/middleware/builtin/csrf}
- *
- * @param {CSRFOptions} [options] - The options for the CSRF protection middleware.
- * @param {string|string[]|(origin: string, context: Context) => boolean} [options.origin] - Specify origins.
- * @returns {MiddlewareHandler} The middleware handler function.
- *
- * @example
- * ```ts
- * const app = new Hono()
- *
- * app.use(csrf())
- *
- * // Specifying origins with using `origin` option
- * // string
- * app.use(csrf({ origin: 'myapp.example.com' }))
- *
- * // string[]
- * app.use(
- *   csrf({
- *     origin: ['myapp.example.com', 'development.myapp.example.com'],
- *   })
- * )
- *
- * // Function
- * // It is strongly recommended that the protocol be verified to ensure a match to `$`.
- * // You should *never* do a forward match.
- * app.use(
- *   '*',
- *   csrf({
- *     origin: (origin) => /https:\/\/(\w+\.)?myapp\.example\.com$/.test(origin),
- *   })
- * )
- * ```
- */
-export const csrf = (options?: CSRFOptions): MiddlewareHandler => {
-  const handler: IsAllowedOriginHandler = ((optsOrigin) => {
-    if (!optsOrigin) {
-      return (origin, c) => origin === new URL(c.req.url).origin
-    } else if (typeof optsOrigin === 'string') {
-      return (origin) => origin === optsOrigin
-    } else if (typeof optsOrigin === 'function') {
-      return optsOrigin
-    } else {
-      return (origin) => optsOrigin.includes(origin)
-    }
-  })(options?.origin)
-  const isAllowedOrigin = (origin: string | undefined, c: Context) => {
-    if (origin === undefined) {
-      // denied always when origin header is not present
-      return false
-    }
-    return handler(origin, c)
-  }
-
-  return async function csrf(c, next) {
-    if (
-      !isSafeMethodRe.test(c.req.method) &&
-      isRequestedByFormElementRe.test(c.req.header('content-type') || '') &&
-      !isAllowedOrigin(c.req.header('origin'), c)
-    ) {
-      const res = new Response('Forbidden', {
-        status: 403,
-      })
-      throw new HTTPException(403, { res })
-    }
-
-    await next()
-  }
-}

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

@@ -1,88 +0,0 @@
-/**
- * @module
- * ETag Middleware for Hono.
- */
-
-import type { MiddlewareHandler } from '../../types'
-import { sha1 } from '../../utils/crypto'
-
-type ETagOptions = {
-  retainedHeaders?: string[]
-  weak?: boolean
-}
-
-/**
- * Default headers to pass through on 304 responses. From the spec:
- * > The response must not contain a body and must include the headers that
- * > would have been sent in an equivalent 200 OK response: Cache-Control,
- * > Content-Location, Date, ETag, Expires, and Vary.
- */
-export const RETAINED_304_HEADERS = [
-  'cache-control',
-  'content-location',
-  'date',
-  'etag',
-  'expires',
-  'vary',
-]
-
-function etagMatches(etag: string, ifNoneMatch: string | null) {
-  return ifNoneMatch != null && ifNoneMatch.split(/,\s*/).indexOf(etag) > -1
-}
-
-/**
- * ETag Middleware for Hono.
- *
- * @see {@link https://hono.dev/docs/middleware/builtin/etag}
- *
- * @param {ETagOptions} [options] - The options for the ETag middleware.
- * @param {boolean} [options.weak=false] - Define using or not using a weak validation. If true is set, then `W/` is added to the prefix of the value.
- * @param {string[]} [options.retainedHeaders=RETAINED_304_HEADERS] - The headers that you want to retain in the 304 Response.
- * @returns {MiddlewareHandler} The middleware handler function.
- *
- * @example
- * ```ts
- * const app = new Hono()
- *
- * app.use('/etag/*', etag())
- * app.get('/etag/abc', (c) => {
- *   return c.text('Hono is cool')
- * })
- * ```
- */
-export const etag = (options?: ETagOptions): MiddlewareHandler => {
-  const retainedHeaders = options?.retainedHeaders ?? RETAINED_304_HEADERS
-  const weak = options?.weak ?? false
-
-  return async function etag(c, next) {
-    const ifNoneMatch = c.req.header('If-None-Match') ?? null
-
-    await next()
-
-    const res = c.res as Response
-    let etag = res.headers.get('ETag')
-
-    if (!etag) {
-      const hash = await sha1(res.clone().body || '')
-      etag = weak ? `W/"${hash}"` : `"${hash}"`
-    }
-
-    if (etagMatches(etag, ifNoneMatch)) {
-      await c.res.blob() // Force using body
-      c.res = new Response(null, {
-        status: 304,
-        statusText: 'Not Modified',
-        headers: {
-          ETag: etag,
-        },
-      })
-      c.res.headers.forEach((_, key) => {
-        if (retainedHeaders.indexOf(key.toLowerCase()) === -1) {
-          c.res.headers.delete(key)
-        }
-      })
-    } else {
-      c.res.headers.set('ETag', etag)
-    }
-  }
-}

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

@@ -1,178 +0,0 @@
-/**
- * IP Restriction Middleware for Hono
- * @module
- */
-
-import type { Context, MiddlewareHandler } from '../..'
-import type { AddressType, GetConnInfo } from '../../helper/conninfo'
-import { HTTPException } from '../../http-exception'
-import {
-  convertIPv4ToBinary,
-  convertIPv6BinaryToString,
-  convertIPv6ToBinary,
-  distinctRemoteAddr,
-} from '../../utils/ipaddr'
-
-/**
- * Function to get IP Address
- */
-type GetIPAddr = GetConnInfo | ((c: Context) => string)
-
-/**
- * ### IPv4 and IPv6
- * - `*` match all
- *
- * ### IPv4
- * - `192.168.2.0` static
- * - `192.168.2.0/24` CIDR Notation
- *
- * ### IPv6
- * - `::1` static
- * - `::1/10` CIDR Notation
- */
-type IPRestrictionRuleFunction = (addr: { addr: string; type: AddressType }) => boolean
-export type IPRestrictionRule = string | ((addr: { addr: string; type: AddressType }) => boolean)
-
-const IS_CIDR_NOTATION_REGEX = /\/[0-9]{0,3}$/
-const buildMatcher = (
-  rules: IPRestrictionRule[]
-): ((addr: { addr: string; type: AddressType; isIPv4: boolean }) => boolean) => {
-  const functionRules: IPRestrictionRuleFunction[] = []
-  const staticRules: Set<string> = new Set()
-  const cidrRules: [boolean, bigint, bigint][] = []
-
-  for (let rule of rules) {
-    if (rule === '*') {
-      return () => true
-    } else if (typeof rule === 'function') {
-      functionRules.push(rule)
-    } else {
-      if (IS_CIDR_NOTATION_REGEX.test(rule)) {
-        const splittedRule = rule.split('/')
-
-        const addrStr = splittedRule[0]
-        const type = distinctRemoteAddr(addrStr)
-        if (type === undefined) {
-          throw new TypeError(`Invalid rule: ${rule}`)
-        }
-
-        const isIPv4 = type === 'IPv4'
-        const prefix = parseInt(splittedRule[1])
-
-        if (isIPv4 ? prefix === 32 : prefix === 128) {
-          // this rule is a static rule
-          rule = addrStr
-        } else {
-          const addr = (isIPv4 ? convertIPv4ToBinary : convertIPv6ToBinary)(addrStr)
-          const mask = ((1n << BigInt(prefix)) - 1n) << BigInt((isIPv4 ? 32 : 128) - prefix)
-
-          cidrRules.push([isIPv4, addr & mask, mask] as [boolean, bigint, bigint])
-          continue
-        }
-      }
-
-      const type = distinctRemoteAddr(rule)
-      if (type === undefined) {
-        throw new TypeError(`Invalid rule: ${rule}`)
-      }
-      staticRules.add(
-        type === 'IPv4'
-          ? rule // IPv4 address is already normalized, so it is registered as is.
-          : convertIPv6BinaryToString(convertIPv6ToBinary(rule)) // normalize IPv6 address (e.g. 0000:0000:0000:0000:0000:0000:0000:0001 => ::1)
-      )
-    }
-  }
-
-  return (remote: {
-    addr: string
-    type: AddressType
-    isIPv4: boolean
-    binaryAddr?: bigint
-  }): boolean => {
-    if (staticRules.has(remote.addr)) {
-      return true
-    }
-    for (const [isIPv4, addr, mask] of cidrRules) {
-      if (isIPv4 !== remote.isIPv4) {
-        continue
-      }
-      const remoteAddr = (remote.binaryAddr ||= (
-        isIPv4 ? convertIPv4ToBinary : convertIPv6ToBinary
-      )(remote.addr))
-      if ((remoteAddr & mask) === addr) {
-        return true
-      }
-    }
-    for (const rule of functionRules) {
-      if (rule({ addr: remote.addr, type: remote.type })) {
-        return true
-      }
-    }
-    return false
-  }
-}
-
-/**
- * Rules for IP Restriction Middleware
- */
-export interface IPRestrictionRules {
-  denyList?: IPRestrictionRule[]
-  allowList?: IPRestrictionRule[]
-}
-
-/**
- * IP Restriction Middleware
- *
- * @param getIP function to get IP Address
- */
-export const ipRestriction = (
-  getIP: GetIPAddr,
-  { denyList = [], allowList = [] }: IPRestrictionRules,
-  onError?: (
-    remote: { addr: string; type: AddressType },
-    c: Context
-  ) => Response | Promise<Response>
-): MiddlewareHandler => {
-  const allowLength = allowList.length
-
-  const denyMatcher = buildMatcher(denyList)
-  const allowMatcher = buildMatcher(allowList)
-
-  const blockError = (c: Context): HTTPException =>
-    new HTTPException(403, {
-      res: c.text('Forbidden', {
-        status: 403,
-      }),
-    })
-
-  return async function ipRestriction(c, next) {
-    const connInfo = getIP(c)
-    const addr = typeof connInfo === 'string' ? connInfo : connInfo.remote.address
-    if (!addr) {
-      throw blockError(c)
-    }
-    const type =
-      (typeof connInfo !== 'string' && connInfo.remote.addressType) || distinctRemoteAddr(addr)
-
-    const remoteData = { addr, type, isIPv4: type === 'IPv4' }
-
-    if (denyMatcher(remoteData)) {
-      if (onError) {
-        return onError({ addr, type }, c)
-      }
-      throw blockError(c)
-    }
-    if (allowMatcher(remoteData)) {
-      return await next()
-    }
-
-    if (allowLength === 0) {
-      return await next()
-    } else {
-      if (onError) {
-        return await onError({ addr, type }, c)
-      }
-      throw blockError(c)
-    }
-  }
-}

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

@@ -1,158 +0,0 @@
-/**
- * @module
- * JSX Renderer Middleware for Hono.
- */
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { Context, PropsForRenderer } from '../../context'
-import { html, raw } from '../../helper/html'
-import { Fragment, createContext, jsx, useContext } from '../../jsx'
-import type { FC, Context as JSXContext, JSXNode, PropsWithChildren } from '../../jsx'
-import { renderToReadableStream } from '../../jsx/streaming'
-import type { Env, Input, MiddlewareHandler } from '../../types'
-import type { HtmlEscapedString } from '../../utils/html'
-
-export const RequestContext: JSXContext<Context<any, any, {}> | null> =
-  createContext<Context | null>(null)
-
-type RendererOptions = {
-  docType?: boolean | string
-  stream?: boolean | Record<string, string>
-}
-
-type Component = (
-  props: PropsForRenderer & { Layout: FC },
-  c: Context
-) => HtmlEscapedString | Promise<HtmlEscapedString>
-
-type ComponentWithChildren = (
-  props: PropsWithChildren<PropsForRenderer & { Layout: FC }>,
-  c: Context
-) => HtmlEscapedString | Promise<HtmlEscapedString>
-
-const createRenderer =
-  (c: Context, Layout: FC, component?: Component, options?: RendererOptions) =>
-  (children: JSXNode, props: PropsForRenderer) => {
-    const docType =
-      typeof options?.docType === 'string'
-        ? options.docType
-        : options?.docType === false
-          ? ''
-          : '<!DOCTYPE html>'
-
-    const currentLayout = component
-      ? jsx(
-          (props: any) => component(props, c),
-          {
-            ...{ Layout, ...(props as any) },
-          },
-          children as any
-        )
-      : children
-
-    const body = html`${raw(docType)}${jsx(
-      RequestContext.Provider,
-      { value: c },
-      currentLayout as any
-    )}`
-
-    if (options?.stream) {
-      if (options.stream === true) {
-        c.header('Transfer-Encoding', 'chunked')
-        c.header('Content-Type', 'text/html; charset=UTF-8')
-        c.header('Content-Encoding', 'Identity')
-      } else {
-        for (const [key, value] of Object.entries(options.stream)) {
-          c.header(key, value)
-        }
-      }
-      return c.body(renderToReadableStream(body))
-    } else {
-      return c.html(body)
-    }
-  }
-
-/**
- * JSX Renderer Middleware for hono.
- *
- * @see {@link https://hono.dev/docs/middleware/builtin/jsx-renderer}
- *
- * @param {ComponentWithChildren} [component] - The component to render, which can accept children and props.
- * @param {RendererOptions} [options] - The options for the JSX renderer middleware.
- * @param {boolean | string} [options.docType=true] - The DOCTYPE to be added at the beginning of the HTML. If set to false, no DOCTYPE will be added.
- * @param {boolean | Record<string, string>} [options.stream=false] - If set to true, enables streaming response with default headers. If a record is provided, custom headers will be used.
- * @returns {MiddlewareHandler} The middleware handler function.
- *
- * @example
- * ```ts
- * const app = new Hono()
- *
- * app.get(
- *   '/page/*',
- *   jsxRenderer(({ children }) => {
- *     return (
- *       <html>
- *         <body>
- *           <header>Menu</header>
- *           <div>{children}</div>
- *         </body>
- *       </html>
- *     )
- *   })
- * )
- *
- * app.get('/page/about', (c) => {
- *   return c.render(<h1>About me!</h1>)
- * })
- * ```
- */
-export const jsxRenderer = (
-  component?: ComponentWithChildren,
-  options?: RendererOptions
-): MiddlewareHandler =>
-  function jsxRenderer(c, next) {
-    const Layout = (c.getLayout() ?? Fragment) as FC
-    if (component) {
-      c.setLayout((props) => {
-        return component({ ...props, Layout }, c)
-      })
-    }
-    c.setRenderer(createRenderer(c, Layout, component, options) as any)
-    return next()
-  }
-
-/**
- * useRequestContext for Hono.
- *
- * @template E - The environment type.
- * @template P - The parameter type.
- * @template I - The input type.
- * @returns {Context<E, P, I>} An instance of Context.
- *
- * @example
- * ```ts
- * const RequestUrlBadge: FC = () => {
- *   const c = useRequestContext()
- *   return <b>{c.req.url}</b>
- * }
- *
- * app.get('/page/info', (c) => {
- *   return c.render(
- *     <div>
- *       You are accessing: <RequestUrlBadge />
- *     </div>
- *   )
- * })
- * ```
- */
-export const useRequestContext = <
-  E extends Env = any,
-  P extends string = any,
-  I extends Input = {},
->(): Context<E, P, I> => {
-  const c = useContext(RequestContext)
-  if (!c) {
-    throw new Error('RequestContext is not provided.')
-  }
-  return c
-}

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

@@ -1,8 +0,0 @@
-import type { JwtVariables } from './jwt'
-export type { JwtVariables }
-export { jwt, verify, decode, sign } from './jwt'
-import type {} from '../..'
-
-declare module '../..' {
-  interface ContextVariableMap extends JwtVariables {}
-}

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

@@ -1,159 +0,0 @@
-/**
- * @module
- * JWT Auth Middleware for Hono.
- */
-
-import type { Context } from '../../context'
-import { getCookie, getSignedCookie } from '../../helper/cookie'
-import { HTTPException } from '../../http-exception'
-import type { MiddlewareHandler } from '../../types'
-import type { CookiePrefixOptions } from '../../utils/cookie'
-import { Jwt } from '../../utils/jwt'
-import '../../context'
-import type { SignatureAlgorithm } from '../../utils/jwt/jwa'
-import type { SignatureKey } from '../../utils/jwt/jws'
-
-export type JwtVariables = {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  jwtPayload: any
-}
-
-/**
- * JWT Auth Middleware for Hono.
- *
- * @see {@link https://hono.dev/docs/middleware/builtin/jwt}
- *
- * @param {object} options - The options for the JWT middleware.
- * @param {SignatureKey} [options.secret] - A value of your secret key.
- * @param {string} [options.cookie] - If this value is set, then the value is retrieved from the cookie header using that value as a key, which is then validated as a token.
- * @param {SignatureAlgorithm} [options.alg=HS256] - An algorithm type that is used for verifying. Available types are `HS256` | `HS384` | `HS512` | `RS256` | `RS384` | `RS512` | `PS256` | `PS384` | `PS512` | `ES256` | `ES384` | `ES512` | `EdDSA`.
- * @returns {MiddlewareHandler} The middleware handler function.
- *
- * @example
- * ```ts
- * const app = new Hono()
- *
- * app.use(
- *   '/auth/*',
- *   jwt({
- *     secret: 'it-is-very-secret',
- *   })
- * )
- *
- * app.get('/auth/page', (c) => {
- *   return c.text('You are authorized')
- * })
- * ```
- */
-export const jwt = (options: {
-  secret: SignatureKey
-  cookie?:
-    | string
-    | { key: string; secret?: string | BufferSource; prefixOptions?: CookiePrefixOptions }
-  alg?: SignatureAlgorithm
-}): MiddlewareHandler => {
-  if (!options || !options.secret) {
-    throw new Error('JWT auth middleware requires options for "secret"')
-  }
-
-  if (!crypto.subtle || !crypto.subtle.importKey) {
-    throw new Error('`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.')
-  }
-
-  return async function jwt(ctx, next) {
-    const credentials = ctx.req.raw.headers.get('Authorization')
-    let token
-    if (credentials) {
-      const parts = credentials.split(/\s+/)
-      if (parts.length !== 2) {
-        const errDescription = 'invalid credentials structure'
-        throw new HTTPException(401, {
-          message: errDescription,
-          res: unauthorizedResponse({
-            ctx,
-            error: 'invalid_request',
-            errDescription,
-          }),
-        })
-      } else {
-        token = parts[1]
-      }
-    } else if (options.cookie) {
-      if (typeof options.cookie == 'string') {
-        token = getCookie(ctx, options.cookie)
-      } else if (options.cookie.secret) {
-        if (options.cookie.prefixOptions) {
-          token = await getSignedCookie(
-            ctx,
-            options.cookie.secret,
-            options.cookie.key,
-            options.cookie.prefixOptions
-          )
-        } else {
-          token = await getSignedCookie(ctx, options.cookie.secret, options.cookie.key)
-        }
-      } else {
-        if (options.cookie.prefixOptions) {
-          token = getCookie(ctx, options.cookie.key, options.cookie.prefixOptions)
-        } else {
-          token = getCookie(ctx, options.cookie.key)
-        }
-      }
-    }
-
-    if (!token) {
-      const errDescription = 'no authorization included in request'
-      throw new HTTPException(401, {
-        message: errDescription,
-        res: unauthorizedResponse({
-          ctx,
-          error: 'invalid_request',
-          errDescription,
-        }),
-      })
-    }
-
-    let payload
-    let cause
-    try {
-      payload = await Jwt.verify(token, options.secret, options.alg)
-    } catch (e) {
-      cause = e
-    }
-    if (!payload) {
-      throw new HTTPException(401, {
-        message: 'Unauthorized',
-        res: unauthorizedResponse({
-          ctx,
-          error: 'invalid_token',
-          statusText: 'Unauthorized',
-          errDescription: 'token verification failure',
-        }),
-        cause,
-      })
-    }
-
-    ctx.set('jwtPayload', payload)
-
-    await next()
-  }
-}
-
-function unauthorizedResponse(opts: {
-  ctx: Context
-  error: string
-  errDescription: string
-  statusText?: string
-}) {
-  return new Response('Unauthorized', {
-    status: 401,
-    statusText: opts.statusText,
-    headers: {
-      'WWW-Authenticate': `Bearer realm="${opts.ctx.req.url}",error="${opts.error}",error_description="${opts.errDescription}"`,
-    },
-  })
-}
-
-export const verify = Jwt.verify
-export const decode = Jwt.decode
-export const sign = Jwt.sign