corecdtl 0.1.0

package/dist/http/content/parser.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentParserTable = void 0;
+function formParse(b) {
+    // application/x-www-form-urlencoded
+    const s = b.toString("utf8");
+    const out = {};
+    for (const pair of s.split("&")) {
+        const [k, v] = pair.split("=");
+        if (!k)
+            continue;
+        out[decodeURIComponent(k)] = decodeURIComponent(v || "");
+    }
+    return out;
+}
+function multipartParser(b) {
+    const raw = b.toString("utf8");
+    const boundaryMatch = raw.match(/boundary=([^\s;]+)/);
+    if (!boundaryMatch) {
+        return {};
+    }
+    const boundary = `--${boundaryMatch[1]}`;
+    const parts = raw.split(boundary).slice(1, -1);
+    const result = {};
+    for (let part of parts) {
+        part = part.trim();
+        if (!part)
+            continue;
+        const [rawHeaders, ...bodyParts] = part.split("\r\n\r\n");
+        const body = bodyParts.join("\r\n\r\n");
+        const headers = rawHeaders.split("\r\n");
+        let name = "";
+        let filename = "";
+        for (const h of headers) {
+            const m = h.match(/name="([^"]+)"/);
+            if (m)
+                name = m[1];
+            const f = h.match(/filename="([^"]+)"/);
+            if (f)
+                filename = f[1];
+        }
+        if (!name)
+            continue;
+        // File part
+        if (filename) {
+            result[name] = {
+                filename,
+                data: Buffer.from(body, "utf8")
+            };
+        }
+        else {
+            // Text field
+            result[name] = body.trim();
+        }
+    }
+    return result;
+}
+const decoder = new TextDecoder('utf-8');
+exports.contentParserTable = {
+    "application/json": JSON.parse,
+    "application/x-www-form-urlencoded": formParse,
+    "multipart/form-data": multipartParser,
+    "text/plain": (b) => decoder.decode
+};

package/dist/http/context/ApiContext.d.ts

@@ -0,0 +1,14 @@
+import { Http } from "../../http";
+import HttpContext from "./HttpContext";
+declare class ApiContext extends HttpContext {
+    protected contentDecoding: Http.ContentDecoding;
+    protected contentEncoding: Http.ContentEncoding;
+    protected contentTypeParsers: Record<string, (b: any) => any>;
+    constructor(opts?: Http.ServerOptions);
+    private bindServer;
+    protected parseInitial: Http.ParseInitialFn;
+    protected parseHeader: Http.ParseInitialFn;
+    registerRouters(mainRoute: Http.Route): void;
+    setHttpCore(): void;
+}
+export default ApiContext;

