corecdtl 0.1.0

package/dist/http/factory/pipeline.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipeline = createPipeline;
+const types_1 = require("util/types");
+const http_1 = require("../../http");
+const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+function createMwsInline(mws) {
+    let ret = ``;
+    for (let i = 0; i < mws.length; i++) {
+        const mw = mws[i];
+        if ((0, types_1.isAsyncFunction)(mw)) {
+            ret += `!res.finishedFlag && await mws[${i}](req, res);\n`;
+        }
+        else {
+            ret += `!res.finishedFlag && mws[${i}](req, res);\n`; // await yok
+        }
+    }
+    return { inlineCode: ret };
+}
+function createPipeline(ep, pipeFns) {
+    const hasAsync = pipeFns.some(mw => (0, types_1.isAsyncFunction)(mw));
+    const { inlineCode } = createMwsInline(pipeFns);
+    const PipelineCtor = hasAsync ? AsyncFunction : Function;
+    const setRequestObj = `const req = {
+    headers: p.headers,
+    params: p.params,
+    query: p.query,
+    url: ""`;
+    // -----------------------
+    // GET & HEAD (NO BODY)
+    // -----------------------
+    if (ep.method === http_1.Http.HttpMethod.GET || ep.method === http_1.Http.HttpMethod.HEAD) {
+        return new PipelineCtor("p", "mws", "cb", `
+            ${setRequestObj}
+            };
+
+            const res = p.allocateResp();
+
+            ${inlineCode}
+            ret = res.getResp();
+            res.freeCPool();
+            cb(ret);
+        `);
+    }
+    // -----------------------
+    // BODY PIPELINE
+    // -----------------------
+    const content = ep.ct;
+    // DECODING
+    let decodeStep = "";
+    let bVar = "b";
+    if (content?.encoding) {
+        decodeStep = `
+        if (${bVar} != null) {
+            ${bVar} = contentDecodingTable["${content.encoding}"](${bVar});
+        }`;
+    }
+    else if (content?.encoding === null) {
+        decodeStep = `/* no encoding */`;
+    }
+    else {
+        decodeStep = `
+        if (${bVar} != null && p.headers["content-encoding"]) {
+            const enc = p.headers["Content-Encoding"];
+            if (contentDecodingTable[enc]) {
+                ${bVar} = contentDecodingTable[enc](${bVar});
+            }
+        }`;
+    }
+    // PARSING
+    let bodyParser = "";
+    if (content?.type) {
+        bodyParser = `
+            ${bVar} = contentTypeTable["${content.type}"](${bVar});
+        `;
+    }
+    else if (content?.type === null) {
+        bodyParser = `/* no content-type parser */`;
+    }
+    else {
+        bodyParser = `
+           if (${bVar} != null) {
+                const ctype = p.headers["content-type"];
+                ${bVar} = contentTypeTable[ctype]?.(${bVar}) ?? ${bVar};
+            }
+        `;
+    }
+    return new PipelineCtor("b", "p", "contentTypeTable", "contentDecodingTable", "mws", "cb", `
+        ${decodeStep}
+        ${bodyParser}
+
+        ${setRequestObj},
+            body: ${bVar}
+        };
+
+        const res = p.allocateResp();
+        ${inlineCode}
+        let ret = res.getResp();
+        res.freeCPool();
+        cb(ret);
+    `);
+}

package/dist/http/response/HttpResponseBase.d.ts

@@ -0,0 +1,10 @@
+export interface IHttpResponseBase {
+    setStatus(code: number): this;
+    setHeader(key: string, value: string): this;
+    setHeaders(obj: Record<string, string>): this;
+    send(payload: string): void;
+    json(obj: unknown): void;
+    redirect(url: string, code?: number): void;
+    getResp(): Buffer;
+    freeCPool(): void;
+}

package/dist/http/response/HttpResponseBase.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/http/response/PipeResponseBase.d.ts

