@smuzi/http-server 0.0.1

package/build/config.d.ts

@@ -0,0 +1,31 @@
+import { Option, HttpProtocol } from "@smuzi/std";
+import { ActionErrorHandler, Http1Router } from "#lib/router.js";
+import { ServerResponse } from "node:http";
+type Cert = Option<{
+    key: string;
+    cert: string;
+}>;
+export type Http1ServerConfig = {
+    host: string;
+    port: number;
+    router: Http1Router;
+    cert: Cert;
+    protocol: HttpProtocol;
+    errorHandler: ActionErrorHandler<ServerResponse>;
+};
+type InputHttp1ServerConfig = Partial<Http1ServerConfig> & {
+    router: Http1Router;
+};
+export declare function buildHttp1ServerConfig({ host, port, router, cert, errorHandler }: InputHttp1ServerConfig): Http1ServerConfig;
+type Http2BaseServerConfig = {
+    host: string;
+    port: number;
+    router: Http1Router;
+    cert?: Cert;
+};
+export type Http2ServerConfig = Http2BaseServerConfig & {
+    cert: Cert;
+    protocol: HttpProtocol;
+};
+export declare function buildHttp2ServerConfig({ host, port, router, cert }: Http2BaseServerConfig): Http2ServerConfig;
+export {};

package/build/config.js

@@ -0,0 +1,27 @@
+import { HttpProtocol, None, HttpResponse, dump } from "@smuzi/std";
+function http1ErrorHandler(context, error) {
+    //TODO: write error to log and remove dump()
+    dump(error);
+    return HttpResponse.asJson({ error: "Internal Server Error" }, 500);
+}
+export function buildHttp1ServerConfig({ host = 'localhost', port = 8080, router, cert = None(), errorHandler = http1ErrorHandler }) {
+    return {
+        host,
+        port,
+        router,
+        cert,
+        protocol: cert.someOrNone(HttpProtocol.HTTPS, HttpProtocol.HTTP),
+        errorHandler,
+    };
+}
+;
+export function buildHttp2ServerConfig({ host, port, router, cert = None() }) {
+    return {
+        host,
+        port,
+        router,
+        cert,
+        protocol: cert.someOrNone(HttpProtocol.HTTPS, HttpProtocol.HTTP)
+    };
+}
+;

package/build/drivers/http1Server.d.ts

@@ -0,0 +1,10 @@
+import { Result, StdError } from '@smuzi/std';
+import { HttpServer, HttpServerRunError, Http1ServerConfig } from "#lib/index.js";
+type NativeServer = any;
+export declare class StdHttp1Server implements HttpServer {
+    #private;
+    constructor(server: NativeServer);
+    close(): Promise<Result<boolean, StdError>>;
+}
+export declare function http1ServerRun(config: Http1ServerConfig): Promise<Result<StdHttp1Server, HttpServerRunError>>;
+export {};

package/build/drivers/http1Server.js

