bluera-knowledge 0.9.21

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

@@ -0,0 +1,93 @@
+/**
+ * @module
+ * Logger Middleware for Hono.
+ */
+
+import type { MiddlewareHandler } from '../../types'
+import { getColorEnabled } from '../../utils/color'
+import { getPath } from '../../utils/url'
+
+enum LogPrefix {
+  Outgoing = '-->',
+  Incoming = '<--',
+  Error = 'xxx',
+}
+
+const humanize = (times: string[]) => {
+  const [delimiter, separator] = [',', '.']
+
+  const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1' + delimiter))
+
+  return orderTimes.join(separator)
+}
+
+const time = (start: number) => {
+  const delta = Date.now() - start
+  return humanize([delta < 1000 ? delta + 'ms' : Math.round(delta / 1000) + 's'])
+}
+
+const colorStatus = (status: number) => {
+  const colorEnabled = getColorEnabled()
+  const out: { [key: string]: string } = {
+    7: colorEnabled ? `\x1b[35m${status}\x1b[0m` : `${status}`,
+    5: colorEnabled ? `\x1b[31m${status}\x1b[0m` : `${status}`,
+    4: colorEnabled ? `\x1b[33m${status}\x1b[0m` : `${status}`,
+    3: colorEnabled ? `\x1b[36m${status}\x1b[0m` : `${status}`,
+    2: colorEnabled ? `\x1b[32m${status}\x1b[0m` : `${status}`,
+    1: colorEnabled ? `\x1b[32m${status}\x1b[0m` : `${status}`,
+    0: colorEnabled ? `\x1b[33m${status}\x1b[0m` : `${status}`,
+  }
+
+  const calculateStatus = (status / 100) | 0
+
+  return out[calculateStatus]
+}
+
+type PrintFunc = (str: string, ...rest: string[]) => void
+
+function log(
+  fn: PrintFunc,
+  prefix: string,
+  method: string,
+  path: string,
+  status: number = 0,
+  elapsed?: string
+) {
+  const out =
+    prefix === LogPrefix.Incoming
+      ? `${prefix} ${method} ${path}`
+      : `${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`
+  fn(out)
+}
+
+/**
+ * Logger Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/logger}
+ *
+ * @param {PrintFunc} [fn=console.log] - Optional function for customized logging behavior.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(logger())
+ * app.get('/', (c) => c.text('Hello Hono!'))
+ * ```
+ */
+export const logger = (fn: PrintFunc = console.log): MiddlewareHandler => {
+  return async function logger(c, next) {
+    const { method } = c.req
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const path = getPath(c.req.raw)
+
+    log(fn, LogPrefix.Incoming, method, path)
+
+    const start = Date.now()
+
+    await next()
+
+    log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start))
+  }
+}

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

