@j3r3mcdev/oast-server 1.0.0

package/dist/core/http/__tests__/middleware-pipeline.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const middleware_1 = require("../../http/middleware");
+const request_1 = require("../../http/request");
+const response_1 = require("../../http/response");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)("MiddlewarePipeline", () => {
+    (0, globals_1.it)("exécute les middlewares dans l'ordre", async () => {
+        const pipeline = new middleware_1.MiddlewarePipeline();
+        const calls = [];
+        pipeline.use(async (req, res, next) => {
+            calls.push("mw1");
+            await next();
+        });
+        pipeline.use(async (req, res, next) => {
+            calls.push("mw2");
+            await next();
+        });
+        const req = new request_1.Request({ method: "GET", path: "/", headers: {} });
+        const res = new response_1.Response({ setHeader: globals_1.jest.fn(), end: globals_1.jest.fn() });
+        await pipeline.run(req, res);
+        (0, globals_1.expect)(calls).toEqual(["mw1", "mw2"]);
+    });
+    (0, globals_1.it)("arrête la chaîne si next() n'est pas appelé", async () => {
+        const pipeline = new middleware_1.MiddlewarePipeline();
+        const calls = [];
+        pipeline.use(async () => {
+            calls.push("mw1");
+            // pas de next()
+        });
+        pipeline.use(async () => {
+            calls.push("mw2");
+        });
+        const req = new request_1.Request({ method: "GET", path: "/", headers: {} });
+        const res = new response_1.Response({ setHeader: globals_1.jest.fn(), end: globals_1.jest.fn() });
+        await pipeline.run(req, res);
+        (0, globals_1.expect)(calls).toEqual(["mw1"]);
+    });
+});

package/dist/core/http/__tests__/request.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_1 = require("../request");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)("Request", () => {
+    (0, globals_1.it)("crée une requête immuable avec les bonnes propriétés", () => {
+        const req = new request_1.Request({
+            method: "GET",
+            path: "/test",
+            headers: { "content-type": "application/json" },
+            query: { a: "1" },
+            params: { id: "123" },
+            body: { x: 1 },
+            ip: "127.0.0.1",
+        });
+        (0, globals_1.expect)(req.method).toBe("GET");
+        (0, globals_1.expect)(req.path).toBe("/test");
+        (0, globals_1.expect)(req.headers["content-type"]).toBe("application/json");
+        (0, globals_1.expect)(req.query.a).toBe("1");
+        (0, globals_1.expect)(req.params.id).toBe("123");
+        (0, globals_1.expect)(req.body.x).toBe(1);
+        (0, globals_1.expect)(req.ip).toBe("127.0.0.1");
+    });
+    (0, globals_1.it)("retourne un header via header()", () => {
+        const req = new request_1.Request({
+            method: "GET",
+            path: "/",
+            headers: { "x-test": "ok" },
+        });
+        (0, globals_1.expect)(req.header("x-test")).toBe("ok");
+    });
+});

package/dist/core/http/__tests__/response.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const response_1 = require("../../http/response");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)("Response", () => {
+    (0, globals_1.it)("enregistre le status et les headers", () => {
+        const raw = {
+            setHeader: globals_1.jest.fn(),
+            end: globals_1.jest.fn(),
+        };
+        const res = new response_1.Response(raw);
+        res.status(201).header("x-test", "ok").send("hello");
+        (0, globals_1.expect)(raw.setHeader).toHaveBeenCalledWith("x-test", "ok");
+        (0, globals_1.expect)(raw.end).toHaveBeenCalledWith("hello");
+    });
+    (0, globals_1.it)("envoie du JSON", () => {
+        const raw = {
+            setHeader: globals_1.jest.fn(),
+            end: globals_1.jest.fn(),
+        };
+        const res = new response_1.Response(raw);
+        res.json({ a: 1 });
+        (0, globals_1.expect)(raw.setHeader).toHaveBeenCalledWith("content-type", "application/json");
+        (0, globals_1.expect)(raw.end).toHaveBeenCalledWith(JSON.stringify({ a: 1 }));
+    });
+});

