bluera-knowledge 0.14.0 → 0.14.2

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/lambda-edge/conninfo.ts

@@ -1,15 +0,0 @@
-import type { GetConnInfo } from '../../helper/conninfo'
-import type { CloudFrontEdgeEvent } from './handler'
-import type { Context } from '../../context'
-
-type Env = {
-  Bindings: {
-    event: CloudFrontEdgeEvent
-  }
-}
-
-export const getConnInfo: GetConnInfo = (c: Context<Env>) => ({
-  remote: {
-    address: c.env.event.Records[0].cf.request.clientIp,
-  },
-})

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/lambda-edge/handler.ts

@@ -1,189 +0,0 @@
-import crypto from 'node:crypto'
-import type { Hono } from '../../hono'
-
-import { decodeBase64, encodeBase64 } from '../../utils/encode'
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-globalThis.crypto ??= crypto
-
-interface CloudFrontHeader {
-  key: string
-  value: string
-}
-
-interface CloudFrontHeaders {
-  [name: string]: CloudFrontHeader[]
-}
-
-interface CloudFrontCustomOrigin {
-  customHeaders: CloudFrontHeaders
-  domainName: string
-  keepaliveTimeout: number
-  path: string
-  port: number
-  protocol: string
-  readTimeout: number
-  sslProtocols: string[]
-}
-// https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html
-interface CloudFrontS3Origin {
-  authMethod: 'origin-access-identity' | 'none'
-  customHeaders: CloudFrontHeaders
-  domainName: string
-  path: string
-  region: string
-}
-type CloudFrontOrigin =
-  | { s3: CloudFrontS3Origin; custom?: never }
-  | { custom: CloudFrontCustomOrigin; s3?: never }
-
-export interface CloudFrontRequest {
-  clientIp: string
-  headers: CloudFrontHeaders
-  method: string
-  querystring: string
-  uri: string
-  body?: {
-    inputTruncated: boolean
-    action: string
-    encoding: string
-    data: string
-  }
-  origin?: CloudFrontOrigin
-}
-
-export interface CloudFrontResponse {
-  headers: CloudFrontHeaders
-  status: string
-  statusDescription?: string
-}
-
-export interface CloudFrontConfig {
-  distributionDomainName: string
-  distributionId: string
-  eventType: string
-  requestId: string
-}
-
-interface CloudFrontEvent {
-  cf: {
-    config: CloudFrontConfig
-    request: CloudFrontRequest
-    response?: CloudFrontResponse
-  }
-}
-
-export interface CloudFrontEdgeEvent {
-  Records: CloudFrontEvent[]
-}
-
-type CloudFrontContext = {}
-
-export interface Callback {
-  (err: Error | null, result?: CloudFrontRequest | CloudFrontResult): void
-}
-
-// https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-generating-http-responses-in-requests.html#lambda-generating-http-responses-programming-model
-interface CloudFrontResult {
-  status: string
-  statusDescription?: string
-  headers?: {
-    [header: string]: {
-      key: string
-      value: string
-    }[]
-  }
-  body?: string
-  bodyEncoding?: 'text' | 'base64'
-}
-
-/**
- * Accepts events from 'Lambda@Edge' event
- * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html
- */
-const convertHeaders = (headers: Headers): CloudFrontHeaders => {
-  const cfHeaders: CloudFrontHeaders = {}
-  headers.forEach((value, key) => {
-    cfHeaders[key.toLowerCase()] = [{ key: key.toLowerCase(), value }]
-  })
-  return cfHeaders
-}
-
-export const handle = (
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  app: Hono<any>
-): ((
-  event: CloudFrontEdgeEvent,
-  context?: CloudFrontContext,
-  callback?: Callback
-) => Promise<CloudFrontResult>) => {
-  return async (event, context?, callback?) => {
-    const res = await app.fetch(createRequest(event), {
-      event,
-      context,
-      callback: (err: Error | null, result?: CloudFrontResult | CloudFrontRequest) => {
-        callback?.(err, result)
-      },
-      config: event.Records[0].cf.config,
-      request: event.Records[0].cf.request,
-      response: event.Records[0].cf.response,
-    })
-    return createResult(res)
-  }
-}
-
-const createResult = async (res: Response): Promise<CloudFrontResult> => {
-  const isBase64Encoded = isContentTypeBinary(res.headers.get('content-type') || '')
-  const body = isBase64Encoded ? encodeBase64(await res.arrayBuffer()) : await res.text()
-
-  return {
-    status: res.status.toString(),
-    headers: convertHeaders(res.headers),
-    body,
-    ...(isBase64Encoded ? { bodyEncoding: 'base64' } : {}),
-  }
-}
-
-const createRequest = (event: CloudFrontEdgeEvent): Request => {
-  const queryString = event.Records[0].cf.request.querystring
-  const urlPath = `https://${event.Records[0].cf.config.distributionDomainName}${event.Records[0].cf.request.uri}`
-  const url = queryString ? `${urlPath}?${queryString}` : urlPath
-
-  const headers = new Headers()
-  Object.entries(event.Records[0].cf.request.headers).forEach(([k, v]) => {
-    v.forEach((header) => headers.set(k, header.value))
-  })
-
-  const requestBody = event.Records[0].cf.request.body
-  const method = event.Records[0].cf.request.method
-  const body = createBody(method, requestBody)
-
-  return new Request(url, {
-    headers,
-    method,
-    body,
-  })
-}
-
-export const createBody = (
-  method: string,
-  requestBody: CloudFrontRequest['body']
-): string | Uint8Array | undefined => {
-  if (!requestBody || !requestBody.data) {
-    return undefined
-  }
-  if (method === 'GET' || method === 'HEAD') {
-    return undefined
-  }
-  if (requestBody.encoding === 'base64') {
-    return decodeBase64(requestBody.data)
-  }
-  return requestBody.data
-}
-
-export const isContentTypeBinary = (contentType: string): boolean => {
-  return !/^(text\/(plain|html|css|javascript|csv).*|application\/(.*json|.*xml).*|image\/svg\+xml.*)$/.test(
-    contentType
-  )
-}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/lambda-edge/index.ts

