bluera-knowledge 0.14.0 → 0.14.2

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

@@ -1,226 +0,0 @@
-/**
- * @module
- * JSON Web Signature (JWS)
- * https://datatracker.ietf.org/doc/html/rfc7515
- */
-
-import { getRuntimeKey } from '../../helper/adapter'
-import { decodeBase64 } from '../encode'
-import type { SignatureAlgorithm } from './jwa'
-import { CryptoKeyUsage, JwtAlgorithmNotImplemented } from './types'
-import { utf8Encoder } from './utf8'
-
-type KeyImporterAlgorithm = Parameters<typeof crypto.subtle.importKey>[2]
-type KeyAlgorithm =
-  | AlgorithmIdentifier
-  | RsaHashedImportParams
-  | (RsaPssParams & RsaHashedImportParams)
-  | (EcdsaParams & EcKeyImportParams)
-  | HmacImportParams
-
-export type SignatureKey = string | JsonWebKey | CryptoKey
-
-export async function signing(
-  privateKey: SignatureKey,
-  alg: SignatureAlgorithm,
-  data: BufferSource
-): Promise<ArrayBuffer> {
-  const algorithm = getKeyAlgorithm(alg)
-  const cryptoKey = await importPrivateKey(privateKey, algorithm)
-  return await crypto.subtle.sign(algorithm, cryptoKey, data)
-}
-
-export async function verifying(
-  publicKey: SignatureKey,
-  alg: SignatureAlgorithm,
-  signature: BufferSource,
-  data: BufferSource
-): Promise<boolean> {
-  const algorithm = getKeyAlgorithm(alg)
-  const cryptoKey = await importPublicKey(publicKey, algorithm)
-  return await crypto.subtle.verify(algorithm, cryptoKey, signature, data)
-}
-
-function pemToBinary(pem: string): Uint8Array {
-  return decodeBase64(pem.replace(/-+(BEGIN|END).*/g, '').replace(/\s/g, ''))
-}
-
-async function importPrivateKey(key: SignatureKey, alg: KeyImporterAlgorithm): Promise<CryptoKey> {
-  if (!crypto.subtle || !crypto.subtle.importKey) {
-    throw new Error('`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.')
-  }
-  if (isCryptoKey(key)) {
-    if (key.type !== 'private') {
-      throw new Error(`unexpected non private key: CryptoKey.type is ${key.type}`)
-    }
-    return key
-  }
-  const usages = [CryptoKeyUsage.Sign]
-  if (typeof key === 'object') {
-    // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey#json_web_key_import
-    return await crypto.subtle.importKey('jwk', key, alg, false, usages)
-  }
-  if (key.includes('PRIVATE')) {
-    // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey#pkcs_8_import
-    return await crypto.subtle.importKey('pkcs8', pemToBinary(key), alg, false, usages)
-  }
-  return await crypto.subtle.importKey('raw', utf8Encoder.encode(key), alg, false, usages)
-}
-
-async function importPublicKey(key: SignatureKey, alg: KeyImporterAlgorithm): Promise<CryptoKey> {
-  if (!crypto.subtle || !crypto.subtle.importKey) {
-    throw new Error('`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.')
-  }
-  if (isCryptoKey(key)) {
-    if (key.type === 'public' || key.type === 'secret') {
-      return key
-    }
-    key = await exportPublicJwkFrom(key)
-  }
-  if (typeof key === 'string' && key.includes('PRIVATE')) {
-    // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey#pkcs_8_import
-    const privateKey = await crypto.subtle.importKey('pkcs8', pemToBinary(key), alg, true, [
-      CryptoKeyUsage.Sign,
-    ])
-    key = await exportPublicJwkFrom(privateKey)
-  }
-  const usages = [CryptoKeyUsage.Verify]
-  if (typeof key === 'object') {
-    // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey#json_web_key_import
-    return await crypto.subtle.importKey('jwk', key, alg, false, usages)
-  }
-  if (key.includes('PUBLIC')) {
-    // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey#subjectpublickeyinfo_import
-    return await crypto.subtle.importKey('spki', pemToBinary(key), alg, false, usages)
-  }
-  return await crypto.subtle.importKey('raw', utf8Encoder.encode(key), alg, false, usages)
-}
-
-// https://datatracker.ietf.org/doc/html/rfc7517
-async function exportPublicJwkFrom(privateKey: CryptoKey): Promise<JsonWebKey> {
-  if (privateKey.type !== 'private') {
-    throw new Error(`unexpected key type: ${privateKey.type}`)
-  }
-  if (!privateKey.extractable) {
-    throw new Error('unexpected private key is unextractable')
-  }
-  const jwk = await crypto.subtle.exportKey('jwk', privateKey)
-  const { kty } = jwk // common
-  const { alg, e, n } = jwk // rsa
-  const { crv, x, y } = jwk // elliptic-curve
-  return { kty, alg, e, n, crv, x, y, key_ops: [CryptoKeyUsage.Verify] }
-}
-
-function getKeyAlgorithm(name: SignatureAlgorithm): KeyAlgorithm {
-  switch (name) {
-    case 'HS256':
-      return {
-        name: 'HMAC',
-        hash: {
-          name: 'SHA-256',
-        },
-      } satisfies HmacImportParams
-    case 'HS384':
-      return {
-        name: 'HMAC',
-        hash: {
-          name: 'SHA-384',
-        },
-      } satisfies HmacImportParams
-    case 'HS512':
-      return {
-        name: 'HMAC',
-        hash: {
-          name: 'SHA-512',
-        },
-      } satisfies HmacImportParams
-    case 'RS256':
-      return {
-        name: 'RSASSA-PKCS1-v1_5',
-        hash: {
-          name: 'SHA-256',
-        },
-      } satisfies RsaHashedImportParams
-    case 'RS384':
-      return {
-        name: 'RSASSA-PKCS1-v1_5',
-        hash: {
-          name: 'SHA-384',
-        },
-      } satisfies RsaHashedImportParams
-    case 'RS512':
-      return {
-        name: 'RSASSA-PKCS1-v1_5',
-        hash: {
-          name: 'SHA-512',
-        },
-      } satisfies RsaHashedImportParams
-    case 'PS256':
-      return {
-        name: 'RSA-PSS',
-        hash: {
-          name: 'SHA-256',
-        },
-        saltLength: 32, // 256 >> 3
-      } satisfies RsaPssParams & RsaHashedImportParams
-    case 'PS384':
-      return {
-        name: 'RSA-PSS',
-        hash: {
-          name: 'SHA-384',
-        },
-        saltLength: 48, // 384 >> 3
-      } satisfies RsaPssParams & RsaHashedImportParams
-    case 'PS512':
-      return {
-        name: 'RSA-PSS',
-        hash: {
-          name: 'SHA-512',
-        },
-        saltLength: 64, // 512 >> 3,
-      } satisfies RsaPssParams & RsaHashedImportParams
-    case 'ES256':
-      return {
-        name: 'ECDSA',
-        hash: {
-          name: 'SHA-256',
-        },
-        namedCurve: 'P-256',
-      } satisfies EcdsaParams & EcKeyImportParams
-    case 'ES384':
-      return {
-        name: 'ECDSA',
-        hash: {
-          name: 'SHA-384',
-        },
-        namedCurve: 'P-384',
-      } satisfies EcdsaParams & EcKeyImportParams
-    case 'ES512':
-      return {
-        name: 'ECDSA',
-        hash: {
-          name: 'SHA-512',
-        },
-        namedCurve: 'P-521',
-      } satisfies EcdsaParams & EcKeyImportParams
-    case 'EdDSA':
-      // Currently, supported only Safari and Deno, Node.js.
-      // See: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/verify
-      return {
-        name: 'Ed25519',
-        namedCurve: 'Ed25519',
-      }
-    default:
-      throw new JwtAlgorithmNotImplemented(name)
-  }
-}
-
-function isCryptoKey(key: SignatureKey): key is CryptoKey {
-  const runtime = getRuntimeKey()
-  // @ts-expect-error CryptoKey hasn't exported to global in node v18
-  if (runtime === 'node' && !!crypto.webcrypto) {
-    // @ts-expect-error CryptoKey hasn't exported to global in node v18
-    return key instanceof crypto.webcrypto.CryptoKey
-  }
-  return key instanceof CryptoKey
-}

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

