acrylblends 0.2.0 → 0.4.0

package/plugins/acryl-node-server/src/adapter/response.ts

@@ -0,0 +1,186 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Define lightweight pseudo Response class and replace global.Response with it.
+
+import type { OutgoingHttpHeaders } from 'node:http'
+
+export const defaultContentType = 'text/plain; charset=UTF-8'
+
+const responseCache = Symbol('responseCache')
+const getResponseCache = Symbol('getResponseCache')
+export const cacheKey = Symbol('cache')
+
+export type InternalCache = [
+  number,
+  string | ReadableStream | null,
+  Record<string, string> | [string, string][] | Headers | OutgoingHttpHeaders | undefined,
+]
+interface LightResponse {
+  [responseCache]?: globalThis.Response
+  [cacheKey]?: InternalCache
+}
+
+export const GlobalResponse = global.Response
+export class Response {
+  #body?: BodyInit | null
+  #init?: ResponseInit;
+
+  [getResponseCache](): globalThis.Response {
+    // If `cacheKey` has been populated with a live `Headers` instance, the
+    // user (or middleware) may have mutated it after construction. Use those
+    // headers so the GlobalResponse reflects the current state.
+    const cache = (this as LightResponse)[cacheKey]
+    const liveHeaders = cache && cache[2] instanceof Headers ? cache[2] : undefined
+    delete (this as LightResponse)[cacheKey]
+    return ((this as LightResponse)[responseCache] ||= new GlobalResponse(
+      this.#body,
+      liveHeaders
+        ? {
+            status: this.#init?.status,
+            statusText: this.#init?.statusText,
+            headers: liveHeaders,
+          }
+        : this.#init
+    ))
+  }
+
+  constructor(body?: BodyInit | null, init?: ResponseInit) {
+    let headers: HeadersInit | undefined
+    this.#body = body
+    if (init instanceof GlobalResponse) {
+      const cachedGlobalResponse = (init as any)[responseCache]
+      if (cachedGlobalResponse) {
+        this.#init = cachedGlobalResponse
+        // instantiate GlobalResponse cache and this object always returns value from global.Response
+        this[getResponseCache]()
+        return
+      }
+      this.#init = init instanceof Response ? init.#init : init
+      headers = new Headers(init.headers)
+    } else {
+      this.#init = init
+    }
+
+    if (
+      body == null ||
+      typeof body === 'string' ||
+      typeof (body as ReadableStream)?.getReader !== 'undefined' ||
+      body instanceof Blob ||
+      body instanceof Uint8Array
+    ) {
+      ;(this as any)[cacheKey] = [init?.status || 200, body ?? null, headers || init?.headers]
+    }
+  }
+
+  get headers(): Headers {
+    const cache = (this as LightResponse)[cacheKey] as InternalCache
+    if (cache) {
+      if (!(cache[2] instanceof Headers)) {
+        cache[2] = new Headers(
+          (cache[2] ||
+            (cache[1] === null ? undefined : { 'content-type': defaultContentType })) as HeadersInit
+        )
+      }
+      return cache[2]
+    }
+    return this[getResponseCache]().headers
+  }
+
+  get status() {
+    return (
+      ((this as LightResponse)[cacheKey] as InternalCache | undefined)?.[0] ??
+      this[getResponseCache]().status
+    )
+  }
+
+  get ok() {
+    const status = this.status
+    return status >= 200 && status < 300
+  }
+}
+;['body', 'bodyUsed', 'redirected', 'statusText', 'trailers', 'type', 'url'].forEach((k) => {
+  Object.defineProperty(Response.prototype, k, {
+    get() {
+      return this[getResponseCache]()[k]
+    },
+  })
+})
+;['arrayBuffer', 'blob', 'clone', 'formData', 'json', 'text'].forEach((k) => {
+  Object.defineProperty(Response.prototype, k, {
+    value: function () {
+      return this[getResponseCache]()[k]()
+    },
+  })
+})
+
+Object.defineProperty(Response.prototype, Symbol.for('nodejs.util.inspect.custom'), {
+  value: function (depth: number, options: object, inspectFn: Function) {
+    const props: Record<string, unknown> = {
+      status: this.status,
+      headers: this.headers,
+      ok: this.ok,
+      nativeResponse: (this as LightResponse)[responseCache],
+    }
+    return `Response (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`
+  },
+})
+
+Object.setPrototypeOf(Response, GlobalResponse)
+Object.setPrototypeOf(Response.prototype, GlobalResponse.prototype)
+
+// Fast path regex: matches http:// or https:// followed by RFC 3986 allowed chars.
+// Character class covers unreserved + reserved chars plus `%` for percent-encoding.
+// !  #-;  =  ?-[  ]  _  a-z  ~  A-Z (A-Z is within ?-[ range but listed for clarity)
+const validRedirectUrl = /^https?:\/\/[!#-;=?-[\]_a-z~A-Z]+$/
+const parseRedirectUrl = (url: string | URL): string => {
+  if (url instanceof URL) {
+    return url.href
+  }
+  if (validRedirectUrl.test(url)) {
+    return url
+  }
+  return new URL(url).href
+}
+
+const validRedirectStatuses = new Set([301, 302, 303, 307, 308])
+
+// Override Response.json() and Response.redirect() to return a LightweightResponse
+// so the listener fast-path (cacheKey check) is hit instead of falling through to ReadableStream reading.
+Object.defineProperty(Response, 'redirect', {
+  value: function redirect(url: string | URL, status = 302): Response {
+    if (!validRedirectStatuses.has(status)) {
+      throw new RangeError('Invalid status code')
+    }
+    return new Response(null, {
+      status,
+      headers: { location: parseRedirectUrl(url) },
+    })
+  },
+  writable: true,
+  configurable: true,
+})
+
+Object.defineProperty(Response, 'json', {
+  value: function json(data?: unknown, init?: ResponseInit): Response {
+    const body = JSON.stringify(data)
+    if (body === undefined) {
+      throw new TypeError('The data is not JSON serializable')
+    }
+    const initHeaders = init?.headers
+    let headers: Record<string, string> | Headers
+    if (initHeaders) {
+      headers = new Headers(initHeaders)
+      if (!headers.has('content-type')) {
+        headers.set('content-type', 'application/json')
+      }
+    } else {
+      headers = { 'content-type': 'application/json' }
+    }
+    return new Response(body, {
+      status: init?.status ?? 200,
+      statusText: init?.statusText,
+      headers,
+    })
+  },
+  writable: true,
+  configurable: true,
+})

package/plugins/acryl-node-server/src/adapter/serve-static.ts

@@ -0,0 +1,238 @@
+import type { Context, Env, MiddlewareHandler } from '../../../acryl-router/src/index.ts'
+import { getMimeType } from '../../../acryl-router/src/helpers/index.ts'
+import type { Stats } from 'node:fs'
+import { createReadStream, statSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { createStreamBody } from './utils/stream.ts'
+
+export type ServeStaticOptions<E extends Env = Env> = {
+  /**
+   * Root path. Relative path is based on current working directory from which the app was started.
+   */
+  root?: string
+  path?: string
+  index?: string // default is 'index.html'
+  precompressed?: boolean
+  /** Allow percent signs in the routed request path. Defaults to false. */
+  allowPercentInPath?: boolean
+  rewriteRequestPath?: (path: string, c: Context<E>) => string
+  onFound?: (path: string, c: Context<E>) => void | Promise<void>
+  onNotFound?: (path: string, c: Context<E>) => void | Promise<void>
+}
+
+const COMPRESSIBLE_CONTENT_TYPE_REGEX =
+  /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i
+const ENCODINGS = {
+  br: '.br',
+  zstd: '.zst',
+  gzip: '.gz',
+} as const
+const ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS) as (keyof typeof ENCODINGS)[]
+
+const getStats = (path: string) => {
+  let stats: Stats | undefined
+  try {
+    stats = statSync(path)
+  } catch {}
+  return stats
+}
+
+type ByteRangeSpec =
+  | { type: 'bounded'; start: number; end: number }
+  | { type: 'open-ended'; start: number }
+  | { type: 'suffix'; length: number }
+
+type ByteRange = { start: number; end: number }
+
+const BYTE_RANGE_PATTERN = /^(?:bytes=)?(?!-$)(\d*)-(\d*)$/
+
+const parseByteRange = (range: string): ByteRangeSpec | undefined => {
+  const match = range.match(BYTE_RANGE_PATTERN)
+  if (!match) {
+    return undefined
+  }
+
+  const [, start, end] = match
+
+  if (start === '') {
+    return { type: 'suffix', length: Number(end) }
+  }
+
+  if (end === '') {
+    return { type: 'open-ended', start: Number(start) }
+  }
+
+  return { type: 'bounded', start: Number(start), end: Number(end) }
+}
+
+const resolveByteRange = (spec: ByteRangeSpec, size: number): ByteRange | undefined => {
+  if (size === 0) {
+    return undefined
+  }
+
+  if (spec.type === 'suffix') {
+    if (spec.length === 0) {
+      return undefined
+    }
+
+    return { start: Math.max(size - spec.length, 0), end: size - 1 }
+  }
+
+  const end = spec.type === 'bounded' ? Math.min(spec.end, size - 1) : size - 1
+  if (spec.start >= size || spec.start > end) {
+    return undefined
+  }
+
+  return { start: spec.start, end }
+}
+
+type Decoder = (str: string) => string
+
+const tryDecode = (str: string, decoder: Decoder): string => {
+  try {
+    return decoder(str)
+  } catch {
+    // Decode only valid %xx sequences in chunks; keep undecodable parts as-is
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+      try {
+        return decoder(match)
+      } catch {
+        return match
+      }
+    })
+  }
+}
+
+const tryDecodeURI = (str: string) => tryDecode(str, decodeURI)
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const serveStatic = <E extends Env = any>(
+  options: ServeStaticOptions<E> = { root: '' }
+): MiddlewareHandler<E> => {
+  const root = options.root || ''
+  const optionPath = options.path
+
+  if (root !== '' && !existsSync(root)) {
+    console.error(`serveStatic: root path '${root}' is not found, are you sure it's correct?`)
+  }
+
+  return async (c, next) => {
+    // Do nothing if Response is already set
+    if (c.finalized) {
+      return next()
+    }
+
+    if (c.req.method !== 'GET' && c.req.method !== 'HEAD') {
+      return next()
+    }
+
+    let filename: string
+
+    if (optionPath) {
+      filename = optionPath
+    } else {
+      try {
+        if (!options.allowPercentInPath && c.req.path.includes('%')) {
+          throw new Error()
+        }
+        filename = tryDecodeURI(c.req.path)
+        if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}|\\/.test(filename)) {
+          throw new Error()
+        }
+      } catch {
+        await options.onNotFound?.(c.req.path, c)
+        return next()
+      }
+    }
+
+    let path = join(
+      root,
+      !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
+    )
+
+    let stats = getStats(path)
+
+    if (stats && stats.isDirectory()) {
+      const indexFile = options.index ?? 'index.html'
+      path = join(path, indexFile)
+      stats = getStats(path)
+    }
+
+    if (!stats) {
+      await options.onNotFound?.(path, c)
+      return next()
+    }
+
+    const mimeType = getMimeType(path)
+    c.header('Content-Type', mimeType || 'application/octet-stream')
+
+    if (
+      options.precompressed &&
+      (!mimeType ||
+        mimeType === 'application/octet-stream' ||
+        COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))
+    ) {
+      const acceptEncodingSet = new Set(
+        c.req
+          .header('Accept-Encoding')
+          ?.split(',')
+          .map((encoding) => encoding.trim())
+      )
+
+      for (const encoding of ENCODINGS_ORDERED_KEYS) {
+        if (!acceptEncodingSet.has(encoding)) {
+          continue
+        }
+        const precompressedStats = getStats(path + ENCODINGS[encoding])
+        if (precompressedStats) {
+          c.header('Content-Encoding', encoding)
+          c.header('Vary', 'Accept-Encoding', { append: true })
+          stats = precompressedStats
+          path = path + ENCODINGS[encoding]
+          break
+        }
+      }
+    }
+
+    let result
+    const size = stats.size
+    const range = c.req.header('range') || ''
+    c.header('Last-Modified', stats.mtime.toUTCString())
+
+    if (c.req.method === 'HEAD') {
+      c.header('Content-Length', size.toString())
+      c.status(200)
+      result = c.body(null)
+    } else if (!range) {
+      c.header('Content-Length', size.toString())
+      result = c.body(createStreamBody(createReadStream(path)), 200)
+    } else {
+      c.header('Accept-Ranges', 'bytes')
+
+      // Preserve the existing behavior of serving the whole representation for
+      // a malformed range.
+      const rangeSpec: ByteRangeSpec = parseByteRange(range) ?? {
+        type: 'open-ended',
+        start: 0,
+      }
+      const resolvedRange = resolveByteRange(rangeSpec, size)
+
+      if (!resolvedRange) {
+        c.header('Content-Range', `bytes */${size}`)
+        result = c.body(null, 416)
+      } else {
+        const { start, end } = resolvedRange
+        const chunkSize = end - start + 1
+        const stream = createReadStream(path, { start, end })
+
+        c.header('Content-Length', chunkSize.toString())
+        c.header('Content-Range', `bytes ${start}-${end}/${size}`)
+
+        result = c.body(createStreamBody(stream), 206)
+      }
+    }
+
+    await options.onFound?.(path, c)
+    return result
+  }
+}

