@j3r3mcdev/oast-server 1.1.6 → 1.1.8

package/src/bootstrap.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/core/__tests__/core-router.test.ts

@@ -1,30 +1,30 @@
-import { CoreRouter, RouterHook } from "../router";
-import { MemoryStorage } from "../../storage-adapters/adapters/memory.storage";
-import { AnyNormalizedEvent } from "../../types/event.types";
-import { describe, it, expect, jest } from "@jest/globals";
-
-describe("CoreRouter", () => {
-  const event: AnyNormalizedEvent = {
-    id: "abc",
-    type: "http",
-    timestamp: 111,
-    sourceIp: "1.1.1.1",
-    request: {
-      method: "GET",
-      path: "/",
-      headers: {},
-      query: {},
-      body: {},
-    },
-  };
-
-  it("appelle les hooks", async () => {
-    const hook: RouterHook = jest.fn((e: AnyNormalizedEvent) => {}); // ← FIX
-
-    const router = new CoreRouter(new MemoryStorage(), { hooks: [hook] });
-
-    await router.dispatch(event);
-
-    expect(hook).toHaveBeenCalledWith(event);
-  });
-});
+import { CoreRouter, RouterHook } from "../router";
+import { MemoryStorage } from "../../storage-adapters/adapters/memory.storage";
+import { AnyNormalizedEvent } from "../../types/event.types";
+import { describe, it, expect, jest } from "@jest/globals";
+
+describe("CoreRouter", () => {
+  const event: AnyNormalizedEvent = {
+    id: "abc",
+    type: "http",
+    timestamp: 111,
+    sourceIp: "1.1.1.1",
+    request: {
+      method: "GET",
+      path: "/",
+      headers: {},
+      query: {},
+      body: {},
+    },
+  };
+
+  it("appelle les hooks", async () => {
+    const hook: RouterHook = jest.fn((e: AnyNormalizedEvent) => {}); // ← FIX
+
+    const router = new CoreRouter(new MemoryStorage(), { hooks: [hook] });
+
+    await router.dispatch(event);
+
+    expect(hook).toHaveBeenCalledWith(event);
+  });
+});

package/src/core/__tests__/core-server.test.ts

@@ -1,44 +1,44 @@
-import { CoreServer } from "../../core/server";
-import { StorageManager } from "../../core/storage";
-import { Logger } from "../../core/logger";
-import { describe, it, expect } from "@jest/globals";
-
-class FakeListener {
-  started = false;
-  stopped = false;
-
-  async start() {
-    this.started = true;
-  }
-
-  async stop() {
-    this.stopped = true;
-  }
-}
-
-describe("CoreServer", () => {
-  it("démarre et arrête les listeners", async () => {
-    const listener = new FakeListener();
-
-    const server = new CoreServer({
-      storage: new StorageManager(),
-      logger: new Logger({ enabled: false }),
-      listeners: [listener],
-    });
-
-    await server.start();
-    expect(listener.started).toBe(true);
-
-    await server.stop();
-    expect(listener.stopped).toBe(true);
-  });
-
-  it("expose le router", () => {
-    const server = new CoreServer({
-      storage: new StorageManager(),
-    });
-
-    const router = server.getRouter();
-    expect(router).toBeDefined();
-  });
-});
+import { CoreServer } from "../../core/server";
+import { StorageManager } from "../../core/storage";
+import { Logger } from "../../core/logger";
+import { describe, it, expect } from "@jest/globals";
+
+class FakeListener {
+  started = false;
+  stopped = false;
+
+  async start() {
+    this.started = true;
+  }
+
+  async stop() {
+    this.stopped = true;
+  }
+}
+
+describe("CoreServer", () => {
+  it("démarre et arrête les listeners", async () => {
+    const listener = new FakeListener();
+
+    const server = new CoreServer({
+      storage: new StorageManager(),
+      logger: new Logger({ enabled: false }),
+      listeners: [listener],
+    });
+
+    await server.start();
+    expect(listener.started).toBe(true);
+
+    await server.stop();
+    expect(listener.stopped).toBe(true);
+  });
+
+  it("expose le router", () => {
+    const server = new CoreServer({
+      storage: new StorageManager(),
+    });
+
+    const router = server.getRouter();
+    expect(router).toBeDefined();
+  });
+});

package/src/core/__tests__/event.normalizer.test.ts