@@ -1,114 +0,0 @@
-/**
- * @module
- * JSON Web Token (JWT)
- * https://datatracker.ietf.org/doc/html/rfc7519
- */
-
-import { decodeBase64Url, encodeBase64Url } from '../../utils/encode'
-import { AlgorithmTypes } from './jwa'
-import type { SignatureAlgorithm } from './jwa'
-import { signing, verifying } from './jws'
-import type { SignatureKey } from './jws'
-import {
-  JwtHeaderInvalid,
-  JwtTokenExpired,
-  JwtTokenInvalid,
-  JwtTokenIssuedAt,
-  JwtTokenNotBefore,
-  JwtTokenSignatureMismatched,
-} from './types'
-import type { JWTPayload } from './types'
-import { utf8Decoder, utf8Encoder } from './utf8'
-
-const encodeJwtPart = (part: unknown): string =>
-  encodeBase64Url(utf8Encoder.encode(JSON.stringify(part))).replace(/=/g, '')
-const encodeSignaturePart = (buf: ArrayBufferLike): string => encodeBase64Url(buf).replace(/=/g, '')
-
-const decodeJwtPart = (part: string): TokenHeader | JWTPayload | undefined =>
-  JSON.parse(utf8Decoder.decode(decodeBase64Url(part)))
-
-export interface TokenHeader {
-  alg: SignatureAlgorithm
-  typ?: 'JWT'
-}
-
-export function isTokenHeader(obj: unknown): obj is TokenHeader {
-  if (typeof obj === 'object' && obj !== null) {
-    const objWithAlg = obj as { [key: string]: unknown }
-    return (
-      'alg' in objWithAlg &&
-      Object.values(AlgorithmTypes).includes(objWithAlg.alg as AlgorithmTypes) &&
-      (!('typ' in objWithAlg) || objWithAlg.typ === 'JWT')
-    )
-  }
-  return false
-}
-
-export const sign = async (
-  payload: JWTPayload,
-  privateKey: SignatureKey,
-  alg: SignatureAlgorithm = 'HS256'
-): Promise<string> => {
-  const encodedPayload = encodeJwtPart(payload)
-  const encodedHeader = encodeJwtPart({ alg, typ: 'JWT' } satisfies TokenHeader)
-
-  const partialToken = `${encodedHeader}.${encodedPayload}`
-
-  const signaturePart = await signing(privateKey, alg, utf8Encoder.encode(partialToken))
-  const signature = encodeSignaturePart(signaturePart)
-
-  return `${partialToken}.${signature}`
-}
-
-export const verify = async (
-  token: string,
-  publicKey: SignatureKey,
-  alg: SignatureAlgorithm = 'HS256'
-): Promise<JWTPayload> => {
-  const tokenParts = token.split('.')
-  if (tokenParts.length !== 3) {
-    throw new JwtTokenInvalid(token)
-  }
-
-  const { header, payload } = decode(token)
-  if (!isTokenHeader(header)) {
-    throw new JwtHeaderInvalid(header)
-  }
-  const now = Math.floor(Date.now() / 1000)
-  if (payload.nbf && payload.nbf > now) {
-    throw new JwtTokenNotBefore(token)
-  }
-  if (payload.exp && payload.exp <= now) {
-    throw new JwtTokenExpired(token)
-  }
-  if (payload.iat && now < payload.iat) {
-    throw new JwtTokenIssuedAt(now, payload.iat)
-  }
-
-  const headerPayload = token.substring(0, token.lastIndexOf('.'))
-  const verified = await verifying(
-    publicKey,
-    alg,
-    decodeBase64Url(tokenParts[2]),
-    utf8Encoder.encode(headerPayload)
-  )
-  if (!verified) {
-    throw new JwtTokenSignatureMismatched(token)
-  }
-
-  return payload
-}
-
-export const decode = (token: string): { header: TokenHeader; payload: JWTPayload } => {
-  try {
-    const [h, p] = token.split('.')
-    const header = decodeJwtPart(h) as TokenHeader
-    const payload = decodeJwtPart(p) as JWTPayload
-    return {
-      header,
-      payload,
-    }
-  } catch (e) {
-    throw new JwtTokenInvalid(token)
-  }
-}

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

