@furystack/rest-service 10.0.28 → 10.1.0

package/src/proxy-manager.ts

@@ -0,0 +1,101 @@
+import { Injectable, Injected } from '@furystack/inject'
+import { EventHub, PathHelper } from '@furystack/utils'
+import type { IncomingMessage, OutgoingHttpHeaders, ServerResponse } from 'http'
+import type { Duplex } from 'stream'
+import { HttpProxyHandler } from './http-proxy-handler.js'
+import { PathProcessor } from './path-processor.js'
+import { ServerManager } from './server-manager.js'
+import { WebSocketProxyHandler } from './websocket-proxy-handler.js'
+
+export interface ProxyOptions {
+  sourceBaseUrl: string
+  targetBaseUrl: string
+  pathRewrite?: (sourcePath: string) => string
+  sourceHostName?: string
+  sourcePort: number
+  headers?: (originalHeaders: OutgoingHttpHeaders) => OutgoingHttpHeaders
+  cookies?: (originalCookies: string[]) => string[]
+  responseCookies?: (responseCookies: string[]) => string[]
+  timeout?: number
+  enableWebsockets?: boolean
+}
+
+/**
+ * Manages HTTP and WebSocket proxy configurations and routing
+ */
+@Injectable({ lifetime: 'singleton' })
+export class ProxyManager extends EventHub<{
+  onProxyFailed: { from: string; to: string; error: unknown }
+  onWebSocketProxyFailed: { from: string; to: string; error: unknown }
+}> {
+  @Injected(ServerManager)
+  declare private readonly serverManager: ServerManager
+
+  private readonly pathProcessor = new PathProcessor()
+
+  /**
+   * Creates a function that determines if a request should be handled by this proxy
+   */
+  public shouldExec =
+    (sourceBaseUrl: string) =>
+    ({ req }: { req: Pick<IncomingMessage, 'url' | 'method'> }) =>
+      req.url ? PathHelper.matchesBaseUrl(req.url, sourceBaseUrl) : false
+
+  /**
+   * Creates an HTTP request handler for the proxy
+   */
+  private createRequestHandler(options: ProxyOptions) {
+    const handler = new HttpProxyHandler({
+      sourceBaseUrl: options.sourceBaseUrl,
+      targetBaseUrl: options.targetBaseUrl,
+      pathRewrite: options.pathRewrite,
+      headers: options.headers,
+      cookies: options.cookies,
+      responseCookies: options.responseCookies,
+      timeout: options.timeout,
+      onError: (error) => this.emit('onProxyFailed', error),
+    })
+
+    return async ({ req, res }: { req: IncomingMessage; res: ServerResponse }) => {
+      await handler.handle(req, res)
+    }
+  }
+
+  /**
+   * Creates a WebSocket upgrade handler for the proxy
+   */
+  private createUpgradeHandler(options: ProxyOptions) {
+    const handler = new WebSocketProxyHandler({
+      sourceBaseUrl: options.sourceBaseUrl,
+      targetBaseUrl: options.targetBaseUrl,
+      pathRewrite: options.pathRewrite,
+      headers: options.headers,
+      timeout: options.timeout,
+      onError: (error) => this.emit('onWebSocketProxyFailed', error),
+    })
+
+    return async ({ req, socket, head }: { req: IncomingMessage; socket: Duplex; head: Buffer }) => {
+      await handler.handle(req, socket, head)
+    }
+  }
+
+  /**
+   * Adds a new proxy configuration
+   * @throws Error if targetBaseUrl is invalid or uses non-HTTP/HTTPS protocol
+   */
+  public async addProxy(options: ProxyOptions): Promise<void> {
+    // Validate targetBaseUrl format
+    const url = this.pathProcessor.validateUrl(options.targetBaseUrl, 'targetBaseUrl')
+    this.pathProcessor.validateHttpProtocol(url)
+
+    const server = await this.serverManager.getOrCreate({ hostName: options.sourceHostName, port: options.sourcePort })
+
+    const api = {
+      shouldExec: this.shouldExec(options.sourceBaseUrl),
+      onRequest: this.createRequestHandler(options),
+      ...(options.enableWebsockets ? { onUpgrade: this.createUpgradeHandler(options) } : {}),
+    }
+
+    server.apis.push(api)
+  }
+}

package/src/server-manager.ts

@@ -4,6 +4,7 @@ import type { IncomingMessage, Server, ServerResponse } from 'http'
 import { createServer } from 'http'
 import type { Socket } from 'net'
 import { Lock } from 'semaphore-async-await'
+import type { Duplex } from 'stream'
 
 export interface ServerOptions {
   hostName?: string
@@ -15,9 +16,16 @@ export interface OnRequest {
   res: ServerResponse
 }
 
+export interface OnUpgrade {
+  req: IncomingMessage
+  socket: Duplex
+  head: Buffer
+}
+
 export interface ServerApi {
   shouldExec: (options: OnRequest) => boolean
   onRequest: (options: OnRequest) => Promise<void>
+  onUpgrade?: (options: OnUpgrade) => Promise<void>
 }
 
 export interface ServerRecord {
@@ -79,6 +87,17 @@ export class ServerManager
                 res.destroy()
               }
             })
