@j3r3mcdev/oast-server 1.1.6 → 1.1.8

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

@@ -1,171 +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([]);
-  });
-});
+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 +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));
-    }
-  }
-}
+// 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 +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,
-  });
-}
+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 +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;
-}
+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 +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",
-      },
-    });
-  }
-}
+// 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",
+      },
+    });
+  }
+}