@smuzi/http-server 0.0.5 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smuzi/http-server",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "HTTP server and routing for JavaScript and TypeScript",
   "type": "module",
   "types": "./build/index.d.ts",
@@ -18,8 +18,8 @@
     "access": "public"
   },
   "files": [
-    "./src",
-    "./build"
+    "build/**/*.js",
+    "build/**/*.d.ts"
   ],
   "exports": {
     "./package.json": "./package.json",
@@ -36,12 +36,12 @@
     "#lib/*": "./src/*"
   },
   "dependencies": {
-    "@smuzi/std": "0.2.6",
-    "@smuzi/schema": "0.0.5"
+    "@smuzi/std": "0.2.8",
+    "@smuzi/schema": "0.0.7"
   },
   "devDependencies": {
-    "@smuzi/faker": "0.0.5",
-    "@smuzi/tests": "0.0.3",
+    "@smuzi/faker": "0.0.6",
+    "@smuzi/tests": "0.0.5",
     "@types/node": "^22.15.21",
     "tsx": "^4.20.6",
     "typescript": "^7.0.2"
@@ -49,5 +49,6 @@
   "scripts": {
     "test": "tsx --conditions=development tests/index.ts",
     "build": "tsc --project tsconfig.build.json"
-  }
+  },
+  "main": "./build/index.js"
 }

package/src/config.ts

@@ -1,60 +0,0 @@
-import {Option, HttpProtocol, None, HttpResponse, transformError, dump} from "@smuzi/std";
-import {ActionErrorHandler, Context, Http1Router} from "./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,
-}
-
-function http1ErrorHandler(context: Context<ServerResponse>, error) {
-    //TODO: write error to log and remove dump()
-    dump({msg: "http1ErrorHandler", error})
-    return HttpResponse.asJson({error:"Internal Server Error"}, 500);
-}
-
-export function buildHttp1ServerConfig({host = 'localhost', port = 8080, router, cert = None(), errorHandler = http1ErrorHandler}: InputHttp1ServerConfig): Http1ServerConfig {
-    return {
-        host, 
-        port,
-        router,
-        cert,
-        protocol: cert.someOrNone(HttpProtocol.HTTPS, HttpProtocol.HTTP),
-        errorHandler,
-    };
-};
-
-type Http2BaseServerConfig = {
-    host: string;
-    port: number,
-    router: Http1Router,
-    cert?: Cert
-}
-
-export type Http2ServerConfig = Http2BaseServerConfig & {
-    cert: Cert,
-    protocol: HttpProtocol,
-}
-
-export function buildHttp2ServerConfig({host, port, router, cert = None() }: Http2BaseServerConfig): Http2ServerConfig {
-    return {
-        host, 
-        port,
-        router,
-        cert,
-        protocol: cert.someOrNone(HttpProtocol.HTTPS, HttpProtocol.HTTP)
-    };
-};

package/src/drivers/http1Server.ts