+            server.on('upgrade', (req, socket, head) => {
+              const apiMatch = apis.find((api) => api.shouldExec({ req, res: {} as ServerResponse }))
+              if (apiMatch?.onUpgrade) {
+                apiMatch.onUpgrade({ req, socket, head }).catch((error) => {
+                  this.emit('onRequestFailed', [error, req, {} as ServerResponse])
+                  socket.destroy()
+                })
+              } else {
+                socket.destroy()
+              }
+            })
             server.on('connection', this.onConnection)
             server.on('listening', () => resolve())
             server.on('error', (err) => reject(err))

package/src/static-server-manager.ts

@@ -1,9 +1,10 @@
 import { Injectable, Injected } from '@furystack/inject'
+import { PathHelper } from '@furystack/utils'
 import { createReadStream } from 'fs'
 import { access, stat } from 'fs/promises'
 import type { IncomingMessage, OutgoingHttpHeaders, ServerResponse } from 'http'
-import { getMimeForFile } from './mime-types.js'
 import { join, normalize, sep } from 'path'
+import { getMimeForFile } from './mime-types.js'
 import { ServerManager } from './server-manager.js'
 
 export interface StaticServerOptions {
@@ -47,11 +48,7 @@ export class StaticServerManager {
   public shouldExec =
     (baseUrl: string) =>
     ({ req }: { req: Pick<IncomingMessage, 'url' | 'method'> }) =>
-      req.url &&
-      req.method?.toUpperCase() === 'GET' &&
-      (req.url === baseUrl || req.url.startsWith(baseUrl[baseUrl.length - 1] === '/' ? baseUrl : `${baseUrl}/`))
-        ? true
-        : false
+      req.url && req.method?.toUpperCase() === 'GET' && PathHelper.matchesBaseUrl(req.url, baseUrl) ? true : false
 
   private onRequest = ({
     path,
@@ -65,7 +62,8 @@ export class StaticServerManager {
     headers?: OutgoingHttpHeaders
   }) => {
     return async ({ req, res }: { req: IncomingMessage; res: ServerResponse }) => {
-      const filePath = (req.url as string).substring(baseUrl.length - 1).replaceAll('/', sep)
+      const extractedPath = PathHelper.extractPath(req.url as string, baseUrl)
+      const filePath = (extractedPath || '/').replaceAll('/', sep)
       const fullPath = normalize(join(path, filePath))
 
       try {

package/src/websocket-proxy-handler.ts

@@ -0,0 +1,204 @@
+import type { IncomingMessage, OutgoingHttpHeaders } from 'http'
+import { request as httpRequest } from 'http'
+import { request as httpsRequest } from 'https'
+import type { Duplex } from 'stream'
+import { HeaderProcessor } from './header-processor.js'
+import { PathProcessor } from './path-processor.js'
+
+export interface WebSocketProxyOptions {
+  sourceBaseUrl: string
+  targetBaseUrl: string
+  pathRewrite?: (sourcePath: string) => string
+  headers?: (originalHeaders: OutgoingHttpHeaders) => OutgoingHttpHeaders
+  timeout?: number
+  onError?: (error: { from: string; to: string; error: unknown }) => void
+}
+
+/**
+ * Handles WebSocket upgrade proxying with bidirectional streaming
+ */
+export class WebSocketProxyHandler {
+  private readonly headerProcessor = new HeaderProcessor()
+  private readonly pathProcessor = new PathProcessor()
+
+  constructor(private readonly options: WebSocketProxyOptions) {}
+
+  /**
+   * Builds WebSocket-specific upgrade headers
+   */
+  private buildUpgradeHeaders(
+    req: IncomingMessage,
+    targetHost: string,
+    finalHeaders: OutgoingHttpHeaders,
+  ): Record<string, string> {
+    const upgradeHeaders = this.headerProcessor.convertHeadersToRecord(finalHeaders)
+
+    // Add required WebSocket upgrade headers
+    upgradeHeaders.Host = targetHost
+    upgradeHeaders.Connection = 'Upgrade'
+    upgradeHeaders.Upgrade = 'websocket'
+    upgradeHeaders['Sec-WebSocket-Version'] = req.headers['sec-websocket-version'] as string
+    upgradeHeaders['Sec-WebSocket-Key'] = req.headers['sec-websocket-key'] as string
+
+    // Add optional WebSocket headers
+    if (req.headers['sec-websocket-protocol']) {
+      upgradeHeaders['Sec-WebSocket-Protocol'] = req.headers['sec-websocket-protocol']
+    }
+    if (req.headers['sec-websocket-extensions']) {
+      upgradeHeaders['Sec-WebSocket-Extensions'] = req.headers['sec-websocket-extensions']
+    }
+
+    return upgradeHeaders
+  }
+
+  /**
+   * Writes the upgrade response headers to the client socket
+   */
+  private writeUpgradeResponse(socket: Duplex, proxyRes: IncomingMessage): void {
+    const responseHeaders = [`HTTP/1.1 ${proxyRes.statusCode} ${proxyRes.statusMessage}`]
+    for (const [key, value] of Object.entries(proxyRes.headers)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => responseHeaders.push(`${key}: ${v}`))
+      } else {
+        responseHeaders.push(`${key}: ${value}`)
+      }
+    }
+    responseHeaders.push('', '')
+    socket.write(responseHeaders.join('\r\n'))
+  }
+
+  /**
+   * Sets up bidirectional piping between client and target sockets with error handling
+   */
+  private setupBidirectionalPipe(
+    clientSocket: Duplex,
+    proxySocket: Duplex,
+    clientHead: Buffer,
+    proxyHead: Buffer,
+  ): void {
+    // Write initial data
+    if (proxyHead.length > 0) {
+      clientSocket.write(proxyHead)
+    }
+    if (clientHead.length > 0) {
+      proxySocket.write(clientHead)
+    }
+
+    // Bidirectional pipe
+    proxySocket.pipe(clientSocket)
+    clientSocket.pipe(proxySocket)
+
+    // Handle errors and cleanup
+    const cleanup = () => {
+      proxySocket.destroy()
+      clientSocket.destroy()
+    }
+
+    const handleError = (error: Error) => {
+      if (this.options.onError) {
+        this.options.onError({
+          from: this.options.sourceBaseUrl,
+          to: this.options.targetBaseUrl,
+          error,
+        })
+      }
+      cleanup()
+    }
+
+    proxySocket.on('error', handleError)
+    clientSocket.on('error', handleError)
+
+    proxySocket.on('close', () => {
+      clientSocket.destroy()
+    })
+
+    clientSocket.on('close', () => {
+      proxySocket.destroy()
+    })
+  }
+
+  /**
+   * Handles WebSocket upgrade errors
+   */
+  private handleUpgradeError(error: unknown, socket: Duplex): void {
+    if (this.options.onError) {
+      this.options.onError({
+        from: this.options.sourceBaseUrl,
+        to: this.options.targetBaseUrl,
+        error,
+      })
+    }
+    socket.destroy()
+  }
+
+  /**
+   * Main handler for WebSocket upgrade requests
+   */
+  public async handle(req: IncomingMessage, socket: Duplex, head: Buffer): Promise<void> {
+    try {
+      // Build target URL
+      const targetUrl = this.pathProcessor.processUrl(
+        req.url as string,
+        this.options.sourceBaseUrl,
+        this.options.targetBaseUrl,
+        this.options.pathRewrite,
+      )
+
+      const parsedTargetUrl = new URL(targetUrl)
+
+      // Process headers
+      const originalHeaders: OutgoingHttpHeaders = {}
+      for (const [key, value] of Object.entries(req.headers)) {
+        originalHeaders[key] = Array.isArray(value) ? value.join(', ') : value
+      }
+
+      const filteredHeaders = this.headerProcessor.filterHeaders(originalHeaders)
+      const finalHeaders = this.options.headers ? this.options.headers(filteredHeaders) : filteredHeaders
+
+      // Build WebSocket upgrade headers
+      const upgradeHeaders = this.buildUpgradeHeaders(req, parsedTargetUrl.host, finalHeaders)
+
+      // Set up timeout
+      const timeoutMs = this.options.timeout ?? 30000
+      const timeoutId = setTimeout(() => {
+        socket.destroy()
+      }, timeoutMs)
+
+      // Create upgrade request to target server
+      const requestFn = parsedTargetUrl.protocol === 'https:' ? httpsRequest : httpRequest
+      const proxyReq = requestFn({
+        host: parsedTargetUrl.hostname,
+        port: parsedTargetUrl.port || (parsedTargetUrl.protocol === 'https:' ? 443 : 80),
+        path: parsedTargetUrl.pathname + parsedTargetUrl.search,
+        method: 'GET',
+        headers: upgradeHeaders,
+      })
+
+      proxyReq.on('upgrade', (proxyRes, proxySocket, proxyHead) => {
+        clearTimeout(timeoutId)
+
+        // Write the upgrade response to the client socket
+        this.writeUpgradeResponse(socket, proxyRes)
+
+        // Set up bidirectional piping
+        this.setupBidirectionalPipe(socket, proxySocket, head, proxyHead)
+      })
+
+      proxyReq.on('error', (error) => {
+        clearTimeout(timeoutId)
+        this.handleUpgradeError(error, socket)
+      })
+
+      proxyReq.on('timeout', () => {
+        clearTimeout(timeoutId)
+        const timeoutError = new Error('WebSocket upgrade timeout')
+        this.handleUpgradeError(timeoutError, socket)
+        proxyReq.destroy()
+      })
+
+      proxyReq.end()
+    } catch (error) {
+      this.handleUpgradeError(error, socket)
+    }
+  }
+}