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

package/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2024 Denis Ilchyshyn
+Copyright (c) 2025 Denys Ilchyshyn
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -1 +1,9 @@
-## HTTP transport for [Neemata](https://github.com/neematajs/neemata)
+# NeemataJS - RPC application server for real-time applications (proof of concept)
+
+### Built with following in mind:
+- transport-agnostic (like WebSockets, WebTransport, .etc)
+- format-agnostic (like JSON, MessagePack, BSON, .etc)
+- binary data streaming and event subscriptions
+- contract-based API
+- end-to-end type safety
+- CPU-intensive task execution on separate workers

package/dist/constants.js

@@ -0,0 +1,146 @@
+import { createMetadataKey } from '@nmtjs/core';
+import { ErrorCode } from '@nmtjs/protocol';
+export var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["Continue"] = 100] = "Continue";
+    HttpStatus[HttpStatus["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+    HttpStatus[HttpStatus["Processing"] = 102] = "Processing";
+    HttpStatus[HttpStatus["EarlyHints"] = 103] = "EarlyHints";
+    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatus[HttpStatus["Created"] = 201] = "Created";
+    HttpStatus[HttpStatus["Accepted"] = 202] = "Accepted";
+    HttpStatus[HttpStatus["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+    HttpStatus[HttpStatus["NoContent"] = 204] = "NoContent";
+    HttpStatus[HttpStatus["ResetContent"] = 205] = "ResetContent";
+    HttpStatus[HttpStatus["PartialContent"] = 206] = "PartialContent";
+    HttpStatus[HttpStatus["MultiStatus"] = 207] = "MultiStatus";
+    HttpStatus[HttpStatus["AlreadyReported"] = 208] = "AlreadyReported";
+    HttpStatus[HttpStatus["IMUsed"] = 226] = "IMUsed";
+    HttpStatus[HttpStatus["MultipleChoices"] = 300] = "MultipleChoices";
+    HttpStatus[HttpStatus["MovedPermanently"] = 301] = "MovedPermanently";
+    HttpStatus[HttpStatus["Found"] = 302] = "Found";
+    HttpStatus[HttpStatus["SeeOther"] = 303] = "SeeOther";
+    HttpStatus[HttpStatus["NotModified"] = 304] = "NotModified";
+    HttpStatus[HttpStatus["UseProxy"] = 305] = "UseProxy";
+    HttpStatus[HttpStatus["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+    HttpStatus[HttpStatus["PermanentRedirect"] = 308] = "PermanentRedirect";
+    HttpStatus[HttpStatus["BadRequest"] = 400] = "BadRequest";
+    HttpStatus[HttpStatus["Unauthorized"] = 401] = "Unauthorized";
+    HttpStatus[HttpStatus["PaymentRequired"] = 402] = "PaymentRequired";
+    HttpStatus[HttpStatus["Forbidden"] = 403] = "Forbidden";
+    HttpStatus[HttpStatus["NotFound"] = 404] = "NotFound";
+    HttpStatus[HttpStatus["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+    HttpStatus[HttpStatus["NotAcceptable"] = 406] = "NotAcceptable";
+    HttpStatus[HttpStatus["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+    HttpStatus[HttpStatus["RequestTimeout"] = 408] = "RequestTimeout";
+    HttpStatus[HttpStatus["Conflict"] = 409] = "Conflict";
+    HttpStatus[HttpStatus["Gone"] = 410] = "Gone";
+    HttpStatus[HttpStatus["LengthRequired"] = 411] = "LengthRequired";
+    HttpStatus[HttpStatus["PreconditionFailed"] = 412] = "PreconditionFailed";
+    HttpStatus[HttpStatus["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+    HttpStatus[HttpStatus["URITooLong"] = 414] = "URITooLong";
+    HttpStatus[HttpStatus["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+    HttpStatus[HttpStatus["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+    HttpStatus[HttpStatus["ExpectationFailed"] = 417] = "ExpectationFailed";
+    HttpStatus[HttpStatus["ImATeapot"] = 418] = "ImATeapot";
+    HttpStatus[HttpStatus["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+    HttpStatus[HttpStatus["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+    HttpStatus[HttpStatus["Locked"] = 423] = "Locked";
+    HttpStatus[HttpStatus["FailedDependency"] = 424] = "FailedDependency";
+    HttpStatus[HttpStatus["TooEarly"] = 425] = "TooEarly";
+    HttpStatus[HttpStatus["UpgradeRequired"] = 426] = "UpgradeRequired";
+    HttpStatus[HttpStatus["PreconditionRequired"] = 428] = "PreconditionRequired";
+    HttpStatus[HttpStatus["TooManyRequests"] = 429] = "TooManyRequests";
+    HttpStatus[HttpStatus["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+    HttpStatus[HttpStatus["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+    HttpStatus[HttpStatus["InternalServerError"] = 500] = "InternalServerError";
+    HttpStatus[HttpStatus["NotImplemented"] = 501] = "NotImplemented";
+    HttpStatus[HttpStatus["BadGateway"] = 502] = "BadGateway";
+    HttpStatus[HttpStatus["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    HttpStatus[HttpStatus["GatewayTimeout"] = 504] = "GatewayTimeout";
+    HttpStatus[HttpStatus["HTTPVersionNotSupported"] = 505] = "HTTPVersionNotSupported";
+    HttpStatus[HttpStatus["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+    HttpStatus[HttpStatus["InsufficientStorage"] = 507] = "InsufficientStorage";
+    HttpStatus[HttpStatus["LoopDetected"] = 508] = "LoopDetected";
+    HttpStatus[HttpStatus["NotExtended"] = 510] = "NotExtended";
+    HttpStatus[HttpStatus["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+})(HttpStatus || (HttpStatus = {}));
+export const HttpStatusText = {
+    [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('http:method');

package/dist/index.js

@@ -1,5 +1,4 @@
-export * from "./lib/server.js";
-export * from "./lib/transport.js";
-export * from "./lib/types.js";
-export * from "./lib/utils.js";
-export * from "./lib/injectables.js";
+export * from "./injectables.js";
+export * from "./server.js";
+export * from "./types.js";
+export * from "./utils.js";

package/dist/injectables.js

@@ -0,0 +1,4 @@
+import { createLazyInjectable, Scope } from '@nmtjs/core';
+import { connectionData as connectionDataInjectable } from '@nmtjs/gateway';
+export const connectionData = connectionDataInjectable.$withType();
+export const httpResponseHeaders = createLazyInjectable(Scope.Call);

package/dist/runtimes/bun.js

@@ -0,0 +1,67 @@
+import { ProxyableTransportType } from '@nmtjs/gateway';
+import * as injectables from "../injectables.js";
+import { createHTTPTransportWorker } from "../server.js";
+import { InternalServerErrorHttpResponse, NotFoundHttpResponse, StatusResponse, } from "../utils.js";
+function adapterFactory(params) {
+    let server = null;
+    function createServer() {
+        return globalThis.Bun.serve({
+            ...params.runtime,
+            unix: params.listen.unix,
+            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 = {
+    proxyable: ProxyableTransportType.HTTP,
+    injectables,
+    factory(options) {
+        return createHTTPTransportWorker(adapterFactory, options);
+    },
+};

package/dist/runtimes/deno.js

@@ -0,0 +1,94 @@
+import { ProxyableTransportType } from '@nmtjs/gateway';
+import * as injectables from "../injectables.js";
+import { createHTTPTransportWorker } from "../server.js";
+import { InternalServerErrorHttpResponse, NotFoundHttpResponse, StatusResponse, } from "../utils.js";
+function adapterFactory(params) {
+    let server = 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((resolve) => {
+            const server = globalThis.Deno.serve({
+                ...params.runtime,
+                ...options,
+                handler: async (request, info) => {
+                    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) {
+                    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 = {
+    proxyable: ProxyableTransportType.HTTP,
+    injectables,
+    factory(options) {
+        return createHTTPTransportWorker(adapterFactory, options);
+    },
+};

package/dist/runtimes/node.js

@@ -0,0 +1,136 @@
+import {} from 'node:dns';
+import { setTimeout } from 'node:timers/promises';
+import { ProxyableTransportType } from '@nmtjs/gateway';
+import * as injectables from "../injectables.js";
+import { createHTTPTransportWorker } from "../server.js";
+import { InternalServerErrorHttpResponse, NotFoundHttpResponse, StatusResponse, } from "../utils.js";
+import { App, SSLApp, us_socket_local_port } from 'uWebSockets.js';
+function adapterFactory(params) {
+    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((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 = {
+    proxyable: ProxyableTransportType.HTTP,
+    injectables,
+    factory(options) {
+        return createHTTPTransportWorker(adapterFactory, options);
+    },
+};