@j3r3mcdev/oast-server 1.0.0 → 1.1.0

package/src/listeners/tcp/tcp.listener.ts

@@ -1,61 +1,61 @@
-import net from "net";
-import { Listener } from "../listener.interface";
-import { CoreRouter } from "../../core/router";
-import { StorageManager } from "../../core/storage";
-import { Logger } from "../../core/logger";
-import { TcpExtractor } from "./tcp.extractor";
-import { RawTcpEvent } from "../../types/event.types";
-
-export interface TcpListenerOptions {
-  port: number;
-  logger?: Logger;
-}
-
-export class TcpListener implements Listener {
-  private server: net.Server;
-  private logger: Logger;
-
-  constructor(
-    private router: CoreRouter,
-    private storage: StorageManager,
-    private options: TcpListenerOptions,
-  ) {
-    this.logger = options.logger ?? new Logger({ context: "TcpListener" });
-    this.server = net.createServer();
-  }
-
-  async start(): Promise<void> {
-    this.server.on("connection", (socket) => {
-      const ip = socket.remoteAddress ?? "unknown";
-      const port = socket.remotePort ?? 0;
-
-      socket.on("data", async (buffer) => {
-        const data = buffer.toString("utf8");
-
-        const rawEvent: RawTcpEvent = {
-          ip,
-          port,
-          data,
-          raw: { ip, port, data },
-        };
-        const normalized = TcpExtractor.normalize(rawEvent);
-
-        await this.storage.save(normalized);
-        this.router.dispatch(normalized);
-      });
-
-      socket.on("error", (err) => {
-        this.logger.error("TCP socket error", { error: err.message });
-      });
-    });
-
-    this.server.listen(this.options.port, () => {
-      this.logger.info(`TCP Listener started on port ${this.options.port}`);
-    });
-  }
-
-  async stop(): Promise<void> {
-    this.server.close();
-    this.logger.info("TCP Listener stopped");
-  }
-}
+import net from "net";
+import { Listener } from "../listener.interface";
+import { CoreRouter } from "../../core/router";
+import { StorageManager } from "../../core/storage";
+import { Logger } from "../../core/logger";
+import { TcpExtractor } from "./tcp.extractor";
+import { RawTcpEvent } from "../../types/event.types";
+
+export interface TcpListenerOptions {
+  port: number;
+  logger?: Logger;
+}
+
+export class TcpListener implements Listener {
+  private server: net.Server;
+  private logger: Logger;
+
+  constructor(
+    private router: CoreRouter,
+    private storage: StorageManager,
+    private options: TcpListenerOptions,
+  ) {
+    this.logger = options.logger ?? new Logger({ context: "TcpListener" });
+    this.server = net.createServer();
+  }
+
+  async start(): Promise<void> {
+    this.server.on("connection", (socket) => {
+      const ip = socket.remoteAddress ?? "unknown";
+      const port = socket.remotePort ?? 0;
+
+      socket.on("data", async (buffer) => {
+        const data = buffer.toString("utf8");
+
+        const rawEvent: RawTcpEvent = {
+          ip,
+          port,
+          data,
+          raw: { ip, port, data },
+        };
+        const normalized = TcpExtractor.normalize(rawEvent);
+
+        await this.storage.save(normalized);
+        this.router.dispatch(normalized);
+      });
+
+      socket.on("error", (err) => {
+        this.logger.error("TCP socket error", { error: err.message });
+      });
+    });
+
+    this.server.listen(this.options.port, () => {
+      this.logger.info(`TCP Listener started on port ${this.options.port}`);
+    });
+  }
+
+  async stop(): Promise<void> {
+    this.server.close();
+    this.logger.info("TCP Listener stopped");
+  }
+}

package/src/listeners/webhook/__tests__/webhook.extractor.test.ts

