@j3r3mcdev/oast-server 1.1.6 → 1.1.8

package/src/listeners/api/api.extractor.ts

@@ -1,43 +1,43 @@
-import { IncomingMessage } from "http";
-import { RawEvent } from "../../types/event.types";
-
-export class ApiExtractor {
-  static async extract(req: IncomingMessage): Promise<RawEvent> {
-    const ip = req.socket.remoteAddress ?? "";
-    const method = req.method ?? "";
-    const url = new URL(req.url ?? "", `http://${req.headers.host}`);
-    const path = url.pathname;
-
-    const query: Record<string, string> = {};
-    for (const [key, value] of url.searchParams.entries()) {
-      query[key] = value;
-    }
-
-    // Lecture du body (si POST/PUT/PATCH)
-    let body: any = null;
-
-    if (method !== "GET" && method !== "HEAD") {
-      body = await new Promise((resolve) => {
-        let data = "";
-        req.on("data", (chunk) => (data += chunk));
-        req.on("end", () => {
-          try {
-            resolve(JSON.parse(data));
-          } catch {
-            resolve(data);
-          }
-        });
-      });
-    }
-
-    return {
-      ip,
-      method,
-      path,
-      headers: req.headers,
-      query,
-      body,
-      raw: req,
-    };
-  }
-}
+import { IncomingMessage } from "http";
+import { RawEvent } from "../../types/event.types";
+
+export class ApiExtractor {
+  static async extract(req: IncomingMessage): Promise<RawEvent> {
+    const ip = req.socket.remoteAddress ?? "";
+    const method = req.method ?? "";
+    const url = new URL(req.url ?? "", `http://${req.headers.host}`);
+    const path = url.pathname;
+
+    const query: Record<string, string> = {};
+    for (const [key, value] of url.searchParams.entries()) {
+      query[key] = value;
+    }
+
+    // Lecture du body (si POST/PUT/PATCH)
+    let body: any = null;
+
+    if (method !== "GET" && method !== "HEAD") {
+      body = await new Promise((resolve) => {
+        let data = "";
+        req.on("data", (chunk) => (data += chunk));
+        req.on("end", () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch {
+            resolve(data);
+          }
+        });
+      });
+    }
+
+    return {
+      ip,
+      method,
+      path,
+      headers: req.headers,
+      query,
+      body,
+      raw: req,
+    };
+  }
+}

package/src/listeners/api/api.listener.ts

@@ -1,50 +1,50 @@
-import { createServer, IncomingMessage, Server, ServerResponse } from "http";
-import { Logger } from "../../core/logger";
-import { StorageManager } from "../../core/storage";
-import { handleApiRequest } from "./api.routes";
-import { ApiSse } from "./api.sse";
-
-export interface ApiListenerOptions {
-  port: number;
-  logger?: Logger;
-}
-
-export class ApiListener {
-  private logger: Logger;
-  private server: Server | null = null;
-  private sse: ApiSse;
-
-  constructor(
-    private storage: StorageManager,
-    private options: ApiListenerOptions,
-  ) {
-    this.logger = options.logger ?? new Logger({ context: "ApiListener" });
-    this.sse = new ApiSse(this.logger);
-  }
-
-  async start() {
-    this.server = createServer((req: IncomingMessage, res: ServerResponse) => {
-      void handleApiRequest(req, res, this.storage, this.sse, this.logger);
-    });
-
-    this.server.listen(this.options.port, () => {
-      this.logger.info(`API Listener started on port ${this.options.port}`);
-    });
-  }
-
-  async stop() {
-    this.sse.closeAll();
-
-    if (this.server) {
-      this.server.close();
-      this.server = null;
-    }
-
-    this.logger.info("API Listener stopped");
-  }
-
-  // Méthode appelée par ton CoreRouter / CoreServer après chaque event
-  public broadcastEvent(event: any) {
-    this.sse.broadcast(event);
-  }
-}
+import { createServer, IncomingMessage, Server, ServerResponse } from "http";
+import { Logger } from "../../core/logger";
+import { StorageManager } from "../../core/storage";
+import { handleApiRequest } from "./api.routes";
+import { ApiSse } from "./api.sse";
+
+export interface ApiListenerOptions {
+  port: number;
+  logger?: Logger;
+}
+
+export class ApiListener {
+  private logger: Logger;
+  private server: Server | null = null;
+  private sse: ApiSse;
+
+  constructor(
+    private storage: StorageManager,
+    private options: ApiListenerOptions,
+  ) {
+    this.logger = options.logger ?? new Logger({ context: "ApiListener" });
+    this.sse = new ApiSse(this.logger);
+  }
+
+  async start() {
+    this.server = createServer((req: IncomingMessage, res: ServerResponse) => {
+      void handleApiRequest(req, res, this.storage, this.sse, this.logger);
+    });
+
+    this.server.listen(this.options.port, () => {
+      this.logger.info(`API Listener started on port ${this.options.port}`);
+    });
+  }
+
+  async stop() {
+    this.sse.closeAll();
+
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+
+    this.logger.info("API Listener stopped");
+  }
+
+  // Méthode appelée par ton CoreRouter / CoreServer après chaque event
+  public broadcastEvent(event: any) {
+    this.sse.broadcast(event);
+  }
+}