@@ -1,83 +0,0 @@
-/**
- * @module
- * Type definitions for JWT utilities.
- */
-
-export class JwtAlgorithmNotImplemented extends Error {
-  constructor(alg: string) {
-    super(`${alg} is not an implemented algorithm`)
-    this.name = 'JwtAlgorithmNotImplemented'
-  }
-}
-
-export class JwtTokenInvalid extends Error {
-  constructor(token: string) {
-    super(`invalid JWT token: ${token}`)
-    this.name = 'JwtTokenInvalid'
-  }
-}
-
-export class JwtTokenNotBefore extends Error {
-  constructor(token: string) {
-    super(`token (${token}) is being used before it's valid`)
-    this.name = 'JwtTokenNotBefore'
-  }
-}
-
-export class JwtTokenExpired extends Error {
-  constructor(token: string) {
-    super(`token (${token}) expired`)
-    this.name = 'JwtTokenExpired'
-  }
-}
-
-export class JwtTokenIssuedAt extends Error {
-  constructor(currentTimestamp: number, iat: number) {
-    super(`Incorrect "iat" claim must be a older than "${currentTimestamp}" (iat: "${iat}")`)
-    this.name = 'JwtTokenIssuedAt'
-  }
-}
-
-export class JwtHeaderInvalid extends Error {
-  constructor(header: object) {
-    super(`jwt header is invalid: ${JSON.stringify(header)}`)
-    this.name = 'JwtHeaderInvalid'
-  }
-}
-
-export class JwtTokenSignatureMismatched extends Error {
-  constructor(token: string) {
-    super(`token(${token}) signature mismatched`)
-    this.name = 'JwtTokenSignatureMismatched'
-  }
-}
-
-export enum CryptoKeyUsage {
-  Encrypt = 'encrypt',
-  Decrypt = 'decrypt',
-  Sign = 'sign',
-  Verify = 'verify',
-  DeriveKey = 'deriveKey',
-  DeriveBits = 'deriveBits',
-  WrapKey = 'wrapKey',
-  UnwrapKey = 'unwrapKey',
-}
-
-/**
- * JWT Payload
- */
-export type JWTPayload = {
-  [key: string]: unknown
-  /**
-   * The token is checked to ensure it has not expired.
-   */
-  exp?: number
-  /**
-   * The token is checked to ensure it is not being used before a specified time.
-   */
-  nbf?: number
-  /**
-   * The token is checked to ensure it is not issued in the future.
-   */
-  iat?: number
-}

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

