@nmtjs/ws-transport 0.12.6 → 0.12.7

package/package.json

@@ -12,26 +12,25 @@
     "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.52.0"
   },
   "peerDependencies": {
-    "@nmtjs/common": "0.12.6",
-    "@nmtjs/protocol": "0.12.6",
-    "@nmtjs/core": "0.12.6"
+    "@nmtjs/common": "0.12.7",
+    "@nmtjs/core": "0.12.7",
+    "@nmtjs/protocol": "0.12.7"
   },
   "devDependencies": {
     "@types/node": "^20",
-    "@nmtjs/protocol": "0.12.6",
-    "@nmtjs/client": "0.12.6",
-    "@nmtjs/common": "0.12.6"
+    "@nmtjs/client": "0.12.7",
+    "@nmtjs/protocol": "0.12.7",
+    "@nmtjs/common": "0.12.7"
   },
   "engines": {
     "node": ">=20"
   },
   "files": [
-    "src",
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.12.6",
+  "version": "0.12.7",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"

package/src/http.ts

@@ -1,150 +0,0 @@
-import { createMetadataKey } from '@nmtjs/core'
-import { ErrorCode } from '@nmtjs/protocol'
-
-export enum HttpCode {
-  Continue = 100,
-  SwitchingProtocols = 101,
-  Processing = 102,
-  EarlyHints = 103,
-  OK = 200,
-  Created = 201,
-  Accepted = 202,
-  NonAuthoritativeInformation = 203,
-  NoContent = 204,
-  ResetContent = 205,
-  PartialContent = 206,
-  MultiStatus = 207,
-  AlreadyReported = 208,
-  IMUsed = 226,
-  MultipleChoices = 300,
-  MovedPermanently = 301,
-  Found = 302,
-  SeeOther = 303,
-  NotModified = 304,
-  UseProxy = 305,
-  TemporaryRedirect = 307,
-  PermanentRedirect = 308,
-  BadRequest = 400,
-  Unauthorized = 401,
-  PaymentRequired = 402,
-  Forbidden = 403,
-  NotFound = 404,
-  MethodNotAllowed = 405,
-  NotAcceptable = 406,
-  ProxyAuthenticationRequired = 407,
-  RequestTimeout = 408,
-  Conflict = 409,
-  Gone = 410,
-  LengthRequired = 411,
-  PreconditionFailed = 412,
-  PayloadTooLarge = 413,
-  URITooLong = 414,
-  UnsupportedMediaType = 415,
-  RangeNotSatisfiable = 416,
-  ExpectationFailed = 417,
-  ImATeapot = 418,
-  MisdirectedRequest = 421,
-  UnprocessableEntity = 422,
-  Locked = 423,
-  FailedDependency = 424,
-  TooEarly = 425,
-  UpgradeRequired = 426,
-  PreconditionRequired = 428,
-  TooManyRequests = 429,
-  RequestHeaderFieldsTooLarge = 431,
-  UnavailableForLegalReasons = 451,
-  InternalServerError = 500,
-  NotImplemented = 501,
-  BadGateway = 502,
-  ServiceUnavailable = 503,
-  GatewayTimeout = 504,
-  HTTPVersionNotSupported = 505,
-  VariantAlsoNegotiates = 506,
-  InsufficientStorage = 507,
-  LoopDetected = 508,
-  NotExtended = 510,
-  NetworkAuthenticationRequired = 511,
-}
-
-export const HttpStatusText: Record<HttpCode, string> = {
-  [HttpCode.Continue]: 'Continue',
-  [HttpCode.SwitchingProtocols]: 'Switching Protocols',
-  [HttpCode.Processing]: 'Processing',
-  [HttpCode.EarlyHints]: 'Early Hints',
-  [HttpCode.OK]: 'OK',
-  [HttpCode.Created]: 'Created',
-  [HttpCode.Accepted]: 'Accepted',
-  [HttpCode.NonAuthoritativeInformation]: 'Non-Authoritative Information',
-  [HttpCode.NoContent]: 'No Content',
-  [HttpCode.ResetContent]: 'Reset Content',
-  [HttpCode.PartialContent]: 'Partial Content',
-  [HttpCode.MultiStatus]: 'Multi-Status',
-  [HttpCode.AlreadyReported]: 'Already Reported',
-  [HttpCode.IMUsed]: 'IM Used',
-  [HttpCode.MultipleChoices]: 'Multiple Choices',
-  [HttpCode.MovedPermanently]: 'Moved Permanently',
-  [HttpCode.Found]: 'Found',
-  [HttpCode.SeeOther]: 'See Other',
-  [HttpCode.NotModified]: 'Not Modified',
-  [HttpCode.UseProxy]: 'Use Proxy',
-  [HttpCode.TemporaryRedirect]: 'Temporary Redirect',
-  [HttpCode.PermanentRedirect]: 'Permanent Redirect',
-  [HttpCode.BadRequest]: 'Bad Request',
-  [HttpCode.Unauthorized]: 'Unauthorized',
-  [HttpCode.PaymentRequired]: 'Payment Required',
-  [HttpCode.Forbidden]: 'Forbidden',
-  [HttpCode.NotFound]: 'Not Found',
-  [HttpCode.MethodNotAllowed]: 'Method Not Allowed',
-  [HttpCode.NotAcceptable]: 'Not Acceptable',
-  [HttpCode.ProxyAuthenticationRequired]: 'Proxy Authentication Required',
-  [HttpCode.RequestTimeout]: 'Request Timeout',
-  [HttpCode.Conflict]: 'Conflict',
-  [HttpCode.Gone]: 'Gone',
-  [HttpCode.LengthRequired]: 'Length Required',
-  [HttpCode.PreconditionFailed]: 'Precondition Failed',
-  [HttpCode.PayloadTooLarge]: 'Payload Too Large',
-  [HttpCode.URITooLong]: 'URI Too Long',
-  [HttpCode.UnsupportedMediaType]: 'Unsupported Media Type',
-  [HttpCode.RangeNotSatisfiable]: 'Range Not Satisfiable',
-  [HttpCode.ExpectationFailed]: 'Expectation Failed',
-  [HttpCode.ImATeapot]: "I'm a Teapot",
-  [HttpCode.MisdirectedRequest]: 'Misdirected Request',
-  [HttpCode.UnprocessableEntity]: 'Unprocessable Entity',
-  [HttpCode.Locked]: 'Locked',
-  [HttpCode.FailedDependency]: 'Failed Dependency',
-  [HttpCode.TooEarly]: 'Too Early',
-  [HttpCode.UpgradeRequired]: 'Upgrade Required',
-  [HttpCode.PreconditionRequired]: 'Precondition Required',
-  [HttpCode.TooManyRequests]: 'Too Many Requests',
-  [HttpCode.RequestHeaderFieldsTooLarge]: 'Request Header Fields Too Large',
-  [HttpCode.UnavailableForLegalReasons]: 'Unavailable For Legal Reasons',
-  [HttpCode.InternalServerError]: 'Internal Server Error',
-  [HttpCode.NotImplemented]: 'Not Implemented',
-  [HttpCode.BadGateway]: 'Bad Gateway',
-  [HttpCode.ServiceUnavailable]: 'Service Unavailable',
-  [HttpCode.GatewayTimeout]: 'Gateway Timeout',
-  [HttpCode.HTTPVersionNotSupported]: 'HTTP Version Not Supported',
-  [HttpCode.VariantAlsoNegotiates]: 'Variant Also Negotiates',
-  [HttpCode.InsufficientStorage]: 'Insufficient Storage',
-  [HttpCode.LoopDetected]: 'Loop Detected',
-  [HttpCode.NotExtended]: 'Not Extended',
-  [HttpCode.NetworkAuthenticationRequired]: 'Network Authentication Required',
-}
-
-export const HttpCodeMap = {
-  [ErrorCode.ValidationError]: HttpCode.BadRequest,
-  [ErrorCode.BadRequest]: HttpCode.BadRequest,
-  [ErrorCode.NotFound]: HttpCode.NotFound,
-  [ErrorCode.Forbidden]: HttpCode.Forbidden,
-  [ErrorCode.Unauthorized]: HttpCode.Unauthorized,
-  [ErrorCode.InternalServerError]: HttpCode.InternalServerError,
-  [ErrorCode.NotAcceptable]: HttpCode.NotAcceptable,
-  [ErrorCode.RequestTimeout]: HttpCode.RequestTimeout,
-  [ErrorCode.GatewayTimeout]: HttpCode.GatewayTimeout,
-  [ErrorCode.ServiceUnavailable]: HttpCode.ServiceUnavailable,
-  [ErrorCode.ClientRequestError]: HttpCode.BadRequest,
-  [ErrorCode.ConnectionError]: HttpCode.NotAcceptable,
-}
-
-export const AllowedHttpMethod =
-  createMetadataKey<Array<'get' | 'post'>>('http:method')

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './injectables.ts'
-export * from './server.ts'
-export * from './transport.ts'
-export * from './types.ts'
-export * from './utils.ts'

package/src/injectables.ts

@@ -1,17 +0,0 @@
-import { createLazyInjectable, type LazyInjectable, Scope } from '@nmtjs/core'
-import { ProtocolInjectables } from '@nmtjs/protocol/server'
-import type { WsUserData } from './types.ts'
-
-const connectionData = ProtocolInjectables.connectionData as LazyInjectable<
-  WsUserData['request'],
-  Scope.Connection
->
-
-const httpResponseHeaders = createLazyInjectable<Headers, Scope.Call>(
-  Scope.Call,
-)
-
-export const WsTransportInjectables = {
-  connectionData,
-  httpResponseHeaders,
-} as const

package/src/server.ts

@@ -1,545 +0,0 @@
-import {
-  App,
-  type HttpRequest,
-  type HttpResponse,
-  SSLApp,
-  type TemplatedApp,
-  us_socket_local_port,
-} from 'uWebSockets.js'
-import { randomUUID } from 'node:crypto'
-import { once } from 'node:events'
-import { Duplex, Readable } from 'node:stream'
-import { Scope } from '@nmtjs/core'
-import {
-  ClientMessageType,
-  decodeNumber,
-  ErrorCode,
-  ProtocolBlob,
-  type ServerMessageType,
-} from '@nmtjs/protocol'
-import {
-  Connection,
-  getFormat,
-  isIterableResult,
-  type ProtocolApiCallOptions,
-  ProtocolClientStream,
-  ProtocolError,
-  ProtocolInjectables,
-  type Transport,
-  type TransportPluginContext,
-  UnsupportedContentTypeError,
-  UnsupportedFormatError,
-} from '@nmtjs/protocol/server'
-import {
-  AllowedHttpMethod,
-  HttpCode,
-  HttpCodeMap,
-  HttpStatusText,
-} from './http.ts'
-import { WsTransportInjectables } from './injectables.ts'
-import type {
-  WsConnectionData,
-  WsTransportOptions,
-  WsTransportSocket,
-  WsUserData,
-} from './types.ts'
-import {
-  getRequestBody,
-  getRequestData,
-  readableToArrayBuffer,
-  send,
-  setHeaders,
-} from './utils.ts'
-
-const DEFAULT_ALLOWED_METHODS = ['post'] as ('get' | 'post')[]
-
-export class WsTransportServer implements Transport<WsConnectionData> {
-  protected server!: TemplatedApp
-  protected clients: Map<string, WsTransportSocket> = new Map()
-
-  constructor(
-    protected readonly context: TransportPluginContext,
-    protected readonly options: WsTransportOptions,
-  ) {
-    this.server = this.options.tls ? SSLApp(options.tls!) : App()
-    this.server
-      .options('/*', (res, req) => {
-        this.applyCors(res, req)
-        res.writeStatus('200 OK')
-        res.endWithoutBody()
-      })
-      .get('/healthy', (res, req) => {
-        this.applyCors(res, req)
-        res.writeHeader('Content-Type', 'text/plain')
-        res.end('OK')
-      })
-      .ws<WsUserData>('/api', {
-        sendPingsAutomatically: true,
-        maxPayloadLength: this.options.maxPayloadLength,
-        upgrade: async (res, req, socketContext) => {
-          const ac = new AbortController()
-
-          res.onAborted(ac.abort.bind(ac))
-
-          const requestData = getRequestData(req, res)
-          const contentType =
-            requestData.query.get('content-type') ||
-            requestData.headers.get('content-type')
-          const acceptType =
-            requestData.query.get('accept') || requestData.headers.get('accept')
-
-          const connectionId = randomUUID()
-          const controller = new AbortController()
-          try {
-            const { context } = await this.protocol.addConnection(
-              this,
-              { id: connectionId, data: { type: 'ws' } },
-              { acceptType, contentType },
-            )
-            context.container.provide(
-              WsTransportInjectables.connectionData,
-              requestData,
-            )
-            context.container.provide(
-              ProtocolInjectables.connectionAbortSignal,
-              controller.signal,
-            )
-
-            if (!ac.signal.aborted) {
-              res.cork(() => {
-                res.upgrade(
-                  {
-                    id: connectionId,
-                    request: requestData,
-                    contentType,
-                    acceptType,
-                    backpressure: null,
-                    context,
-                    controller,
-                  } as WsUserData,
-                  req.getHeader('sec-websocket-key'),
-                  req.getHeader('sec-websocket-protocol'),
-                  req.getHeader('sec-websocket-extensions'),
-                  socketContext,
-                )
-              })
-            }
-          } catch (error) {
-            this.logger.debug(
-              new Error('Failed to upgrade connection', { cause: error }),
-            )
-            if (!ac.signal.aborted) {
-              res.cork(() => {
-                res.writeStatus('500 Internal Server Error')
-                res.endWithoutBody()
-              })
-            }
-          }
-        },
-        open: (ws: WsTransportSocket) => {
-          const { id } = ws.getUserData()
-          this.logger.debug('Connection %s opened', id)
-          this.clients.set(id, ws)
-        },
-        message: async (ws: WsTransportSocket, buffer) => {
-          const messageType = decodeNumber(buffer, 'Uint8')
-          if (messageType in this === false) {
-            ws.end(1011, 'Unknown message type')
-          } else {
-            try {
-              await this[messageType](
-                ws,
-                buffer.slice(Uint8Array.BYTES_PER_ELEMENT),
-              )
-            } catch (error: any) {
-              this.logError(error, 'Error while processing message')
-            }
-          }
-        },
-        drain: (ws: WsTransportSocket) => {
-          const data = ws.getUserData()
-          data.backpressure?.resolve()
-          data.backpressure = null
-        },
-        close: async (ws: WsTransportSocket, code, message) => {
-          const { id, controller } = ws.getUserData()
-          controller.abort()
-          this.logger.debug(
-            'Connection %s closed with code %s: %s',
-            id,
-            code,
-            Buffer.from(message).toString(),
-          )
-          this.clients.delete(id)
-          await this.protocol.removeConnection(id)
-        },
-      })
-      .get('/api/:namespace/:procedure', this.httpHandler.bind(this))
-      .post('/api/:namespace/:procedure', this.httpHandler.bind(this))
-  }
-
-  send(
-    connection: Connection<WsConnectionData>,
-    messageType: ServerMessageType,
-    buffer: ArrayBuffer,
-  ) {
-    const ws = this.clients.get(connection.id)
-    if (ws) send(ws, messageType, buffer)
-  }
-
-  async start() {
-    return new Promise<void>((resolve, reject) => {
-      const { hostname = '127.0.0.1', port = 0, unix } = this.options
-      if (unix) {
-        this.server.listen_unix((socket) => {
-          if (socket) {
-            this.logger.info('Server started on unix://%s', unix)
-            resolve()
-          } else {
-            reject(new Error('Failed to start WebSockets server'))
-          }
-        }, unix)
-      } else {
-        this.server.listen(hostname, port, (socket) => {
-          if (socket) {
-            this.logger.info(
-              'WebSocket Server started on %s:%s',
-              hostname,
-              us_socket_local_port(socket),
-            )
-            resolve()
-          } else {
-            reject(new Error('Failed to start WebSockets server'))
-          }
-        })
-      }
-    })
-  }
-
-  async stop() {
-    this.server.close()
-  }
-
-  // TODO: decompose this mess
-  protected async httpHandler(res: HttpResponse, req: HttpRequest) {
-    this.applyCors(res, req)
-
-    const controller = new AbortController()
-
-    res.onAborted(controller.abort.bind(controller))
-
-    const method = req.getMethod() as 'get' | 'post'
-    const namespace = req.getParameter('namespace')
-    const procedure = req.getParameter('procedure')
-    const requestData = getRequestData(req, res)
-
-    if (!namespace || !procedure) {
-      const status = HttpCode.NotFound
-      const text = HttpStatusText[status]
-      return void res.cork(() => {
-        if (controller.signal.aborted) return
-        res.writeStatus(`${status} ${text}`)
-        res.endWithoutBody()
-      })
-    }
-
-    const isBlob = requestData.headers.get('x-neemata-blob') === 'true'
-
-    const contentType = requestData.headers.get('content-type')
-    const acceptType = requestData.headers.get('accept')
-    const connectionId = randomUUID()
-    const connection = new Connection<WsConnectionData>({
-      id: connectionId,
-      data: { type: 'http' },
-    })
-    const responseHeaders = new Headers()
-    const container = this.context.container.fork(Scope.Call)
-    container.provide(ProtocolInjectables.connection, connection)
-    container.provide(
-      ProtocolInjectables.connectionAbortSignal,
-      controller.signal,
-    )
-    container.provide(WsTransportInjectables.connectionData, requestData)
-    container.provide(
-      WsTransportInjectables.httpResponseHeaders,
-      responseHeaders,
-    )
-
-    const body = method === 'post' ? getRequestBody(res) : undefined
-
-    const metadata: ProtocolApiCallOptions['metadata'] = (metadata) => {
-      const allowHttpMethod =
-        metadata.get(AllowedHttpMethod) ?? DEFAULT_ALLOWED_METHODS
-      if (!allowHttpMethod.includes(method)) {
-        throw new ProtocolError(ErrorCode.NotFound)
-      }
-    }
-    let format: ReturnType<typeof getFormat>
-    try {
-      format = getFormat(this.context.format, {
-        acceptType,
-        contentType: isBlob ? '*/*' : contentType,
-      })
-
-      let payload: any
-
-      if (body) {
-        if (isBlob) {
-          const type = contentType || 'application/octet-stream'
-          const contentLength = requestData.headers.get('content-length')
-          const size = contentLength
-            ? Number.parseInt(contentLength)
-            : undefined
-          const stream = new ProtocolClientStream(-1, { size, type })
-          body.pipe(stream)
-          payload = stream
-        } else {
-          const buffer = await readableToArrayBuffer(body)
-          if (buffer.byteLength > 0) {
-            payload = format.decoder.decode(buffer)
-          }
-        }
-      }
-
-      const result = await this.protocol.call({
-        connection,
-        namespace,
-        procedure,
-        payload,
-        metadata,
-        container,
-        signal: controller.signal,
-      })
-
-      if (isIterableResult(result)) {
-        res.cork(() => {
-          if (controller.signal.aborted) return
-          const status = HttpCode.NotImplemented
-          const text = HttpStatusText[status]
-          res.writeStatus(`${status} ${text}`)
-          res.end()
-        })
-      } else {
-        const { output } = result
-
-        if (output instanceof ProtocolBlob) {
-          const { source, metadata } = output
-          const { type } = metadata
-
-          let stream: Readable
-
-          if (source instanceof ReadableStream) {
-            stream = Readable.fromWeb(source as any)
-          } else if (source instanceof Readable || source instanceof Duplex) {
-            stream = Readable.from(source)
-          } else {
-            throw new Error('Invalid stream source')
-          }
-
-          res.cork(() => {
-            if (controller.signal.aborted) return
-            responseHeaders.set('X-Neemata-Blob', 'true')
-            responseHeaders.set('Content-Type', type)
-            if (metadata.size)
-              res.writeHeader('Content-Length', metadata.size.toString())
-            setHeaders(res, responseHeaders)
-          })
-
-          controller.signal.addEventListener('abort', () => stream.destroy(), {
-            once: true,
-          })
-
-          stream.on('data', (chunk) => {
-            if (controller.signal.aborted) return
-            const buf = Buffer.from(chunk)
-            const ab = buf.buffer.slice(
-              buf.byteOffset,
-              buf.byteOffset + buf.byteLength,
-            )
-            const ok = res.write(ab)
-            if (!ok) {
-              stream.pause()
-              res.onWritable(() => {
-                stream.resume()
-                return true
-              })
-            }
-          })
-          await once(stream, 'end')
-          if (stream.readableAborted) {
-            res.end(undefined, true)
-          } else {
-            res.end()
-          }
-        } else {
-          res.cork(() => {
-            if (controller.signal.aborted) return
-            const status = HttpCode.OK
-            const text = HttpStatusText[status]
-            const buffer = format.encoder.encode(output)
-            res.writeStatus(`${status} ${text}`)
-            responseHeaders.set('Content-Type', format.encoder.contentType)
-            setHeaders(res, responseHeaders)
-            res.end(buffer)
-          })
-        }
-      }
-    } catch (error) {
-      if (controller.signal.aborted) return
-      if (error instanceof UnsupportedFormatError) {
-        res.cork(() => {
-          if (controller.signal.aborted) return
-          const status =
-            error instanceof UnsupportedContentTypeError
-              ? HttpCode.UnsupportedMediaType
-              : HttpCode.NotAcceptable
-          const text = HttpStatusText[status]
-          res.writeStatus(`${status} ${text}`)
-          res.end()
-        })
-      } else if (error instanceof ProtocolError) {
-        res.cork(() => {
-          if (controller.signal.aborted) return
-          const status =
-            error.code in HttpCodeMap
-              ? HttpCodeMap[error.code]
-              : HttpCode.InternalServerError
-          const text = HttpStatusText[status]
-          res.writeStatus(`${status} ${text}`)
-          res.end(format!.encoder.encode(error))
-        })
-      } else {
-        this.logError(error, 'Unknown error while processing request')
-        res.cork(() => {
-          if (controller.signal.aborted) return
-          const status = HttpCode.InternalServerError
-          const text = HttpStatusText[status]
-          const payload = format!.encoder.encode(
-            new ProtocolError(
-              ErrorCode.InternalServerError,
-              'Internal Server Error',
-            ),
-          )
-          res.writeStatus(`${status} ${text}`)
-          res.end(payload)
-        })
-      }
-    } finally {
-      container.dispose().catch((error) => {
-        this.logError(error, 'Error while disposing call container')
-      })
-    }
-  }
-
-  protected get protocol() {
-    return this.context.protocol
-  }
-
-  protected get logger() {
-    return this.context.logger
-  }
-
-  protected async logError(
-    cause: any,
-    message = 'Unknown error while processing request',
-  ) {
-    this.logger.error(new Error(message, { cause }))
-  }
-
-  protected applyCors(res: HttpResponse, req: HttpRequest) {
-    if (this.options.cors === false) return
-
-    const origin = req.getHeader('origin')
-    if (!origin) return
-
-    let allowed = false
-
-    if (this.options.cors === undefined || this.options.cors === true) {
-      allowed = true
-    } else if (Array.isArray(this.options.cors)) {
-      allowed = this.options.cors.includes(origin)
-    } else {
-      allowed = this.options.cors(origin)
-    }
-
-    if (!allowed) return
-
-    res.writeHeader('Access-Control-Allow-Origin', origin)
-    res.writeHeader('Access-Control-Allow-Headers', 'Content-Type')
-    res.writeHeader('Access-Control-Allow-Methods', 'GET, POST')
-    res.writeHeader('Access-Control-Allow-Credentials', 'true')
-  }
-
-  protected [ClientMessageType.Rpc](
-    ws: WsTransportSocket,
-    buffer: ArrayBuffer,
-  ) {
-    const { id } = ws.getUserData()
-    this.protocol.rpcRaw(id, buffer)
-  }
-
-  protected [ClientMessageType.RpcAbort](
-    ws: WsTransportSocket,
-    buffer: ArrayBuffer,
-  ) {
-    const { id } = ws.getUserData()
-    this.protocol.rpcAbortRaw(id, buffer)
-  }
-
-  protected [ClientMessageType.RpcStreamAbort](
-    ws: WsTransportSocket,
-    buffer: ArrayBuffer,
-  ) {
-    const { id } = ws.getUserData()
-    this.protocol.rpcStreamAbortRaw(id, buffer)
-  }
-
-  protected [ClientMessageType.ClientStreamPush](
-    ws: WsTransportSocket,
-    buffer: ArrayBuffer,
-  ) {
-    const { id } = ws.getUserData()
-    const streamId = decodeNumber(buffer, 'Uint32')
-    this.protocol.pushClientStream(
-      id,
-      streamId,
-      buffer.slice(Uint32Array.BYTES_PER_ELEMENT),
-    )
-  }
-
-  protected [ClientMessageType.ClientStreamEnd](
-    ws: WsTransportSocket,
-    buffer: ArrayBuffer,
-  ) {
-    const { id } = ws.getUserData()
-    const streamId = decodeNumber(buffer, 'Uint32')
-    this.protocol.endClientStream(id, streamId)
-  }
-
-  protected [ClientMessageType.ClientStreamAbort](
-    ws: WsTransportSocket,
-    buffer: ArrayBuffer,
-  ) {
-    const { id } = ws.getUserData()
-    const streamId = decodeNumber(buffer, 'Uint32')
-    this.protocol.abortClientStream(id, streamId)
-  }
-
-  protected [ClientMessageType.ServerStreamPull](
-    ws: WsTransportSocket,
-    buffer: ArrayBuffer,
-  ) {
-    const { id } = ws.getUserData()
-    const streamId = decodeNumber(buffer, 'Uint32')
-    this.protocol.pullServerStream(id, streamId)
-  }
-
-  protected [ClientMessageType.ServerStreamAbort](
-    ws: WsTransportSocket,
-    buffer: ArrayBuffer,
-  ) {
-    const { id } = ws.getUserData()
-    const streamId = decodeNumber(buffer, 'Uint32')
-    this.protocol.abortServerStream(id, streamId)
-  }
-}

package/src/transport.ts

@@ -1,10 +0,0 @@
-import { createTransport } from '@nmtjs/protocol/server'
-import { WsTransportServer } from './server.ts'
-import type { WsConnectionData, WsTransportOptions } from './types.ts'
-
-export const WsTransport = createTransport<
-  WsConnectionData,
-  WsTransportOptions
->('WsTransport', (context, options) => {
-  return new WsTransportServer(context, options)
-})

package/src/types.ts

@@ -1,28 +0,0 @@
-import type { AppOptions, WebSocket } from 'uWebSockets.js'
-import type { InteractivePromise } from '@nmtjs/common'
-import type { Connection, ConnectionContext } from '@nmtjs/protocol/server'
-import type { RequestData } from './utils.ts'
-
-export type WsConnectionData = { type: 'ws' | 'http' }
-
-export type WsUserData = {
-  id: Connection['id']
-  backpressure: InteractivePromise<void> | null
-  request: RequestData
-  acceptType: string | null
-  contentType: string | null
-  context: ConnectionContext
-  controller: AbortController
-}
-
-export type WsTransportSocket = WebSocket<WsUserData>
-
-export type WsTransportOptions = {
-  port?: number
-  hostname?: string
-  unix?: string
-  tls?: AppOptions
-  cors?: boolean | string[] | ((origin: string) => boolean)
-  maxPayloadLength?: number
-  maxStreamChunkLength?: number
-}

package/src/utils.ts

@@ -1,126 +0,0 @@
-import type { HttpRequest, HttpResponse } from 'uWebSockets.js'
-import { PassThrough, type Readable } from 'node:stream'
-import { createPromise } from '@nmtjs/common'
-import { concat, ErrorCode, encodeNumber } from '@nmtjs/protocol'
-import { ProtocolError } from '@nmtjs/protocol/server'
-import type { WsTransportSocket } from './types.ts'
-
-export const send = (
-  ws: WsTransportSocket,
-  type: number,
-  ...buffers: ArrayBuffer[]
-): boolean | null => {
-  const data = ws.getUserData()
-  try {
-    const buffer = concat(encodeNumber(type, 'Uint8'), ...buffers)
-    const result = ws.send(buffer, true)
-    if (result === 0) {
-      data.backpressure = createPromise()
-      return false
-    }
-    if (result === 2) {
-      return null
-    }
-    return true
-  } catch {
-    return null
-  }
-}
-
-export const toRecord = (input: {
-  forEach: (cb: (value, key) => void) => void
-}) => {
-  const obj: Record<string, string> = {}
-  input.forEach((value, key) => {
-    obj[key] = value
-  })
-  return obj
-}
-
-export type RequestData = Readonly<{
-  url: string
-  origin: URL | null
-  method: string
-  headers: Headers
-  querystring: string
-  query: URLSearchParams
-  remoteAddress: string
-  proxiedRemoteAddress: string
-}>
-
-export const getRequestData = (
-  req: HttpRequest,
-  res: HttpResponse,
-): RequestData => {
-  const url = req.getUrl()
-  const method = req.getMethod()
-  const headers = new Headers()
-  const querystring = req.getQuery()
-  const query = new URLSearchParams(querystring)
-  const origin = headers.get('origin')
-  const proxiedRemoteAddress = res.getProxiedRemoteAddressAsText()
-  const remoteAddress = res.getRemoteAddressAsText()
-
-  req.forEach((key, value) => headers.append(key, value))
-
-  return Object.freeze({
-    url,
-    origin: origin ? new URL(url, origin) : null,
-    method,
-    headers,
-    querystring,
-    query,
-    remoteAddress: Buffer.from(remoteAddress).toString(),
-    proxiedRemoteAddress: Buffer.from(proxiedRemoteAddress).toString(),
-  })
-}
-
-export function getRequestBody(res: HttpResponse) {
-  const stream = new PassThrough()
-  res.onData((chunk, isLast) => {
-    stream.write(Buffer.from(chunk))
-    if (isLast) stream.end()
-  })
-  res.onAborted(() => stream.destroy())
-  return stream
-}
-
-export function setHeaders(res: HttpResponse, headers: Headers) {
-  headers.forEach((value, key) => {
-    if (key === 'set-cookie') return
-    res.writeHeader(key, value)
-  })
-  const cookies = headers.getSetCookie()
-  if (cookies) {
-    for (const cookie of cookies) {
-      res.writeHeader('set-cookie', cookie)
-    }
-  }
-}
-
-export function readableToArrayBuffer(stream: Readable): Promise<ArrayBuffer> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = []
-    stream.on('data', (chunk) => {
-      chunks.push(chunk)
-    })
-    stream.on('end', () => {
-      resolve(Buffer.concat(chunks).buffer)
-    })
-    stream.on('error', (error) => {
-      reject(error)
-    })
-  })
-}
-
-export const InternalError = (message = 'Internal Server Error') =>
-  new ProtocolError(ErrorCode.InternalServerError, message)
-
-export const NotFoundError = (message = 'Not Found') =>
-  new ProtocolError(ErrorCode.NotFound, message)
-
-export const ForbiddenError = (message = 'Forbidden') =>
-  new ProtocolError(ErrorCode.Forbidden, message)
-
-export const RequestTimeoutError = (message = 'Request Timeout') =>
-  new ProtocolError(ErrorCode.RequestTimeout, message)