package/dist/http/context/ApiContext.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = require("../content/parser");
+const encoding_1 = require("../content/encoding");
+const http_1 = require("../../http");
+const HttpContext_1 = __importDefault(require("./HttpContext"));
+const net_1 = __importDefault(require("net"));
+class ApiContext extends HttpContext_1.default {
+    constructor(opts) {
+        super(opts);
+        this.contentDecoding = encoding_1.contentDecodingTable;
+        this.contentEncoding = encoding_1.contentEncodingTable;
+        this.contentTypeParsers = parser_1.contentParserTable;
+        this.parseInitial = (socket, chunk, p) => {
+            const routeId = this.httpCore.scannerRouteFirst(chunk, p, this.state.maxHeaderNameSize, this.state.maxHeaderValueSize, this.state.maxHeaderSize, this.state.requestQuerySize);
+            if (p.retFlag !== http_1.Http.RetFlagBits.FLAG_OK) {
+                switch (p.retFlag) {
+                    // --- CORS 204 ---
+                    case http_1.Http.RetFlagBits.FLAG_CORS_PREFLIGHT:
+                        socket.write(Buffer.from("HTTP/1.1 204 No Content\r\n" +
+                            this.state.corsHeaders + "\r\n" +
+                            "Content-Length: 0\r\n\r\n"));
+                        socket.destroy();
+                        return;
+                    // --- VERSION UNSUPPORTED ---
+                    case http_1.Http.RetFlagBits.FLAG_HTTP_VERSION_UNSUPPORTED:
+                        socket.write(this.errorRespMap.RESP_505);
+                        socket.destroy();
+                        return;
+                    // --- METHOD NOT ALLOWED ---
+                    case http_1.Http.RetFlagBits.FLAG_METHOD_NOT_ALLOWED:
+                        socket.write(this.errorRespMap.RESP_405);
+                        socket.destroy();
+                        return;
+                    // --- REQUEST QUERY EXCEEDED ---
+                    case http_1.Http.RetFlagBits.FLAG_REQUEST_QUERY_EXCEEDED:
+                        socket.write(this.errorRespMap.RESP_414);
+                        socket.destroySoon();
+                        return;
+                    // --- NOT FOUND ---
+                    case http_1.Http.RetFlagBits.FLAG_NOT_FOUND:
+                        if (this.enableCors) {
+                            socket.write(this.errorRespMap.RESP_204);
+                        }
+                        else {
+                            socket.write(this.errorRespMap.RESP_404);
+                        }
+                        socket.destroy();
+                        return;
+                    // === HEADER ERRORS ===
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_ARGUMENT:
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_HEADER:
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_CONTENT_LENGTH:
+                    case http_1.Http.RetFlagBits.FLAG_CONTENT_LENGTH_EXCEEDED:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_SIZE:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_NAME_SIZE:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_VALUE_SIZE:
+                    case http_1.Http.RetFlagBits.FLAG_DUPLICATE_SINGLE_HEADER:
+                        socket.write(this.errorRespMap.RESP_400);
+                        socket.destroy();
+                        return;
+                    case http_1.Http.RetFlagBits.FLAG_UNTERMINATED_HEADERS:
+                        p.rawBuf = chunk;
+                        p.routePipe = this.routePipes[routeId];
+                        p.fn = this.parseHeader;
+                        return;
+                    // --- OTHER (fallback) ---
+                    default:
+                        socket.write(this.errorRespMap.RESP_400);
+                        socket.destroy();
+                        return;
+                }
+            }
+            p.rawBuf = chunk;
+            const h = p.headers;
+            const hostHeader = h.host;
+            if (!hostHeader) {
+                socket.write(this.errorRespMap.RESP_400);
+                socket.destroy();
+                return;
+            }
+            p.routePipe = this.routePipes[routeId];
+            p.routePipe.accumulateHandler(socket, p);
+            return;
+        };
+        this.parseHeader = (socket, chunk, p) => {
+            p.rawBuf = Buffer.concat([p.rawBuf, chunk]);
+            this.httpCore.scannerHeader(p.rawBuf, p, this.state.maxHeaderNameSize, this.state.maxHeaderValueSize, this.state.maxHeaderSize);
+            if (p.retFlag !== http_1.Http.RetFlagBits.FLAG_OK) {
+                switch (p.retFlag) {
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_ARGUMENT:
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_HEADER:
+                    case http_1.Http.RetFlagBits.FLAG_INVALID_CONTENT_LENGTH:
+                    case http_1.Http.RetFlagBits.FLAG_CONTENT_LENGTH_EXCEEDED:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_SIZE:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_NAME_SIZE:
+                    case http_1.Http.RetFlagBits.FLAG_MAX_HEADER_VALUE_SIZE:
+                        socket.write(this.errorRespMap.RESP_400);
+                        socket.destroySoon();
+                        return;
+                    case http_1.Http.RetFlagBits.FLAG_UNTERMINATED_HEADERS:
+                        return;
+                }
+            }
+            const h = p.headers;
+            const hostHeader = h.Host ?? h.host ?? h.HOST;
+            if (!hostHeader) {
+                socket.write(this.errorRespMap.RESP_400);
+                return socket.destroy();
+            }
+            p.routePipe.accumulateHandler(socket, p);
+            return;
+        };
+        this.initRuntime();
+        this.bindServer(opts?.netServerOptions);
+    }
+    bindServer(netServerOptions) {
+        this.server = new net_1.default.Server(netServerOptions, (socket) => {
+            let p = this.chunkPool.allocate();
+            if (!p) {
+                socket.destroy();
+                return;
+            }
+            socket.setTimeout(this.state.timeout);
+            // socket.setNoDelay(true);
+            // socket.setKeepAlive(true, 60000);
+            socket.on("data", chunk => {
+                p.fn(socket, chunk, p);
+            });
+            socket.on("timeout", () => {
+                socket.destroy();
+            });
+            socket.on("error", (err) => {
+                socket.destroy();
+            });
+            socket.on("close", () => {
+                p.free();
+            });
+        });
+    }
+    registerRouters(mainRoute) {
+        super.registerRouters(mainRoute);
+    }
+    setHttpCore() {
+        super.setHttpCore("api");
+    }
+}
+exports.default = ApiContext;

