@j3r3mcdev/oast-server 1.0.0

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

@@ -0,0 +1,171 @@
+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

@@ -0,0 +1,51 @@
+// 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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,37 @@
+// 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

@@ -0,0 +1,52 @@
+// 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);
+  }
+}

package/src/core/http/middleware.ts

@@ -0,0 +1,160 @@
+// src/http/middleware.ts
+
+import { Request } from "./request";
+import { Response } from "./response";
+
+export type Middleware = (
+  req: Request,
+  res: Response,
+  next: () => Promise<void>,
+) => Promise<void> | void;
+
+export class MiddlewarePipeline {
+  private middlewares: Middleware[] = [];
+
+  use(mw: Middleware): this {
+    this.middlewares.push(mw);
+    return this;
+  }
+
+  async run(req: Request, res: Response): Promise<void> {
+    let index = -1;
+
+    const next = async (): Promise<void> => {
+      index++;
+
+      if (index >= this.middlewares.length) return;
+
+      const mw = this.middlewares[index];
+
+      await Promise.resolve(mw(req, res, next));
+    };
+
+    await next();
+  }
+}
+
+/* ---------------------------------------------------------
+   JSON PARSER
+--------------------------------------------------------- */
+export async function bodyParserJson(req: Request, res: Response) {
+  const raw = req.raw;
+  const contentType = raw.headers["content-type"] ?? "";
+
+  if (!contentType.includes("application/json")) {
+    return;
+  }
+
+  const chunks: Buffer[] = [];
+  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
+--------------------------------------------------------- */
+export async function bodyParserRaw(req: Request, res: Response) {
+  const raw = req.raw;
+  const contentType = raw.headers["content-type"] ?? "";
+
+  if (contentType.includes("application/json")) return;
+
+  const chunks: Buffer[] = [];
+  for await (const chunk of raw) chunks.push(chunk);
+
+  req.bodyRaw = Buffer.concat(chunks);
+}
+
+/* ---------------------------------------------------------
+   TEXT PARSER
+--------------------------------------------------------- */
+export async function bodyParserText(req: Request, res: Response) {
+  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: Buffer[] = [];
+  for await (const chunk of raw) chunks.push(chunk);
+
+  req.bodyText = Buffer.concat(chunks).toString("utf8");
+}
+
+/* ---------------------------------------------------------
+   MULTIPART PARSER
+--------------------------------------------------------- */
+export async function bodyParserMultipart(req: Request, res: Response) {
+  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: Buffer[] = [];
+  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/src/core/http/request.ts

@@ -0,0 +1,55 @@
+// src/http/request.ts
+
+export interface RequestContext {
+  // espace réservé pour les middlewares
+  [key: string]: any;
+}
+
+export class Request {
+  readonly method: string;
+  readonly path: string;
+  readonly headers: Record<string, string>;
+  readonly query: Record<string, string | string[]>;
+  readonly params: Record<string, string>;
+  body: any;
+  bodyRaw?: Buffer;
+  bodyText?: string;
+  files?: Array<{
+    fieldname: string;
+    filename: string;
+    contentType: string;
+    data: Buffer;
+  }>;
+  form?: Record<string, string>;
+
+  readonly ip: string;
+  readonly raw: any; // Node IncomingMessage ou autre selon l'adaptateur
+  readonly context: RequestContext;
+
+  constructor(options: {
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    query?: Record<string, string | string[]>;
+    params?: Record<string, string>;
+    body?: any;
+    ip?: string;
+    raw?: any;
+    context?: RequestContext;
+  }) {
+    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: string): string | undefined {
+    return this.headers[name.toLowerCase()];
+  }
+}

package/src/core/http/response.ts

@@ -0,0 +1,93 @@
+// src/http/response.ts
+
+export class Response {
+  private _status = 200;
+  private _headers: Record<string, string> = {};
+  private _sent = false;
+  private _raw: any; // Node ServerResponse ou autre selon l'adaptateur
+
+  constructor(raw: any) {
+    this._raw = raw;
+  }
+
+  status(code: number): this {
+    this._status = code;
+    return this;
+  }
+
+  header(name: string, value: string): this {
+    this._headers[name.toLowerCase()] = value;
+    return this;
+  }
+
+  json(data: any): void {
+    this.ensureNotSent();
+    this.header("content-type", "application/json");
+    this.send(JSON.stringify(data));
+  }
+
+  text(data: string): void {
+    this.ensureNotSent();
+    this.header("content-type", "text/plain");
+    this.send(data);
+  }
+
+  send(data: any): void {
+    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: NodeJS.ReadableStream): void {
+    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(): void {
+    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: string): void {
+    this._raw.write(data);
+  }
+
+  end(): void {
+    if (!this._sent) {
+      this._raw.end();
+      this._sent = true;
+    }
+  }
+
+  private ensureNotSent() {
+    if (this._sent) {
+      throw new Error("Response already sent");
+    }
+  }
+}