@furystack/rest-service 13.0.0 → 14.0.0

package/src/server-manager.ts

@@ -1,135 +0,0 @@
-import { Injectable } from '@furystack/inject'
-import { EventHub, type ListenerErrorPayload } from '@furystack/utils'
-import type { IncomingMessage, Server, ServerResponse } from 'http'
-import { createServer } from 'http'
-import type { Socket } from 'net'
-import type { Duplex } from 'stream'
-
-export interface ServerOptions {
-  hostName?: string
-  port: number
-}
-
-export interface OnRequest {
-  req: IncomingMessage
-  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 {
-  server: Server
-  apis: ServerApi[]
-}
-
-@Injectable({ lifetime: 'singleton' })
-export class ServerManager
-  extends EventHub<{
-    onRequestFailed: [unknown, IncomingMessage, ServerResponse<IncomingMessage>]
-    onServerListening: { url: string; port: number; hostName?: string }
-    onServerClosed: { url: string }
-    onListenerError: ListenerErrorPayload
-  }>
-  implements AsyncDisposable
-{
-  public static DEFAULT_HOST = 'localhost'
-  public servers = new Map<string, ServerRecord>()
-  private openedSockets = new Set<Socket>()
-  private readonly pendingCreates = new Map<string, Promise<ServerRecord>>()
-  private getHostUrl = (options: ServerOptions) =>
-    `http://${options.hostName || ServerManager.DEFAULT_HOST}:${options.port}`
-
-  private onConnection = (socket: Socket) => {
-    this.openedSockets.add(socket)
-    socket.once('close', () => this.openedSockets.delete(socket))
-  }
-  public async [Symbol.asyncDispose]() {
-    await Promise.allSettled([...this.pendingCreates.values()])
-    this.openedSockets.forEach((s) => s.destroy())
-    await Promise.allSettled(
-      [...this.servers.entries()].map(
-        ([url, s]) =>
-          new Promise<void>((resolve, reject) => {
-            s.server.close((err) => {
-              if (err) {
-                reject(err)
-              } else {
-                this.emit('onServerClosed', { url })
-                resolve()
-              }
-            })
-            s.server.off('connection', this.onConnection)
-          }),
-      ),
-    )
-    this.servers.clear()
-    super[Symbol.dispose]?.()
-  }
-
-  public async getOrCreate(options: ServerOptions): Promise<ServerRecord> {
-    const url = this.getHostUrl(options)
-
-    const existing = this.servers.get(url)
-    if (existing) {
-      return existing
-    }
-
-    const pending = this.pendingCreates.get(url)
-    if (pending) {
-      return pending
-    }
-
-    const createPromise = this.createServer(url, options)
-    this.pendingCreates.set(url, createPromise)
-    return createPromise
-  }
-
-  private async createServer(url: string, options: ServerOptions): Promise<ServerRecord> {
-    const apis: ServerRecord['apis'] = []
-    const server = createServer((req, res) => {
-      const apiMatch = apis.find((api) => api.shouldExec({ req, res }))
-      if (apiMatch) {
-        apiMatch.onRequest({ req, res }).catch((error) => {
-          this.emit('onRequestFailed', [error, req, res])
-        })
-      } else {
-        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)
-    try {
-      await new Promise<void>((resolve, reject) => {
-        server.on('listening', () => resolve())
-        server.on('error', (err) => reject(err))
-        server.listen(options.port, options.hostName)
-      })
-      const record: ServerRecord = { server, apis }
-      this.servers.set(url, record)
-      this.emit('onServerListening', { url, port: options.port, hostName: options.hostName })
-      return record
-    } finally {
-      this.pendingCreates.delete(url)
-    }
-  }
-}

package/src/static-server-manager.ts

@@ -1,90 +0,0 @@
-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 { join, normalize, sep } from 'path'
-import { getMimeForFile } from './mime-types.js'
-import { ServerManager } from './server-manager.js'
-
-export interface StaticServerOptions {
-  baseUrl: string
-  path: string
-  hostName?: string
-  port: number
-  fallback?: string
-  headers?: OutgoingHttpHeaders
-}
-
-@Injectable({ lifetime: 'singleton' })
-export class StaticServerManager {
-  @Injected(ServerManager)
-  declare private readonly serverManager: ServerManager
-
-  private async sendFile({
-    fullPath,
-    headers,
-    res,
-  }: {
-    fullPath: string
-    res: ServerResponse
-    headers?: OutgoingHttpHeaders
-  }) {
-    const { size } = await stat(fullPath)
-
-    await access(fullPath)
-
-    const head = {
-      ...headers,
-      'Content-Length': size,
-      'Content-Type': getMimeForFile(fullPath),
-    }
-    Object.entries(head).map(([key, value]) => res.setHeader(key, value))
-    await new Promise<void>((resolve, reject) =>
-      createReadStream(fullPath, { autoClose: true }).once('finish', resolve).once('error', reject).pipe(res),
-    )
-  }
-
-  public shouldExec =
-    (baseUrl: string) =>
-    ({ req }: { req: Pick<IncomingMessage, 'url' | 'method'> }) =>
-      req.url && req.method?.toUpperCase() === 'GET' && PathHelper.matchesBaseUrl(req.url, baseUrl) ? true : false
-
-  private onRequest = ({
-    path,
-    baseUrl,
-    fallback,
-    headers,
-  }: {
-    path: string
-    baseUrl: string
-    fallback?: string
-    headers?: OutgoingHttpHeaders
-  }) => {
-    return async ({ req, res }: { req: IncomingMessage; res: ServerResponse }) => {
-      const extractedPath = PathHelper.extractPath(req.url as string, baseUrl)
-      const filePath = (extractedPath || '/').replaceAll('/', sep)
-      const fullPath = normalize(join(path, filePath))
-
-      try {
-        await this.sendFile({ fullPath, res, headers })
-      } catch (error) {
-        if (fallback) {
-          await this.sendFile({ fullPath: normalize(join(path, fallback)), res, headers })
-        } else {
-          res.writeHead(404, { 'Content-Type': 'text/plain' })
-          res.end('Not found')
-        }
-      }
-    }
-  }
-
-  public async addStaticSite(options: StaticServerOptions) {
-    const server = await this.serverManager.getOrCreate({ hostName: options.hostName, port: options.port })
-
-    server.apis.push({
-      shouldExec: this.shouldExec(options.baseUrl),
-      onRequest: this.onRequest({ ...options }),
-    })
-  }
-}