@@ -0,0 +1,146 @@
+/**
+ * @module
+ * Method Override Middleware for Hono.
+ */
+
+import type { Context, ExecutionContext } from '../../context'
+import type { Hono } from '../../hono'
+import type { MiddlewareHandler } from '../../types'
+import { parseBody } from '../../utils/body'
+
+type MethodOverrideOptions = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  app: Hono<any, any, any>
+} & (
+  | {
+      // Default is 'form' and the value is `_method`
+      form?: string
+      header?: never
+      query?: never
+    }
+  | {
+      form?: never
+      header: string
+      query?: never
+    }
+  | {
+      form?: never
+      header?: never
+      query: string
+    }
+)
+
+const DEFAULT_METHOD_FORM_NAME = '_method'
+
+/**
+ * Method Override Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/method-override}
+ *
+ * @param {MethodOverrideOptions} options - The options for the method override middleware.
+ * @param {Hono} options.app - The instance of Hono is used in your application.
+ * @param {string} [options.form=_method] - Form key with a value containing the method name.
+ * @param {string} [options.header] - Header name with a value containing the method name.
+ * @param {string} [options.query] - Query parameter key with a value containing the method name.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * // If no options are specified, the value of `_method` in the form,
+ * // e.g. DELETE, is used as the method.
+ * app.use('/posts', methodOverride({ app }))
+ *
+ * app.delete('/posts', (c) => {
+ *   // ....
+ * })
+ * ```
+ */
+export const methodOverride = (options: MethodOverrideOptions): MiddlewareHandler =>
+  async function methodOverride(c, next) {
+    if (c.req.method === 'GET') {
+      return await next()
+    }
+
+    const app = options.app
+    // Method override by form
+    if (!(options.header || options.query)) {
+      const contentType = c.req.header('content-type')
+      const methodFormName = options.form || DEFAULT_METHOD_FORM_NAME
+      const clonedRequest = c.req.raw.clone()
+      const newRequest = clonedRequest.clone()
+      // Content-Type is `multipart/form-data`
+      if (contentType?.startsWith('multipart/form-data')) {
+        const form = await clonedRequest.formData()
+        const method = form.get(methodFormName)
+        if (method) {
+          const newForm = await newRequest.formData()
+          newForm.delete(methodFormName)
+          const newHeaders = new Headers(clonedRequest.headers)
+          newHeaders.delete('content-type')
+          newHeaders.delete('content-length')
+          const request = new Request(c.req.url, {
+            body: newForm,
+            headers: newHeaders,
+            method: method as string,
+          })
+          return app.fetch(request, c.env, getExecutionCtx(c))
+        }
+      }
+      // Content-Type is `application/x-www-form-urlencoded`
+      if (contentType === 'application/x-www-form-urlencoded') {
+        const params = await parseBody<Record<string, string>>(clonedRequest)
+        const method = params[methodFormName]
+        if (method) {
+          delete params[methodFormName]
+          const newParams = new URLSearchParams(params)
+          const request = new Request(newRequest, {
+            body: newParams,
+            method: method as string,
+          })
+          return app.fetch(request, c.env, getExecutionCtx(c))
+        }
+      }
+    }
+    // Method override by header
+    else if (options.header) {
+      const headerName = options.header
+      const method = c.req.header(headerName)
+      if (method) {
+        const newHeaders = new Headers(c.req.raw.headers)
+        newHeaders.delete(headerName)
+        const request = new Request(c.req.raw, {
+          headers: newHeaders,
+          method,
+        })
+        return app.fetch(request, c.env, getExecutionCtx(c))
+      }
+    }
+    // Method override by query
+    else if (options.query) {
+      const queryName = options.query
+      const method = c.req.query(queryName)
+      if (method) {
+        const url = new URL(c.req.url)
+        url.searchParams.delete(queryName)
+        const request = new Request(url.toString(), {
+          body: c.req.raw.body,
+          headers: c.req.raw.headers,
+          method,
+        })
+        return app.fetch(request, c.env, getExecutionCtx(c))
+      }
+    }
+    await next()
+  }
+
+const getExecutionCtx = (c: Context) => {
+  let executionCtx: ExecutionContext | undefined
+  try {
+    executionCtx = c.executionCtx
+  } catch {
+    // Do nothing
+  }
+  return executionCtx
+}

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

@@ -0,0 +1,13 @@
+/**
+ * @module
+ * Powered By Middleware for Hono.
+ */
+
+import type { MiddlewareHandler } from '../../types'
+
+export const poweredBy = (): MiddlewareHandler => {
+  return async function poweredBy(c, next) {
+    await next()
+    c.res.headers.set('X-Powered-By', 'Hono')
+  }
+}

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

@@ -0,0 +1,50 @@
+/**
+ * @module
+ * Pretty JSON Middleware for Hono.
+ */
+
+import type { MiddlewareHandler } from '../../types'
+
+interface PrettyOptions {
+  /**
+   * Number of spaces for indentation.
+   * @default 2
+   */
+  space?: number
+
+  /**
+   * Query conditions for when to Pretty.
+   * @default 'pretty'
+   */
+  query?: string
+}
+
+/**
+ * Pretty JSON Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/pretty-json}
+ *
+ * @param options - The options for the pretty JSON middleware.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(prettyJSON()) // With options: prettyJSON({ space: 4 })
+ * app.get('/', (c) => {
+ *   return c.json({ message: 'Hono!' })
+ * })
+ * ```
+ */
+export const prettyJSON = (options?: PrettyOptions): MiddlewareHandler => {
+  const targetQuery = options?.query ?? 'pretty'
+  return async function prettyJSON(c, next) {
+    const pretty = c.req.query(targetQuery) || c.req.query(targetQuery) === ''
+    await next()
+    if (pretty && c.res.headers.get('Content-Type')?.startsWith('application/json')) {
+      const obj = await c.res.json()
+      c.res = new Response(JSON.stringify(obj, null, options?.space ?? 2), c.res)
+    }
+  }
+}

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

@@ -0,0 +1,8 @@
+import type { RequestIdVariables } from './request-id'
+export type { RequestIdVariables }
+export { requestId } from './request-id'
+import type {} from '../..'
+
+declare module '../..' {
+  interface ContextVariableMap extends RequestIdVariables {}
+}

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