package/plugins/acryl-node-server/src/adapter/server.ts

@@ -0,0 +1,36 @@
+import { createServer as createServerHTTP } from 'node:http'
+import type { AddressInfo } from 'node:net'
+import { getRequestListener } from './listener.ts'
+import type { Options, ServerType } from './types.ts'
+import { setupWebSocket } from './websocket.ts'
+
+export const createAdaptorServer = (options: Options): ServerType => {
+  const fetchCallback = options.fetch
+  const requestListener = getRequestListener(fetchCallback, {
+    hostname: options.hostname,
+    overrideGlobalObjects: options.overrideGlobalObjects,
+    autoCleanupIncoming: options.autoCleanupIncoming,
+  })
+  // ts will complain about createServerHTTP and createServerHTTP2 not being callable, which works just fine
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const createServer: any = options.createServer || createServerHTTP
+  const server: ServerType = createServer(options.serverOptions || {}, requestListener)
+  if (options.websocket && options.websocket.server) {
+    if (options.websocket.server.options.noServer !== true)
+      throw new Error('WebSocket server must be created with { noServer: true } option')
+    setupWebSocket({ server, fetchCallback, wss: options.websocket.server })
+  }
+  return server
+}
+
+export const serve = (
+  options: Options,
+  listeningListener?: (info: AddressInfo) => void
+): ServerType => {
+  const server = createAdaptorServer(options)
+  server.listen(options?.port ?? 3000, options.hostname, () => {
+    const serverInfo = server.address() as AddressInfo
+    listeningListener && listeningListener(serverInfo)
+  })
+  return server
+}