package/dist/core/http/__tests__/router-match.test.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const router_1 = require("../router");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)("Router.match", () => {
+    (0, globals_1.it)("match une route statique", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/tasks", () => "ok");
+        const result = router.match("GET", "/tasks");
+        (0, globals_1.expect)(result).not.toBeNull();
+        (0, globals_1.expect)(result?.handler()).toBe("ok");
+        (0, globals_1.expect)(result?.params).toEqual({});
+        (0, globals_1.expect)(result?.middlewares).toEqual([]);
+    });
+    (0, globals_1.it)("match une route avec paramètre", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/tasks/:id", () => "task");
+        const result = router.match("GET", "/tasks/42");
+        (0, globals_1.expect)(result).not.toBeNull();
+        (0, globals_1.expect)(result?.handler()).toBe("task");
+        (0, globals_1.expect)(result?.params).toEqual({ id: "42" });
+        (0, globals_1.expect)(result?.middlewares).toEqual([]);
+    });
+    (0, globals_1.it)("match une route avec wildcard", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/files/*", () => "wild");
+        const result = router.match("GET", "/files/any/path/here");
+        (0, globals_1.expect)(result).not.toBeNull();
+        (0, globals_1.expect)(result?.handler()).toBe("wild");
+        (0, globals_1.expect)(result?.params).toEqual({});
+        (0, globals_1.expect)(result?.middlewares).toEqual([]);
+    });
+    (0, globals_1.it)("match un chemin complexe avec static, param et wildcard", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/a/:b/*/c", () => "complex");
+        const result = router.match("GET", "/a/hello/anything/here/c");
+        (0, globals_1.expect)(result).not.toBeNull();
+        (0, globals_1.expect)(result?.handler()).toBe("complex");
+        (0, globals_1.expect)(result?.params).toEqual({ b: "hello" });
+        (0, globals_1.expect)(result?.middlewares).toEqual([]);
+    });
+    (0, globals_1.it)("ne match pas quand le chemin ne correspond pas", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/tasks/:id", () => "ok");
+        const result = router.match("GET", "/tasks");
+        (0, globals_1.expect)(result).toBeNull();
+    });
+    (0, globals_1.it)("ne match pas quand le chemin est trop long", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/tasks/:id", () => "ok");
+        const result = router.match("GET", "/tasks/42/extra");
+        (0, globals_1.expect)(result).toBeNull();
+    });
+    (0, globals_1.it)("ne match pas quand la méthode HTTP ne correspond pas", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/tasks", () => "ok");
+        const result = router.match("POST", "/tasks");
+        (0, globals_1.expect)(result).toBeNull();
+    });
+    (0, globals_1.it)("match une route avec plusieurs paramètres", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/users/:userId/tasks/:taskId", () => "multi");
+        const result = router.match("GET", "/users/12/tasks/99");
+        (0, globals_1.expect)(result).not.toBeNull();
+        (0, globals_1.expect)(result?.handler()).toBe("multi");
+        (0, globals_1.expect)(result?.params).toEqual({
+            userId: "12",
+            taskId: "99",
+        });
+        (0, globals_1.expect)(result?.middlewares).toEqual([]);
+    });
+    (0, globals_1.it)("match une route complexe avec plusieurs paramètres et un wildcard", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
+        const result = router.match("GET", "/users/12/any/path/here/tasks/99");
+        (0, globals_1.expect)(result).not.toBeNull();
+        (0, globals_1.expect)(result?.handler()).toBe("mw");
+        (0, globals_1.expect)(result?.params).toEqual({
+            userId: "12",
+            taskId: "99",
+        });
+        (0, globals_1.expect)(result?.middlewares).toEqual([]);
+    });
+    (0, globals_1.it)("ne match pas un chemin complexe si la fin ne correspond pas", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
+        const result = router.match("GET", "/users/12/any/path/here/taskz/99");
+        (0, globals_1.expect)(result).toBeNull();
+    });
+    (0, globals_1.it)("ne match pas si le paramètre final est manquant", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
+        const result = router.match("GET", "/users/12/any/path/here/tasks/");
+        (0, globals_1.expect)(result).toBeNull();
+    });
+    (0, globals_1.it)("ne match pas si le paramètre du début est manquant", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
+        const result = router.match("GET", "/users//any/path/tasks/99");
+        (0, globals_1.expect)(result).toBeNull();
+    });
+    (0, globals_1.it)("ne match pas si le wildcard est vide", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
+        const result = router.match("GET", "/users/12//tasks/99");
+        (0, globals_1.expect)(result).toBeNull();
+    });
+    (0, globals_1.it)("match une route avec wildcard en fin de chemin", () => {
+        const router = new router_1.Router();
+        router.register("GET", "/files/*", () => "end");
+        const result = router.match("GET", "/files/path/to/something");
+        (0, globals_1.expect)(result).not.toBeNull();
+        (0, globals_1.expect)(result?.handler()).toBe("end");
+        (0, globals_1.expect)(result?.params).toEqual({});
+        (0, globals_1.expect)(result?.middlewares).toEqual([]);
+    });
+});