@@ -0,0 +1,31 @@
+import { IHttpResponseBase } from "./HttpResponseBase";
+/**
+ * @class PipeResponseBase
+ * @description The base Response class used by Http.
+ * This class manages the HTTP response status code, headers, and body.
+ * Developers can inherit this class and override methods (e.g., `json`, `getResp`) to create custom response types.
+ */
+export declare class PipeResponseBase implements IHttpResponseBase {
+    protected body: string;
+    protected status: number;
+    protected headers: Record<string, string>;
+    protected finishedFlag: boolean;
+    protected contentEncodingTable: Record<string, Function>;
+    protected compression: "gzip" | "br" | "deflate" | null;
+    protected objId: number;
+    protected cPool: any;
+    constructor();
+    setCPool(cPool: any, objId: number): void;
+    freeCPool(): void;
+    getStatus(): number;
+    getHeaders(): Record<string, string>;
+    getBody(): string;
+    setStatus(code: number): this;
+    setHeader(key: string, value: string): this;
+    setHeaders(obj: Record<string, string>): this;
+    send(payload: string): void;
+    json(obj: unknown): void;
+    redirect(url: string, code?: number): void;
+    setCompression(enc: "gzip" | "br" | "deflate"): this;
+    getResp(): Buffer;
+}

package/dist/http/response/PipeResponseBase.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipeResponseBase = void 0;
+/**
+ * @class PipeResponseBase
+ * @description The base Response class used by Http.
+ * This class manages the HTTP response status code, headers, and body.
+ * Developers can inherit this class and override methods (e.g., `json`, `getResp`) to create custom response types.
+ */
+class PipeResponseBase {
+    constructor() {
+        this.body = "";
+        this.status = 200;
+        this.headers = Object.create(null);
+        this.finishedFlag = false;
+        this.compression = null;
+        this.objId = -1;
+        // JIT / inline safety
+        Object.defineProperty(this, "getResp", {
+            value: this.getResp.bind(this),
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+    }
+    /* ===================== */
+    /* ===== POOL API ====== */
+    /* ===================== */
+    setCPool(cPool, objId) {
+        this.objId = objId;
+        this.cPool = cPool;
+    }
+    freeCPool() {
+        this.body = "";
+        this.status = 200;
+        this.headers = Object.create(null);
+        this.finishedFlag = false;
+        this.compression = null;
+        this.cPool.free(this.objId);
+    }
+    /* ===================== */
+    /* ===== GETTERS ======= */
+    /* ===================== */
+    getStatus() {
+        return this.status;
+    }
+    getHeaders() {
+        return this.headers;
+    }
+    getBody() {
+        return this.body;
+    }
+    /* ===================== */
+    /* ===== MUTATORS ====== */
+    /* ===================== */
+    setStatus(code) {
+        this.status = code | 0;
+        return this;
+    }
+    setHeader(key, value) {
+        this.headers[key] = value;
+        return this;
+    }
+    setHeaders(obj) {
+        for (const k in obj)
+            this.headers[k] = obj[k];
+        return this;
+    }
+    /* ===================== */
+    /* ===== SEND API ====== */
+    /* ===================== */
+    send(payload) {
+        this.body = payload;
+        this.finishedFlag = true;
+    }
+    json(obj) {
+        this.setHeader("Content-Type", "application/json");
+        this.body = JSON.stringify(obj);
+        this.finishedFlag = true;
+    }
+    redirect(url, code = 302) {
+        this.status = code | 0;
+        this.headers["Location"] = url;
+        this.body = "";
+        this.finishedFlag = true;
+    }
+    setCompression(enc) {
+        this.compression = enc;
+        this.headers["Content-Encoding"] = enc;
+        return this;
+    }
+    /* ===================== */
+    /* ===== FINALIZE ====== */
+    /* ===================== */
+    getResp() {
+        const hdr = { ...this.headers };
+        let bodyBuf = Buffer.from(this.body, "utf-8");
+        if (this.compression) {
+            const fn = this.contentEncodingTable[this.compression];
+            if (fn)
+                bodyBuf = fn(bodyBuf);
+            hdr["Content-Encoding"] = this.compression;
+        }
+        hdr["Content-Length"] = Buffer.byteLength(bodyBuf).toString();
+        let headerStr = `HTTP/1.1 ${this.status}\r\n`;
+        for (const k in hdr)
+            headerStr += `${k}: ${hdr[k]}\r\n`;
+        headerStr += `\r\n`;
+        return Buffer.concat([
+            Buffer.from(headerStr, "ascii"),
+            bodyBuf
+        ]);
+    }
+}
+exports.PipeResponseBase = PipeResponseBase;