@@ -1,56 +1,56 @@
-import { EventNormalizer } from "../event.normalizer";
-import { describe, it, expect, jest } from "@jest/globals";
-import { IdGenerator } from "../id-generator";
-
-describe("EventNormalizer.normalizeHttp", () => {
-  it("normalise correctement une requête HTTP", () => {
-    // Mock du timestamp
-    const fakeNow = 1234567890;
-    jest.spyOn(Date, "now").mockReturnValue(fakeNow);
-
-    // Mock de l'ID
-    jest.spyOn(IdGenerator, "generate").mockReturnValue("uuid-test");
-
-    const req = {
-      ip: "9.9.9.9",
-      method: "POST",
-      path: "/test",
-      headers: { "x-forwarded-for": "9.9.9.9" },
-      query: { a: "1" },
-      body: { hello: "world" },
-      raw: {}, // obligatoire
-    };
-
-    const event = EventNormalizer.normalizeHttp(req);
-
-    expect(event).toEqual({
-      id: "uuid-test",
-      type: "http",
-      timestamp: fakeNow,
-      sourceIp: "9.9.9.9",
-      request: {
-        method: "POST",
-        path: "/test",
-        headers: { "x-forwarded-for": "9.9.9.9" },
-        query: { a: "1" },
-        body: { hello: "world" },
-      },
-    });
-  });
-
-  it("retourne 'unknown' si aucune IP n'est trouvée", () => {
-    const req = {
-      ip: "",
-      method: "GET",
-      path: "/",
-      headers: {},
-      query: {},
-      body: {},
-      raw: {},
-    };
-
-    const event = EventNormalizer.normalizeHttp(req);
-
-    expect(event.sourceIp).toBe("unknown");
-  });
-});
+import { EventNormalizer } from "../event.normalizer";
+import { describe, it, expect, jest } from "@jest/globals";
+import { IdGenerator } from "../id-generator";
+
+describe("EventNormalizer.normalizeHttp", () => {
+  it("normalise correctement une requête HTTP", () => {
+    // Mock du timestamp
+    const fakeNow = 1234567890;
+    jest.spyOn(Date, "now").mockReturnValue(fakeNow);
+
+    // Mock de l'ID
+    jest.spyOn(IdGenerator, "generate").mockReturnValue("uuid-test");
+
+    const req = {
+      ip: "9.9.9.9",
+      method: "POST",
+      path: "/test",
+      headers: { "x-forwarded-for": "9.9.9.9" },
+      query: { a: "1" },
+      body: { hello: "world" },
+      raw: {}, // obligatoire
+    };
+
+    const event = EventNormalizer.normalizeHttp(req);
+
+    expect(event).toEqual({
+      id: "uuid-test",
+      type: "http",
+      timestamp: fakeNow,
+      sourceIp: "9.9.9.9",
+      request: {
+        method: "POST",
+        path: "/test",
+        headers: { "x-forwarded-for": "9.9.9.9" },
+        query: { a: "1" },
+        body: { hello: "world" },
+      },
+    });
+  });
+
+  it("retourne 'unknown' si aucune IP n'est trouvée", () => {
+    const req = {
+      ip: "",
+      method: "GET",
+      path: "/",
+      headers: {},
+      query: {},
+      body: {},
+      raw: {},
+    };
+
+    const event = EventNormalizer.normalizeHttp(req);
+
+    expect(event.sourceIp).toBe("unknown");
+  });
+});

package/src/core/__tests__/event.router.test.ts