package/dist/core/http/adapter-node.js

@@ -0,0 +1,44 @@
+"use strict";
+// src/http/adapter-node.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeAdapter = void 0;
+const response_1 = require("./response");
+const errors_1 = require("./errors");
+const buildRequest_1 = require("./buildRequest");
+class NodeAdapter {
+    constructor(router, pipeline) {
+        this.router = router;
+        this.pipeline = pipeline;
+    }
+    async handle(req, res) {
+        try {
+            // 1) Construire la Request SANS params
+            const baseRequest = (0, buildRequest_1.buildRequest)(req);
+            const response = new response_1.Response(res);
+            // 2) Résoudre la route
+            const match = this.router.match(baseRequest.method, baseRequest.path);
+            if (!match) {
+                response.status(404).json({ error: "Not Found" });
+                return;
+            }
+            // 3) Construire la Request AVEC params
+            const request = (0, buildRequest_1.buildRequest)(req, match.params);
+            // 4) Middlewares par route
+            for (const mw of match.middlewares ?? []) {
+                if (res.writableEnded)
+                    return;
+                await mw(request, response, async () => { });
+            }
+            // 5) Pipeline global
+            await this.pipeline.run(request, response);
+            // 6) Handler final
+            if (!res.writableEnded) {
+                await match.handler(request, response);
+            }
+        }
+        catch (err) {
+            errors_1.ErrorHandler.handle(err, new response_1.Response(res));
+        }
+    }
+}
+exports.NodeAdapter = NodeAdapter;

package/dist/core/http/buildRequest.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRequest = buildRequest;
+const request_1 = require("./request");
+function buildRequest(raw, params = {}) {
+    const url = new URL(raw.url, `http://${raw.headers.host}`);
+    return new request_1.Request({
+        method: raw.method,
+        path: url.pathname,
+        headers: raw.headers,
+        query: Object.fromEntries(url.searchParams.entries()),
+        params,
+        ip: raw.socket?.remoteAddress ?? null,
+        raw,
+    });
+}

package/dist/core/http/compile-path.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilePath = compilePath;
+function compilePath(path) {
+    const segments = path.replace(/^\//, "").split("/");
+    const compiled = [];
+    for (const segment of segments) {
+        // analyse ici
+        if (segment !== "*" && !segment.startsWith(":")) {
+            compiled.push({ type: "static", value: segment });
+            continue;
+        }
+        if (segment.startsWith(":")) {
+            compiled.push({
+                type: "param",
+                name: segment.slice(1),
+            });
+            continue;
+        }
+        if (segment === "*") {
+            compiled.push({ type: "wildcard" });
+            continue;
+        }
+        if (segment === "*") {
+            compiled.push({ type: "wildcard" });
+            continue;
+        }
+    }
+    return compiled;
+}

package/dist/core/http/errors.js

@@ -0,0 +1,35 @@
+"use strict";
+// src/http/error.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandler = exports.HttpError = void 0;
+class HttpError extends Error {
+    constructor(status, code, message, details) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.details = details;
+    }
+}
+exports.HttpError = HttpError;
+class ErrorHandler {
+    static handle(err, res) {
+        if (err instanceof HttpError) {
+            res.status(err.status).json({
+                error: {
+                    code: err.code,
+                    message: err.message,
+                    details: err.details ?? null,
+                },
+            });
+            return;
+        }
+        // Erreur inconnue → 500
+        res.status(500).json({
+            error: {
+                code: "INTERNAL_ERROR",
+                message: "An unexpected error occurred",
+            },
+        });
+    }
+}
+exports.ErrorHandler = ErrorHandler;

package/dist/core/http/http-server.js

