weifuwu 0.25.2 → 0.27.0

package/core/router.ts

@@ -0,0 +1,795 @@
+/* eslint-disable no-console */
+import { WebSocketServer } from 'ws'
+import type {
+  WebSocket,
+  Context,
+  Handler,
+  Middleware,
+  MiddlewareMeta,
+  ErrorHandler,
+} from '../types.ts'
+import http, { type IncomingMessage } from 'node:http'
+import type { Duplex } from 'node:stream'
+import { createHub, type Hub } from '../hub.ts'
+
+import { isProd } from './env.ts'
+
+export type WebSocketHandler = {
+  open?: (ws: WebSocket, ctx: Context) => void | Promise<void>
+  message?: (ws: WebSocket, ctx: Context, data: string | Buffer) => void | Promise<void>
+  close?: (ws: WebSocket, ctx: Context) => void | Promise<void>
+  error?: (ws: WebSocket, ctx: Context, error: Error) => void | Promise<void>
+}
+
+type TrieNode = {
+  children: Map<string, TrieNode>
+  handlers: Map<string, Handler>
+  middlewares: Map<string, Middleware[]>
+  param?: string
+  wildcard?: boolean
+  pathMws: Middleware[]
+}
+
+type WsTrieNode = {
+  children: Map<string, WsTrieNode>
+  handler?: WebSocketHandler
+  middlewares: Middleware[]
+  param?: string
+  wildcard?: boolean
+}
+
+const createTrieNode = (): TrieNode => ({
+  children: new Map(),
+  handlers: new Map(),
+  middlewares: new Map(),
+  pathMws: [],
+})
+
+const createWsNode = (): WsTrieNode => ({
+  children: new Map(),
+  middlewares: [],
+})
+
+interface TrieNodeBase<T> {
+  children: Map<string, T>
+  param?: string
+  wildcard?: boolean
+}
+
+function createParamChild<T extends TrieNodeBase<T>>(
+  node: T,
+  segment: string,
+  createNode: () => T,
+): T {
+  const paramName = segment.slice(1)
+  if (!node.children.has(':')) {
+    const child = createNode()
+    child.param = paramName
+    node.children.set(':', child)
+  }
+  const child = node.children.get(':')!
+  if (child.param !== paramName) {
+    throw new Error(
+      `Param name conflict: ":${child.param}" already registered, cannot register ":"${paramName}"`,
+    )
+  }
+  return child
+}
+
+function getOrCreateChild<T extends TrieNodeBase<T>>(
+  node: T,
+  segment: string,
+  createNode: () => T,
+  allowWildcard: boolean,
+): T {
+  if (allowWildcard && segment === '*') {
+    node.wildcard = true
+    return node
+  }
+  if (segment.startsWith(':')) return createParamChild(node, segment, createNode)
+  if (!node.children.has(segment)) node.children.set(segment, createNode())
+  return node.children.get(segment)!
+}
+
+function matchChild<T extends TrieNodeBase<T>>(
+  node: T,
+  segment: string,
+  params: Record<string, string>,
+  allowWildcard = false,
+): T | null {
+  if (node.children.has(segment)) return node.children.get(segment)!
+  if (node.children.has(':')) {
+    const child = node.children.get(':')!
+    if (child.param) params[child.param] = segment
+    return child
+  }
+  if (allowWildcard && node.wildcard) return node
+  return null
+}
+
+type WsMatchResult = {
+  handler: WebSocketHandler
+  middlewares: Middleware[]
+  params: Record<string, string>
+} | null
+
+type WsUpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => void
+
+// Router<T> — T accumulates types from global middleware calls via use(mw).
+// Route-level middleware does not change the Router's type parameter.
+export class Router<T extends Context = Context> {
+  private root: TrieNode = createTrieNode()
+  private wsRoot: WsTrieNode = createWsNode()
+  private globalMws: Middleware[] = []
+  private errorHandler?: ErrorHandler<T>
+  private _hasWildcard = false
+  private _hub?: Hub
+  private _wss?: WebSocketServer
+  /** Track which ctx fields have been injected so far (for dependency checking). */
+  private _ctxFields = new Set<string>()
+  private get wss(): WebSocketServer {
+    if (!this._wss) this._wss = new WebSocketServer({ noServer: true })
+    return this._wss
+  }
+
+  private get hub(): Hub {
+    if (!this._hub) this._hub = createHub()
+    return this._hub
+  }
+
+  /** Inject a custom hub (e.g. with Redis for cross-process broadcast). */
+  wsHub(hub: Hub): this {
+    this._hub = hub
+    return this
+  }
+
+  // Global middleware — accumulates types into Router<T>.
+  // The middleware's In type is Context (base); Out is what it injects.
+  // Router accumulates via intersection: Router<T & Out>
+  use<Out extends Context>(mw: Middleware<Context, Out>): Router<T & Out>
+  // Path-scoped middleware — does not accumulate
+  use(path: string, mw: Middleware<T, T>): Router<T>
+  // Mount sub-router — flattens into parent, does not accumulate
+  use(path: string, router: Router<Context>): Router<T>
+  // Module with .middleware() — auto-register middleware + mount at /
+  use(mod: Router & { middleware: () => Middleware }): Router<T>
+  use(
+    arg1: string | Middleware<Context, Context> | (Router & { middleware: () => Middleware }),
+    arg2?: Router<Context> | Middleware<T, T>,
+  ): Router<T> {
+    if (typeof arg1 === 'string') {
+      if (arg2 instanceof Router) {
+        this._mountRouter(arg1, arg2)
+      } else if (typeof arg2 === 'function') {
+        let node = this.root
+        for (const segment of this.splitPath(arg1)) {
+          node = getOrCreateChild(node, segment, createTrieNode, false)
+        }
+        node.pathMws.push(arg2 as unknown as Middleware)
+        this._checkMiddlewareMeta(arg2, `${arg1}`)
+      }
+    } else if (typeof arg1 === 'function') {
+      this.globalMws.push(arg1 as unknown as Middleware)
+      this._checkMiddlewareMeta(arg1, 'global')
+    } else if (
+      typeof arg1 === 'object' &&
+      arg1 !== null &&
+      'middleware' in arg1 &&
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      typeof (arg1 as any).middleware === 'function' &&
+      arg1 instanceof Router
+    ) {
+      // Auto-register modules with .middleware() — e.g. theme(), i18n(), analytics()
+      // Registers both the middleware and mounts routes at /
+      const mod = arg1 as Router & { middleware: () => Middleware }
+      const mw = mod.middleware()
+      this.globalMws.push(mw as unknown as Middleware)
+      this._checkMiddlewareMeta(mw, 'global (auto-registered)')
+      this._mountRouter('/', mod as Router)
+    }
+    return this
+  }
+
+  /**
+   * Check a middleware's dependency metadata and emit warnings if
+   * required fields haven't been injected yet.
+   * Attach __meta to a middleware function:
+   *
+   * ```ts
+   * mw.__meta = { injects: ['sql'], depends: ['session'] }
+   * ```
+   */
+  private _checkMiddlewareMeta(mw: unknown, location: string): void {
+    const meta: MiddlewareMeta | undefined =
+      (mw as Middleware).__meta ??
+      (typeof mw === 'object' && mw && 'middleware' in mw
+        ? (mw as { middleware(): Middleware }).middleware().__meta
+        : undefined)
+    if (!meta) return
+
+    for (const dep of meta.depends) {
+      if (!this._ctxFields.has(dep)) {
+        console.warn(
+          `[weifuwu] Middleware at "${location}" depends on ctx.${dep} but it hasn't been registered yet.` +
+            `\n  Register the provider before this middleware:` +
+            `\n    app.use(${dep}())  // add before this middleware` +
+            `\n  Current ctx fields: [${[...this._ctxFields].join(', ')}]`,
+        )
+      }
+    }
+
+    for (const field of meta.injects) {
+      this._ctxFields.add(field)
+    }
+  }
+
+  // Route registration — returns Router<T> unchanged.
+  // Route-level middleware and handlers get Context<T>.
+  get(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T> {
+    return this._route('GET', path, ...args)
+  }
+
+  post(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T> {
+    return this._route('POST', path, ...args)
+  }
+
+  put(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T> {
+    return this._route('PUT', path, ...args)
+  }
+
+  delete(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T> {
+    return this._route('DELETE', path, ...args)
+  }
+
+  patch(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T> {
+    return this._route('PATCH', path, ...args)
+  }
+
+  head(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T> {
+    return this._route('HEAD', path, ...args)
+  }
+
+  options(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T> {
+    return this._route('OPTIONS', path, ...args)
+  }
+
+  all(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T> {
+    return this._route('*', path, ...args)
+  }
+
+  onError(handler: ErrorHandler<T>): Router<T> {
+    this.errorHandler = handler
+    return this
+  }
+
+  private _route(
+    method: string,
+    path: string,
+    ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]
+  ): Router<T> {
+    return this._routeImpl(method, path, args)
+  }
+
+  /** Internal route registration — no type constraints (used by _mountRouter). */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private _routeImpl(method: string, path: string, args: any[]): Router<T> {
+    const last = args[args.length - 1]
+    if (last instanceof Router) {
+      this._mountRouter(path, last, args.slice(0, -1))
+      return this
+    }
+    const handler = args.pop()
+    const middlewares: Middleware[] = args
+    const segments = this.splitPath(path)
+    let node = this.root
+
+    for (const segment of segments) {
+      if (segment === '*') {
+        this._hasWildcard = true
+        const remaining = segments.indexOf('*') < segments.length - 1
+        if (remaining) {
+          console.warn(`Route "${path}": segments after "*" are ignored`)
+        }
+        node.wildcard = true
+        node.handlers.set(method, handler)
+        if (middlewares.length > 0) node.middlewares.set(method, middlewares)
+        return this
+      }
+      node = getOrCreateChild(node, segment, createTrieNode, false)
+    }
+
+    if (!isProd() && node.handlers.has(method)) {
+      console.warn(`[router] route conflict: ${method} ${path} overwrites existing handler`)
+    }
+    node.handlers.set(method, handler)
+    if (middlewares.length > 0) node.middlewares.set(method, middlewares)
+    return this
+  }
+
+  ws(path: string, ...args: [...Middleware<T, T>[], WebSocketHandler]): Router<T> {
+    const handler = args.pop()! as WebSocketHandler
+    const middlewares = args as unknown as Middleware[]
+    const segments = this.splitPath(path)
+    let node = this.wsRoot
+
+    for (const segment of segments) {
+      node = getOrCreateChild(node, segment, createWsNode, true)
+    }
+
+    node.handler = handler
+    node.middlewares = middlewares
+    return this
+  }
+
+  handler(): Handler<T> {
+    return (req, ctx) => {
+      const url = new URL(req.url)
+      return this.handle(req, ctx as Context, this.splitPath(url.pathname))
+    }
+  }
+
+  /** Returns a human-readable list of all registered routes. Useful for debugging. */
+  routes(): string[] {
+    const result: string[] = []
+    if (this.globalMws.length > 0) {
+      result.push(`MIDDLEWARE  [${this.globalMws.length} global]`)
+    }
+    this._collectRoutes(this.root, '', result)
+    this._collectWsRoutes(this.wsRoot, '', result)
+    return result
+  }
+
+  private _collectRoutes(node: TrieNode, prefix: string, result: string[]): void {
+    for (const [method] of node.handlers) {
+      const m = method === '*' ? 'ANY' : method
+      const path = (prefix || '/') + (node.wildcard ? '/*' : '')
+      const middlewares = node.middlewares.get(method)
+      const mwCount = middlewares ? ` (+${middlewares.length} mw)` : ''
+      result.push(`${m.padEnd(7)} ${path}${mwCount}`)
+    }
+    for (const [seg, child] of node.children) {
+      const segment = seg === ':' ? `:${child.param}` : seg
+      this._collectRoutes(child, prefix + '/' + segment, result)
+    }
+  }
+
+  private _collectWsRoutes(node: WsTrieNode, prefix: string, result: string[]): void {
+    if (node.handler) {
+      const path = prefix || '/'
+      const mwCount = node.middlewares.length ? ` (+${node.middlewares.length} mw)` : ''
+      result.push(`WS       ${path}${mwCount}`)
+    }
+    for (const [seg, child] of node.children) {
+      const segment = seg === ':' ? `:${child.param}` : seg
+      this._collectWsRoutes(child, prefix + '/' + segment, result)
+    }
+  }
+
+  websocketHandler(): WsUpgradeHandler {
+    const wsRoot = this.wsRoot
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const router = this
+
+    return (req, socket, head) => {
+      const url = new URL(req.url ?? '/', 'http://localhost')
+      const segments = url.pathname.split('/').filter(Boolean)
+
+      const match = router.matchWsTrie(wsRoot, segments)
+      if (!match) {
+        socket.destroy()
+        return
+      }
+
+      const query = Object.fromEntries(url.searchParams)
+      const ctx = { params: match.params, query } as Context
+
+      const allMws =
+        router.globalMws.length === 0 && match.middlewares.length === 0
+          ? ([] as Middleware[])
+          : [...router.globalMws, ...match.middlewares]
+
+      if (allMws.length === 0) {
+        upgradeSocket(router.wss, req, socket, head, match.handler, ctx, router.hub)
+        return
+      }
+
+      const finalHandler: Handler = () => {
+        try {
+          upgradeSocket(router.wss, req, socket, head, match.handler, ctx, router.hub)
+        } catch {
+          socket.destroy()
+          return new Response('WebSocket upgrade failed', { status: 500 })
+        }
+        return new Response(null, { status: 200 })
+      }
+
+      const webReq = new Request(url.href, {
+        method: req.method ?? 'GET',
+        headers: nodeReqHeadersToRecord(req.headers),
+      })
+
+      void router
+        .runChain(allMws, finalHandler, webReq, ctx)
+        .then((result) => {
+          if (result.status >= 400) {
+            sendHttpResponseOnSocket(socket, result)
+          }
+        })
+        .catch(() => {
+          socket.destroy()
+        })
+    }
+  }
+
+  private _mountRouter(prefix: string, sub: Router<Context>, extraMws: Middleware[] = []): void {
+    const base = prefix === '/' ? '' : prefix.replace(/\/$/, '')
+
+    const mountMw: Middleware = (req, ctx, next) => {
+      ctx.mountPath = (ctx.mountPath || '') + base
+      return next(req, ctx)
+    }
+
+    const allExtra =
+      extraMws.length === 0 && sub.globalMws.length === 0
+        ? [mountMw]
+        : [mountMw, ...extraMws, ...sub.globalMws]
+
+    const routes: Array<{
+      method: string
+      path: string
+      handler: Handler
+      middlewares: Middleware[]
+    }> = []
+    this._collect(sub.root, '', routes, [])
+    for (const { method, path, handler, middlewares } of routes) {
+      this._routeImpl(method, base + path, [...allExtra, ...middlewares, handler])
+    }
+
+    const wsRoutes: Array<{ path: string; handler: WebSocketHandler; middlewares: Middleware[] }> =
+      []
+    this._collectWs(sub.wsRoot, '', wsRoutes)
+    for (const { path, handler, middlewares } of wsRoutes) {
+      this.ws(
+        base + path,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ...(allExtra as Middleware<any, any>[]),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ...(middlewares as Middleware<any, any>[]),
+        handler,
+      )
+    }
+  }
+
+  private mergeMws(base: Middleware[], extra: Middleware[]): Middleware[] {
+    if (base.length === 0) return extra.length === 0 ? base : extra
+    if (extra.length === 0) return base
+    return [...base, ...extra]
+  }
+
+  private _collect(
+    node: TrieNode,
+    prefix: string,
+    result: Array<{ method: string; path: string; handler: Handler; middlewares: Middleware[] }>,
+    pathMwsAcc: Middleware[],
+  ): void {
+    const mws = this.mergeMws(pathMwsAcc, node.pathMws)
+    for (const [method, handler] of node.handlers) {
+      const rmws = node.middlewares.get(method) || []
+      const suffix = node.wildcard ? '/*' : ''
+      result.push({
+        method,
+        path: (prefix || '/') + suffix,
+        handler,
+        middlewares: this.mergeMws(mws, rmws),
+      })
+    }
+    for (const [seg, child] of node.children) {
+      const next = seg === ':' ? `/:${child.param}` : `/${seg}`
+      this._collect(child, prefix + next, result, mws)
+    }
+  }
+
+  private _collectWs(
+    node: WsTrieNode,
+    prefix: string,
+    result: Array<{ path: string; handler: WebSocketHandler; middlewares: Middleware[] }>,
+    pathMwsAcc: Middleware[] = [],
+  ): void {
+    const mws = this.mergeMws(pathMwsAcc, node.middlewares)
+    if (node.handler) result.push({ path: prefix || '/', handler: node.handler, middlewares: mws })
+    for (const [seg, child] of node.children) {
+      const next = seg === ':' ? `/:${child.param}` : `/${seg}`
+      this._collectWs(child, prefix + next, result, mws)
+    }
+  }
+
+  private splitPath(path: string): string[] {
+    return path.split('/').filter(Boolean)
+  }
+
+  private matchTrie(
+    method: string,
+    segments: string[],
+  ): {
+    handler?: Handler
+    middlewares: Middleware[]
+    pathMws: Middleware[]
+    params: Record<string, string>
+    allowedMethods?: string[]
+  } | null {
+    let node = this.root
+    const params: Record<string, string> = {}
+    const pathMws: Middleware[] = []
+    let wildcardHandler: Handler | null = null
+    let wildcardMws: Middleware[] = []
+    let wildcardIdx = -1
+
+    for (let i = 0; i < segments.length; i++) {
+      pathMws.push(...node.pathMws)
+
+      if (this._hasWildcard && node.wildcard) {
+        const h = node.handlers.get('*') || node.handlers.get(method)
+        if (h) {
+          wildcardHandler = h
+          wildcardMws = node.middlewares.get(method) || node.middlewares.get('*') || []
+          wildcardIdx = i
+        }
+      }
+
+      const segment = segments[i]
+
+      const next = matchChild(node, segment, params, false)
+      if (!next) {
+        if (wildcardHandler) {
+          params['*'] = segments.slice(wildcardIdx).join('/')
+          return { handler: wildcardHandler, middlewares: wildcardMws, pathMws, params }
+        }
+        return null
+      }
+      node = next
+    }
+
+    pathMws.push(...node.pathMws)
+
+    const handler = node.handlers.get(method) || node.handlers.get('*')
+    if (handler) {
+      if (node.wildcard) params['*'] = segments.slice(segments.length).join('/')
+      return {
+        handler,
+        middlewares: node.middlewares.get(method) || node.middlewares.get('*') || [],
+        pathMws,
+        params,
+      }
+    }
+
+    if (wildcardHandler) {
+      params['*'] = segments.slice(wildcardIdx).join('/')
+      return { handler: wildcardHandler, middlewares: wildcardMws, pathMws, params }
+    }
+
+    if (node.handlers.size > 0) {
+      return {
+        middlewares: [],
+        pathMws,
+        params,
+        allowedMethods: [...node.handlers.keys()].filter((k) => k !== '*'),
+      }
+    }
+
+    return null
+  }
+
+  private matchWsTrie(root: WsTrieNode, segments: string[]): WsMatchResult {
+    let node = root
+    const params: Record<string, string> = {}
+
+    for (const segment of segments) {
+      const next = matchChild(node, segment, params, true)
+      if (!next) return null
+      node = next
+    }
+
+    return node.handler ? { handler: node.handler, middlewares: node.middlewares, params } : null
+  }
+
+  private async handleError(e: unknown, req: Request, ctx: Context): Promise<Response> {
+    const err = e instanceof Error ? e : new Error(String(e))
+    console.error(err)
+    return this.errorHandler
+      ? await this.errorHandler(err, req, ctx as T)
+      : new Response('Internal Server Error', { status: 500 })
+  }
+
+  private async handle(req: Request, ctx: Context, segments: string[]): Promise<Response> {
+    const match = this.matchTrie(req.method, segments)
+
+    if (match) {
+      Object.assign(ctx.params, match.params)
+
+      if (match.handler) {
+        const { handler, middlewares: routeMws, pathMws } = match
+        const mws = this.mergeMws(this.mergeMws(this.globalMws, pathMws), routeMws)
+        try {
+          return await this.runChain(mws, handler, req, ctx)
+        } catch (e) {
+          return this.handleError(e, req, ctx)
+        }
+      }
+
+      if (match.allowedMethods && match.allowedMethods.length > 0) {
+        if (this.globalMws.length > 0) {
+          try {
+            return await this.runChain(
+              this.globalMws,
+              () =>
+                new Response('Method Not Allowed', {
+                  status: 405,
+                  headers: { Allow: match.allowedMethods!.join(', ') },
+                }),
+              req,
+              ctx,
+            )
+          } catch (e) {
+            return this.handleError(e, req, ctx)
+          }
+        }
+        return new Response('Method Not Allowed', {
+          status: 405,
+          headers: { Allow: match.allowedMethods.join(', ') },
+        })
+      }
+    }
+
+    if (this.globalMws.length > 0) {
+      try {
+        return await this.runChain(
+          this.globalMws,
+          () => {
+            if (!isProd()) {
+              return Response.json(
+                { error: 'Not Found', path: '/' + segments.join('/'), method: req.method },
+                { status: 404 },
+              )
+            }
+            return new Response('Not Found', { status: 404 })
+          },
+          req,
+          ctx,
+        )
+      } catch (e) {
+        return this.handleError(e, req, ctx)
+      }
+    }
+
+    if (!isProd()) {
+      return Response.json(
+        {
+          error: 'Not Found',
+          path: '/' + segments.join('/'),
+          method: req.method,
+        },
+        { status: 404 },
+      )
+    }
+    return new Response('Not Found', { status: 404 })
+  }
+
+  private async runChain(
+    middlewares: Middleware[],
+    finalHandler: Handler,
+    req: Request,
+    ctx: Context,
+  ): Promise<Response> {
+    if (middlewares.length === 0) return await finalHandler(req, ctx)
+    return await runChainLoop(middlewares, 0, finalHandler, req, ctx)
+  }
+}
+
+function runChainLoop(
+  middlewares: Middleware[],
+  index: number,
+  finalHandler: Handler,
+  req: Request,
+  ctx: Context,
+): Promise<Response> {
+  if (index < middlewares.length) {
+    const mw = middlewares[index]
+    let called = false
+    const dispatch: Handler = (r, c) => {
+      if (called) {
+        console.warn(
+          '[router] next() called more than once in middleware — ignoring duplicate call',
+        )
+        return Promise.resolve(new Response('Internal Server Error', { status: 500 }))
+      }
+      called = true
+      return runChainLoop(middlewares, index + 1, finalHandler, r, c)
+    }
+    return Promise.resolve(mw(req, ctx, dispatch as unknown as Parameters<typeof mw>[2]))
+  }
+  return Promise.resolve(finalHandler(req, ctx))
+}
+
+function upgradeSocket(
+  wss: WebSocketServer,
+  req: IncomingMessage,
+  socket: Duplex,
+  head: Buffer,
+  handler: WebSocketHandler,
+  ctx: Context,
+  hub: Hub,
+): void {
+  wss.handleUpgrade(req, socket, head, (ws) => {
+    // ── Per-connection ctx — cloned from upgrade ctx ─────────
+    // Each connection gets its own ctx, inheriting params/query/user/etc.
+    const connCtx: Context = { ...ctx, params: { ...ctx.params }, query: { ...ctx.query } }
+
+    // ── ctx.ws — per-connection WS helpers ───────────────────
+    const wsState: Record<string, unknown> = {}
+    connCtx.ws = {
+      get state() {
+        return wsState
+      },
+      json(data: unknown) {
+        ws.send(JSON.stringify(data))
+      },
+      join(room: string) {
+        hub.join(room, ws)
+      },
+      leave(_room: string) {
+        hub.leave(ws)
+      },
+      sendRoom(room: string, data: unknown) {
+        hub.broadcast(room, JSON.stringify(data))
+      },
+    }
+
+    if (handler.open) {
+      handler.open(ws, connCtx)
+    }
+
+    ws.on('message', (data) => {
+      handler.message?.(ws, connCtx, data as string | Buffer)
+    })
+
+    ws.on('close', () => {
+      hub.leave(ws)
+      handler.close?.(ws, connCtx)
+    })
+
+    ws.on('error', (err) => {
+      handler.error?.(ws, connCtx, err)
+    })
+  })
+}
+
+function nodeReqHeadersToRecord(headers: http.IncomingHttpHeaders): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const [k, v] of Object.entries(headers)) {
+    if (v !== undefined) result[k] = Array.isArray(v) ? v.join(', ') : v
+  }
+  return result
+}
+
+function sendHttpResponseOnSocket(socket: Duplex, response: Response): void {
+  const statusLine = `HTTP/1.1 ${response.status} ${response.statusText}`
+  const headerLines: string[] = [statusLine]
+  response.headers.forEach((value, key) => {
+    headerLines.push(`${key}: ${value}`)
+  })
+  headerLines.push('Connection: close')
+  headerLines.push('')
+  const headerStr = headerLines.join('\r\n')
+
+  response
+    .arrayBuffer()
+    .then((buf) => {
+      socket.write(headerStr + '\r\n')
+      if (buf.byteLength > 0) socket.write(Buffer.from(buf))
+      socket.end()
+    })
+    .catch(() => {
+      socket.write(headerStr + '\r\n')
+      socket.end()
+    })
+}