@@ -1,14 +0,0 @@
-/**
- * @module
- * Lambda@Edge Adapter for Hono.
- */
-
-export { handle } from './handler'
-export { getConnInfo } from './conninfo'
-export type {
-  Callback,
-  CloudFrontConfig,
-  CloudFrontRequest,
-  CloudFrontResponse,
-  CloudFrontEdgeEvent,
-} from './handler'

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/netlify/handler.ts

@@ -1,10 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { Hono } from '../../hono'
-
-export const handle = (
-  app: Hono<any, any>
-): ((req: Request, context: any) => Response | Promise<Response>) => {
-  return (req: Request, context: any) => {
-    return app.fetch(req, { context })
-  }
-}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/netlify/index.ts

@@ -1,6 +0,0 @@
-/**
- * @module
- * Netlify Adapter for Hono.
- */
-
-export * from './mod'

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/netlify/mod.ts

@@ -1 +0,0 @@
-export { handle } from './handler'

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/service-worker/handler.ts

@@ -1,34 +0,0 @@
-/**
- * Handler for Service Worker
- * @module
- */
-
-import type { Hono } from '../../hono'
-import type { FetchEvent } from './types'
-
-type Handler = (evt: FetchEvent) => void
-
-/**
- * Adapter for Service Worker
- */
-export const handle = (
-  app: Hono,
-  opts: {
-    fetch?: typeof fetch
-  } = {
-    // To use `fetch` on a Service Worker correctly, first refer to `self.fetch`.
-    fetch: globalThis.self !== undefined ? globalThis.self.fetch : fetch,
-  }
-): Handler => {
-  return (evt) => {
-    evt.respondWith(
-      (async () => {
-        const res = await app.fetch(evt.request)
-        if (opts.fetch && res.status === 404) {
-          return await opts.fetch(evt.request)
-        }
-        return res
-      })()
-    )
-  }
-}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/service-worker/index.ts

@@ -1,5 +0,0 @@
-/**
- * Cloudflare Workers Adapter for Hono.
- * @module
- */
-export { handle } from './handler'

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/service-worker/types.ts

