@j3r3mcdev/oast-server 1.0.0 → 1.1.0

package/src/index.ts

@@ -1,89 +1,89 @@
-import { Logger } from "./core/logger";
-import { StorageManager } from "./core/storage";
-import { CoreRouter } from "./core/router";
-import { CoreServer } from "./core/server";
-
-// Listeners
-import { ApiListener } from "./listeners/api/api.listener";
-import { HttpListener } from "./listeners/http/http.listener";
-import { DnsListener } from "./listeners/dns/dns.listener";
-import { SmtpListener } from "./listeners/smtp/smtp.listener";
-import { TcpListener } from "./listeners/tcp/tcp.listener";
-
-async function main() {
-  const logger = new Logger({ context: "Bootstrap" });
-
-  // Core components
-  const storage = new StorageManager({
-    logger: logger.withContext("Storage"),
-  });
-
-  const router = new CoreRouter(storage, {
-    logger: logger.withContext("CoreRouter"),
-  });
-
-  // ---------------------------
-  // LISTENERS
-  // ---------------------------
-
-  // API → (router, storage, options)
-  const apiListener = new ApiListener(storage, {
-    port: 3100,
-    logger: logger.withContext("ApiListener"),
-  });
-
-  // HTTP → (router, options)
-  const httpListener = new HttpListener(router, {
-    port: 8080,
-    logger: logger.withContext("HttpListener"),
-  });
-
-  // DNS → (router, options)
-  const dnsListener = new DnsListener(router, {
-    server: {} as any,
-    logger: logger.withContext("DnsListener"),
-  });
-
-  const smtpListener = new SmtpListener(router, {
-    server: {} as any,
-    logger: logger.withContext("SmtpListener"),
-  });
-
-  // TCP → (router, storage, options)
-  const tcpListener = new TcpListener(router, storage, {
-    port: 9000,
-    logger: logger.withContext("TcpListener"),
-  });
-
-  // ---------------------------
-  // CORE SERVER
-  // ---------------------------
-  const server = new CoreServer({
-    logger: logger.withContext("CoreServer"),
-    storage,
-    listeners: [
-      apiListener,
-      httpListener,
-      dnsListener,
-      smtpListener,
-      tcpListener,
-    ],
-  });
-
-  await server.start();
-
-  // Graceful shutdown
-  const shutdown = async () => {
-    logger.warn("Received shutdown signal, stopping server...");
-    await server.stop();
-    process.exit(0);
-  };
-
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-}
-
-main().catch((err) => {
-  console.error("Fatal error in bootstrap:", err);
-  process.exit(1);
-});
+import { Logger } from "./core/logger";
+import { StorageManager } from "./core/storage";
+import { CoreRouter } from "./core/router";
+import { CoreServer } from "./core/server";
+
+// Listeners
+import { ApiListener } from "./listeners/api/api.listener";
+import { HttpListener } from "./listeners/http/http.listener";
+import { DnsListener } from "./listeners/dns/dns.listener";
+import { SmtpListener } from "./listeners/smtp/smtp.listener";
+import { TcpListener } from "./listeners/tcp/tcp.listener";
+
+async function main() {
+  const logger = new Logger({ context: "Bootstrap" });
+
+  // Core components
+  const storage = new StorageManager({
+    logger: logger.withContext("Storage"),
+  });
+
+  const router = new CoreRouter(storage, {
+    logger: logger.withContext("CoreRouter"),
+  });
+
+  // ---------------------------
+  // LISTENERS
+  // ---------------------------
+
+  // API → (router, storage, options)
+  const apiListener = new ApiListener(storage, {
+    port: 3100,
+    logger: logger.withContext("ApiListener"),
+  });
+
+  // HTTP → (router, options)
+  const httpListener = new HttpListener(router, {
+    port: 8080,
+    logger: logger.withContext("HttpListener"),
+  });
+
+  // DNS → (router, options)
+  const dnsListener = new DnsListener(router, {
+    server: {} as any,
+    logger: logger.withContext("DnsListener"),
+  });
+
+  const smtpListener = new SmtpListener(router, {
+    server: {} as any,
+    logger: logger.withContext("SmtpListener"),
+  });
+
+  // TCP → (router, storage, options)
+  const tcpListener = new TcpListener(router, storage, {
+    port: 9000,
+    logger: logger.withContext("TcpListener"),
+  });
+
+  // ---------------------------
+  // CORE SERVER
+  // ---------------------------
+  const server = new CoreServer({
+    logger: logger.withContext("CoreServer"),
+    storage,
+    listeners: [
+      apiListener,
+      httpListener,
+      dnsListener,
+      smtpListener,
+      tcpListener,
+    ],
+  });
+
+  await server.start();
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    logger.warn("Received shutdown signal, stopping server...");
+    await server.stop();
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+main().catch((err) => {
+  console.error("Fatal error in bootstrap:", err);
+  process.exit(1);
+});

package/src/listeners/api/__tests__/api.controller.test.ts

@@ -1,116 +1,116 @@
-import { ApiController } from "../api.controllers";
-import { StorageManager } from "../../../core/storage";
-import { ServerResponse, IncomingMessage } from "http";
-import { Socket } from "net";
-import { describe, it, expect, beforeEach, jest } from "@jest/globals";
-
-// Mock ServerResponse
-function mockRes(): ServerResponse {
-  const socket = new Socket();
-  const req = new IncomingMessage(socket);
-  const res = new ServerResponse(req);
-
-  jest.spyOn(res, "writeHead");
-  jest.spyOn(res, "end");
-
-  return res;
-}
-
-describe("ApiController", () => {
-  let storage: StorageManager;
-
-  beforeEach(() => {
-    // On utilise un vrai StorageManager en mémoire
-    storage = new StorageManager();
-  });
-
-  it("listEvents renvoie la liste des events (vide par défaut)", async () => {
-    const res = mockRes();
-    const url = new URL("http://localhost/events?page=2&type=http");
-
-    await ApiController.listEvents(url, res, storage);
-
-    expect(storage.listEvents).toBeDefined();
-
-    expect(res.writeHead).toHaveBeenCalledWith(200, {
-      "Content-Type": "application/json",
-    });
-
-    const body = (res.end as jest.Mock).mock.calls[0][0] as string;
-    const payload = JSON.parse(body);
-    expect(payload.success).toBe(true);
-    expect(payload.events).toEqual([]);
-  });
-
-  it("getEvent renvoie 404 si event absent", async () => {
-    const res = mockRes();
-
-    await ApiController.getEvent("unknown", res, storage);
-
-    expect(res.writeHead).toHaveBeenCalledWith(404, {
-      "Content-Type": "application/json",
-    });
-
-    const body = (res.end as jest.Mock).mock.calls[0][0] as string;
-    const payload = JSON.parse(body);
-    expect(payload.success).toBe(false);
-  });
-
-  it("getEvent renvoie l'event si présent", async () => {
-    // On mocke juste getEvent pour ce test
-    jest.spyOn(storage, "getEvent").mockResolvedValue({ id: "abc" } as any);
-
-    const res = mockRes();
-
-    await ApiController.getEvent("abc", res, storage);
-
-    expect(res.writeHead).toHaveBeenCalledWith(200, {
-      "Content-Type": "application/json",
-    });
-
-    const body = (res.end as jest.Mock).mock.calls[0][0] as string;
-    const payload = JSON.parse(body);
-    expect(payload.success).toBe(true);
-    expect(payload.event.id).toBe("abc");
-  });
-
-  it("deleteAll supprime tous les events", async () => {
-    const res = mockRes();
-
-    await ApiController.deleteAll(res, storage);
-
-    const body = (res.end as jest.Mock).mock.calls[0][0] as string;
-    const payload = JSON.parse(body);
-    expect(payload.success).toBe(true);
-  });
-
-  it("deleteOne supprime un event", async () => {
-    const res = mockRes();
-
-    await storage.save({
-      id: "xyz",
-      type: "http",
-      timestamp: Date.now(),
-      sourceIp: "127.0.0.1",
-      request: { method: "GET", path: "/", headers: {}, query: {}, body: "" },
-    });
-
-    await ApiController.deleteOne("xyz", res, storage);
-
-    const raw = String((res.end as jest.Mock).mock.calls[0][0]);
-    const payload = JSON.parse(raw);
-
-    expect(payload.success).toBe(true);
-  });
-
-  it("stats renvoie les stats", async () => {
-    const res = mockRes();
-
-    await ApiController.stats(res, storage);
-
-    const body = (res.end as jest.Mock).mock.calls[0][0] as string;
-    const payload = JSON.parse(body);
-    expect(payload.success).toBe(true);
-    expect(payload.stats).toEqual({ total: 0, byType: {} });
-  });
-});
+import { ApiController } from "../api.controllers";
+import { StorageManager } from "../../../core/storage";
+import { ServerResponse, IncomingMessage } from "http";
+import { Socket } from "net";
+import { describe, it, expect, beforeEach, jest } from "@jest/globals";
+
+// Mock ServerResponse
+function mockRes(): ServerResponse {
+  const socket = new Socket();
+  const req = new IncomingMessage(socket);
+  const res = new ServerResponse(req);
+
+  jest.spyOn(res, "writeHead");
+  jest.spyOn(res, "end");
+
+  return res;
+}
+
+describe("ApiController", () => {
+  let storage: StorageManager;
+
+  beforeEach(() => {
+    // On utilise un vrai StorageManager en mémoire
+    storage = new StorageManager();
+  });
+
+  it("listEvents renvoie la liste des events (vide par défaut)", async () => {
+    const res = mockRes();
+    const url = new URL("http://localhost/events?page=2&type=http");
+
+    await ApiController.listEvents(url, res, storage);
+
+    expect(storage.listEvents).toBeDefined();
+
+    expect(res.writeHead).toHaveBeenCalledWith(200, {
+      "Content-Type": "application/json",
+    });
+
+    const body = (res.end as jest.Mock).mock.calls[0][0] as string;
+    const payload = JSON.parse(body);
+    expect(payload.success).toBe(true);
+    expect(payload.events).toEqual([]);
+  });
+
+  it("getEvent renvoie 404 si event absent", async () => {
+    const res = mockRes();
+
+    await ApiController.getEvent("unknown", res, storage);
+
+    expect(res.writeHead).toHaveBeenCalledWith(404, {
+      "Content-Type": "application/json",
+    });
+
+    const body = (res.end as jest.Mock).mock.calls[0][0] as string;
+    const payload = JSON.parse(body);
+    expect(payload.success).toBe(false);
+  });
+
+  it("getEvent renvoie l'event si présent", async () => {
+    // On mocke juste getEvent pour ce test
+    jest.spyOn(storage, "getEvent").mockResolvedValue({ id: "abc" } as any);
+
+    const res = mockRes();
+
+    await ApiController.getEvent("abc", res, storage);
+
+    expect(res.writeHead).toHaveBeenCalledWith(200, {
+      "Content-Type": "application/json",
+    });
+
+    const body = (res.end as jest.Mock).mock.calls[0][0] as string;
+    const payload = JSON.parse(body);
+    expect(payload.success).toBe(true);
+    expect(payload.event.id).toBe("abc");
+  });
+
+  it("deleteAll supprime tous les events", async () => {
+    const res = mockRes();
+
+    await ApiController.deleteAll(res, storage);
+
+    const body = (res.end as jest.Mock).mock.calls[0][0] as string;
+    const payload = JSON.parse(body);
+    expect(payload.success).toBe(true);
+  });
+
+  it("deleteOne supprime un event", async () => {
+    const res = mockRes();
+
+    await storage.save({
+      id: "xyz",
+      type: "http",
+      timestamp: Date.now(),
+      sourceIp: "127.0.0.1",
+      request: { method: "GET", path: "/", headers: {}, query: {}, body: "" },
+    });
+
+    await ApiController.deleteOne("xyz", res, storage);
+
+    const raw = String((res.end as jest.Mock).mock.calls[0][0]);
+    const payload = JSON.parse(raw);
+
+    expect(payload.success).toBe(true);
+  });
+
+  it("stats renvoie les stats", async () => {
+    const res = mockRes();
+
+    await ApiController.stats(res, storage);
+
+    const body = (res.end as jest.Mock).mock.calls[0][0] as string;
+    const payload = JSON.parse(body);
+    expect(payload.success).toBe(true);
+    expect(payload.stats).toEqual({ total: 0, byType: {} });
+  });
+});

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

@@ -1,46 +1,46 @@
-import { ApiExtractor } from "../api.extractor";
-import { IncomingMessage } from "http";
-import { Socket } from "net";
-import { describe, it, expect } from "@jest/globals";
-
-function mockReq(url: string, method = "GET", body?: any): IncomingMessage {
-  const socket = new Socket();
-  const req = new IncomingMessage(socket);
-
-  req.url = url;
-  req.method = method;
-  req.headers = { host: "localhost" };
-
-  if (body !== undefined) {
-    const json = JSON.stringify(body);
-    process.nextTick(() => {
-      req.emit("data", json);
-      req.emit("end");
-    });
-  } else {
-    process.nextTick(() => req.emit("end"));
-  }
-
-  return req;
-}
-
-describe("ApiExtractor", () => {
-  it("extrait un RawEvent GET", async () => {
-    const req = mockReq("/events?page=2&type=http");
-
-    const event = await ApiExtractor.extract(req);
-
-    expect(event.method).toBe("GET");
-    expect(event.path).toBe("/events");
-    expect(event.query).toEqual({ page: "2", type: "http" });
-  });
-
-  it("extrait un RawEvent POST avec body JSON", async () => {
-    const req = mockReq("/events", "POST", { hello: "world" });
-
-    const event = await ApiExtractor.extract(req);
-
-    expect(event.method).toBe("POST");
-    expect(event.body).toEqual({ hello: "world" });
-  });
-});
+import { ApiExtractor } from "../api.extractor";
+import { IncomingMessage } from "http";
+import { Socket } from "net";
+import { describe, it, expect } from "@jest/globals";
+
+function mockReq(url: string, method = "GET", body?: any): IncomingMessage {
+  const socket = new Socket();
+  const req = new IncomingMessage(socket);
+
+  req.url = url;
+  req.method = method;
+  req.headers = { host: "localhost" };
+
+  if (body !== undefined) {
+    const json = JSON.stringify(body);
+    process.nextTick(() => {
+      req.emit("data", json);
+      req.emit("end");
+    });
+  } else {
+    process.nextTick(() => req.emit("end"));
+  }
+
+  return req;
+}
+
+describe("ApiExtractor", () => {
+  it("extrait un RawEvent GET", async () => {
+    const req = mockReq("/events?page=2&type=http");
+
+    const event = await ApiExtractor.extract(req);
+
+    expect(event.method).toBe("GET");
+    expect(event.path).toBe("/events");
+    expect(event.query).toEqual({ page: "2", type: "http" });
+  });
+
+  it("extrait un RawEvent POST avec body JSON", async () => {
+    const req = mockReq("/events", "POST", { hello: "world" });
+
+    const event = await ApiExtractor.extract(req);
+
+    expect(event.method).toBe("POST");
+    expect(event.body).toEqual({ hello: "world" });
+  });
+});

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

@@ -1,82 +1,82 @@
-import http from "http";
-import { ApiListener } from "../api.listener";
-import { StorageManager } from "../../../core/storage";
-import { Logger } from "../../../core/logger";
-import { describe, test, beforeEach, afterEach, expect } from "@jest/globals";
-import { ApiController } from "../api.controllers";
-
-describe("ApiListener", () => {
-  let storage: StorageManager;
-  let api: ApiListener;
-
-  beforeEach(async () => {
-    storage = new StorageManager();
-
-    api = new ApiListener(storage, {
-      port: 9999,
-      logger: new Logger({ context: "ApiTest" }),
-    });
-
-    await api.start();
-  });
-
-  afterEach(async () => {
-    await api.stop();
-  });
-
-  test("GET /events returns empty list", async () => {
-    const res = await fetch("http://localhost:9999/events");
-    const json = await res.json();
-
-    expect(json.success).toBe(true);
-    expect(json.events).toEqual([]);
-  });
-
-  test("GET /stats returns correct structure", async () => {
-    const res = await fetch("http://localhost:9999/stats");
-    const json = await res.json();
-
-    expect(json.success).toBe(true);
-    expect(json.stats.total).toBe(0);
-    expect(json.stats.byType).toEqual({});
-  });
-
-  test("GET /events/:id returns 404 when not found", async () => {
-    const res = await fetch("http://localhost:9999/events/unknown");
-    const json = await res.json();
-
-    expect(res.status).toBe(404);
-    expect(json.success).toBe(false);
-  });
-
-  test("DELETE /events clears all events", async () => {
-    // On ajoute un event dans le storage
-    await storage.save({
-      id: "1",
-      type: "http",
-      timestamp: Date.now(),
-      sourceIp: "127.0.0.1",
-      request: {
-        method: "GET",
-        path: "/",
-        headers: {},
-        query: {},
-        body: "",
-      },
-    });
-
-    let events = await storage.listEvents({});
-    expect(events.length).toBe(1);
-
-    // On appelle l'API réelle
-    const res = await fetch("http://localhost:9999/events", {
-      method: "DELETE",
-    });
-
-    const json = await res.json();
-    expect(json.success).toBe(true);
-
-    events = await storage.listEvents({});
-    expect(events.length).toBe(0);
-  });
-});
+import http from "http";
+import { ApiListener } from "../api.listener";
+import { StorageManager } from "../../../core/storage";
+import { Logger } from "../../../core/logger";
+import { describe, test, beforeEach, afterEach, expect } from "@jest/globals";
+import { ApiController } from "../api.controllers";
+
+describe("ApiListener", () => {
+  let storage: StorageManager;
+  let api: ApiListener;
+
+  beforeEach(async () => {
+    storage = new StorageManager();
+
+    api = new ApiListener(storage, {
+      port: 9999,
+      logger: new Logger({ context: "ApiTest" }),
+    });
+
+    await api.start();
+  });
+
+  afterEach(async () => {
+    await api.stop();
+  });
+
+  test("GET /events returns empty list", async () => {
+    const res = await fetch("http://localhost:9999/events");
+    const json = await res.json();
+
+    expect(json.success).toBe(true);
+    expect(json.events).toEqual([]);
+  });
+
+  test("GET /stats returns correct structure", async () => {
+    const res = await fetch("http://localhost:9999/stats");
+    const json = await res.json();
+
+    expect(json.success).toBe(true);
+    expect(json.stats.total).toBe(0);
+    expect(json.stats.byType).toEqual({});
+  });
+
+  test("GET /events/:id returns 404 when not found", async () => {
+    const res = await fetch("http://localhost:9999/events/unknown");
+    const json = await res.json();
+
+    expect(res.status).toBe(404);
+    expect(json.success).toBe(false);
+  });
+
+  test("DELETE /events clears all events", async () => {
+    // On ajoute un event dans le storage
+    await storage.save({
+      id: "1",
+      type: "http",
+      timestamp: Date.now(),
+      sourceIp: "127.0.0.1",
+      request: {
+        method: "GET",
+        path: "/",
+        headers: {},
+        query: {},
+        body: "",
+      },
+    });
+
+    let events = await storage.listEvents({});
+    expect(events.length).toBe(1);
+
+    // On appelle l'API réelle
+    const res = await fetch("http://localhost:9999/events", {
+      method: "DELETE",
+    });
+
+    const json = await res.json();
+    expect(json.success).toBe(true);
+
+    events = await storage.listEvents({});
+    expect(events.length).toBe(0);
+  });
+});