package/src/listeners/api/api.routes.ts

@@ -1,76 +1,76 @@
-import { IncomingMessage, ServerResponse } from "http";
-import { Logger } from "../../core/logger";
-import { StorageManager } from "../../core/storage";
-import { ApiSse } from "./api.sse";
-import { ApiController } from "./api.controllers";
-
-export async function handleApiRequest(
-  req: IncomingMessage,
-  res: ServerResponse,
-  storage: StorageManager,
-  sse: ApiSse,
-  logger: Logger,
-): Promise<void> {
-  try {
-    const url = new URL(req.url ?? "", `http://${req.headers.host}`);
-    const path = url.pathname;
-    const method = req.method ?? "GET";
-
-    // ---------------------------
-    // SSE STREAM
-    // ---------------------------
-    if (method === "GET" && path === "/events/stream") {
-      await sse.handle(res);
-      return;
-    }
-
-    // ---------------------------
-    // ROUTES REST
-    // ---------------------------
-
-    // GET /events
-    if (method === "GET" && path === "/events") {
-      await ApiController.listEvents(url, res, storage);
-      return;
-    }
-
-    // GET /events/:id
-    if (method === "GET" && path.startsWith("/events/")) {
-      const id = path.split("/")[2];
-      await ApiController.getEvent(id, res, storage);
-      return;
-    }
-
-    // DELETE /events
-    if (method === "DELETE" && path === "/events") {
-      await ApiController.deleteAll(res, storage);
-      return;
-    }
-
-    // DELETE /events/:id
-    if (method === "DELETE" && path.startsWith("/events/")) {
-      const id = path.split("/")[2];
-      await ApiController.deleteOne(id, res, storage);
-      return;
-    }
-
-    // GET /stats
-    if (method === "GET" && path === "/stats") {
-      await ApiController.stats(res, storage);
-      return;
-    }
-
-    // 404
-    res.writeHead(404, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ success: false, error: "Not found" }));
-  } catch (err: any) {
-    logger.error("API error", { error: err?.message ?? String(err) });
-    res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(
-      JSON.stringify({
-        success: false,
-        error: err?.message ?? "Internal server error",
-      }),
-    );
-  }
-}
+import { IncomingMessage, ServerResponse } from "http";
+import { Logger } from "../../core/logger";
+import { StorageManager } from "../../core/storage";
+import { ApiSse } from "./api.sse";
+import { ApiController } from "./api.controllers";
+
+export async function handleApiRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  storage: StorageManager,
+  sse: ApiSse,
+  logger: Logger,
+): Promise<void> {
+  try {
+    const url = new URL(req.url ?? "", `http://${req.headers.host}`);
+    const path = url.pathname;
+    const method = req.method ?? "GET";
+
+    // ---------------------------
+    // SSE STREAM
+    // ---------------------------
+    if (method === "GET" && path === "/events/stream") {
+      await sse.handle(res);
+      return;
+    }
+
+    // ---------------------------
+    // ROUTES REST
+    // ---------------------------
+
+    // GET /events
+    if (method === "GET" && path === "/events") {
+      await ApiController.listEvents(url, res, storage);
+      return;
+    }
+
+    // GET /events/:id
+    if (method === "GET" && path.startsWith("/events/")) {
+      const id = path.split("/")[2];
+      await ApiController.getEvent(id, res, storage);
+      return;
+    }
+
+    // DELETE /events
+    if (method === "DELETE" && path === "/events") {
+      await ApiController.deleteAll(res, storage);
+      return;
+    }
+
+    // DELETE /events/:id
+    if (method === "DELETE" && path.startsWith("/events/")) {
+      const id = path.split("/")[2];
+      await ApiController.deleteOne(id, res, storage);
+      return;
+    }
+
+    // GET /stats
+    if (method === "GET" && path === "/stats") {
+      await ApiController.stats(res, storage);
+      return;
+    }
+
+    // 404
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: false, error: "Not found" }));
+  } catch (err: any) {
+    logger.error("API error", { error: err?.message ?? String(err) });
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        success: false,
+        error: err?.message ?? "Internal server error",
+      }),
+    );
+  }
+}