package/dist/http/context/HttpContext.d.ts

@@ -0,0 +1,42 @@
+import { Http } from "../../http";
+import { type IHttpCore, type ICPool } from "../../hypernode";
+import net from "net";
+import { createAccumulators } from "../factory/accumulator";
+declare abstract class HttpContext {
+    protected MODE: "web" | "api";
+    protected abstract contentDecoding: Http.ContentDecoding;
+    protected abstract contentEncoding: Http.ContentEncoding;
+    protected abstract contentTypeParsers: Http.ContentTypeParser;
+    protected errorRespMap: Http.HttpStaticResponseMap;
+    server: net.Server;
+    protected chunkPool: ICPool;
+    protected respPool: ICPool;
+    protected routePipes: Http.RoutePipe[];
+    protected accumulators: ReturnType<typeof createAccumulators>;
+    protected abstract parseInitial: Http.ParseInitialFn;
+    protected state: Http.ServerState;
+    protected enableCors: boolean;
+    protected httpCore: IHttpCore;
+    protected setHttpCore(mode: "web" | "api"): void;
+    private bootstrapPoolChunkProgressionFn?;
+    constructor(opts?: Http.ServerOptions);
+    private setRegisterResp;
+    private setRegisterChunkProgression;
+    protected initRuntime(): void;
+    protected registerRouters(mainRoute: Http.Route): void;
+    private buildRoute;
+    enabledCors(cfg: Http.CorsConfig): void;
+    setTimeout(timeout: number): void;
+    setRequestQuerySize(requestQuerySize: number): void;
+    setMaxHeaderNameSize(maxHeaderNameSize: number): void;
+    setMaxHeaderValueSize(maxHeaderValueSize: number): void;
+    setMaxContentSize(maxContentSize: number): void;
+    listen(port?: number | undefined, hostname?: string | undefined, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
+    setMaxRequests(n: number): boolean;
+    getTimeout(): number;
+    getRequestQuerySize(): number;
+    getMaxHeaderNameSize(): number;
+    getMaxHeaderValueSize(): number;
+    getMaxContentSize(): number;
+}
+export default HttpContext;

package/dist/http/context/HttpContext.js

@@ -0,0 +1,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("../../http");
+const hypernode_1 = require("../../hypernode");
+const pipeline_1 = require("../factory/pipeline");
+const PipeResponseBase_1 = require("../response/PipeResponseBase");
+const ChunkProgression_1 = __importDefault(require("../chunker/ChunkProgression"));
+const accumulator_1 = require("../factory/accumulator");
+class HttpContext {
+    setHttpCore(mode) {
+        this.MODE = mode;
+        this.httpCore = new hypernode_1.hypernode.HttpCore();
+    }
+    constructor(opts) {
+        this.errorRespMap = {
+            RESP_505: Buffer.from("HTTP/1.1 505 HTTP Version Not Supported\r\nContent-Length: 0\r\n\r\n"),
+            RESP_405: Buffer.from("HTTP/1.1 405 Method Not Allowed\r\nContent-Length: 0\r\n\r\n"),
+            RESP_400: Buffer.from("HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\n\r\n"),
+            RESP_404: Buffer.from("HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n"),
+            RESP_413: Buffer.from("HTTP/1.1 413 Payload Too Large\r\nContent-Length: 0\r\n\r\n"),
+            RESP_414: Buffer.from("HTTP/1.1 414 Request-URI Too Large\r\nContent-Length: 0\r\n\r\n"),
+            RESP_204: Buffer.from("HTTP/1.1 204 No Content\r\n\r\n")
+        };
+        this.enableCors = false;
+        this.state = {
+            corsHeaders: "",
+            maxHeaderSize: opts?.maxHeaderSize || 10 * 1024,
+            maxHeaderNameSize: opts?.maxHeaderNameSize || 512,
+            maxHeaderValueSize: opts?.maxHeaderValueSize || 1024,
+            maxContentSize: opts?.maxContentSize || 3 * 1024 * 1024,
+            requestQuerySize: opts?.requestQuerySize || 2048,
+            timeout: opts?.timeout || 3000,
+            untilEnd: opts?.untilEnd || false,
+            maxRequests: opts?.maxRequests || 5000,
+            ResponseCtor: opts?.ResponseCtor || PipeResponseBase_1.PipeResponseBase
+        };
+        if (opts?.bootstrapPoolChunkProgression) {
+            // @ts-ignore
+            this.bootstrapPoolChunkProgressionFn = opts?.bootstrapPoolChunkProgression;
+        }
+    }
+    setRegisterResp(n, cPool) {
+        for (let i = 0; i < n; i++) {
+            let cObj = new this.state.ResponseCtor();
+            let objId = cPool.registerObj(cObj);
+            cObj.setCPool(cPool, objId);
+        }
+    }
+    setRegisterChunkProgression(n, cPool, respCPool) {
+        const objs = [];
+        for (let i = 0; i < n; i++) {
+            const cpObj = new ChunkProgression_1.default(cPool, this.parseInitial, respCPool);
+            if (this.bootstrapPoolChunkProgressionFn) {
+                this.bootstrapPoolChunkProgressionFn(cpObj);
+            }
+            objs.push(cpObj);
+        }
+        return objs;
+    }
+    initRuntime() {
+        this.respPool = new hypernode_1.hypernode.CPool();
+        this.respPool.initializePool(this.state.maxRequests);
+        this.setRegisterResp(this.state.maxRequests, this.respPool);
+        this.chunkPool = new hypernode_1.hypernode.CPool();
+        this.chunkPool.initializePool(this.state.maxRequests);
+        this.setRegisterChunkProgression(this.state.maxRequests, this.chunkPool, this.respPool);
+    }
+    registerRouters(mainRoute) {
+        this.accumulators = (0, accumulator_1.createAccumulators)({
+            contentDecoding: this.contentDecoding,
+            contentTypeParsers: this.contentTypeParsers,
+            errorRespMap: this.errorRespMap
+        });
+        this.buildRoute(mainRoute, this.state);
+    }
+    buildRoute(_Route, state) {
+        let buildedRoutes = [];
+        let routePipes = [];
+        let accumulators = this.accumulators;
+        function getMethodStr(method) {
+            switch (method) {
+                case http_1.Http.HttpMethod.GET: return "GET";
+                case http_1.Http.HttpMethod.POST: return "POST";
+                case http_1.Http.HttpMethod.PUT: return "PUT";
+                case http_1.Http.HttpMethod.PATCH: return "PATCH";
+                case http_1.Http.HttpMethod.DELETE: return "DELETE";
+                case http_1.Http.HttpMethod.OPTIONS: return "OPTIONS";
+                case http_1.Http.HttpMethod.HEAD: return "HEAD";
+                default: return "UNKNOWN";
+            }
+        }
+        function normalizeRoutePattern(route) {
+            let normalized = route.replace(/:([^\/]*)/g, ':');
+            if (normalized.endsWith(':')) {
+                normalized += '/';
+            }
+            return normalized;
+        }
+        function desicionMaker(ep) {
+            if (ep.method === http_1.Http.HttpMethod.GET || ep.method === http_1.Http.HttpMethod.HEAD)
+                return accumulators.accumulatorHeadGet;
+            if (ep.accumulateHandle)
+                return ep.accumulateHandle;
+            if (ep.ct) {
+                if (ep.ct.encoding && ep.ct.type)
+                    return accumulators.accumulatorDefinedTypeEncode;
+                else if (ep.ct.encoding)
+                    return accumulators.accumulatorDefinedEncode;
+                else if (ep.ct.type)
+                    return accumulators.accumulatorDefinedType;
+            }
+            return accumulators.decisionAccumulate;
+        }
+        function buildSubTree(rootRoute, url, _mws) {
+            let mws = [..._mws];
+            let mwIdx = 0;
+            while (mwIdx < rootRoute.middlewares.length) {
+                let mw = rootRoute.middlewares[mwIdx++];
+                mws.push(mw);
+            }
+            let epIdx = 0;
+            while (epIdx < rootRoute.endpoints.length) {
+                let ep = rootRoute.endpoints[epIdx++];
+                let pipeFns = [...mws.map((v) => v.handle), ...ep.middlewares.map((v) => v.handle), ep.handle];
+                let accumulateHandler = desicionMaker(ep);
+                let mainIndex = routePipes.push({
+                    url: url + ep.url,
+                    ct: ep?.ct,
+                    mws: pipeFns,
+                    pipeHandler: (0, pipeline_1.createPipeline)(ep, pipeFns),
+                    ResponseCtor: state.ResponseCtor,
+                    accumulateHandler: accumulateHandler,
+                    routeId: epIdx,
+                    maxContentSize: ep.maxContentSize || state.maxContentSize,
+                    maxHeaderSize: ep.maxHeaderSize || state.maxHeaderNameSize,
+                    untilEnd: ep.untilEnd || state.untilEnd,
+                }) - 1;
+                let bRoute = {
+                    method: getMethodStr(ep.method),
+                    route: normalizeRoutePattern(url + ep.url),
+                    vptrTableIndex: mainIndex
+                };
+                buildedRoutes.push(bRoute);
+            }
+            let routeIdx = 0;
+            while (routeIdx < rootRoute.routes.length) {
+                let childRoute = rootRoute.routes[routeIdx++];
+                let childUrl = url + childRoute.url;
+                buildSubTree(childRoute, childUrl, mws);
+            }
+        }
+        buildSubTree(_Route, _Route.url, []);
+        if (this.httpCore.registerRoutes(buildedRoutes) != buildedRoutes.length)
+            throw new Error("Building Route Tree");
+        this.routePipes = routePipes;
+    }
+    enabledCors(cfg) {
+        function toHeaderValue(v) {
+            if (!v)
+                return undefined;
+            return Array.isArray(v) ? v.join(",") : v;
+        }
+        const headers = [];
+        const allowedOrigins = cfg.allowedOrigins == true ? "*" : toHeaderValue(cfg.allowedOrigins);
+        const allowedMethods = toHeaderValue(cfg.allowedMethods);
+        const allowedHeaders = toHeaderValue(cfg.allowedHeaders);
+        const exposedHeaders = toHeaderValue(cfg.exposedHeaders);
+        const credentials = cfg.credentials;
+        const maxAge = cfg.maxAge;
+        if (allowedOrigins)
+            headers.push(`Access-Control-Allow-Origin: ${allowedOrigins}`);
+        if (allowedMethods)
+            headers.push(`Access-Control-Allow-Methods: ${allowedMethods}`);
+        if (allowedHeaders)
+            headers.push(`Access-Control-Allow-Headers: ${allowedHeaders}`);
+        if (exposedHeaders)
+            headers.push(`Access-Control-Expose-Headers: ${exposedHeaders}`);
+        if (credentials !== undefined)
+            headers.push(`Access-Control-Allow-Credentials: ${credentials}`);
+        if (maxAge !== undefined)
+            headers.push(`Access-Control-Max-Age: ${maxAge}`);
+        this.state.corsHeaders = headers.join("\n");
+        this.errorRespMap.RESP_204 = Buffer.from("HTTP/1.1 404 Not Found\r\n" +
+            this.state.corsHeaders + "\r\n" +
+            "Content-Length: 0\r\n\r\n");
+        this.enableCors = true;
+    }
+    setTimeout(timeout) {
+        timeout > 0 ? this.state.timeout = timeout : null;
+    }
+    setRequestQuerySize(requestQuerySize) {
+        requestQuerySize > 0 ? this.state.requestQuerySize = requestQuerySize : null;
+    }
+    setMaxHeaderNameSize(maxHeaderNameSize) {
+        maxHeaderNameSize > 0 ? this.state.maxHeaderNameSize = maxHeaderNameSize : null;
+    }
+    setMaxHeaderValueSize(maxHeaderValueSize) {
+        maxHeaderValueSize > 0 ? this.state.maxHeaderValueSize = maxHeaderValueSize : null;
+    }
+    setMaxContentSize(maxContentSize) {
+        maxContentSize > 0 ? this.state.maxContentSize = maxContentSize : null;
+    }
+    listen(port, hostname, backlog, listeningListener) {
+        this.server.listen(port, hostname, backlog, listeningListener);
+        return this;
+    }
+    setMaxRequests(n) {
+        if (n < 1) {
+            return false;
+        }
+        this.state.maxRequests = n;
+        try {
+            this.chunkPool.resizePool(n);
+            this.respPool.resizePool(n);
+        }
+        catch (error) {
+            console.error(error);
+            return false;
+        }
+        return true;
+    }
+    getTimeout() { return this.state.timeout; }
+    getRequestQuerySize() { return this.state.requestQuerySize; }
+    getMaxHeaderNameSize() { return this.state.maxHeaderNameSize; }
+    getMaxHeaderValueSize() { return this.state.maxHeaderValueSize; }
+    getMaxContentSize() { return this.state.maxContentSize; }
+}
+exports.default = HttpContext;

package/dist/http/context/WebContext.d.ts

@@ -0,0 +1,31 @@
+import { Http } from "../../http";
+import HttpContext from "./HttpContext";
+import net from "net";
+type RouteDefinationFn = (socket: net.Socket, p: Http.ChunkProgression, routeId: number, chunk: Buffer<ArrayBufferLike>) => void;
+declare class WebContext extends HttpContext {
+    protected contentDecoding: Http.ContentDecoding;
+    protected contentEncoding: Http.ContentEncoding;
+    protected contentTypeParsers: Record<string, (b: any) => any>;
+    private assetCache;
+    private assetParser;
+    protected spaRootPath: string;
+    protected spaRespBuffer: Buffer;
+    private publicRoutePathName;
+    private publicStaticRoute;
+    private routeDefinationFns;
+    constructor(ctxOpts: Http.WebContextState, opts?: Http.ServerOptions);
+    private bindServer;
+    protected parseInitial: Http.ParseInitialFn;
+    protected publicRouteDefinationFn: RouteDefinationFn;
+    protected spaRouteDefinationFn: RouteDefinationFn;
+    protected dynamicRouteDefinationFn: RouteDefinationFn;
+    protected parseHeader: Http.ParseInitialFn;
+    registerRouters(mainRoute: Http.Route | undefined): void;
+    private makeRouteSPA;
+    private makeRoutePublic;
+    private setRouteDefinationFn;
+    protected setAllAssets(): void;
+    private loadAsset;
+    setHttpCore(): void;
+}
+export default WebContext;