@@ -0,0 +1,48 @@
+"use strict";
+// src/api/http/http-server.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpServer = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+class HttpServer {
+    constructor(router) {
+        this.router = router;
+        this.server = null;
+    }
+    start(port) {
+        this.server = node_http_1.default.createServer((req, res) => {
+            const method = req.method || "GET";
+            const url = req.url || "/";
+            const match = this.router.match(method, url);
+            if (!match) {
+                res.statusCode = 404;
+                res.end("Not found");
+                return;
+            }
+            const result = match.handler({
+                params: match.params,
+                req,
+                res,
+            });
+            if (!res.writableEnded) {
+                res.end(result ?? "");
+            }
+        });
+        this.server.listen(port, () => {
+            console.log(`HTTP server running on port ${port}`);
+        });
+        // 🔥 Shutdown propre
+        const shutdown = () => {
+            console.log("Shutting down HTTP server gracefully...");
+            this.server?.close(() => {
+                console.log("HTTP server closed.");
+                process.exit(0);
+            });
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+    }
+}
+exports.HttpServer = HttpServer;

package/dist/core/http/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/core/http/main.js

@@ -0,0 +1 @@
+"use strict";

package/dist/core/http/middleware.js

@@ -0,0 +1,133 @@
+"use strict";
+// src/http/middleware.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewarePipeline = void 0;
+exports.bodyParserJson = bodyParserJson;
+exports.bodyParserRaw = bodyParserRaw;
+exports.bodyParserText = bodyParserText;
+exports.bodyParserMultipart = bodyParserMultipart;
+class MiddlewarePipeline {
+    constructor() {
+        this.middlewares = [];
+    }
+    use(mw) {
+        this.middlewares.push(mw);
+        return this;
+    }
+    async run(req, res) {
+        let index = -1;
+        const next = async () => {
+            index++;
+            if (index >= this.middlewares.length)
+                return;
+            const mw = this.middlewares[index];
+            await Promise.resolve(mw(req, res, next));
+        };
+        await next();
+    }
+}
+exports.MiddlewarePipeline = MiddlewarePipeline;
+/* ---------------------------------------------------------
+   JSON PARSER
+--------------------------------------------------------- */
+async function bodyParserJson(req, res) {
+    const raw = req.raw;
+    const contentType = raw.headers["content-type"] ?? "";
+    if (!contentType.includes("application/json")) {
+        return;
+    }
+    const chunks = [];
+    for await (const chunk of raw)
+        chunks.push(chunk);
+    const text = Buffer.concat(chunks).toString("utf8");
+    try {
+        req.body = text.length > 0 ? JSON.parse(text) : {};
+    }
+    catch {
+        res.status(400).json({ error: "Invalid JSON" });
+    }
+}
+/* ---------------------------------------------------------
+   RAW PARSER
+--------------------------------------------------------- */
+async function bodyParserRaw(req, res) {
+    const raw = req.raw;
+    const contentType = raw.headers["content-type"] ?? "";
+    if (contentType.includes("application/json"))
+        return;
+    const chunks = [];
+    for await (const chunk of raw)
+        chunks.push(chunk);
+    req.bodyRaw = Buffer.concat(chunks);
+}
+/* ---------------------------------------------------------
+   TEXT PARSER
+--------------------------------------------------------- */
+async function bodyParserText(req, res) {
+    const raw = req.raw;
+    const contentType = raw.headers["content-type"] ?? "";
+    const isText = contentType.startsWith("text/") ||
+        contentType.includes("application/xml") ||
+        contentType.includes("application/xhtml+xml");
+    if (!isText)
+        return;
+    const chunks = [];
+    for await (const chunk of raw)
+        chunks.push(chunk);
+    req.bodyText = Buffer.concat(chunks).toString("utf8");
+}
+/* ---------------------------------------------------------
+   MULTIPART PARSER
+--------------------------------------------------------- */
+async function bodyParserMultipart(req, res) {
+    const raw = req.raw;
+    const contentType = raw.headers["content-type"] ?? "";
+    if (!contentType.startsWith("multipart/form-data"))
+        return;
+    const boundaryMatch = contentType.match(/boundary=(.+)$/);
+    if (!boundaryMatch) {
+        res.status(400).json({ error: "Missing multipart boundary" });
+        return;
+    }
+    const boundary = "--" + boundaryMatch[1];
+    const chunks = [];
+    for await (const chunk of raw)
+        chunks.push(chunk);
+    const buffer = Buffer.concat(chunks);
+    const parts = buffer.toString("binary").split(boundary);
+    req.files = [];
+    req.form = {};
+    for (const part of parts) {
+        if (part === "--\r\n" || part === "" || part === "\r\n")
+            continue;
+        const [rawHeaders, rawBody] = part.split("\r\n\r\n");
+        if (!rawBody)
+            continue;
+        // Nettoyage du body brut
+        const cleaned = rawBody.replace(/\r\n--$/, "");
+        const body = Buffer.from(cleaned, "binary");
+        const disposition = rawHeaders.match(/name="([^"]+)"/);
+        if (!disposition)
+            continue;
+        const fieldname = disposition[1];
+        const filenameMatch = rawHeaders.match(/filename="([^"]+)"/);
+        if (filenameMatch) {
+            // ----------- FICHIER -----------
+            const filename = filenameMatch[1];
+            const contentTypeMatch = rawHeaders.match(/Content-Type: (.+)/);
+            req.files.push({
+                fieldname,
+                filename,
+                contentType: contentTypeMatch
+                    ? contentTypeMatch[1]
+                    : "application/octet-stream",
+                // 🔥 Correction : retirer le \r\n final
+                data: Buffer.from(body.toString("binary").replace(/\r\n$/, ""), "binary"),
+            });
+        }
+        else {
+            // ----------- CHAMP TEXTE -----------
+            req.form[fieldname] = body.toString("utf8").replace(/\r\n$/, ""); // 🔥 Correction champ texte
+        }
+    }
+}