package/plugins/acryl-node-server/src/adapter/types.ts

@@ -0,0 +1,82 @@
+import type {
+  createServer,
+  IncomingMessage,
+  Server,
+  ServerOptions as HttpServerOptions,
+  ServerResponse as HttpServerResponse,
+} from 'node:http'
+import type {
+  createSecureServer as createSecureHttp2Server,
+  createServer as createHttp2Server,
+  Http2ServerRequest,
+  Http2Server,
+  Http2ServerResponse,
+  Http2SecureServer,
+  SecureServerOptions as SecureHttp2ServerOptions,
+  ServerOptions as Http2ServerOptions,
+} from 'node:http2'
+import type {
+  createServer as createHttpsServer,
+  ServerOptions as HttpsServerOptions,
+} from 'node:https'
+import type { WebSocketServerLike } from './websocket-types.ts'
+
+export type HttpBindings = {
+  incoming: IncomingMessage
+  outgoing: HttpServerResponse
+}
+
+export type Http2Bindings = {
+  incoming: Http2ServerRequest
+  outgoing: Http2ServerResponse
+}
+
+export type FetchCallback = (
+  request: Request,
+  env: HttpBindings | Http2Bindings
+) => Promise<unknown> | unknown
+
+export type NextHandlerOption = {
+  fetch: FetchCallback
+}
+
+export type ServerType = Server | Http2Server | Http2SecureServer
+
+type createHttpOptions = {
+  serverOptions?: HttpServerOptions
+  createServer?: typeof createServer
+}
+
+type createHttpsOptions = {
+  serverOptions?: HttpsServerOptions
+  createServer?: typeof createHttpsServer
+}
+
+type createHttp2Options = {
+  serverOptions?: Http2ServerOptions
+  createServer?: typeof createHttp2Server
+}
+
+type createSecureHttp2Options = {
+  serverOptions?: SecureHttp2ServerOptions
+  createServer?: typeof createSecureHttp2Server
+}
+
+export type ServerOptions =
+  | createHttpOptions
+  | createHttpsOptions
+  | createHttp2Options
+  | createSecureHttp2Options
+
+export type Options = {
+  fetch: FetchCallback
+  overrideGlobalObjects?: boolean
+  autoCleanupIncoming?: boolean
+  port?: number
+  hostname?: string
+  websocket?: {
+    server: WebSocketServerLike
+  }
+} & ServerOptions
+
+export type CustomErrorHandler = (err: unknown) => void | Response | Promise<void | Response>