@@ -1,14 +0,0 @@
-interface ExtendableEvent extends Event {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  waitUntil(f: Promise<any>): void
-}
-
-export interface FetchEvent extends ExtendableEvent {
-  readonly clientId: string
-  readonly handled: Promise<undefined>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  readonly preloadResponse: Promise<any>
-  readonly request: Request
-  readonly resultingClientId: string
-  respondWith(r: Response | PromiseLike<Response>): void
-}

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/vercel/conninfo.ts

@@ -1,8 +0,0 @@
-import type { GetConnInfo } from '../../helper/conninfo'
-
-export const getConnInfo: GetConnInfo = (c) => ({
-  remote: {
-    // https://github.com/vercel/vercel/blob/b70bfb5fbf28a4650d4042ce68ca5c636d37cf44/packages/edge/src/edge-headers.ts#L10-L12C32
-    address: c.req.header('x-real-ip'),
-  },
-})

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/vercel/handler.ts

@@ -1,9 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { Hono } from '../../hono'
-import type { FetchEventLike } from '../../types'
-
-export const handle =
-  (app: Hono<any, any, any>) =>
-  (req: Request, requestContext: FetchEventLike): Response | Promise<Response> => {
-    return app.fetch(req, {}, requestContext as any)
-  }

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/vercel/index.ts

@@ -1,7 +0,0 @@
-/**
- * @module
- * Vercel Adapter for Hono.
- */
-
-export { handle } from './handler'
-export { getConnInfo } from './conninfo'

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