@@ -0,0 +1,59 @@
+/**
+ * @module
+ * Request ID Middleware for Hono.
+ */
+
+import type { Context } from '../../context'
+import type { MiddlewareHandler } from '../../types'
+
+export type RequestIdVariables = {
+  requestId: string
+}
+
+export type RequestIdOptions = {
+  limitLength?: number
+  headerName?: string
+  generator?: (c: Context) => string
+}
+
+/**
+ * Request ID Middleware for Hono.
+ *
+ * @param {object} options - Options for Request ID middleware.
+ * @param {number} [options.limitLength=255] - The maximum length of request id.
+ * @param {string} [options.headerName=X-Request-Id] - The header name used in request id.
+ * @param {generator} [options.generator=() => crypto.randomUUID()] - The request id generation function.
+ *
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * type Variables = RequestIdVariables
+ * const app = new Hono<{Variables: Variables}>()
+ *
+ * app.use(requestId())
+ * app.get('/', (c) => {
+ *   console.log(c.get('requestId')) // Debug
+ *   return c.text('Hello World!')
+ * })
+ * ```
+ */
+export const requestId = ({
+  limitLength = 255,
+  headerName = 'X-Request-Id',
+  generator = () => crypto.randomUUID(),
+}: RequestIdOptions = {}): MiddlewareHandler => {
+  return async function requestId(c, next) {
+    // If `headerName` is empty string, req.header will return the object
+    let reqId = headerName ? c.req.header(headerName) : undefined
+    if (!reqId || reqId.length > limitLength || /[^\w\-]/.test(reqId)) {
+      reqId = generator(c)
+    }
+
+    c.set('requestId', reqId)
+    if (headerName) {
+      c.header(headerName, reqId)
+    }
+    await next()
+  }
+}

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

@@ -0,0 +1,8 @@
+export type { ContentSecurityPolicyOptionHandler } from './secure-headers'
+export { NONCE, secureHeaders } from './secure-headers'
+import type { SecureHeadersVariables } from './secure-headers'
+export type { SecureHeadersVariables }
+
+declare module '../..' {
+  interface ContextVariableMap extends SecureHeadersVariables {}
+}

package/tests/fixtures/corpus/oss-repos/hono/src/middleware/secure-headers/permissions-policy.ts

@@ -0,0 +1,86 @@
+// https://github.com/w3c/webappsec-permissions-policy/blob/main/features.md
+
+export type PermissionsPolicyDirective =
+  | StandardizedFeatures
+  | ProposedFeatures
+  | ExperimentalFeatures
+
+/**
+ * These features have been declared in a published version of the respective specification.
+ */
+type StandardizedFeatures =
+  | 'accelerometer'
+  | 'ambientLightSensor'
+  | 'attributionReporting'
+  | 'autoplay'
+  | 'battery'
+  | 'bluetooth'
+  | 'camera'
+  | 'chUa'
+  | 'chUaArch'
+  | 'chUaBitness'
+  | 'chUaFullVersion'
+  | 'chUaFullVersionList'
+  | 'chUaMobile'
+  | 'chUaModel'
+  | 'chUaPlatform'
+  | 'chUaPlatformVersion'
+  | 'chUaWow64'
+  | 'computePressure'
+  | 'crossOriginIsolated'
+  | 'directSockets'
+  | 'displayCapture'
+  | 'encryptedMedia'
+  | 'executionWhileNotRendered'
+  | 'executionWhileOutOfViewport'
+  | 'fullscreen'
+  | 'geolocation'
+  | 'gyroscope'
+  | 'hid'
+  | 'identityCredentialsGet'
+  | 'idleDetection'
+  | 'keyboardMap'
+  | 'magnetometer'
+  | 'microphone'
+  | 'midi'
+  | 'navigationOverride'
+  | 'payment'
+  | 'pictureInPicture'
+  | 'publickeyCredentialsGet'
+  | 'screenWakeLock'
+  | 'serial'
+  | 'storageAccess'
+  | 'syncXhr'
+  | 'usb'
+  | 'webShare'
+  | 'windowManagement'
+  | 'xrSpatialTracking'
+
+/**
+ * These features have been proposed, but the definitions have not yet been integrated into their respective specs.
+ */
+type ProposedFeatures =
+  | 'clipboardRead'
+  | 'clipboardWrite'
+  | 'gemepad'
+  | 'sharedAutofill'
+  | 'speakerSelection'
+
+/**
+ * These features generally have an explainer only, but may be available for experimentation by web developers.
+ */
+type ExperimentalFeatures =
+  | 'allScreensCapture'
+  | 'browsingTopics'
+  | 'capturedSurfaceControl'
+  | 'conversionMeasurement'
+  | 'digitalCredentialsGet'
+  | 'focusWithoutUserActivation'
+  | 'joinAdInterestGroup'
+  | 'localFonts'
+  | 'runAdAuction'
+  | 'smartCard'
+  | 'syncScript'
+  | 'trustTokenRedemption'
+  | 'unload'
+  | 'verticalScroll'