@@ -0,0 +1,187 @@
+import http from 'node:http';
+import https from 'node:https';
+import { TLSSocket } from 'node:tls';
+import fs from 'node:fs';
+import { methodFromString } from "#lib/router.js";
+import { isArray, isObject, isString, matchUnknown, OptionFromNullable, Err, Ok, isNull, transformError, StdError, HttpResponse, HttpRequest, StdMap, isOption, isResult, RequestHttpHeaders, asList, asRecord, asMap, querystring, StdJson } from '@smuzi/std';
+export class StdHttp1Server {
+    #server;
+    constructor(server) {
+        this.#server = server;
+    }
+    async close() {
+        return new Promise(resolve => {
+            this.#server.close((err) => {
+                return resolve(isNull(err) ? Ok(true) : Err(transformError(err)));
+            });
+        });
+    }
+}
+function readRequestBodyAsBuffer(req) {
+    return async () => {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on("data", (chunk) => {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            req.on("end", () => {
+                resolve(Ok(Buffer.concat(chunks)));
+            });
+            req.on("error", (err) => reject(Err(err)));
+        });
+    };
+}
+function readRequestJson(req) {
+    return async (encoding = "utf-8") => {
+        return new Promise((resolve) => {
+            let body = "";
+            req.setEncoding(encoding);
+            req.on("data", (chunk) => {
+                body += chunk;
+            });
+            req.on("end", () => {
+                resolve(StdJson.fromString(body));
+            });
+            req.on("error", (err) => resolve(Err(transformError(err))));
+        });
+    };
+}
+function readRequestInput(req) {
+    return async (encoding = "utf-8") => {
+        return new Promise((resolve) => {
+            let body = "";
+            req.setEncoding(encoding);
+            req.on("data", (chunk) => {
+                body += chunk;
+            });
+            req.on("end", () => {
+                resolve(querystring.fromString(body));
+            });
+            req.on("error", (err) => resolve(Err(transformError(err))));
+        });
+    };
+}
+function readRawBody(req) {
+    return async (encoding = "utf-8") => {
+        return new Promise((resolve) => {
+            let body = "";
+            req.setEncoding(encoding);
+            req.on("data", (chunk) => {
+                body += chunk;
+            });
+            req.on("end", () => {
+                resolve(Ok(body));
+            });
+            req.on("error", (err) => resolve(Err(transformError(err))));
+        });
+    };
+}
+let COUNTER = 0;
+export async function http1ServerRun(config) {
+    return new Promise((resolve) => {
+        async function handler(nativeRequest, nativeResponse) {
+            const methodStr = OptionFromNullable(nativeRequest.method).unwrap();
+            const fullUrl = nativeRequest.url || "/";
+            const isHttps = nativeRequest.socket instanceof TLSSocket;
+            const urlObj = new URL(fullUrl, (isHttps ? "http" : "https") + `://${nativeRequest.headers.host}`);
+            const path = OptionFromNullable(urlObj.pathname).unwrap();
+            const request = {
+                path: path.replace(/^\//, '').replace(/\/$/, ''),
+                method: methodFromString(methodStr).unwrap(`Error: undefined http method '${methodStr}'`),
+            };
+            const routeMatched = config.router.match(request);
+            let context = {
+                request: new HttpRequest({
+                    method: request.method,
+                    path: request.path,
+                    query: () => new StdMap(urlObj.searchParams),
+                    headers: new RequestHttpHeaders(nativeRequest.headers),
+                    buffer: readRequestBodyAsBuffer(nativeRequest),
+                    body: readRawBody(nativeRequest),
+                    json: readRequestJson(nativeRequest),
+                    form: readRequestInput(nativeRequest),
+                }),
+                response: nativeResponse,
+                pathParams: routeMatched.pathParams,
+            };
+            let response;
+            try {
+                response = await routeMatched.action(context);
+            }
+            catch (error) {
+                response = await config.errorHandler(context, error);
+            }
+            if (isOption(response)) {
+                response = response.someOr("");
+            }
+            else if (isResult(response)) {
+                response = response.unsafeSource();
+            }
+            if (isNull(response)) {
+                return;
+            }
+            const handlers = new Map();
+            handlers.set(resp => isString(resp) || resp instanceof Buffer, (response) => {
+                nativeResponse.writeHead(200, {
+                    "Content-Type": "text/html; charset=utf-8",
+                });
+                nativeResponse.end(response);
+            });
+            handlers.set(resp => resp instanceof HttpResponse, (response) => {
+                nativeResponse.statusCode = response.status;
+                nativeResponse.statusMessage = response.statusText;
+                nativeResponse.setHeaders(response.headers.unsafeSource());
+                nativeResponse.end(response.body.someOr(""));
+            });
+            handlers.set(resp => resp instanceof StdError, (error) => {
+                nativeResponse.statusCode = 500;
+                nativeResponse.statusMessage = error.message;
+                nativeResponse.end(error.message);
+            });
+            handlers.set((response) => isObject(response) || isArray(response) || asList(response) || asRecord(response) || asMap(response), (response) => {
+                //TODO: return respons on top instead of changed nativeResponse inner
+                nativeResponse.setHeader("Content-Type", "application/json; charset=utf-8");
+                try {
+                    const resp = StdJson.toString(response).match({
+                        Ok: (jsonStr) => ({ status: 200, body: jsonStr }),
+                        Err: (err) => ({ status: 500, body: '{"error":"Internal Server Error"}' }),
+                    });
+                    nativeResponse.statusCode = resp.status;
+                    nativeResponse.end(resp.body);
+                }
+                catch (err) {
+                    nativeResponse.statusCode = 500;
+                    nativeResponse.end('{"error":"Internal Server Error"}');
+                }
+            });
+            matchUnknown(response, handlers, () => {
+                nativeResponse.writeHead(500, { "Content-Type": "text/html; charset=utf-8" });
+                nativeResponse.end("Internal Server Error");
+            }, false);
+        }
+        const server = config.cert.match({
+            Some: cert => {
+                return https.createServer({
+                    key: fs.readFileSync(cert.key),
+                    cert: fs.readFileSync(cert.cert),
+                }, handler);
+            },
+            None: () => {
+                return http.createServer(handler);
+            }
+        });
+        server.once('error', (nativeError) => {
+            resolve(Err({
+                errno: OptionFromNullable(nativeError.errno),
+                code: OptionFromNullable(nativeError.code),
+                syscall: OptionFromNullable(nativeError.syscall),
+                path: OptionFromNullable(nativeError.path),
+                port: OptionFromNullable(nativeError.port),
+                address: OptionFromNullable(nativeError.address),
+            }));
+        });
+        server.listen(config.port, () => {
+            resolve(Ok(new StdHttp1Server(server)));
+        });
+    });
+}

package/build/drivers/http2Server.d.ts

@@ -0,0 +1,11 @@
+import { Http2SecureServer, Http2Server } from 'node:http2';
+import { Result, StdError } from '@smuzi/std';
+import { HttpServer, HttpServerRunError, Http2ServerConfig } from "#lib/index.js";
+type NativeServer = Http2SecureServer | Http2Server;
+export declare class StdHttp2Server implements HttpServer {
+    #private;
+    constructor(server: NativeServer);
+    close(): Promise<Result<boolean, StdError>>;
+}
+export declare function http2ServerRun(config: Http2ServerConfig): Promise<Result<StdHttp2Server, HttpServerRunError>>;
+export {};

package/build/drivers/http2Server.js

@@ -0,0 +1,92 @@
+import http2 from 'node:http2';
+import fs from 'node:fs';
+import { methodFromString } from "#lib/router.js";
+import { isArray, isObject, isString, matchUnknown, OptionFromNullable, Err, Ok, isNull, transformError, HttpResponse, StdJson } from '@smuzi/std';
+export class StdHttp2Server {
+    #server;
+    constructor(server) {
+        this.#server = server;
+    }
+    async close() {
+        return new Promise(resolve => {
+            this.#server.close((err) => {
+                return resolve(isNull(err) ? Ok(true) : Err(transformError(err)));
+            });
+        });
+    }
+}
+export function http2ServerRun(config) {
+    return new Promise((resolve) => {
+        const server = config.cert.match({
+            Some: cert => {
+                return http2.createSecureServer({
+                    key: fs.readFileSync(cert.key),
+                    cert: fs.readFileSync(cert.cert),
+                });
+            },
+            None: () => {
+                return http2.createServer();
+            }
+        });
+        server.once('error', (nativeError) => {
+            resolve(Err({
+                errno: OptionFromNullable(nativeError.errno),
+                code: OptionFromNullable(nativeError.code),
+                syscall: OptionFromNullable(nativeError.syscall),
+                path: OptionFromNullable(nativeError.path),
+                port: OptionFromNullable(nativeError.port),
+                address: OptionFromNullable(nativeError.address),
+            }));
+        });
+        server.on('stream', (stream, headers) => {
+            const methodStr = OptionFromNullable(headers[':method']).unwrap();
+            const path = OptionFromNullable(headers[':path']).unwrap().replace(/^\//, '').replace(/\/$/, '');
+            const urlObj = new URL(path, `http://${headers[':authority']}`);
+            const request = {
+                path: path,
+                method: methodFromString(methodStr).unwrap(`Error: undefined http method '${methodStr}'`),
+                query: urlObj.searchParams,
+            };
+            const response = config.router.match(request);
+            const handlers = new Map();
+            handlers.set(isString, (response) => {
+                stream.respond({
+                    'content-type': 'text/html; charset=utf-8',
+                    ':status': 200,
+                });
+                stream.end(response);
+            });
+            handlers.set(resp => resp instanceof HttpResponse, (response) => {
+                stream.respond({
+                    'content-type': 'application/json; charset=utf-8',
+                    ':status': response.status,
+                });
+            });
+            handlers.set(response => isObject(response) || isArray(response), (response) => {
+                stream.respond({
+                    'content-type': 'application/json; charset=utf-8',
+                    ':status': 200,
+                });
+                stream.end(StdJson.toString(response).match({
+                    Ok: (json) => json,
+                    Err: (err) => {
+                        stream.respond({
+                            'content-type': 'application/json; charset=utf-8',
+                            ':status': 500,
+                        });
+                        return `{"error":"Internal Server Error"}`;
+                    }
+                }));
+            });
+            matchUnknown(response, handlers, _ => {
+                stream.respond({
+                    ':status': 500,
+                });
+                stream.end('Internal Server Error');
+            }, false);
+        });
+        server.listen(config.port, () => {
+            resolve(Ok(new StdHttp2Server(server)));
+        });
+    });
+}

package/build/index.d.ts

@@ -0,0 +1,5 @@
+export * from "#lib/drivers/http2Server.js";
+export * from "#lib/drivers/http1Server.js";
+export * from "#lib/config.js";
+export * from "./router.js";
+export * from "#lib/types.js";

package/build/index.js

@@ -0,0 +1,5 @@
+export * from "#lib/drivers/http2Server.js";
+export * from "#lib/drivers/http1Server.js";
+export * from "#lib/config.js";
+export * from "./router.js";
+export * from "#lib/types.js";

package/build/router.d.ts

@@ -0,0 +1,51 @@
+import { MatchedData, Option, HttpMethod, HttpRequest, Result, HttpResponse, StdMap, StdRecord, StdList } from "@smuzi/std";
+import { ServerResponse } from "node:http";
+import { ServerHttp2Stream } from "node:http2";
+type Request = {
+    path: string;
+    method: HttpMethod;
+};
+type P = any;
+type ActionPrimitiveResponse = P | StdMap<string> | StdRecord<any> | StdList | Record<PropertyKey, P> | Record<PropertyKey, P>[];
+export type ActionResponse = void | ActionPrimitiveResponse | HttpResponse | Option<ActionPrimitiveResponse> | Result<ActionPrimitiveResponse, ActionPrimitiveResponse>;
+export type Action<Resp extends THttpResponse> = (context: Context<Resp>) => ActionResponse | Promise<ActionResponse>;
+export type PathParam = string | RegExp;
+export type ActionErrorHandler<Resp extends THttpResponse> = (context: Context<Resp>, err: any) => ActionResponse | Promise<ActionResponse>;
+type THttpResponse = ServerResponse | ServerHttp2Stream;
+type Route = {
+    path: PathParam;
+    method: HttpMethod;
+};
+type GroupRoute = {
+    path: PathParam;
+};
+type RouteMatched = MatchedData<Request, Option<{
+    path: Record<string, string>;
+}>>;
+type RouteMatchResult<Resp extends THttpResponse> = {
+    action: Action<Resp>;
+    pathParams: Option<Record<string, string | number | boolean>>;
+};
+export type Router<Resp extends THttpResponse, A = Action<Resp>> = {
+    group: (groupRouter: Router<Resp>) => void;
+    getMapRoutes: () => Map<Route, (routeData: RouteMatched) => RouteMatchResult<Resp>>;
+    getGroupRoute(): GroupRoute;
+    get: (path: PathParam, action: A) => void;
+    post: (path: PathParam, action: A) => void;
+    put: (path: PathParam, action: A) => void;
+    delete: (path: PathParam, action: A) => void;
+    match: (request: Request) => RouteMatchResult<Resp>;
+};
+export type Http1Router = Router<ServerResponse>;
+export type Http2Router = Router<ServerHttp2Stream>;
+export type Context<Resp extends THttpResponse, Params = unknown> = {
+    request: HttpRequest;
+    response: Resp;
+    pathParams: Params;
+};
+export declare function processPath(path: PathParam): PathParam;
+export declare function contactPaths(path1: PathParam, path2: PathParam): PathParam | never;
+export declare function toStartWithPattern(input: PathParam): RegExp;
+export declare function methodFromString(method: string): Option<HttpMethod>;
+export declare function CreateHttpRouter<Resp extends THttpResponse, GR extends Router<Resp>>(groupRoute: GroupRoute, notFound: Action<Resp>): Router<Resp>;
+export {};

package/build/router.js

@@ -0,0 +1,110 @@
+import { asRegExp, asString, match, None, Some, HttpMethod, HttpResponse, } from "@smuzi/std";
+export function processPath(path) {
+    if (!asString(path))
+        return path;
+    if (!/\{[a-zA-Z0-9_]+\}/g.test(path))
+        return path;
+    const pattern = `^${path.replace(/\{([a-zA-Z0-9_]+)\}/g, (_, name) => `(?<${name}>[^/]+)`).replace(/\//g, '\\/')}$`;
+    return new RegExp(pattern);
+}
+export function contactPaths(path1, path2) {
+    const path1AsRegExp = asRegExp(path1);
+    const path2AsRegExp = asRegExp(path2);
+    if (path1AsRegExp || path2AsRegExp) {
+        return new RegExp((path1AsRegExp ? path1.source : path1) + (path2AsRegExp ? path2.source : path2));
+    }
+    return path1 + path2;
+}
+export function toStartWithPattern(input) {
+    if (asString(input)) {
+        const escaped = input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return new RegExp(`^${escaped}.*`);
+    }
+    let pattern = input.source;
+    if (pattern.endsWith('$')) {
+        pattern = pattern.slice(0, -1);
+    }
+    return new RegExp(`${pattern}.*`, input.flags);
+}
+export function methodFromString(method) {
+    const handers = new Map([
+        ['GET', Some(HttpMethod.GET)],
+        ['POST', Some(HttpMethod.POST)],
+        ['PUT', Some(HttpMethod.PUT)],
+        ['DELETE', Some(HttpMethod.DELETE)],
+    ]);
+    return match(method, handers, None(), false);
+}
+function http1NotFoundHandler(context) {
+    return HttpResponse.asJson({ error: "Not Found" }, 404);
+}
+function http2NotFoundHandler(context) {
+    context.response.respond({
+        'content-type': 'application/json; charset=utf-8',
+        ':status': 404,
+    });
+    context.response.end();
+}
+export function CreateHttpRouter(groupRoute, notFound) {
+    const routes = new Map();
+    const add = (route, action) => {
+        route.path = processPath(contactPaths(groupRoute.path, route.path));
+        routes.set(route, (routeData) => {
+            return {
+                action,
+                pathParams: routeData.params.flatByKey("path"),
+            };
+        });
+    };
+    const addGroup = (route, action) => {
+        route.path = processPath(contactPaths(groupRoute.path, route.path));
+        routes.set(route, action);
+    };
+    return {
+        get(path, action) {
+            add({ path, method: HttpMethod.GET }, action);
+        },
+        post(path, action) {
+            add({ path, method: HttpMethod.POST }, action);
+        },
+        put(path, action) {
+            add({ path, method: HttpMethod.PUT }, action);
+        },
+        delete(path, action) {
+            add({ path, method: HttpMethod.DELETE }, action);
+        },
+        group(groupRouter) {
+            const groupPath = groupRouter.getGroupRoute().path;
+            const startWithPattern = toStartWithPattern(groupPath);
+            addGroup({ path: startWithPattern }, (routeData) => {
+                return groupRouter.match(routeData.val);
+            });
+        },
+        getMapRoutes() {
+            return routes;
+        },
+        getGroupRoute() {
+            return groupRoute;
+        },
+        match(request) {
+            return match(request, this.getMapRoutes(), (routeData) => {
+                return {
+                    action: notFound,
+                    pathParams: routeData.params.flatByKey("path"),
+                };
+            });
+        }
+    };
+}
+// export function CreateHttp1Router(
+//     groupRoute: GroupRoute,
+//     notFound: Action<ServerResponse> = http1NotFoundHandler,
+// ): Http1Router {
+//     return CreateHttpRouter<ServerResponse, Http1Router>(groupRoute, notFound);
+// }
+// export function CreateHttp2Router(
+//     groupRoute: GroupRoute,
+//     notFound: Action<ServerHttp2Stream> = http2NotFoundHandler
+// ): Http2Router {
+//     return CreateHttpRouter<ServerHttp2Stream, Http2Router>(groupRoute, notFound);
+// }

package/build/types.d.ts

@@ -0,0 +1,12 @@
+import { Option, Result, StdError } from "@smuzi/std";
+export interface HttpServer {
+    close(): Promise<Result<boolean, StdError>>;
+}
+export type HttpServerRunError = {
+    errno: Option<number>;
+    code: Option<string>;
+    syscall: Option<string>;
+    path: Option<string>;
+    port: Option<string>;
+    address: Option<string>;
+};

package/build/types.js

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

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@smuzi/http-server",
+  "version": "0.0.1",
+  "description": "HTTP server and routing for JavaScript and TypeScript",
+  "scripts": {
+    "test": "tsx tests/index.ts",
+    "build": "tsc --project tsconfig.build.json",
+    "prepublishOnly": "npm run build"
+  },
+  "type": "module",
+  "keywords": [
+    "http",
+    "router",
+    "server",
+    "https",
+    "routing",
+    "middleware"
+  ],
+  "author": "Denis Ratushniak <dinisimys2018@gmail.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "./build"
+  ],
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "imports": {
+    "#lib/*": "./src/*"
+  },
+  "devDependencies": {
+    "@smuzi/std": "workspace:*",
+    "@smuzi/faker": "workspace:*",
+    "@smuzi/schema": "workspace:*",
+    "@smuzi/tests": "workspace:*",
+    "@types/node": "^22.15.21",
+    "tsx": "^4.20.6",
+    "typescript": "^7.0.2"
+  }
+}