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

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

@@ -0,0 +1,4 @@
+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);
+    },
+};

package/dist/server.js

@@ -0,0 +1,343 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { Buffer } from 'node:buffer';
+import { Duplex, Readable } from 'node:stream';
+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 { AllowedHttpMethod, HttpCodeMap, HttpStatus, HttpStatusText, } from "./constants.js";
+import * as injections from "./injectables.js";
+const NEEMATA_BLOB_HEADER = 'X-Neemata-Blob';
+const DEFAULT_ALLOWED_METHODS = Object.freeze(['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: [],
+});
+const CORS_HEADERS_MAP = {
+    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, options) {
+    return new HttpTransportServer(adapterFactory, options);
+}
+export class HttpTransportServer {
+    adapterFactory;
+    options;
+    #server;
+    #corsOptions;
+    params;
+    constructor(adapterFactory, options) {
+        this.adapterFactory = adapterFactory;
+        this.options = options;
+        this.#server = this.createServer();
+        this.#corsOptions = this.options.cors;
+    }
+    async start(hooks) {
+        this.params = hooks;
+        return await this.#server.start();
+    }
+    async stop() {
+        await this.#server.stop();
+    }
+    async httpHandler(request, body, requestSignal) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            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') || '*/*';
+            const connection = __addDisposableResource(env_1, await this.params.onConnect({
+                accept,
+                contentType: isBlob ? '*/*' : contentType,
+                data: request,
+                protocolVersion: ProtocolVersion.v1,
+                type: ConnectionType.Unidirectional,
+            }), true);
+            try {
+                // Parse request body if present
+                let payload;
+                if (canHaveBody && body) {
+                    const bodyStream = Readable.fromWeb(body);
+                    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 = (metadata) => {
+                    const allowHttpMethod = metadata.get(AllowedHttpMethod) ?? DEFAULT_ALLOWED_METHODS;
+                    if (!allowHttpMethod.includes(method)) {
+                        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;
+                    if (source instanceof ReadableStream) {
+                        stream = source;
+                    }
+                    else if (source instanceof Readable || source instanceof Duplex) {
+                        stream = Readable.toWeb(source);
+                    }
+                    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,
+                });
+            }
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    applyCors(origin, request, headers) {
+        if (!this.#corsOptions)
+            return;
+        let params = 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);
+            }
+        }
+    }
+    createServer() {
+        // const hooks = this.createWsHooks()
+        const opts = {
+            ...this.options,
+            // logger: this.logger.child({ $lable: 'WsServer' }),
+            fetchHandler: this.httpHandler.bind(this),
+        };
+        return this.adapterFactory(opts);
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.js

@@ -0,0 +1,15 @@
+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 });

package/package.json

@@ -9,20 +9,20 @@
   },
   "devDependencies": {
     "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.56.0",
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/gateway": "0.15.0-beta.1",
-    "@nmtjs/protocol": "0.15.0-beta.1",
-    "@nmtjs/client": "0.15.0-beta.1"
+    "@nmtjs/client": "0.15.0-beta.2",
+    "@nmtjs/gateway": "0.15.0-beta.2",
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/protocol": "0.15.0-beta.2"
   },
   "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.1",
-    "@nmtjs/core": "0.15.0-beta.1",
-    "@nmtjs/gateway": "0.15.0-beta.1",
-    "@nmtjs/protocol": "0.15.0-beta.1"
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/core": "0.15.0-beta.2",
+    "@nmtjs/protocol": "0.15.0-beta.2",
+    "@nmtjs/gateway": "0.15.0-beta.2"
   },
   "peerDependenciesMeta": {
     "@types/bun": {
@@ -48,7 +48,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.1",
+  "version": "0.15.0-beta.2",
   "scripts": {
     "clean-build": "rm -rf ./dist",
     "build": "tsc",