bluera-knowledge 0.9.21

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

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

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

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

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

@@ -0,0 +1,8 @@
+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

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