@@ -1,263 +0,0 @@
-import http, { IncomingMessage, ServerResponse } from 'node:http';
-import https from 'node:https';
-import { TLSSocket } from 'node:tls';
-import fs from 'node:fs';
-
-import { methodFromString } from "../router.js";
-import {
-    isArray,
-    isObject,
-    isString,
-    match,
-    StdRecord,
-    matchUnknown,
-    OptionFromNullable,
-    Some,
-    Result,
-    Option,
-    Err,
-    Ok,
-    isNull,
-    transformError,
-    StdError,
-    dump,
-    HttpResponse,
-    HttpRequest,
-    StdMap,
-    isSome,
-    isOption,
-    isResult,
-    isIterable,
-    ResponseHttpHeaders, RequestHttpHeaders, asList, asRecord, asMap, querystring, QueryParams,
-    StdJson, uuid
-} from '@smuzi/std';
-import { HttpServer, HttpServerRunError, Http1ServerConfig } from "../index.js";
-import { log } from 'node:console';
-
-type NativeServer = any
-
-export class StdHttp1Server implements HttpServer {
-    readonly #server: NativeServer
-
-    constructor(server: NativeServer) {
-        this.#server = server;
-    }
-    async close(): Promise<Result<boolean, StdError>> {
-        return new Promise(resolve => {
-            this.#server.close((err) => {
-                return resolve(isNull(err) ? Ok(true) : Err(transformError(err)));
-            })
-        })
-    }
-}
-
-function readRequestBodyAsBuffer(req: IncomingMessage): () => Promise<Result<Buffer, Error>> {
-    return async () => {
-        return new Promise((resolve, reject) => {
-            const chunks: Buffer[] = [];
-
-            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: IncomingMessage): <T>() => Promise<Result<Option<T>, StdError>> {
-    return async(encoding: BufferEncoding = "utf-8") => {
-        return new Promise((resolve) => {
-        let body = "";
-
-        req.setEncoding(encoding);
-
-        req.on("data", (chunk: string) => {
-            body += chunk;
-        });
-
-        req.on("end", () => {
-            resolve(StdJson.fromString(body));
-        });
-
-        req.on("error", (err) => resolve(Err(transformError(err))));
-    });
-    }
-}
-
-function readRequestInput(req: IncomingMessage): <T extends StdRecord<QueryParams>>() => Promise<Result<T, StdError>> {
-    return async(encoding: BufferEncoding = "utf-8") => {
-        return new Promise((resolve) => {
-            let body = "";
-
-            req.setEncoding(encoding);
-
-            req.on("data", (chunk: string) => {
-                body += chunk;
-            });
-
-            req.on("end", () => {
-                resolve(querystring.fromString(body));
-            });
-
-            req.on("error", (err) => resolve(Err(transformError(err))));
-        });
-    }
-}
-
-function readRawBody(req: IncomingMessage): <T>() => Promise<Result<string, StdError>> {
-    return async(encoding: BufferEncoding = "utf-8") => {
-        return new Promise((resolve) => {
-            let body = "";
-
-            req.setEncoding(encoding);
-
-            req.on("data", (chunk: string) => {
-                body += chunk;
-            });
-
-            req.on("end", () => {
-                resolve(Ok(body));
-            });
-
-            req.on("error", (err) => resolve(Err(transformError(err))));
-        });
-    }
-}
-
-let COUNTER = 0;
-
-export async function http1ServerRun(config: Http1ServerConfig): Promise<Result<StdHttp1Server, HttpServerRunError>> {
-    return new Promise((resolve) => {
-        async function handler(nativeRequest: IncomingMessage, nativeResponse: ServerResponse) {
-            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 StdRecord<QueryParams>(Object.fromEntries(urlObj.searchParams.entries())),
-                    headers: new RequestHttpHeaders(nativeRequest.headers as any),
-                    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: HttpResponse) => {
-                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: StdError) => {
-                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: any) => {
-            log("Server started on", 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, () => {
-            log("Server started on " + config.protocol + "://" + config.host + ":" + config.port)
-
-            resolve(Ok(new StdHttp1Server(server)));
-        });
-
-    });
-}

package/src/drivers/http2Server.ts

@@ -1,125 +0,0 @@
-import http2, { Http2SecureServer, Http2Server, IncomingHttpHeaders, ServerHttp2Stream } from 'node:http2';
-import fs from 'node:fs';
-
-import { methodFromString } from "../router.js";
-import { isArray, isObject, isString, match, matchUnknown, OptionFromNullable, Some, Result, Option, Err, Ok, isNull, transformError, StdError, dump, HttpResponse, StdJson } from '@smuzi/std';
-import { HttpServer, HttpServerRunError, Http2ServerConfig } from "../index.js";
-
-type NativeServer = Http2SecureServer | Http2Server;
-
-export class StdHttp2Server implements HttpServer {
-    readonly #server: NativeServer
-
-    constructor(server: NativeServer) {
-        this.#server = server;
-    }
-    async close(): Promise<Result<boolean, StdError>> {
-        return new Promise(resolve => {
-            this.#server.close((err) => {
-                return resolve(isNull(err) ? Ok(true) : Err(transformError(err)));
-            })
-        })
-    }
-}
-
-export function http2ServerRun(config: Http2ServerConfig): Promise<Result<StdHttp2Server, HttpServerRunError>> {
-    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: ServerHttp2Stream, headers: IncomingHttpHeaders) => {
-            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: HttpResponse) => {
-                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/src/index.ts

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

package/src/router.ts

@@ -1,257 +0,0 @@
-import {
-    asRegExp,
-    asString,
-    match,
-    MatchedData,
-    None,
-    Option,
-    Some,
-    HttpMethod,
-    HttpRequest,
-    Result,
-    HttpResponse,
-    StdError,
-    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 function processPath(path: PathParam): PathParam {
-    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: PathParam, path2: PathParam): PathParam | never {
-    const path1AsRegExp = asRegExp(path1);
-    const path2AsRegExp = asRegExp(path2);
-
-    if (path1AsRegExp || path2AsRegExp) {
- const source1 = path1AsRegExp
-            ? path1.source
-            : path1;
-
-        const source2 = path2AsRegExp
-            ? path2.source
-            : path2;
-
-        return new RegExp(
-            "^"+(source1 + source2).replaceAll('^', '')
-        );    
-    }
-
-    return path1 + path2;
-}
-
-
-export function toStartWithPattern(input: PathParam): RegExp {
-    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: string): Option<HttpMethod> {
-    const handers = new Map<string, Option<HttpMethod>>([
-        ['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: Context<ServerResponse>) {
-    return HttpResponse.asJson({error:"Not Found"}, 404);
-}
-
-
-function http2NotFoundHandler(context: Context<ServerHttp2Stream>) {
-    context.response.respond({
-        'content-type': 'application/json; charset=utf-8',
-        ':status': 404,
-    });
-    context.response.end();
-
-}
-
-
-
-// Internal-only surface: lets a parent router recompute a child router's
-// (and, recursively, its own nested groups') absolute paths after nesting.
-// Not part of the public `Router` type — accessed via a narrow cast.
-type Rebasable = { __rebase: (newBase: PathParam) => void };
-
-export function CreateHttpRouter<Resp extends THttpResponse, GR extends Router<Resp>>(
-    groupRoute: GroupRoute,
-    notFound: Action<Resp>,
-): Router<Resp> {
-    const routes = new Map()
-
-    // Every own route/subgroup is registered ONCE at startup. We additionally
-    // remember each one's path *relative to this router* so that, if this
-    // router later gets attached to a parent via `.group()`, we can recompute
-    // every already-registered absolute path exactly once at that moment —
-    // never again on every match()/request.
-    const ownRoutes: { route: Route; localPath: PathParam }[] = [];
-    const ownGroups: { route: GroupRoute; localGroupPath: PathParam; childRouter: Router<any> }[] = [];
-
-    const computeAbsolute = (localPath: PathParam) =>
-        processPath(contactPaths(groupRoute.path, localPath));
-
-    const add = (route: Route, action: any) => {
-        const localPath = route.path;
-        route.path = computeAbsolute(localPath);
-        ownRoutes.push({ route, localPath });
-
-        routes.set(route, (routeData: RouteMatched) => {
-            return {
-                action,
-                pathParams: routeData.params.flatByKey("path"),
-            };
-        })
-    };
-
-    const addGroup = (localGroupPath: PathParam, childRouter: Router<any>, action: any) => {
-        const route: GroupRoute = { path: computeAbsolute(toStartWithPattern(localGroupPath)) };
-        ownGroups.push({ route, localGroupPath, childRouter });
-        routes.set(route, action)
-    };
-
-    // Recomputes this router's own base plus every route/subgroup registered
-    // on it so far, then recurses into any already-nested group routers so
-    // the whole subtree stays consistent — called once, when this router is
-    // attached to a parent via `.group()`.
-    const rebase = (newBase: PathParam) => {
-        groupRoute.path = newBase;
-
-        for (const entry of ownRoutes) {
-            entry.route.path = computeAbsolute(entry.localPath);
-        }
-
-        for (const entry of ownGroups) {
-            entry.route.path = computeAbsolute(toStartWithPattern(entry.localGroupPath));
-            (entry.childRouter as unknown as Rebasable).__rebase(
-                contactPaths(newBase, entry.localGroupPath)
-            );
-        }
-    };
-
-    const router: Router<Resp> & Rebasable = {
-        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: GR) {
-            const localGroupPath = groupRouter.getGroupRoute().path;
-
-            addGroup(localGroupPath, groupRouter, (routeData: RouteMatched) => {
-                return groupRouter.match(routeData.val);
-            });
-
-            // Re-derive every path already registered on the nested router
-            // (and anything nested under IT) against our current absolute base.
-            (groupRouter as unknown as Rebasable).__rebase(
-                contactPaths(groupRoute.path, localGroupPath)
-            );
-        },
-        getMapRoutes() {
-            return routes;
-        },
-        getGroupRoute(): GroupRoute {
-            return groupRoute;
-        },
-        match(request: Request) {
-            return match(request, this.getMapRoutes(), (routeData: RouteMatched) => {
-                return {
-                    action: notFound,
-                    pathParams: routeData.params.flatByKey("path"),
-                } as RouteMatchResult<Resp>;
-            })
-        },
-        __rebase: rebase,
-    };
-
-    return router;
-}
-
-
-
-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/src/types.ts

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