@j3r3mcdev/oast-server 1.1.1 → 1.1.3

package/src/core/server.ts

@@ -1,85 +1,85 @@
-import { Logger } from "./logger";
-import { CoreRouter } from "./router";
-import { StorageManager } from "./storage";
-import { Listener } from "../listeners/listener.interface";
-export interface CoreServerOptions {
-  logger?: Logger;
-  storage?: StorageManager;
-  listeners?: Listener[];
-}
-
-export class CoreServer {
-  private logger: Logger;
-  private storage: StorageManager;
-  private router: CoreRouter;
-  private listeners: Listener[];
-
-  constructor(options: CoreServerOptions = {}) {
-    this.logger = options.logger ?? new Logger({ context: "CoreServer" });
-    this.storage =
-      options.storage ?? new StorageManager({ logger: this.logger });
-    this.router = new CoreRouter(this.storage, { logger: this.logger });
-    this.listeners = options.listeners ?? [];
-  }
-
-  getRouter() {
-    return this.router;
-  }
-
-  getStorage() {
-    return this.storage;
-  }
-
-  async start(): Promise<void> {
-    this.logger.info("Starting OAST server...");
-
-    // Démarrage des listeners
-    for (const listener of this.listeners) {
-      try {
-        await listener.start();
-        this.logger.info(`Listener started`, {
-          listener: listener.constructor.name,
-        });
-      } catch (err: any) {
-        this.logger.error("Listener failed to start", {
-          listener: listener.constructor.name,
-          error: err.message,
-        });
-      }
-    }
-
-    this.logger.info("OAST server started");
-  }
-
-  async stop(): Promise<void> {
-    this.logger.info("Stopping OAST server...");
-
-    for (const listener of this.listeners) {
-      try {
-        await listener.stop();
-        this.logger.info(`Listener stopped`, {
-          listener: listener.constructor.name,
-        });
-      } catch (err: any) {
-        this.logger.error("Listener failed to stop", {
-          listener: listener.constructor.name,
-          error: err.message,
-        });
-      }
-    }
-
-    this.logger.info("OAST server stopped");
-  }
-
-  /**
-   * Méthode appelée par CoreRouter après chaque event normalisé.
-   * Permet de diffuser l’event aux listeners SSE (ApiListener).
-   */
-  broadcast(event: any) {
-    for (const listener of this.listeners) {
-      if (typeof (listener as any).broadcastEvent === "function") {
-        (listener as any).broadcastEvent(event);
-      }
-    }
-  }
-}
+import { Logger } from "./logger";
+import { CoreRouter } from "./router";
+import { StorageManager } from "./storage";
+import { Listener } from "../listeners/listener.interface";
+export interface CoreServerOptions {
+  logger?: Logger;
+  storage?: StorageManager;
+  listeners?: Listener[];
+}
+
+export class CoreServer {
+  private logger: Logger;
+  private storage: StorageManager;
+  private router: CoreRouter;
+  private listeners: Listener[];
+
+  constructor(options: CoreServerOptions = {}) {
+    this.logger = options.logger ?? new Logger({ context: "CoreServer" });
+    this.storage =
+      options.storage ?? new StorageManager({ logger: this.logger });
+    this.router = new CoreRouter(this.storage, { logger: this.logger });
+    this.listeners = options.listeners ?? [];
+  }
+
+  getRouter() {
+    return this.router;
+  }
+
+  getStorage() {
+    return this.storage;
+  }
+
+  async start(): Promise<void> {
+    this.logger.info("Starting OAST server...");
+
+    // Démarrage des listeners
+    for (const listener of this.listeners) {
+      try {
+        await listener.start();
+        this.logger.info(`Listener started`, {
+          listener: listener.constructor.name,
+        });
+      } catch (err: any) {
+        this.logger.error("Listener failed to start", {
+          listener: listener.constructor.name,
+          error: err.message,
+        });
+      }
+    }
+
+    this.logger.info("OAST server started");
+  }
+
+  async stop(): Promise<void> {
+    this.logger.info("Stopping OAST server...");
+
+    for (const listener of this.listeners) {
+      try {
+        await listener.stop();
+        this.logger.info(`Listener stopped`, {
+          listener: listener.constructor.name,
+        });
+      } catch (err: any) {
+        this.logger.error("Listener failed to stop", {
+          listener: listener.constructor.name,
+          error: err.message,
+        });
+      }
+    }
+
+    this.logger.info("OAST server stopped");
+  }
+
+  /**
+   * Méthode appelée par CoreRouter après chaque event normalisé.
+   * Permet de diffuser l’event aux listeners SSE (ApiListener).
+   */
+  broadcast(event: any) {
+    for (const listener of this.listeners) {
+      if (typeof (listener as any).broadcastEvent === "function") {
+        (listener as any).broadcastEvent(event);
+      }
+    }
+  }
+}