package/plugins/acryl-node-server/src/adapter/url.ts

@@ -0,0 +1,42 @@
+import { RequestError } from './error.ts'
+
+// Fast-path character validation for request URLs.
+// Matches: ! # $ & ' ( ) * + , - . / 0-9 : ; = ? @ A-Z [ ] _ a-z ~
+// Rejects: control chars, space, " % < > \ ^ ` { | } DEL, non-ASCII → fallback to new URL()
+const reValidRequestUrl = /^\/[!#$&-;=?-\[\]_a-z~]*$/
+
+// Dot segments: /. or /.. followed by / ? # or end-of-string
+const reDotSegment = /\/\.\.?(?:[/?#]|$)/
+
+// Host validation: a-z 0-9 . - _ with optional port 1000-59999
+const reValidHost = /^[a-z0-9._-]+(?::(?:[1-5]\d{3,4}|[6-9]\d{3}))?$/
+
+export const buildUrl = (scheme: string, host: string, incomingUrl: string) => {
+  const url = `${scheme}://${host}${incomingUrl}`
+
+  if (!reValidHost.test(host)) {
+    const urlObj = new URL(url)
+
+    // if suspicious, check by host. host header sometimes contains port.
+    if (
+      urlObj.hostname.length !== host.length &&
+      urlObj.hostname !== (host.includes(':') ? host.replace(/:\d+$/, '') : host).toLowerCase()
+    ) {
+      throw new RequestError('Invalid host header')
+    }
+    return urlObj.href
+  } else if (incomingUrl.length === 0) {
+    return url + '/'
+  } else {
+    if (incomingUrl.charCodeAt(0) !== 0x2f) {
+      // '/'
+      throw new RequestError('Invalid URL')
+    }
+
+    if (!reValidRequestUrl.test(incomingUrl) || reDotSegment.test(incomingUrl)) {
+      return new URL(url).href
+    }
+
+    return url
+  }
+}

package/plugins/acryl-node-server/src/adapter/utils/response/constants.ts

@@ -0,0 +1 @@
+export const X_ALREADY_SENT = 'x-acryl-already-sent'

package/plugins/acryl-node-server/src/adapter/utils/response.ts

@@ -0,0 +1,4 @@
+import { X_ALREADY_SENT } from './response/constants.ts'
+export const RESPONSE_ALREADY_SENT = new Response(null, {
+  headers: { [X_ALREADY_SENT]: 'true' },
+})

package/plugins/acryl-node-server/src/adapter/utils/stream.ts

@@ -0,0 +1,88 @@
+import type { ReadStream } from 'node:fs'
+import { versions } from 'node:process'
+import { Readable } from 'node:stream'
+
+// In Node.js versions that do not have the following PR applied, using Readable.toWeb may cause unexpected exceptions.
+// https://github.com/nodejs/node/pull/54206
+const pr54206Applied = () => {
+  const [major, minor] = versions.node.split('.').map((component) => parseInt(component))
+  return major >= 23 || (major === 22 && minor >= 7) || (major === 20 && minor >= 18)
+}
+const useReadableToWeb = pr54206Applied()
+
+export const createStreamBody = (
+  stream: ReadStream,
+  useNativeReadableToWeb = useReadableToWeb
+): ReadableStream<Uint8Array> => {
+  if (useNativeReadableToWeb) {
+    return Readable.toWeb(stream) as ReadableStream<Uint8Array>
+  }
+
+  let controller: ReadableStreamDefaultController<Uint8Array> | undefined
+  let settled = false
+
+  const cleanup = () => {
+    stream.off('data', onData)
+    stream.off('error', onError)
+    stream.off('end', onTerminate)
+    stream.off('close', onTerminate)
+  }
+
+  const settle = (callback?: () => void) => {
+    if (settled) {
+      return
+    }
+    settled = true
+    cleanup()
+    callback?.()
+  }
+
+  const onData = (chunk: Buffer | string) => {
+    if (settled || !controller) {
+      return
+    }
+    // createReadStream is called without `encoding`, so chunks are always Buffer.
+    controller.enqueue(chunk as Buffer)
+    if ((controller.desiredSize ?? 0) <= 0) {
+      stream.pause()
+    }
+  }
+
+  const onError = (error: Error) => {
+    settle(() => {
+      controller?.error(error)
+    })
+  }
+
+  const onTerminate = () => {
+    settle(() => {
+      controller?.close()
+    })
+  }
+
+  return new ReadableStream<Uint8Array>({
+    start(streamController) {
+      controller = streamController
+      stream.on('data', onData)
+      stream.on('error', onError)
+      stream.on('end', onTerminate)
+      stream.on('close', onTerminate)
+      stream.pause()
+    },
+
+    pull() {
+      if (!settled) {
+        stream.resume()
+      }
+    },
+
+    cancel() {
+      settle()
+      // Suppress late `error` emitted between destroy() and the terminal `close`.
+      const ignoreError = () => {}
+      stream.on('error', ignoreError)
+      stream.once('close', () => stream.off('error', ignoreError))
+      stream.destroy()
+    },
+  })
+}