@@ -1,35 +1,35 @@
-import { describe, it, expect } from "@jest/globals";
-import { WebhookExtractor } from "../webhook.extractor";
-
-describe("WebhookExtractor", () => {
-  it("extrait correctement toutes les données", () => {
-    const req: any = {
-      ip: "1.2.3.4",
-      headers: { "x-test": "ok" },
-    };
-
-    const body = { hello: "world" };
-
-    const extracted = WebhookExtractor.extract(req, body);
-
-    expect(extracted).toEqual({
-      ip: "1.2.3.4",
-      headers: { "x-test": "ok" },
-      body,
-      raw: req,
-    });
-  });
-
-  it("retourne une structure complète même si des champs manquent", () => {
-    const req: any = {};
-
-    const extracted = WebhookExtractor.extract(req, null);
-
-    expect(extracted).toEqual({
-      ip: "",
-      headers: {},
-      body: null,
-      raw: req,
-    });
-  });
-});
+import { describe, it, expect } from "@jest/globals";
+import { WebhookExtractor } from "../webhook.extractor";
+
+describe("WebhookExtractor", () => {
+  it("extrait correctement toutes les données", () => {
+    const req: any = {
+      ip: "1.2.3.4",
+      headers: { "x-test": "ok" },
+    };
+
+    const body = { hello: "world" };
+
+    const extracted = WebhookExtractor.extract(req, body);
+
+    expect(extracted).toEqual({
+      ip: "1.2.3.4",
+      headers: { "x-test": "ok" },
+      body,
+      raw: req,
+    });
+  });
+
+  it("retourne une structure complète même si des champs manquent", () => {
+    const req: any = {};
+
+    const extracted = WebhookExtractor.extract(req, null);
+
+    expect(extracted).toEqual({
+      ip: "",
+      headers: {},
+      body: null,
+      raw: req,
+    });
+  });
+});

package/src/listeners/webhook/__tests__/webhook.listener.test.ts

@@ -1,122 +1,122 @@
-import {
-  describe,
-  it,
-  expect,
-  jest,
-  beforeEach,
-  afterEach,
-} from "@jest/globals";
-
-import http from "http";
-import { WebhookListener } from "../webhook.listener";
-import { WebhookExtractor } from "../webhook.extractor";
-import { EventNormalizer } from "../../../core/event.normalizer";
-
-jest.mock("../webhook.extractor");
-jest.mock("../../../core/event.normalizer");
-
-describe("WebhookListener", () => {
-  let router: any;
-  let port: number;
-  let listener: WebhookListener;
-
-  beforeEach(() => {
-    router = {
-      dispatch: jest.fn(),
-    };
-
-    port = 13000 + Math.floor(Math.random() * 2000);
-
-    (WebhookExtractor.extract as jest.Mock).mockReturnValue({
-      ip: "1.2.3.4",
-      headers: { "x-test": "ok" },
-      body: { hello: "world" },
-      raw: {},
-    });
-
-    (EventNormalizer.normalizeWebhook as jest.Mock).mockReturnValue({
-      id: "abc",
-      type: "webhook",
-      timestamp: 111,
-      sourceIp: "1.2.3.4",
-      headers: { "x-test": "ok" },
-      body: { hello: "world" },
-    });
-
-    listener = new WebhookListener(router, port);
-  });
-
-  afterEach(() => {
-    listener.stop();
-  });
-
-  it("appelle router.dispatch avec l'événement normalisé", async () => {
-    await new Promise<void>((resolve) => {
-      const req = http.request(
-        {
-          hostname: "localhost",
-          port,
-          path: "/",
-          method: "POST",
-          headers: { "content-type": "application/json" },
-        },
-        (res) => {
-          expect(res.statusCode).toBe(200);
-          expect(router.dispatch).toHaveBeenCalledTimes(1);
-          expect(router.dispatch).toHaveBeenCalledWith({
-            id: "abc",
-            type: "webhook",
-            timestamp: 111,
-            sourceIp: "1.2.3.4",
-            headers: { "x-test": "ok" },
-            body: { hello: "world" },
-          });
-          resolve();
-        },
-      );
-
-      req.write(JSON.stringify({ hello: "world" }));
-      req.end();
-    });
-  });
-
-  it("retourne 500 si router.dispatch échoue", async () => {
-    router.dispatch.mockRejectedValue(new Error("fail"));
-
-    await new Promise<void>((resolve) => {
-      const req = http.request(
-        {
-          hostname: "localhost",
-          port,
-          path: "/",
-          method: "POST",
-        },
-        (res) => {
-          expect(res.statusCode).toBe(500);
-          resolve();
-        },
-      );
-
-      req.write("{}");
-      req.end();
-    });
-  });
-
-  it("retourne 405 si la méthode n'est pas POST", async () => {
-    await new Promise<void>((resolve) => {
-      const req = http.request(
-        {
-          hostname: "localhost",
-          port,
-          path: "/",
-          method: "GET",
-        },
-        (res) => {
-          expect(res.statusCode).toBe(405);
-          resolve();
-        },
-      );
-      req.end();
-    });
-  });
-});
+import {
+  describe,
+  it,
+  expect,
+  jest,
+  beforeEach,
+  afterEach,
+} from "@jest/globals";
+
+import http from "http";
+import { WebhookListener } from "../webhook.listener";
+import { WebhookExtractor } from "../webhook.extractor";
+import { EventNormalizer } from "../../../core/event.normalizer";
+
+jest.mock("../webhook.extractor");
+jest.mock("../../../core/event.normalizer");
+
+describe("WebhookListener", () => {
+  let router: any;
+  let port: number;
+  let listener: WebhookListener;
+
+  beforeEach(() => {
+    router = {
+      dispatch: jest.fn(),
+    };
+
+    port = 13000 + Math.floor(Math.random() * 2000);
+
+    (WebhookExtractor.extract as jest.Mock).mockReturnValue({
+      ip: "1.2.3.4",
+      headers: { "x-test": "ok" },
+      body: { hello: "world" },
+      raw: {},
+    });
+
+    (EventNormalizer.normalizeWebhook as jest.Mock).mockReturnValue({
+      id: "abc",
+      type: "webhook",
+      timestamp: 111,
+      sourceIp: "1.2.3.4",
+      headers: { "x-test": "ok" },
+      body: { hello: "world" },
+    });
+
+    listener = new WebhookListener(router, port);
+  });
+
+  afterEach(() => {
+    listener.stop();
+  });
+
+  it("appelle router.dispatch avec l'événement normalisé", async () => {
+    await new Promise<void>((resolve) => {
+      const req = http.request(
+        {
+          hostname: "localhost",
+          port,
+          path: "/",
+          method: "POST",
+          headers: { "content-type": "application/json" },
+        },
+        (res) => {
+          expect(res.statusCode).toBe(200);
+          expect(router.dispatch).toHaveBeenCalledTimes(1);
+          expect(router.dispatch).toHaveBeenCalledWith({
+            id: "abc",
+            type: "webhook",
+            timestamp: 111,
+            sourceIp: "1.2.3.4",
+            headers: { "x-test": "ok" },
+            body: { hello: "world" },
+          });
+          resolve();
+        },
+      );
+
+      req.write(JSON.stringify({ hello: "world" }));
+      req.end();
+    });
+  });
+
+  it("retourne 500 si router.dispatch échoue", async () => {
+    router.dispatch.mockRejectedValue(new Error("fail"));
+
+    await new Promise<void>((resolve) => {
+      const req = http.request(
+        {
+          hostname: "localhost",
+          port,
+          path: "/",
+          method: "POST",
+        },
+        (res) => {
+          expect(res.statusCode).toBe(500);
+          resolve();
+        },
+      );
+
+      req.write("{}");
+      req.end();
+    });
+  });
+
+  it("retourne 405 si la méthode n'est pas POST", async () => {
+    await new Promise<void>((resolve) => {
+      const req = http.request(
+        {
+          hostname: "localhost",
+          port,
+          path: "/",
+          method: "GET",
+        },
+        (res) => {
+          expect(res.statusCode).toBe(405);
+          resolve();
+        },
+      );
+      req.end();
+    });
+  });
+});

