@j3r3mcdev/oast-server 1.1.12 → 1.1.14

package/src/core/http/__tests__/adapter-node.test.ts

@@ -1,52 +0,0 @@
-import { NodeAdapter } from "../adapter-node";
-import { MiddlewarePipeline } from "../middleware";
-import { Router } from "../router";
-import { Request } from "../request";
-import { Response } from "../response";
-import { describe, it, expect, jest } from "@jest/globals";
-import * as Build from "../buildRequest";
-
-describe("NodeAdapter.handle", () => {
-  it("appelle le handler quand la route match", async () => {
-    const router = new Router();
-    const pipeline = new MiddlewarePipeline();
-
-    // mock buildRequest
-    const buildRequestMock = jest
-      .spyOn(Build, "buildRequest")
-      .mockImplementation(
-        (raw: any, params?: Record<string, string>) =>
-          new Request({
-            method: "GET",
-            path: "/test",
-            headers: {},
-            params: params ?? {},
-          }),
-      );
-
-    const handler = jest.fn();
-
-    router.match = jest.fn(() => ({
-      handler,
-      params: { id: "42" },
-      middlewares: [],
-    })) as any;
-
-    pipeline.run = jest.fn(async () => {}) as any;
-
-    const res = {
-      writableEnded: false,
-      setHeader: jest.fn(),
-      end: jest.fn(),
-      statusCode: 200,
-    };
-
-    const adapter = new NodeAdapter(router, pipeline);
-
-    await adapter.handle({ url: "/test", method: "GET", headers: {} }, res);
-
-    expect(handler).toHaveBeenCalled();
-    expect(pipeline.run).toHaveBeenCalled();
-    expect(buildRequestMock).toHaveBeenCalledTimes(2);
-  });
-});

package/src/core/http/__tests__/body-parser-multipart.test.ts

@@ -1,41 +0,0 @@
-import { bodyParserMultipart } from "../middleware";
-import { Request } from "../request";
-import { Response } from "../response";
-import { describe, it, expect } from "@jest/globals";
-
-describe("bodyParserMultipart", () => {
-  it("parse un champ texte et un fichier", async () => {
-    const boundary = "----1234";
-
-    const raw = {
-      headers: { "content-type": `multipart/form-data; boundary=${boundary}` },
-      [Symbol.asyncIterator]: async function* () {
-        yield Buffer.from(
-          `--${boundary}\r\n` +
-            `Content-Disposition: form-data; name="username"\r\n\r\n` +
-            `jeremy\r\n` +
-            `--${boundary}\r\n` +
-            `Content-Disposition: form-data; name="file"; filename="test.txt"\r\n` +
-            `Content-Type: text/plain\r\n\r\n` +
-            `Hello world\r\n` +
-            `--${boundary}--`,
-        );
-      },
-    };
-
-    const req = new Request({
-      method: "POST",
-      path: "/upload",
-      headers: raw.headers,
-      raw,
-    });
-
-    const res = new Response({});
-
-    await bodyParserMultipart(req, res);
-
-    expect(req.form?.username).toBe("jeremy");
-    expect(req.files?.[0].filename).toBe("test.txt");
-    expect(req.files?.[0].data.toString()).toBe("Hello world");
-  });
-});

package/src/core/http/__tests__/body-parser-raw.test.ts

@@ -1,28 +0,0 @@
-import { bodyParserRaw } from "../middleware";
-import { Request } from "../request";
-import { Response } from "../response";
-import { describe, it, expect } from "@jest/globals";
-
-describe("bodyParserRaw", () => {
-  it("lit le body brut", async () => {
-    const raw = {
-      headers: { "content-type": "application/octet-stream" },
-      [Symbol.asyncIterator]: async function* () {
-        yield Buffer.from([1, 2, 3, 4]);
-      },
-    };
-
-    const req = new Request({
-      method: "POST",
-      path: "/",
-      headers: raw.headers,
-      raw,
-    });
-
-    const res = new Response({});
-
-    await bodyParserRaw(req, res);
-
-    expect(req.bodyRaw).toEqual(Buffer.from([1, 2, 3, 4]));
-  });
-});

package/src/core/http/__tests__/body-parser-text.test.ts

@@ -1,28 +0,0 @@
-import { bodyParserText } from "../middleware";
-import { Request } from "../request";
-import { Response } from "../response";
-import { describe, it, expect } from "@jest/globals";
-
-describe("bodyParserText", () => {
-  it("lit le body text", async () => {
-    const raw = {
-      headers: { "content-type": "text/plain" },
-      [Symbol.asyncIterator]: async function* () {
-        yield Buffer.from("Hello world");
-      },
-    };
-
-    const req = new Request({
-      method: "POST",
-      path: "/",
-      headers: raw.headers,
-      raw,
-    });
-
-    const res = new Response({});
-
-    await bodyParserText(req, res);
-
-    expect(req.bodyText).toBe("Hello world");
-  });
-});

package/src/core/http/__tests__/compile-path.test.ts