package/src/listeners/api/api.sse.ts

@@ -1,38 +1,38 @@
-import { ServerResponse } from "http";
-import { Logger } from "../../core/logger";
-
-export class ApiSse {
-  private clients: Set<ServerResponse> = new Set();
-
-  constructor(private logger: Logger) {}
-
-  handle(res: ServerResponse): void {
-    res.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-    });
-
-    this.clients.add(res);
-    res.write(`event: connected\ndata: "ok"\n\n`);
-
-    res.on("close", () => {
-      this.clients.delete(res);
-      this.logger.debug?.("SSE client disconnected");
-    });
-  }
-
-  broadcast(event: any): void {
-    const payload = `event: event\ndata: ${JSON.stringify(event)}\n\n`;
-    for (const client of this.clients) {
-      client.write(payload);
-    }
-  }
-
-  closeAll(): void {
-    for (const client of this.clients) {
-      client.end();
-    }
-    this.clients.clear();
-  }
-}
+import { ServerResponse } from "http";
+import { Logger } from "../../core/logger";
+
+export class ApiSse {
+  private clients: Set<ServerResponse> = new Set();
+
+  constructor(private logger: Logger) {}
+
+  handle(res: ServerResponse): void {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    });
+
+    this.clients.add(res);
+    res.write(`event: connected\ndata: "ok"\n\n`);
+
+    res.on("close", () => {
+      this.clients.delete(res);
+      this.logger.debug?.("SSE client disconnected");
+    });
+  }
+
+  broadcast(event: any): void {
+    const payload = `event: event\ndata: ${JSON.stringify(event)}\n\n`;
+    for (const client of this.clients) {
+      client.write(payload);
+    }
+  }
+
+  closeAll(): void {
+    for (const client of this.clients) {
+      client.end();
+    }
+    this.clients.clear();
+  }
+}

package/src/listeners/dns/__tests__/dns.test.ts