@@ -1,7 +0,0 @@
-/**
- * @module
- * Functions for encoding/decoding UTF8.
- */
-
-export const utf8Encoder: TextEncoder = new TextEncoder()
-export const utf8Decoder: TextDecoder = new TextDecoder()

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

@@ -1,142 +0,0 @@
-/**
- * @module
- * MIME utility.
- */
-
-export const getMimeType = (
-  filename: string,
-  mimes: Record<string, string> = baseMimes
-): string | undefined => {
-  const regexp = /\.([a-zA-Z0-9]+?)$/
-  const match = filename.match(regexp)
-  if (!match) {
-    return
-  }
-  let mimeType = mimes[match[1]]
-  if ((mimeType && mimeType.startsWith('text')) || mimeType === 'application/json') {
-    mimeType += '; charset=utf-8'
-  }
-  return mimeType
-}
-
-export const getExtension = (mimeType: string): string | undefined => {
-  for (const ext in baseMimes) {
-    if (baseMimes[ext] === mimeType) {
-      return ext
-    }
-  }
-}
-
-export { baseMimes as mimes }
-
-/**
- * Union types for BaseMime
- */
-export type BaseMime =
-  | 'audio/aac'
-  | 'video/x-msvideo'
-  | 'image/avif'
-  | 'video/av1'
-  | 'application/octet-stream'
-  | 'image/bmp'
-  | 'text/css'
-  | 'text/csv'
-  | 'application/vnd.ms-fontobject'
-  | 'application/epub+zip'
-  | 'image/gif'
-  | 'application/gzip'
-  | 'text/html'
-  | 'image/x-icon'
-  | 'text/calendar'
-  | 'image/jpeg'
-  | 'text/javascript'
-  | 'application/json'
-  | 'application/ld+json'
-  | 'audio/x-midi'
-  | 'audio/mpeg'
-  | 'video/mp4'
-  | 'video/mpeg'
-  | 'audio/ogg'
-  | 'video/ogg'
-  | 'application/ogg'
-  | 'audio/opus'
-  | 'font/otf'
-  | 'application/pdf'
-  | 'image/png'
-  | 'application/rtf'
-  | 'image/svg+xml'
-  | 'image/tiff'
-  | 'video/mp2t'
-  | 'font/ttf'
-  | 'text/plain'
-  | 'application/wasm'
-  | 'video/webm'
-  | 'audio/webm'
-  | 'image/webp'
-  | 'font/woff'
-  | 'font/woff2'
-  | 'application/xhtml+xml'
-  | 'application/xml'
-  | 'application/zip'
-  | 'video/3gpp'
-  | 'video/3gpp2'
-  | 'model/gltf+json'
-  | 'model/gltf-binary'
-
-const baseMimes: Record<string, BaseMime> = {
-  aac: 'audio/aac',
-  avi: 'video/x-msvideo',
-  avif: 'image/avif',
-  av1: 'video/av1',
-  bin: 'application/octet-stream',
-  bmp: 'image/bmp',
-  css: 'text/css',
-  csv: 'text/csv',
-  eot: 'application/vnd.ms-fontobject',
-  epub: 'application/epub+zip',
-  gif: 'image/gif',
-  gz: 'application/gzip',
-  htm: 'text/html',
-  html: 'text/html',
-  ico: 'image/x-icon',
-  ics: 'text/calendar',
-  jpeg: 'image/jpeg',
-  jpg: 'image/jpeg',
-  js: 'text/javascript',
-  json: 'application/json',
-  jsonld: 'application/ld+json',
-  map: 'application/json',
-  mid: 'audio/x-midi',
-  midi: 'audio/x-midi',
-  mjs: 'text/javascript',
-  mp3: 'audio/mpeg',
-  mp4: 'video/mp4',
-  mpeg: 'video/mpeg',
-  oga: 'audio/ogg',
-  ogv: 'video/ogg',
-  ogx: 'application/ogg',
-  opus: 'audio/opus',
-  otf: 'font/otf',
-  pdf: 'application/pdf',
-  png: 'image/png',
-  rtf: 'application/rtf',
-  svg: 'image/svg+xml',
-  tif: 'image/tiff',
-  tiff: 'image/tiff',
-  ts: 'video/mp2t',
-  ttf: 'font/ttf',
-  txt: 'text/plain',
-  wasm: 'application/wasm',
-  webm: 'video/webm',
-  weba: 'audio/webm',
-  webp: 'image/webp',
-  woff: 'font/woff',
-  woff2: 'font/woff2',
-  xhtml: 'application/xhtml+xml',
-  xml: 'application/xml',
-  zip: 'application/zip',
-  '3gp': 'video/3gpp',
-  '3g2': 'video/3gpp2',
-  gltf: 'model/gltf+json',
-  glb: 'model/gltf-binary',
-}

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