@@ -1,39 +0,0 @@
-import { compilePath } from "../compile-path";
-import { describe, it, expect } from "@jest/globals";
-
-describe("compilePath", () => {
-  it("compile un chemin simple avec segment statique", () => {
-    const result = compilePath("/tasks");
-
-    expect(result).toEqual([{ type: "static", value: "tasks" }]);
-  });
-
-  it("compile un chemin avec paramètre", () => {
-    const result = compilePath("/tasks/:id");
-
-    expect(result).toEqual([
-      { type: "static", value: "tasks" },
-      { type: "param", name: "id" },
-    ]);
-  });
-
-  it("compile un chemin avec paramètre", () => {
-    const result = compilePath("/tasks/:id");
-
-    expect(result).toEqual([
-      { type: "static", value: "tasks" },
-      { type: "param", name: "id" },
-    ]);
-  });
-
-  it("compile un chemin complexe avec static, param et wildcard", () => {
-    const result = compilePath("/a/:b/*/c");
-
-    expect(result).toEqual([
-      { type: "static", value: "a" },
-      { type: "param", name: "b" },
-      { type: "wildcard" },
-      { type: "static", value: "c" },
-    ]);
-  });
-});

package/src/core/http/__tests__/middleware-pipeline.test.ts

@@ -1,51 +0,0 @@
-import { MiddlewarePipeline } from "../../http/middleware";
-import { Request } from "../../http/request";
-import { Response } from "../../http/response";
-import { describe, it, expect, jest } from "@jest/globals";
-
-describe("MiddlewarePipeline", () => {
-  it("exécute les middlewares dans l'ordre", async () => {
-    const pipeline = new MiddlewarePipeline();
-
-    const calls: string[] = [];
-
-    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({ method: "GET", path: "/", headers: {} });
-    const res = new Response({ setHeader: jest.fn(), end: jest.fn() });
-
-    await pipeline.run(req, res);
-
-    expect(calls).toEqual(["mw1", "mw2"]);
-  });
-
-  it("arrête la chaîne si next() n'est pas appelé", async () => {
-    const pipeline = new MiddlewarePipeline();
-
-    const calls: string[] = [];
-
-    pipeline.use(async () => {
-      calls.push("mw1");
-      // pas de next()
-    });
-
-    pipeline.use(async () => {
-      calls.push("mw2");
-    });
-
-    const req = new Request({ method: "GET", path: "/", headers: {} });
-    const res = new Response({ setHeader: jest.fn(), end: jest.fn() });
-
-    await pipeline.run(req, res);
-
-    expect(calls).toEqual(["mw1"]);
-  });
-});

package/src/core/http/__tests__/request.test.ts

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

package/src/core/http/__tests__/response.test.ts

@@ -1,35 +0,0 @@
-import { Response } from "../../http/response";
-import { describe, it, expect, jest } from "@jest/globals";
-
-describe("Response", () => {
-  it("enregistre le status et les headers", () => {
-    const raw = {
-      setHeader: jest.fn(),
-      end: jest.fn(),
-    };
-
-    const res = new Response(raw);
-
-    res.status(201).header("x-test", "ok").send("hello");
-
-    expect(raw.setHeader).toHaveBeenCalledWith("x-test", "ok");
-    expect(raw.end).toHaveBeenCalledWith("hello");
-  });
-
-  it("envoie du JSON", () => {
-    const raw = {
-      setHeader: jest.fn(),
-      end: jest.fn(),
-    };
-
-    const res = new Response(raw);
-
-    res.json({ a: 1 });
-
-    expect(raw.setHeader).toHaveBeenCalledWith(
-      "content-type",
-      "application/json",
-    );
-    expect(raw.end).toHaveBeenCalledWith(JSON.stringify({ a: 1 }));
-  });
-});

package/src/core/http/__tests__/router-match.test.ts

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

package/src/core/http/adapter-node.ts

@@ -1,51 +0,0 @@
-// src/http/adapter-node.ts
-
-import { Request } from "./request";
-import { Response } from "./response";
-import { ErrorHandler } from "./errors";
-import { MiddlewarePipeline } from "./middleware";
-import { Router } from "./router";
-import { buildRequest } from "./buildRequest";
-
-export class NodeAdapter {
-  constructor(
-    private router: Router,
-    private pipeline: MiddlewarePipeline,
-  ) {}
-
-  async handle(req: any, res: any) {
-    try {
-      // 1) Construire la Request SANS params
-      const baseRequest = buildRequest(req);
-
-      const response = new 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 = 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) {
-      ErrorHandler.handle(err, new Response(res));
-    }
-  }
-}

package/src/core/http/buildRequest.ts

@@ -1,18 +0,0 @@
-import { Request } from "./request";
-
-export function buildRequest(
-  raw: any,
-  params: Record<string, string> = {},
-): Request {
-  const url = new URL(raw.url, `http://${raw.headers.host}`);
-
-  return new Request({
-    method: raw.method,
-    path: url.pathname,
-    headers: raw.headers,
-    query: Object.fromEntries(url.searchParams.entries()),
-    params,
-    ip: raw.socket?.remoteAddress ?? null,
-    raw,
-  });
-}

package/src/core/http/compile-path.ts

@@ -1,32 +0,0 @@
-export function compilePath(path: string) {
-  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/src/core/http/errors.ts

@@ -1,37 +0,0 @@
-// src/http/error.ts
-
-export class HttpError extends Error {
-  readonly status: number;
-  readonly code: string;
-  readonly details?: any;
-
-  constructor(status: number, code: string, message: string, details?: any) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.details = details;
-  }
-}
-
-export class ErrorHandler {
-  static handle(err: unknown, res: any) {
-    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",
-      },
-    });
-  }
-}

package/src/core/http/http-server.ts

@@ -1,52 +0,0 @@
-// src/api/http/http-server.ts
-
-import http from "node:http";
-import { Router } from "./router";
-
-export class HttpServer {
-  private server: http.Server | null = null;
-
-  constructor(private router: Router) {}
-
-  start(port: number) {
-    this.server = http.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);
-  }
-}