@nmtjs/http-transport 0.15.0-beta.3 → 0.15.0-beta.4

package/package.json

@@ -9,20 +9,20 @@
   },
   "devDependencies": {
     "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.56.0",
-    "@nmtjs/client": "0.15.0-beta.3",
-    "@nmtjs/common": "0.15.0-beta.3",
-    "@nmtjs/gateway": "0.15.0-beta.3",
-    "@nmtjs/protocol": "0.15.0-beta.3"
+    "@nmtjs/client": "0.15.0-beta.4",
+    "@nmtjs/common": "0.15.0-beta.4",
+    "@nmtjs/gateway": "0.15.0-beta.4",
+    "@nmtjs/protocol": "0.15.0-beta.4"
   },
   "peerDependencies": {
     "@types/bun": "^1.3.0",
     "@types/deno": "^2.3.0",
     "@types/node": "^24",
     "uWebSockets.js": "^20.56.0",
-    "@nmtjs/common": "0.15.0-beta.3",
-    "@nmtjs/core": "0.15.0-beta.3",
-    "@nmtjs/gateway": "0.15.0-beta.3",
-    "@nmtjs/protocol": "0.15.0-beta.3"
+    "@nmtjs/common": "0.15.0-beta.4",
+    "@nmtjs/core": "0.15.0-beta.4",
+    "@nmtjs/gateway": "0.15.0-beta.4",
+    "@nmtjs/protocol": "0.15.0-beta.4"
   },
   "peerDependenciesMeta": {
     "@types/bun": {
@@ -45,10 +45,11 @@
   },
   "files": [
     "dist",
+    "src",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.3",
+  "version": "0.15.0-beta.4",
   "scripts": {
     "clean-build": "rm -rf ./dist",
     "build": "tsc --declaration --sourcemap",

package/src/constants.ts

@@ -0,0 +1,152 @@
+import { createMetadataKey } from '@nmtjs/core'
+import { ErrorCode } from '@nmtjs/protocol'
+
+export enum HttpStatus {
+  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<HttpStatus, string> = {
+  [HttpStatus.Continue]: 'Continue',
+  [HttpStatus.SwitchingProtocols]: 'Switching Protocols',
+  [HttpStatus.Processing]: 'Processing',
+  [HttpStatus.EarlyHints]: 'Early Hints',
+  [HttpStatus.OK]: 'OK',
+  [HttpStatus.Created]: 'Created',
+  [HttpStatus.Accepted]: 'Accepted',
+  [HttpStatus.NonAuthoritativeInformation]: 'Non-Authoritative Information',
+  [HttpStatus.NoContent]: 'No Content',
+  [HttpStatus.ResetContent]: 'Reset Content',
+  [HttpStatus.PartialContent]: 'Partial Content',
+  [HttpStatus.MultiStatus]: 'Multi-Status',
+  [HttpStatus.AlreadyReported]: 'Already Reported',
+  [HttpStatus.IMUsed]: 'IM Used',
+  [HttpStatus.MultipleChoices]: 'Multiple Choices',
+  [HttpStatus.MovedPermanently]: 'Moved Permanently',
+  [HttpStatus.Found]: 'Found',
+  [HttpStatus.SeeOther]: 'See Other',
+  [HttpStatus.NotModified]: 'Not Modified',
+  [HttpStatus.UseProxy]: 'Use Proxy',
+  [HttpStatus.TemporaryRedirect]: 'Temporary Redirect',
+  [HttpStatus.PermanentRedirect]: 'Permanent Redirect',
+  [HttpStatus.BadRequest]: 'Bad Request',
+  [HttpStatus.Unauthorized]: 'Unauthorized',
+  [HttpStatus.PaymentRequired]: 'Payment Required',
+  [HttpStatus.Forbidden]: 'Forbidden',
+  [HttpStatus.NotFound]: 'Not Found',
+  [HttpStatus.MethodNotAllowed]: 'Method Not Allowed',
+  [HttpStatus.NotAcceptable]: 'Not Acceptable',
+  [HttpStatus.ProxyAuthenticationRequired]: 'Proxy Authentication Required',
+  [HttpStatus.RequestTimeout]: 'Request Timeout',
+  [HttpStatus.Conflict]: 'Conflict',
+  [HttpStatus.Gone]: 'Gone',
+  [HttpStatus.LengthRequired]: 'Length Required',
+  [HttpStatus.PreconditionFailed]: 'Precondition Failed',
+  [HttpStatus.PayloadTooLarge]: 'Payload Too Large',
+  [HttpStatus.URITooLong]: 'URI Too Long',
+  [HttpStatus.UnsupportedMediaType]: 'Unsupported Media Type',
+  [HttpStatus.RangeNotSatisfiable]: 'Range Not Satisfiable',
+  [HttpStatus.ExpectationFailed]: 'Expectation Failed',
+  [HttpStatus.ImATeapot]: "I'm a Teapot",
+  [HttpStatus.MisdirectedRequest]: 'Misdirected Request',
+  [HttpStatus.UnprocessableEntity]: 'Unprocessable Entity',
+  [HttpStatus.Locked]: 'Locked',
+  [HttpStatus.FailedDependency]: 'Failed Dependency',
+  [HttpStatus.TooEarly]: 'Too Early',
+  [HttpStatus.UpgradeRequired]: 'Upgrade Required',
+  [HttpStatus.PreconditionRequired]: 'Precondition Required',
+  [HttpStatus.TooManyRequests]: 'Too Many Requests',
+  [HttpStatus.RequestHeaderFieldsTooLarge]: 'Request Header Fields Too Large',
+  [HttpStatus.UnavailableForLegalReasons]: 'Unavailable For Legal Reasons',
+  [HttpStatus.InternalServerError]: 'Internal Server Error',
+  [HttpStatus.NotImplemented]: 'Not Implemented',
+  [HttpStatus.BadGateway]: 'Bad Gateway',
+  [HttpStatus.ServiceUnavailable]: 'Service Unavailable',
+  [HttpStatus.GatewayTimeout]: 'Gateway Timeout',
+  [HttpStatus.HTTPVersionNotSupported]: 'HTTP Version Not Supported',
+  [HttpStatus.VariantAlsoNegotiates]: 'Variant Also Negotiates',
+  [HttpStatus.InsufficientStorage]: 'Insufficient Storage',
+  [HttpStatus.LoopDetected]: 'Loop Detected',
+  [HttpStatus.NotExtended]: 'Not Extended',
+  [HttpStatus.NetworkAuthenticationRequired]: 'Network Authentication Required',
+}
+
+export const HttpCodeMap = {
+  [ErrorCode.ValidationError]: HttpStatus.BadRequest,
+  [ErrorCode.BadRequest]: HttpStatus.BadRequest,
+  [ErrorCode.NotFound]: HttpStatus.NotFound,
+  [ErrorCode.Forbidden]: HttpStatus.Forbidden,
+  [ErrorCode.Unauthorized]: HttpStatus.Unauthorized,
+  [ErrorCode.InternalServerError]: HttpStatus.InternalServerError,
+  [ErrorCode.NotAcceptable]: HttpStatus.NotAcceptable,
+  [ErrorCode.RequestTimeout]: HttpStatus.RequestTimeout,
+  [ErrorCode.GatewayTimeout]: HttpStatus.GatewayTimeout,
+  [ErrorCode.ServiceUnavailable]: HttpStatus.ServiceUnavailable,
+  [ErrorCode.ClientRequestError]: HttpStatus.BadRequest,
+  [ErrorCode.ConnectionError]: HttpStatus.NotAcceptable,
+}
+
+export const AllowedHttpMethod =
+  createMetadataKey<Array<'get' | 'post' | 'put' | 'delete' | 'patch'>>(
+    'http:method',
+  )

package/src/index.ts

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

package/src/injectables.ts

@@ -0,0 +1,11 @@
+import { createLazyInjectable, Scope } from '@nmtjs/core'
+import { connectionData as connectionDataInjectable } from '@nmtjs/gateway'
+
+import type { HttpTransportServerRequest } from './types.ts'
+
+export const connectionData =
+  connectionDataInjectable.$withType<HttpTransportServerRequest>()
+
+export const httpResponseHeaders = createLazyInjectable<Headers, Scope.Call>(
+  Scope.Call,
+)

package/src/runtimes/bun.ts

@@ -0,0 +1,91 @@
+import type { Transport } from '@nmtjs/gateway'
+import type { ConnectionType } from '@nmtjs/protocol'
+import { ProxyableTransportType } from '@nmtjs/gateway'
+
+import type {
+  HttpAdapterParams,
+  HttpAdapterServer,
+  HttpTransportOptions,
+} from '../types.ts'
+import * as injectables from '../injectables.ts'
+import { createHTTPTransportWorker } from '../server.ts'
+import {
+  InternalServerErrorHttpResponse,
+  NotFoundHttpResponse,
+  StatusResponse,
+} from '../utils.ts'
+
+function adapterFactory(params: HttpAdapterParams<'bun'>): HttpAdapterServer {
+  let server: Bun.Server<undefined> | null = null
+
+  function createServer() {
+    return globalThis.Bun.serve({
+      ...params.runtime,
+      unix: params.listen.unix as string,
+      port: params.listen.port ?? 0,
+      hostname: params.listen.hostname,
+      reusePort: params.listen.reusePort,
+      tls: params.tls
+        ? {
+            cert: params.tls.cert,
+            key: params.tls.key,
+            passphrase: params.tls.passphrase,
+          }
+        : undefined,
+      // @ts-expect-error
+      routes: {
+        ...params.runtime?.routes,
+        '/healthy': { GET: StatusResponse },
+      },
+      async fetch(request, server) {
+        const url = new URL(request.url)
+        try {
+          if (request.headers.get('upgrade') === 'websocket')
+            return NotFoundHttpResponse()
+          const { body, headers, method } = request
+          return await params.fetchHandler(
+            { url, method, headers },
+            body,
+            request.signal,
+          )
+        } catch (err) {
+          // TODO: proper logging
+          console.error(err)
+          // params.logger.error({ err }, 'Error in fetch handler')
+          return InternalServerErrorHttpResponse()
+        }
+      },
+    })
+  }
+
+  return {
+    runtime: {
+      get bun() {
+        return server!
+      },
+    },
+    start: async () => {
+      server = createServer()
+      return server!.url.href
+    },
+    stop: async () => {
+      if (server) {
+        await server.stop()
+        server = null
+      }
+    },
+  }
+}
+
+export const HttpTransport: Transport<
+  ConnectionType.Unidirectional,
+  HttpTransportOptions<'deno'>,
+  typeof injectables,
+  ProxyableTransportType.HTTP
+> = {
+  proxyable: ProxyableTransportType.HTTP,
+  injectables,
+  factory(options) {
+    return createHTTPTransportWorker(adapterFactory, options)
+  },
+}

package/src/runtimes/deno.ts

@@ -0,0 +1,139 @@
+import type { Transport } from '@nmtjs/gateway'
+import type { ConnectionType } from '@nmtjs/protocol'
+import { ProxyableTransportType } from '@nmtjs/gateway'
+
+import type {
+  DenoServer,
+  HttpAdapterParams,
+  HttpAdapterServer,
+  HttpTransportOptions,
+} from '../types.ts'
+import * as injectables from '../injectables.ts'
+import { createHTTPTransportWorker } from '../server.ts'
+import {
+  InternalServerErrorHttpResponse,
+  NotFoundHttpResponse,
+  StatusResponse,
+} from '../utils.ts'
+
+interface DenoNetAddr {
+  transport: 'tcp' | 'udp'
+  hostname: string
+  port: number
+}
+
+interface DenoUnixAddr {
+  transport: 'unix' | 'unixpacket'
+  path: string
+}
+
+interface DenoVsockAddr {
+  transport: 'vsock'
+  cid: number
+  port: number
+}
+
+type DenoAddr = DenoNetAddr | DenoUnixAddr | DenoVsockAddr
+
+function adapterFactory(params: HttpAdapterParams<'deno'>): HttpAdapterServer {
+  let server: DenoServer | null = null
+
+  function createServer() {
+    const listenOptions = params.listen.unix
+      ? { path: params.listen.unix }
+      : {
+          port: params.listen.port,
+          hostname: params.listen.hostname,
+          reusePort: params.listen.reusePort,
+        }
+    const options = {
+      ...listenOptions,
+      tls: params.tls
+        ? {
+            cert: params.tls.cert,
+            key: params.tls.key,
+            passphrase: params.tls.passphrase,
+          }
+        : undefined,
+    }
+
+    return new Promise<{ server: DenoServer; addr: DenoAddr }>((resolve) => {
+      const server = globalThis.Deno.serve({
+        ...params.runtime,
+        ...options,
+        handler: async (request: Request, info: any) => {
+          const url = new URL(request.url)
+          if (url.pathname === '/healthy') {
+            return StatusResponse()
+          }
+          try {
+            if (request.headers.get('upgrade') === 'websocket') {
+              return NotFoundHttpResponse()
+            }
+            const { headers, method, body } = request
+            return await params.fetchHandler(
+              { url, method, headers },
+              body,
+              request.signal,
+            )
+          } catch (err) {
+            // TODO: proper logging
+            console.error(err)
+            // params.logger.error({ err }, 'Error in fetch handler')
+            return InternalServerErrorHttpResponse()
+          }
+        },
+        onListen(addr: DenoAddr) {
+          setTimeout(() => {
+            resolve({ server, addr })
+          }, 1)
+        },
+      })
+    })
+  }
+
+  return {
+    runtime: {
+      get deno() {
+        return server!
+      },
+    },
+    start: async () => {
+      const { server: _server, addr } = await createServer()
+      server = _server
+      switch (addr.transport) {
+        case 'unix':
+        case 'unixpacket':
+          return `unix://${addr.path}`
+        case 'tcp':
+        case 'udp': {
+          const proto = params.tls ? 'https' : 'http'
+          return `${proto}://${addr.hostname}:${addr.port}`
+        }
+        case 'vsock':
+          return `vsock://${addr.cid}:${addr.port}`
+        default:
+          throw new Error(`Unsupported address transport`)
+      }
+    },
+    stop: async () => {
+      if (server) {
+        await server.shutdown()
+        server = null
+      }
+    },
+  }
+}
+
+export const HttpTransport: Transport<
+  ConnectionType.Unidirectional,
+  HttpTransportOptions<'deno'>,
+  typeof injectables,
+  ProxyableTransportType.HTTP
+> = {
+  proxyable: ProxyableTransportType.HTTP,
+  injectables,
+  factory(options) {
+    return createHTTPTransportWorker(adapterFactory, options)
+  },
+}

package/src/runtimes/node.ts

@@ -0,0 +1,157 @@
+import {} from 'node:dns'
+import { setTimeout } from 'node:timers/promises'
+
+import type { Transport } from '@nmtjs/gateway'
+import type { ConnectionType } from '@nmtjs/protocol'
+import { ProxyableTransportType } from '@nmtjs/gateway'
+
+import type {
+  HttpAdapterParams,
+  HttpAdapterServer,
+  HttpTransportOptions,
+} from '../types.ts'
+import * as injectables from '../injectables.ts'
+import { createHTTPTransportWorker } from '../server.ts'
+import {
+  InternalServerErrorHttpResponse,
+  NotFoundHttpResponse,
+  StatusResponse,
+} from '../utils.ts'
+
+import { App, SSLApp, us_socket_local_port } from 'uWebSockets.js'
+
+function adapterFactory(params: HttpAdapterParams<'node'>): HttpAdapterServer {
+  const server = params.tls
+    ? SSLApp({
+        passphrase: params.tls.passphrase,
+        key_file_name: params.tls.key,
+        cert_file_name: params.tls.cert,
+      })
+    : App()
+
+  server
+    .get('/healthy', async (res) => {
+      res.onAborted(() => {})
+      const response = StatusResponse()
+      res.cork(async () => {
+        res
+          .writeStatus(`${response.status} ${response.statusText}`)
+          .end(await response.arrayBuffer())
+      })
+    })
+    .any('/*', async (res, req) => {
+      const controller = new AbortController()
+      res.onAborted(() => {
+        res.aborted = true
+        controller.abort()
+      })
+
+      let response = NotFoundHttpResponse()
+
+      const headers = new Headers()
+      const method = req.getMethod()
+      req.forEach((k, v) => headers.append(k, v))
+
+      const host = headers.get('host') || 'localhost'
+      const proto =
+        headers.get('x-forwarded-proto') || params.tls ? 'https' : 'http'
+      const url = new URL(req.getUrl(), `${proto}://${host}`)
+
+      try {
+        const body = new ReadableStream({
+          start(controller) {
+            res.onData((chunk, isLast) => {
+              if (chunk) {
+                const copy = Buffer.allocUnsafe(chunk.byteLength)
+                copy.set(new Uint8Array(chunk))
+                controller.enqueue(copy)
+              }
+              if (isLast) controller.close()
+            })
+            res.onAborted(() => controller.error())
+          },
+        })
+        response = await params.fetchHandler(
+          { url, method, headers },
+          body,
+          controller.signal,
+        )
+      } catch (err) {
+        // TODO: proper logging
+        console.error(err)
+        // params.logger.error({ err }, 'Error in fetch handler')
+        response = InternalServerErrorHttpResponse()
+      }
+      if (res.aborted) return undefined
+      else {
+        res.cork(() => {
+          if (res.aborted) return undefined
+          res.writeStatus(
+            `${response.status.toString()} ${response.statusText}`,
+          )
+          response.headers.forEach((v, k) => res.writeHeader(k, v))
+        })
+        if (response.body) {
+          try {
+            const reader = response.body.getReader()
+            let chunk = await reader.read()
+            do {
+              if (res.aborted) break
+              if (chunk.value) res.cork(() => res.write(chunk.value!))
+              chunk = await reader.read()
+            } while (!chunk.done)
+            if (!res.aborted) res.cork(() => res.end())
+          } catch {
+            if (!res.aborted) res.cork(() => res.close())
+          }
+        } else {
+          if (!res.aborted) res.cork(() => res.end())
+        }
+      }
+    })
+
+  return {
+    runtime: { node: server },
+    start: () =>
+      new Promise<string>((resolve, reject) => {
+        if (params.listen.unix) {
+          server.listen_unix((socket) => {
+            if (socket) {
+              resolve('unix://' + params.listen.unix)
+            } else {
+              reject(new Error('Failed to start WebSockets server'))
+            }
+          }, params.listen.unix)
+        } else if (typeof params.listen.port === 'number') {
+          const proto = params.tls ? 'https' : 'http'
+          const hostname = params.listen.hostname || '127.0.0.1'
+
+          server.listen(hostname, params.listen.port, (socket) => {
+            if (socket) {
+              resolve(`${proto}://${hostname}:${us_socket_local_port(socket)}`)
+            } else {
+              reject(new Error('Failed to start WebSockets server'))
+            }
+          })
+        } else {
+          reject(new Error('Invalid listen parameters'))
+        }
+      }),
+    stop: () => {
+      server.close()
+    },
+  }
+}
+
+export const HttpTransport: Transport<
+  ConnectionType.Unidirectional,
+  HttpTransportOptions<'node'>,
+  typeof injectables,
+  ProxyableTransportType.HTTP
+> = {
+  proxyable: ProxyableTransportType.HTTP,
+  injectables,
+  factory(options) {
+    return createHTTPTransportWorker(adapterFactory, options)
+  },
+}

package/src/server.ts

@@ -0,0 +1,365 @@
+import { Buffer } from 'node:buffer'
+import { Duplex, Readable } from 'node:stream'
+
+import type {
+  GatewayApiCallOptions,
+  TransportWorker,
+  TransportWorkerParams,
+} from '@nmtjs/gateway'
+import { anyAbortSignal, isAbortError, isAsyncIterable } from '@nmtjs/common'
+import { provide } from '@nmtjs/core'
+import {
+  ConnectionType,
+  ErrorCode,
+  ProtocolBlob,
+  ProtocolVersion,
+} from '@nmtjs/protocol'
+import {
+  ProtocolClientStream,
+  ProtocolError,
+  UnsupportedContentTypeError,
+  UnsupportedFormatError,
+} from '@nmtjs/protocol/server'
+
+import type {
+  HttpAdapterParams,
+  HttpAdapterServer,
+  HttpAdapterServerFactory,
+  HttpTransportCorsCustomParams,
+  HttpTransportCorsOptions,
+  HttpTransportOptions,
+  HttpTransportServerRequest,
+} from './types.ts'
+import {
+  AllowedHttpMethod,
+  HttpCodeMap,
+  HttpStatus,
+  HttpStatusText,
+} from './constants.ts'
+import * as injections from './injectables.ts'
+
+const NEEMATA_BLOB_HEADER = 'X-Neemata-Blob'
+const DEFAULT_ALLOWED_METHODS = Object.freeze(['post']) as ('get' | 'post')[]
+const DEFAULT_CORS_PARAMS = Object.freeze({
+  allowCredentials: 'true',
+  allowMethods: ['GET', 'POST'],
+  allowHeaders: [
+    'Content-Type',
+    'Content-Disposition',
+    'Content-Length',
+    'Accept',
+    'Transfer-Encoding',
+  ],
+  maxAge: undefined,
+  requestMethod: undefined,
+  exposeHeaders: [],
+  requestHeaders: [],
+}) satisfies HttpTransportCorsCustomParams
+const CORS_HEADERS_MAP: Record<
+  keyof HttpTransportCorsCustomParams | 'origin',
+  string
+> = {
+  origin: 'Access-Control-Allow-Origin',
+  allowMethods: 'Access-Control-Allow-Methods',
+  allowHeaders: 'Access-Control-Allow-Headers',
+  allowCredentials: 'Access-Control-Allow-Credentials',
+  maxAge: 'Access-Control-Max-Age',
+  exposeHeaders: 'Access-Control-Expose-Headers',
+  requestHeaders: 'Access-Control-Request-Headers',
+  requestMethod: 'Access-Control-Request-Method',
+}
+
+export function createHTTPTransportWorker(
+  adapterFactory: HttpAdapterServerFactory<any>,
+  options: HttpTransportOptions,
+): TransportWorker<ConnectionType.Unidirectional> {
+  return new HttpTransportServer(adapterFactory, options)
+}
+
+export class HttpTransportServer
+  implements TransportWorker<ConnectionType.Unidirectional>
+{
+  #server: HttpAdapterServer
+  #corsOptions?:
+    | null
+    | true
+    | string[]
+    | HttpTransportCorsOptions
+    | ((origin: string) => boolean | HttpTransportCorsOptions)
+
+  params!: TransportWorkerParams<ConnectionType.Unidirectional>
+
+  constructor(
+    protected readonly adapterFactory: HttpAdapterServerFactory<any>,
+    protected readonly options: HttpTransportOptions,
+  ) {
+    this.#server = this.createServer()
+    this.#corsOptions = this.options.cors
+  }
+
+  async start(hooks: TransportWorkerParams<ConnectionType.Unidirectional>) {
+    this.params = hooks
+    return await this.#server.start()
+  }
+
+  async stop() {
+    await this.#server.stop()
+  }
+
+  async httpHandler(
+    request: HttpTransportServerRequest,
+    body: ReadableStream | null,
+    requestSignal: AbortSignal,
+  ): Promise<Response> {
+    const url = new URL(request.url)
+    const procedure = url.pathname.slice(1) // remove leading '/'
+    const method = request.method.toLowerCase()
+    const origin = request.headers.get('origin')
+    const responseHeaders = new Headers()
+    if (origin) this.applyCors(origin, request, responseHeaders)
+
+    // Handle preflight requests
+    if (method === 'options') {
+      return new Response(null, {
+        status: HttpStatus.OK,
+        headers: responseHeaders,
+      })
+    }
+
+    const controller = new AbortController()
+    const signal = anyAbortSignal(requestSignal, controller.signal)
+    const canHaveBody = method !== 'get'
+    const isBlob = request.headers.get(NEEMATA_BLOB_HEADER) === 'true'
+    const contentType = request.headers.get('content-type')
+    const accept = request.headers.get('accept') || '*/*'
+
+    await using connection = await this.params.onConnect({
+      accept,
+      contentType: isBlob ? '*/*' : contentType,
+      data: request,
+      protocolVersion: ProtocolVersion.v1,
+      type: ConnectionType.Unidirectional,
+    })
+
+    try {
+      // Parse request body if present
+      let payload: any
+      if (canHaveBody && body) {
+        const bodyStream = Readable.fromWeb(body as any)
+        const cannotDecode =
+          !contentType || !this.params.formats.supportsDecoder(contentType)
+        if (isBlob || cannotDecode) {
+          const type = contentType || 'application/octet-stream'
+          const contentLength = request.headers.get('content-length')
+          const size = contentLength
+            ? Number.parseInt(contentLength)
+            : undefined
+          payload = new ProtocolClientStream(-1, { size, type })
+          bodyStream.pipe(payload)
+        } else {
+          const buffer = Buffer.concat(await bodyStream.toArray())
+          if (buffer.byteLength > 0) {
+            payload = connection.decoder.decode(buffer)
+          }
+        }
+      } else {
+        const querystring = url.searchParams.get('payload')
+        if (querystring) {
+          payload = JSON.parse(querystring)
+        }
+      }
+
+      const metadata: GatewayApiCallOptions['metadata'] = (metadata) => {
+        const allowHttpMethod =
+          metadata.get(AllowedHttpMethod) ?? DEFAULT_ALLOWED_METHODS
+        if (!allowHttpMethod.includes(method as any)) {
+          throw new ProtocolError(ErrorCode.NotFound)
+        }
+      }
+
+      const result = await this.params.onRpc(
+        connection,
+        {
+          callId: 0, // since the connection is closed after the call, only one call exists per connection
+          payload,
+          procedure,
+          metadata,
+        },
+        signal,
+        provide(injections.httpResponseHeaders, responseHeaders),
+      )
+
+      // Handle blob responses
+      if (result instanceof ProtocolBlob) {
+        const { source, metadata } = result
+        const { type } = metadata
+
+        responseHeaders.set(NEEMATA_BLOB_HEADER, 'true')
+        responseHeaders.set('Content-Type', type)
+        if (metadata.size) {
+          responseHeaders.set('Content-Length', metadata.size.toString())
+        }
+
+        // Convert source to ReadableStream
+        let stream: ReadableStream
+
+        if (source instanceof ReadableStream) {
+          stream = source
+        } else if (source instanceof Readable || source instanceof Duplex) {
+          stream = Readable.toWeb(source) as unknown as ReadableStream
+        } else {
+          throw new Error('Invalid stream source')
+        }
+
+        return new Response(stream, {
+          status: HttpStatus.OK,
+          statusText: HttpStatusText[HttpStatus.OK],
+          headers: responseHeaders,
+        })
+      } else if (isAsyncIterable(result)) {
+        responseHeaders.set('Content-Type', connection.encoder.contentType)
+        responseHeaders.set('Transfer-Encoding', 'chunked')
+        const stream = new ReadableStream({
+          async start(controller) {
+            try {
+              for await (const chunk of result) {
+                const encoded = connection.encoder.encode(chunk)
+                const base64 = Buffer.from(
+                  encoded.buffer,
+                  encoded.byteOffset,
+                  encoded.byteLength,
+                ).toString('base64')
+                controller.enqueue(`data: ${base64}\n\n`)
+              }
+              controller.close()
+            } catch (error) {
+              if (isAbortError(error)) controller.close()
+              else controller.error(error)
+            }
+          },
+        })
+        return new Response(stream, {
+          status: HttpStatus.OK,
+          statusText: HttpStatusText[HttpStatus.OK],
+          headers: responseHeaders,
+        })
+      } else {
+        // Handle regular responses
+        const buffer = connection.encoder.encode(result)
+        responseHeaders.set('Content-Type', connection.encoder.contentType)
+
+        // @ts-expect-error
+        return new Response(buffer, {
+          status: HttpStatus.OK,
+          statusText: HttpStatusText[HttpStatus.OK],
+          headers: responseHeaders,
+        })
+      }
+    } catch (error) {
+      console.error(error)
+      if (error instanceof UnsupportedFormatError) {
+        const status =
+          error instanceof UnsupportedContentTypeError
+            ? HttpStatus.UnsupportedMediaType
+            : HttpStatus.NotAcceptable
+        const text = HttpStatusText[status]
+
+        return new Response(text, {
+          status,
+          statusText: text,
+          headers: responseHeaders,
+        })
+      }
+
+      if (error instanceof ProtocolError) {
+        const status =
+          error.code in HttpCodeMap
+            ? HttpCodeMap[error.code]
+            : HttpStatus.InternalServerError
+        const text = HttpStatusText[status]
+        const payload = connection.encoder.encode(error)
+        responseHeaders.set('Content-Type', connection.encoder.contentType)
+
+        // @ts-expect-error
+        return new Response(payload, {
+          status,
+          statusText: text,
+          headers: responseHeaders,
+        })
+      }
+
+      // Unknown error
+      // this.logError(error, 'Unknown error while processing HTTP request')
+      console.error(error)
+
+      const payload = connection.encoder.encode(
+        new ProtocolError(
+          ErrorCode.InternalServerError,
+          'Internal Server Error',
+        ),
+      )
+      responseHeaders.set('Content-Type', connection.encoder.contentType)
+
+      // @ts-expect-error
+      return new Response(payload, {
+        status: HttpStatus.InternalServerError,
+        statusText: HttpStatusText[HttpStatus.InternalServerError],
+        headers: responseHeaders,
+      })
+    }
+  }
+
+  private applyCors(
+    origin: string,
+    request: HttpTransportServerRequest,
+    headers: Headers,
+  ) {
+    if (!this.#corsOptions) return
+
+    let params: HttpTransportCorsCustomParams | null = null
+
+    if (this.options.cors === true) {
+      params = { ...DEFAULT_CORS_PARAMS }
+    } else if (
+      Array.isArray(this.options.cors) &&
+      this.options.cors.includes(origin)
+    ) {
+      params = { ...DEFAULT_CORS_PARAMS }
+    } else if (typeof this.options.cors === 'function') {
+      const result = this.options.cors(origin, request)
+      if (typeof result === 'boolean') {
+        if (result) {
+          params = { ...DEFAULT_CORS_PARAMS }
+        }
+      } else if (typeof result === 'object') {
+        params = { ...DEFAULT_CORS_PARAMS }
+        for (const key in DEFAULT_CORS_PARAMS) {
+          params[key] = result[key]
+        }
+      }
+    }
+
+    if (params === null) return
+
+    headers.set(CORS_HEADERS_MAP.origin, origin)
+
+    for (const key in params) {
+      const header = CORS_HEADERS_MAP[key]
+      if (header) {
+        let value = params[key]
+        if (Array.isArray(value)) value = value.filter(Boolean).join(', ')
+        if (value) headers.set(header, value)
+      }
+    }
+  }
+
+  private createServer() {
+    // const hooks = this.createWsHooks()
+    const opts: HttpAdapterParams = {
+      ...this.options,
+      // logger: this.logger.child({ $lable: 'WsServer' }),
+      fetchHandler: this.httpHandler.bind(this),
+    }
+    return this.adapterFactory(opts)
+  }
+}

package/src/types.ts

@@ -0,0 +1,102 @@
+import type { Async, OneOf } from '@nmtjs/common'
+
+export type HttpTransportServerRequest = {
+  url: URL
+  method: string
+  headers: Headers
+}
+
+export type HttpTransportOptions<
+  R extends keyof HttpTransportRuntimes = keyof HttpTransportRuntimes,
+> = {
+  listen: HttpTransportListenOptions
+  cors?: HttpTransportCorsOptions
+  tls?: HttpTransportTlsOptions
+  runtime?: HttpTransportRuntimes[R]
+}
+
+export type HttpTransportCorsCustomParams = {
+  allowMethods?: string[]
+  allowHeaders?: string[]
+  allowCredentials?: string
+  maxAge?: string
+  exposeHeaders?: string[]
+  requestHeaders?: string[]
+  requestMethod?: string
+}
+
+export type HttpTransportCorsOptions =
+  | true
+  | string[]
+  | HttpTransportCorsCustomParams
+  | ((
+      origin: string,
+      request: HttpTransportServerRequest,
+    ) => boolean | HttpTransportCorsCustomParams)
+
+export type HttpTransportListenOptions = OneOf<
+  [{ port: number; hostname?: string; reusePort?: boolean }, { unix: string }]
+>
+
+export type HttpTransportRuntimeBun = Partial<
+  Pick<
+    import('bun').Serve.Options<undefined>,
+    'development' | 'id' | 'maxRequestBodySize' | 'idleTimeout' | 'ipv6Only'
+  > &
+    import('bun').Serve.Routes<any, any>
+>
+
+export type HttpTransportRuntimeNode = {}
+
+export type HttpTransportRuntimeDeno = {}
+
+export type HttpTransportRuntimes = {
+  bun: HttpTransportRuntimeBun
+  node: HttpTransportRuntimeNode
+  deno: HttpTransportRuntimeDeno
+}
+
+export type HttpTransportTlsOptions = {
+  /**
+   * File path or inlined TLS certificate in PEM format (required).
+   */
+  cert?: string
+  /**
+   * File path or inlined TLS private key in PEM format (required).
+   */
+  key?: string
+  /**
+   * Passphrase for the private key (optional).
+   */
+  passphrase?: string
+}
+
+export type HttpAdapterParams<
+  R extends keyof HttpTransportRuntimes = keyof HttpTransportRuntimes,
+> = {
+  listen: HttpTransportListenOptions
+  fetchHandler: (
+    request: HttpTransportServerRequest,
+    body: ReadableStream | null,
+    signal: AbortSignal,
+  ) => Async<Response>
+  cors?: HttpTransportCorsOptions
+  tls?: HttpTransportTlsOptions
+  runtime?: HttpTransportRuntimes[R]
+}
+
+export type DenoServer = ReturnType<typeof globalThis.Deno.serve>
+
+export interface HttpAdapterServer {
+  runtime: {
+    bun?: import('bun').Server<undefined>
+    node?: import('uWebSockets.js').TemplatedApp
+    deno?: DenoServer
+  }
+  stop: () => Async<any>
+  start: () => Async<string>
+}
+
+export type HttpAdapterServerFactory<
+  R extends keyof HttpTransportRuntimes = keyof HttpTransportRuntimes,
+> = (params: HttpAdapterParams<R>) => HttpAdapterServer

package/src/utils.ts

@@ -0,0 +1,28 @@
+import { ErrorCode } from '@nmtjs/protocol'
+import { ProtocolError } from '@nmtjs/protocol/server'
+
+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)
+
+export const NotFoundHttpResponse = () =>
+  new Response('Not Found', {
+    status: 404,
+    headers: { 'Content-Type': 'text/plain' },
+  })
+
+export const InternalServerErrorHttpResponse = () =>
+  new Response('Internal Server Error', {
+    status: 500,
+    headers: { 'Content-Type': 'text/plain' },
+  })
+
+export const StatusResponse = () => new Response('OK', { status: 200 })