@@ -1,96 +0,0 @@
-/**
- * @module
- * Stream utility.
- */
-
-export class StreamingApi {
-  private writer: WritableStreamDefaultWriter<Uint8Array>
-  private encoder: TextEncoder
-  private writable: WritableStream
-  private abortSubscribers: (() => void | Promise<void>)[] = []
-  responseReadable: ReadableStream
-  /**
-   * Whether the stream has been aborted.
-   */
-  aborted: boolean = false
-  /**
-   * Whether the stream has been closed normally.
-   */
-  closed: boolean = false
-
-  constructor(writable: WritableStream, _readable: ReadableStream) {
-    this.writable = writable
-    this.writer = writable.getWriter()
-    this.encoder = new TextEncoder()
-
-    const reader = _readable.getReader()
-
-    // in case the user disconnects, let the reader know to cancel
-    // this in-turn results in responseReadable being closed
-    // and writeSSE method no longer blocks indefinitely
-    this.abortSubscribers.push(async () => {
-      await reader.cancel()
-    })
-
-    this.responseReadable = new ReadableStream({
-      async pull(controller) {
-        const { done, value } = await reader.read()
-        done ? controller.close() : controller.enqueue(value)
-      },
-      cancel: () => {
-        this.abort()
-      },
-    })
-  }
-
-  async write(input: Uint8Array | string): Promise<StreamingApi> {
-    try {
-      if (typeof input === 'string') {
-        input = this.encoder.encode(input)
-      }
-      await this.writer.write(input)
-    } catch (e) {
-      // Do nothing. If you want to handle errors, create a stream by yourself.
-    }
-    return this
-  }
-
-  async writeln(input: string): Promise<StreamingApi> {
-    await this.write(input + '\n')
-    return this
-  }
-
-  sleep(ms: number): Promise<unknown> {
-    return new Promise((res) => setTimeout(res, ms))
-  }
-
-  async close() {
-    try {
-      await this.writer.close()
-    } catch (e) {
-      // Do nothing. If you want to handle errors, create a stream by yourself.
-    }
-    this.closed = true
-  }
-
-  async pipe(body: ReadableStream) {
-    this.writer.releaseLock()
-    await body.pipeTo(this.writable, { preventClose: true })
-    this.writer = this.writable.getWriter()
-  }
-
-  onAbort(listener: () => void | Promise<void>) {
-    this.abortSubscribers.push(listener)
-  }
-
-  /**
-   * Abort the stream.
-   * You can call this method when stream is aborted by external event.
-   */
-  abort() {
-    if (!this.aborted) {
-      this.aborted = true
-      this.abortSubscribers.forEach((subscriber) => subscriber())
-    }
-  }
-}