@@ -1,89 +1,89 @@
-import {
-  AnyNormalizedEvent,
-  NormalizedHttpEvent,
-} from "../../types/event.types";
-import {
-  StorageListParams,
-  Storage,
-} from "../../storage-adapters/storage.interface";
-import { EventRouter } from "../event.router";
-import { EventNormalizer } from "../event.normalizer";
-import { describe, it, expect, jest } from "@jest/globals";
-
-class MockStorage implements Storage {
-  save = jest.fn<(event: AnyNormalizedEvent) => Promise<void>>();
-  getEvent = jest.fn<(id: string) => Promise<AnyNormalizedEvent | null>>();
-  listEvents =
-    jest.fn<(params: StorageListParams) => Promise<AnyNormalizedEvent[]>>();
-  deleteEvent = jest.fn<(id: string) => Promise<boolean>>();
-  clearEvents = jest.fn<() => Promise<void>>();
-  getStats =
-    jest.fn<() => Promise<{ total: number; byType: Record<string, number> }>>();
-  getAll = jest.fn<() => Promise<AnyNormalizedEvent[]>>();
-}
-
-describe("EventRouter", () => {
-  it("enregistre un événement HTTP normalisé", async () => {
-    const mockStorage = new MockStorage();
-
-    const fakeEvent: NormalizedHttpEvent = {
-      id: "123",
-      type: "http",
-      timestamp: 111,
-      sourceIp: "1.1.1.1",
-      request: {
-        method: "GET",
-        path: "/",
-        headers: {},
-        query: {},
-        body: {},
-      },
-    };
-
-    jest.spyOn(EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
-
-    const router = new EventRouter(mockStorage);
-
-    const req = {
-      ip: "1.1.1.1",
-      method: "GET",
-      path: "/",
-      headers: {},
-      query: {},
-      body: {},
-      raw: {},
-    };
-
-    const result = await router.handleHttp(req);
-
-    expect(EventNormalizer.normalizeHttp).toHaveBeenCalledWith(req);
-    expect(mockStorage.save).toHaveBeenCalledWith(fakeEvent);
-    expect(result).toEqual(fakeEvent);
-  });
-
-  it("propagate une erreur si normalizeHttp throw", async () => {
-    const mockStorage = new MockStorage();
-
-    jest.spyOn(EventNormalizer, "normalizeHttp").mockImplementation(() => {
-      throw new Error("Boom");
-    });
-
-    const router = new EventRouter(mockStorage);
-
-    await expect(router.handleHttp({} as any)).rejects.toThrow("Boom");
-    expect(mockStorage.save).not.toHaveBeenCalled();
-  });
-
-  it("propagate une erreur si storage.save throw", async () => {
-    const mockStorage = new MockStorage();
-
-    const fakeEvent = { id: "x", type: "http" } as any;
-
-    jest.spyOn(EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
-    mockStorage.save.mockRejectedValue(new Error("DB error"));
-
-    const router = new EventRouter(mockStorage);
-
-    await expect(router.handleHttp({} as any)).rejects.toThrow("DB error");
-  });
-});
+import {
+  AnyNormalizedEvent,
+  NormalizedHttpEvent,
+} from "../../types/event.types";
+import {
+  StorageListParams,
+  Storage,
+} from "../../storage-adapters/storage.interface";
+import { EventRouter } from "../event.router";
+import { EventNormalizer } from "../event.normalizer";
+import { describe, it, expect, jest } from "@jest/globals";
+
+class MockStorage implements Storage {
+  save = jest.fn<(event: AnyNormalizedEvent) => Promise<void>>();
+  getEvent = jest.fn<(id: string) => Promise<AnyNormalizedEvent | null>>();
+  listEvents =
+    jest.fn<(params: StorageListParams) => Promise<AnyNormalizedEvent[]>>();
+  deleteEvent = jest.fn<(id: string) => Promise<boolean>>();
+  clearEvents = jest.fn<() => Promise<void>>();
+  getStats =
+    jest.fn<() => Promise<{ total: number; byType: Record<string, number> }>>();
+  getAll = jest.fn<() => Promise<AnyNormalizedEvent[]>>();
+}
+
+describe("EventRouter", () => {
+  it("enregistre un événement HTTP normalisé", async () => {
+    const mockStorage = new MockStorage();
+
+    const fakeEvent: NormalizedHttpEvent = {
+      id: "123",
+      type: "http",
+      timestamp: 111,
+      sourceIp: "1.1.1.1",
+      request: {
+        method: "GET",
+        path: "/",
+        headers: {},
+        query: {},
+        body: {},
+      },
+    };
+
+    jest.spyOn(EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
+
+    const router = new EventRouter(mockStorage);
+
+    const req = {
+      ip: "1.1.1.1",
+      method: "GET",
+      path: "/",
+      headers: {},
+      query: {},
+      body: {},
+      raw: {},
+    };
+
+    const result = await router.handleHttp(req);
+
+    expect(EventNormalizer.normalizeHttp).toHaveBeenCalledWith(req);
+    expect(mockStorage.save).toHaveBeenCalledWith(fakeEvent);
+    expect(result).toEqual(fakeEvent);
+  });
+
+  it("propagate une erreur si normalizeHttp throw", async () => {
+    const mockStorage = new MockStorage();
+
+    jest.spyOn(EventNormalizer, "normalizeHttp").mockImplementation(() => {
+      throw new Error("Boom");
+    });
+
+    const router = new EventRouter(mockStorage);
+
+    await expect(router.handleHttp({} as any)).rejects.toThrow("Boom");
+    expect(mockStorage.save).not.toHaveBeenCalled();
+  });
+
+  it("propagate une erreur si storage.save throw", async () => {
+    const mockStorage = new MockStorage();
+
+    const fakeEvent = { id: "x", type: "http" } as any;
+
+    jest.spyOn(EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
+    mockStorage.save.mockRejectedValue(new Error("DB error"));
+
+    const router = new EventRouter(mockStorage);
+
+    await expect(router.handleHttp({} as any)).rejects.toThrow("DB error");
+  });
+});