package/src/core/storage.ts

@@ -1,64 +1,64 @@
-import { Storage } from "../storage-adapters/storage.interface";
-import { AnyNormalizedEvent } from "../types/event.types";
-import { Logger } from "./logger";
-
-export class StorageManager implements Storage {
-  private events: AnyNormalizedEvent[] = [];
-  private logger: Logger;
-
-  constructor(options: { logger?: Logger } = {}) {
-    this.logger = options.logger ?? new Logger({ context: "StorageManager" });
-  }
-
-  async save(event: AnyNormalizedEvent): Promise<void> {
-    this.events.push(event);
-  }
-
-  async getEvent(id: string): Promise<AnyNormalizedEvent | null> {
-    return this.events.find((e) => e.id === id) ?? null;
-  }
-
-  async listEvents(params: {
-    type?: string;
-    page?: number;
-    limit?: number;
-  }): Promise<AnyNormalizedEvent[]> {
-    const { type, page = 1, limit = 50 } = params;
-
-    let filtered = this.events;
-    if (type) filtered = filtered.filter((e) => e.type === type);
-
-    const start = (page - 1) * limit;
-    return filtered.slice(start, start + limit);
-  }
-
-  async getAll(): Promise<AnyNormalizedEvent[]> {
-    return this.events;
-  }
-
-  async deleteEvent(id: string): Promise<boolean> {
-    const before = this.events.length;
-    this.events = this.events.filter((e) => e.id !== id);
-    return this.events.length !== before;
-  }
-
-  async clearEvents(): Promise<void> {
-    this.events = [];
-  }
-
-  async getStats(): Promise<{
-    total: number;
-    byType: Record<string, number>;
-  }> {
-    const byType: Record<string, number> = {};
-
-    for (const e of this.events) {
-      byType[e.type] = (byType[e.type] ?? 0) + 1;
-    }
-
-    return {
-      total: this.events.length,
-      byType,
-    };
-  }
-}
+import { Storage } from "../storage-adapters/storage.interface";
+import { AnyNormalizedEvent } from "../types/event.types";
+import { Logger } from "./logger";
+
+export class StorageManager implements Storage {
+  private events: AnyNormalizedEvent[] = [];
+  private logger: Logger;
+
+  constructor(options: { logger?: Logger } = {}) {
+    this.logger = options.logger ?? new Logger({ context: "StorageManager" });
+  }
+
+  async save(event: AnyNormalizedEvent): Promise<void> {
+    this.events.push(event);
+  }
+
+  async getEvent(id: string): Promise<AnyNormalizedEvent | null> {
+    return this.events.find((e) => e.id === id) ?? null;
+  }
+
+  async listEvents(params: {
+    type?: string;
+    page?: number;
+    limit?: number;
+  }): Promise<AnyNormalizedEvent[]> {
+    const { type, page = 1, limit = 50 } = params;
+
+    let filtered = this.events;
+    if (type) filtered = filtered.filter((e) => e.type === type);
+
+    const start = (page - 1) * limit;
+    return filtered.slice(start, start + limit);
+  }
+
+  async getAll(): Promise<AnyNormalizedEvent[]> {
+    return this.events;
+  }
+
+  async deleteEvent(id: string): Promise<boolean> {
+    const before = this.events.length;
+    this.events = this.events.filter((e) => e.id !== id);
+    return this.events.length !== before;
+  }
+
+  async clearEvents(): Promise<void> {
+    this.events = [];
+  }
+
+  async getStats(): Promise<{
+    total: number;
+    byType: Record<string, number>;
+  }> {
+    const byType: Record<string, number> = {};
+
+    for (const e of this.events) {
+      byType[e.type] = (byType[e.type] ?? 0) + 1;
+    }
+
+    return {
+      total: this.events.length,
+      byType,
+    };
+  }
+}

package/src/index.ts

@@ -1,89 +1,10 @@
-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);
-});
+export { ApiListener } from "./listeners/api/api.listener";
+export { HttpListener } from "./listeners/http/http.listener";
+export { DnsListener } from "./listeners/dns/dns.listener";
+export { SmtpListener } from "./listeners/smtp/smtp.listener";
+export { TcpListener } from "./listeners/tcp/tcp.listener";
+
+export { CoreServer } from "./core/server";
+export { CoreRouter } from "./core/router";
+export { StorageManager } from "./core/storage";
+export { Logger } from "./core/logger";

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: {} });
+  });
+});