@@ -1,214 +0,0 @@
-import type { Hono } from '../hono'
-import type { FormValue, ValidationTargets } from '../types'
-import { serialize } from '../utils/cookie'
-import type { UnionToIntersection } from '../utils/types'
-import type { Callback, Client, ClientRequestOptions } from './types'
-import {
-  deepMerge,
-  mergePath,
-  removeIndexString,
-  replaceUrlParam,
-  replaceUrlProtocol,
-} from './utils'
-
-const createProxy = (callback: Callback, path: string[]) => {
-  const proxy: unknown = new Proxy(() => {}, {
-    get(_obj, key) {
-      if (typeof key !== 'string' || key === 'then') {
-        return undefined
-      }
-      return createProxy(callback, [...path, key])
-    },
-    apply(_1, _2, args) {
-      return callback({
-        path,
-        args,
-      })
-    },
-  })
-  return proxy
-}
-
-class ClientRequestImpl {
-  private url: string
-  private method: string
-  private queryParams: URLSearchParams | undefined = undefined
-  private pathParams: Record<string, string> = {}
-  private rBody: BodyInit | undefined
-  private cType: string | undefined = undefined
-
-  constructor(url: string, method: string) {
-    this.url = url
-    this.method = method
-  }
-  fetch = async (
-    args?: ValidationTargets<FormValue> & {
-      param?: Record<string, string>
-    },
-    opt?: ClientRequestOptions
-  ) => {
-    if (args) {
-      if (args.query) {
-        for (const [k, v] of Object.entries(args.query)) {
-          if (v === undefined) {
-            continue
-          }
-
-          this.queryParams ||= new URLSearchParams()
-          if (Array.isArray(v)) {
-            for (const v2 of v) {
-              this.queryParams.append(k, v2)
-            }
-          } else {
-            this.queryParams.set(k, v)
-          }
-        }
-      }
-
-      if (args.form) {
-        const form = new FormData()
-        for (const [k, v] of Object.entries(args.form)) {
-          if (Array.isArray(v)) {
-            for (const v2 of v) {
-              form.append(k, v2)
-            }
-          } else {
-            form.append(k, v)
-          }
-        }
-        this.rBody = form
-      }
-
-      if (args.json) {
-        this.rBody = JSON.stringify(args.json)
-        this.cType = 'application/json'
-      }
-
-      if (args.param) {
-        this.pathParams = args.param
-      }
-    }
-
-    let methodUpperCase = this.method.toUpperCase()
-
-    const headerValues: Record<string, string> = {
-      ...(args?.header ?? {}),
-      ...(typeof opt?.headers === 'function'
-        ? await opt.headers()
-        : opt?.headers
-          ? opt.headers
-          : {}),
-    }
-
-    if (args?.cookie) {
-      const cookies: string[] = []
-      for (const [key, value] of Object.entries(args.cookie)) {
-        cookies.push(serialize(key, value, { path: '/' }))
-      }
-      headerValues['Cookie'] = cookies.join(',')
-    }
-
-    if (this.cType) {
-      headerValues['Content-Type'] = this.cType
-    }
-
-    const headers = new Headers(headerValues ?? undefined)
-    let url = this.url
-
-    url = removeIndexString(url)
-    url = replaceUrlParam(url, this.pathParams)
-
-    if (this.queryParams) {
-      url = url + '?' + this.queryParams.toString()
-    }
-    methodUpperCase = this.method.toUpperCase()
-    const setBody = !(methodUpperCase === 'GET' || methodUpperCase === 'HEAD')
-
-    // Pass URL string to 1st arg for testing with MSW and node-fetch
-    return (opt?.fetch || fetch)(url, {
-      body: setBody ? this.rBody : undefined,
-      method: methodUpperCase,
-      headers: headers,
-      ...opt?.init,
-    })
-  }
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const hc = <T extends Hono<any, any, any>>(
-  baseUrl: string,
-  options?: ClientRequestOptions
-) =>
-  createProxy(function proxyCallback(opts) {
-    const parts = [...opts.path]
-
-    // allow calling .toString() and .valueOf() on the proxy
-    if (parts[parts.length - 1] === 'toString') {
-      if (parts[parts.length - 2] === 'name') {
-        // e.g. hc().somePath.name.toString() -> "somePath"
-        return parts[parts.length - 3] || ''
-      }
-      // e.g. hc().somePath.toString()
-      return proxyCallback.toString()
-    }
-
-    if (parts[parts.length - 1] === 'valueOf') {
-      if (parts[parts.length - 2] === 'name') {
-        // e.g. hc().somePath.name.valueOf() -> "somePath"
-        return parts[parts.length - 3] || ''
-      }
-      // e.g. hc().somePath.valueOf()
-      return proxyCallback
-    }
-
-    let method = ''
-    if (/^\$/.test(parts[parts.length - 1])) {
-      const last = parts.pop()
-      if (last) {
-        method = last.replace(/^\$/, '')
-      }
-    }
-
-    const path = parts.join('/')
-    const url = mergePath(baseUrl, path)
-    if (method === 'url') {
-      if (opts.args[0] && opts.args[0].param) {
-        return new URL(replaceUrlParam(url, opts.args[0].param))
-      }
-      return new URL(url)
-    }
-    if (method === 'ws') {
-      const webSocketUrl = replaceUrlProtocol(
-        opts.args[0] && opts.args[0].param ? replaceUrlParam(url, opts.args[0].param) : url,
-        'ws'
-      )
-      const targetUrl = new URL(webSocketUrl)
-
-      const queryParams: Record<string, string | string[]> | undefined = opts.args[0]?.query
-      if (queryParams) {
-        Object.entries(queryParams).forEach(([key, value]) => {
-          if (Array.isArray(value)) {
-            value.forEach((item) => targetUrl.searchParams.append(key, item))
-          } else {
-            targetUrl.searchParams.set(key, value)
-          }
-        })
-      }
-      const establishWebSocket = (...args: ConstructorParameters<typeof WebSocket>) => {
-        if (options?.webSocket !== undefined && typeof options.webSocket === 'function') {
-          return options.webSocket(...args)
-        }
-        return new WebSocket(...args)
-      }
-
-      return establishWebSocket(targetUrl.toString())
-    }
-
-    const req = new ClientRequestImpl(url, method)
-    if (method) {
-      options ??= {}
-      const args = deepMerge<ClientRequestOptions>(options, { ...(opts.args[1] ?? {}) })
-      return req.fetch(opts.args[0], args)
-    }
-    return req
-  }, []) as UnionToIntersection<Client<T>>

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

@@ -1,14 +0,0 @@
-/**
- * @module
- * The HTTP Client for Hono.
- */
-
-export { hc } from './client'
-export type {
-  InferResponseType,
-  InferRequestType,
-  Fetch,
-  ClientRequestOptions,
-  ClientRequest,
-  ClientResponse,
-} from './types'