package/dist/core/http/request.js

@@ -0,0 +1,22 @@
+"use strict";
+// src/http/request.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Request = void 0;
+class Request {
+    constructor(options) {
+        this.method = options.method;
+        this.path = options.path;
+        this.headers = options.headers;
+        this.query = options.query ?? {};
+        this.params = options.params ?? {};
+        this.body = options.body ?? null;
+        this.ip = options.ip ?? "";
+        this.raw = options.raw ?? null;
+        this.context = options.context ?? {};
+    }
+    // Exemple d'utilitaire PRO
+    header(name) {
+        return this.headers[name.toLowerCase()];
+    }
+}
+exports.Request = Request;

package/dist/core/http/response.js

@@ -0,0 +1,74 @@
+"use strict";
+// src/http/response.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
+class Response {
+    constructor(raw) {
+        this._status = 200;
+        this._headers = {};
+        this._sent = false;
+        this._raw = raw;
+    }
+    status(code) {
+        this._status = code;
+        return this;
+    }
+    header(name, value) {
+        this._headers[name.toLowerCase()] = value;
+        return this;
+    }
+    json(data) {
+        this.ensureNotSent();
+        this.header("content-type", "application/json");
+        this.send(JSON.stringify(data));
+    }
+    text(data) {
+        this.ensureNotSent();
+        this.header("content-type", "text/plain");
+        this.send(data);
+    }
+    send(data) {
+        this.ensureNotSent();
+        for (const [name, value] of Object.entries(this._headers)) {
+            this._raw.setHeader(name, value);
+        }
+        this._raw.statusCode = this._status;
+        this._raw.end(data);
+        this._sent = true;
+    }
+    stream(readable) {
+        this.ensureNotSent();
+        for (const [name, value] of Object.entries(this._headers)) {
+            this._raw.setHeader(name, value);
+        }
+        this._raw.statusCode = this._status;
+        readable.pipe(this._raw);
+        this._sent = true;
+    }
+    sse() {
+        this.ensureNotSent();
+        this.header("content-type", "text/event-stream");
+        this.header("cache-control", "no-cache");
+        this.header("connection", "keep-alive");
+        for (const [name, value] of Object.entries(this._headers)) {
+            this._raw.setHeader(name, value);
+        }
+        this._raw.flushHeaders?.();
+        this._sent = false; // SSE reste ouvert
+    }
+    write(data) {
+        this._raw.write(data);
+    }
+    end() {
+        if (!this._sent) {
+            this._raw.end();
+            this._sent = true;
+        }
+    }
+    ensureNotSent() {
+        if (this._sent) {
+            throw new Error("Response already sent");
+        }
+    }
+}
+exports.Response = Response;