package/src/listeners/webhook/webhook.extractor.ts

@@ -1,12 +1,12 @@
-export class WebhookExtractor {
-  static extract(req: any, body: any) {
-    const headers = req.headers ?? {};
-
-    return {
-      ip: req.ip ?? headers["x-forwarded-for"] ?? "",
-      headers,
-      body,
-      raw: req,
-    };
-  }
-}
+export class WebhookExtractor {
+  static extract(req: any, body: any) {
+    const headers = req.headers ?? {};
+
+    return {
+      ip: req.ip ?? headers["x-forwarded-for"] ?? "",
+      headers,
+      body,
+      raw: req,
+    };
+  }
+}

package/src/listeners/webhook/webhook.listener.ts

@@ -1,58 +1,58 @@
-import http from "http";
-import { CoreRouter } from "../../core/router";
-import { WebhookExtractor } from "./webhook.extractor";
-import { EventNormalizer } from "../../core/event.normalizer";
-import { Logger } from "../../core/logger";
-
-export class WebhookListener {
-  private router: CoreRouter;
-  private server: http.Server;
-  private logger: Logger;
-
-  constructor(router: CoreRouter, port: number) {
-    this.router = router;
-    this.logger = new Logger({ context: "WebhookListener" });
-
-    this.server = http.createServer(async (req, res) => {
-      if (req.method !== "POST") {
-        res.writeHead(405);
-        return res.end("Method Not Allowed");
-      }
-
-      let chunks: Buffer[] = [];
-
-      req.on("data", (chunk) => chunks.push(chunk));
-
-      req.on("end", async () => {
-        try {
-          const bodyRaw = Buffer.concat(chunks).toString();
-          let body: any = null;
-
-          try {
-            body = JSON.parse(bodyRaw);
-          } catch {
-            body = bodyRaw;
-          }
-
-          const extracted = WebhookExtractor.extract(req, body);
-          const event = EventNormalizer.normalizeWebhook(extracted);
-
-          await this.router.dispatch(event);
-
-          res.writeHead(200);
-          res.end("OK");
-        } catch (err) {
-          res.writeHead(500);
-          res.end("ERROR");
-        }
-      });
-    });
-
-    this.server.listen(port);
-  }
-
-  stop() {
-    this.server.close();
-    this.logger.info("Webhook Listener stopped");
-  }
-}
+import http from "http";
+import { CoreRouter } from "../../core/router";
+import { WebhookExtractor } from "./webhook.extractor";
+import { EventNormalizer } from "../../core/event.normalizer";
+import { Logger } from "../../core/logger";
+
+export class WebhookListener {
+  private router: CoreRouter;
+  private server: http.Server;
+  private logger: Logger;
+
+  constructor(router: CoreRouter, port: number) {
+    this.router = router;
+    this.logger = new Logger({ context: "WebhookListener" });
+
+    this.server = http.createServer(async (req, res) => {
+      if (req.method !== "POST") {
+        res.writeHead(405);
+        return res.end("Method Not Allowed");
+      }
+
+      let chunks: Buffer[] = [];
+
+      req.on("data", (chunk) => chunks.push(chunk));
+
+      req.on("end", async () => {
+        try {
+          const bodyRaw = Buffer.concat(chunks).toString();
+          let body: any = null;
+
+          try {
+            body = JSON.parse(bodyRaw);
+          } catch {
+            body = bodyRaw;
+          }
+
+          const extracted = WebhookExtractor.extract(req, body);
+          const event = EventNormalizer.normalizeWebhook(extracted);
+
+          await this.router.dispatch(event);
+
+          res.writeHead(200);
+          res.end("OK");
+        } catch (err) {
+          res.writeHead(500);
+          res.end("ERROR");
+        }
+      });
+    });
+
+    this.server.listen(port);
+  }
+
+  stop() {
+    this.server.close();
+    this.logger.info("Webhook Listener stopped");
+  }
+}

