bluera-knowledge 0.9.21

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

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

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

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

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

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

@@ -0,0 +1,96 @@
+/**
+ * @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())
+    }
+  }
+}