@@ -1,118 +1,118 @@
-import { describe, it, expect, jest, beforeEach } from "@jest/globals";
-import { DnsListener } from "../dns.listener";
-import { EventNormalizer } from "../../../core/event.normalizer";
-import { CoreRouter } from "../../../core/router";
-
-// Mock EventNormalizer
-jest.mock("../../../core/event.normalizer", () => ({
-  EventNormalizer: {
-    normalizeDns: jest.fn(),
-  },
-}));
-
-describe("DnsListener", () => {
-  let router: CoreRouter;
-  let server: any;
-  let listener: DnsListener;
-
-  beforeEach(() => {
-    router = {
-      dispatch: jest
-        .fn<(event: any) => Promise<void>>()
-        .mockResolvedValue(undefined),
-    } as any;
-
-    server = {
-      on: jest.fn(),
-      close: jest.fn(),
-    };
-
-    listener = new DnsListener(router, { server });
-  });
-
-  it("traite un paquet DNS valide et renvoie eventId", async () => {
-    const send = jest.fn();
-
-    (EventNormalizer.normalizeDns as jest.Mock).mockReturnValue({
-      id: "dns-123",
-      source: "dns",
-    });
-
-    await listener.start();
-
-    // simulate server.on("request", callback)
-    const callback = server.on.mock.calls[0][1];
-
-    const packet = {
-      client: { address: "1.2.3.4" },
-      questions: [{ name: "example.com", type: "A" }],
-    };
-
-    await callback(packet, send);
-
-    expect(EventNormalizer.normalizeDns).toHaveBeenCalled();
-    expect(router.dispatch).toHaveBeenCalled();
-    expect(send).toHaveBeenCalledWith({
-      success: true,
-      eventId: "dns-123",
-    });
-  });
-
-  it("renvoie une erreur si normalizeDns échoue", async () => {
-    const send = jest.fn();
-
-    (EventNormalizer.normalizeDns as jest.Mock).mockImplementation(() => {
-      throw new Error("bad dns");
-    });
-
-    await listener.start();
-
-    const callback = server.on.mock.calls[0][1];
-
-    const packet = {
-      client: { address: "1.2.3.4" },
-      questions: [{ name: "example.com", type: "A" }],
-    };
-
-    await callback(packet, send);
-
-    expect(send).toHaveBeenCalledWith({
-      success: false,
-      error: "bad dns",
-    });
-  });
-
-  it("renvoie une erreur si router.dispatch échoue", async () => {
-    const send = jest.fn();
-
-    (EventNormalizer.normalizeDns as jest.Mock).mockReturnValue({
-      id: "dns-999",
-      source: "dns",
-    });
-
-    (
-      router.dispatch as jest.MockedFunction<(event: any) => Promise<void>>
-    ).mockRejectedValueOnce(new Error("dispatch failed"));
-
-    await listener.start();
-
-    const callback = server.on.mock.calls[0][1];
-
-    const packet = {
-      client: { address: "1.2.3.4" },
-      questions: [{ name: "example.com", type: "A" }],
-    };
-
-    await callback(packet, send);
-
-    expect(send).toHaveBeenCalledWith({
-      success: false,
-      error: "dispatch failed",
-    });
-  });
-
-  it("stop() appelle server.close si disponible", async () => {
-    await listener.stop();
-    expect(server.close).toHaveBeenCalled();
-  });
-});
+import { describe, it, expect, jest, beforeEach } from "@jest/globals";
+import { DnsListener } from "../dns.listener";
+import { EventNormalizer } from "../../../core/event.normalizer";
+import { CoreRouter } from "../../../core/router";
+
+// Mock EventNormalizer
+jest.mock("../../../core/event.normalizer", () => ({
+  EventNormalizer: {
+    normalizeDns: jest.fn(),
+  },
+}));
+
+describe("DnsListener", () => {
+  let router: CoreRouter;
+  let server: any;
+  let listener: DnsListener;
+
+  beforeEach(() => {
+    router = {
+      dispatch: jest
+        .fn<(event: any) => Promise<void>>()
+        .mockResolvedValue(undefined),
+    } as any;
+
+    server = {
+      on: jest.fn(),
+      close: jest.fn(),
+    };
+
+    listener = new DnsListener(router, { server });
+  });
+
+  it("traite un paquet DNS valide et renvoie eventId", async () => {
+    const send = jest.fn();
+
+    (EventNormalizer.normalizeDns as jest.Mock).mockReturnValue({
+      id: "dns-123",
+      source: "dns",
+    });
+
+    await listener.start();
+
+    // simulate server.on("request", callback)
+    const callback = server.on.mock.calls[0][1];
+
+    const packet = {
+      client: { address: "1.2.3.4" },
+      questions: [{ name: "example.com", type: "A" }],
+    };
+
+    await callback(packet, send);
+
+    expect(EventNormalizer.normalizeDns).toHaveBeenCalled();
+    expect(router.dispatch).toHaveBeenCalled();
+    expect(send).toHaveBeenCalledWith({
+      success: true,
+      eventId: "dns-123",
+    });
+  });
+
+  it("renvoie une erreur si normalizeDns échoue", async () => {
+    const send = jest.fn();
+
+    (EventNormalizer.normalizeDns as jest.Mock).mockImplementation(() => {
+      throw new Error("bad dns");
+    });
+
+    await listener.start();
+
+    const callback = server.on.mock.calls[0][1];
+
+    const packet = {
+      client: { address: "1.2.3.4" },
+      questions: [{ name: "example.com", type: "A" }],
+    };
+
+    await callback(packet, send);
+
+    expect(send).toHaveBeenCalledWith({
+      success: false,
+      error: "bad dns",
+    });
+  });
+
+  it("renvoie une erreur si router.dispatch échoue", async () => {
+    const send = jest.fn();
+
+    (EventNormalizer.normalizeDns as jest.Mock).mockReturnValue({
+      id: "dns-999",
+      source: "dns",
+    });
+
+    (
+      router.dispatch as jest.MockedFunction<(event: any) => Promise<void>>
+    ).mockRejectedValueOnce(new Error("dispatch failed"));
+
+    await listener.start();
+
+    const callback = server.on.mock.calls[0][1];
+
+    const packet = {
+      client: { address: "1.2.3.4" },
+      questions: [{ name: "example.com", type: "A" }],
+    };
+
+    await callback(packet, send);
+
+    expect(send).toHaveBeenCalledWith({
+      success: false,
+      error: "dispatch failed",
+    });
+  });
+
+  it("stop() appelle server.close si disponible", async () => {
+    await listener.stop();
+    expect(server.close).toHaveBeenCalled();
+  });
+});