package/src/listeners/websocket/__tests__/websocket.extractor.test.ts

@@ -1,33 +1,33 @@
-import { describe, it, expect } from "@jest/globals";
-import { WebSocketExtractor } from "../websocket.extractor";
-
-describe("WebSocketExtractor", () => {
-  it("extrait correctement les données", () => {
-    const ws: any = {};
-    const req: any = {
-      socket: { remoteAddress: "1.2.3.4" },
-      headers: { host: "example.com" },
-    };
-
-    const extracted = WebSocketExtractor.extract(ws, req, "hello");
-
-    expect(extracted).toEqual({
-      ip: "1.2.3.4",
-      message: "hello",
-      raw: { ws, req },
-    });
-  });
-
-  it("retourne une structure complète même si des champs manquent", () => {
-    const ws: any = {};
-    const req: any = {};
-
-    const extracted = WebSocketExtractor.extract(ws, req, "test");
-
-    expect(extracted).toEqual({
-      ip: "",
-      message: "test",
-      raw: { ws, req },
-    });
-  });
-});
+import { describe, it, expect } from "@jest/globals";
+import { WebSocketExtractor } from "../websocket.extractor";
+
+describe("WebSocketExtractor", () => {
+  it("extrait correctement les données", () => {
+    const ws: any = {};
+    const req: any = {
+      socket: { remoteAddress: "1.2.3.4" },
+      headers: { host: "example.com" },
+    };
+
+    const extracted = WebSocketExtractor.extract(ws, req, "hello");
+
+    expect(extracted).toEqual({
+      ip: "1.2.3.4",
+      message: "hello",
+      raw: { ws, req },
+    });
+  });
+
+  it("retourne une structure complète même si des champs manquent", () => {
+    const ws: any = {};
+    const req: any = {};
+
+    const extracted = WebSocketExtractor.extract(ws, req, "test");
+
+    expect(extracted).toEqual({
+      ip: "",
+      message: "test",
+      raw: { ws, req },
+    });
+  });
+});