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

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)
+  },
+}