@j3r3mcdev/oast-server 1.1.1 → 1.1.3

package/src/listeners/websocket/websocket.listener.ts

@@ -1,40 +1,40 @@
-import { WebSocketServer, WebSocket, RawData } from "ws";
-import type { IncomingMessage } from "http";
-import { CoreRouter } from "../../core/router";
-import { WebSocketExtractor } from "./websocket.extractor";
-import { EventNormalizer } from "../../core/event.normalizer";
-import { Logger } from "../../core/logger";
-
-export class WebSocketListener {
-  private router: CoreRouter;
-  private server: WebSocketServer;
-  private logger: Logger;
-
-  constructor(router: CoreRouter, port: number) {
-    this.router = router;
-    this.logger = new Logger({ context: "WebSocketListener" });
-
-    this.server = new WebSocketServer({ port });
-
-    this.server.on("connection", (ws: WebSocket, req: IncomingMessage) => {
-      ws.on("message", async (data: RawData) => {
-        try {
-          const message = data.toString();
-          const extracted = WebSocketExtractor.extract(ws, req, message);
-          const event = EventNormalizer.normalizeWebSocket(extracted);
-
-          await this.router.dispatch(event);
-        } catch (err) {
-          this.logger.error("WebSocket error", err);
-        }
-      });
-    });
-
-    this.logger.info(`WebSocket Listener listening on port ${port}`);
-  }
-
-  stop() {
-    this.server.close();
-    this.logger.info("WebSocket Listener stopped");
-  }
-}
+import { WebSocketServer, WebSocket, RawData } from "ws";
+import type { IncomingMessage } from "http";
+import { CoreRouter } from "../../core/router";
+import { WebSocketExtractor } from "./websocket.extractor";
+import { EventNormalizer } from "../../core/event.normalizer";
+import { Logger } from "../../core/logger";
+
+export class WebSocketListener {
+  private router: CoreRouter;
+  private server: WebSocketServer;
+  private logger: Logger;
+
+  constructor(router: CoreRouter, port: number) {
+    this.router = router;
+    this.logger = new Logger({ context: "WebSocketListener" });
+
+    this.server = new WebSocketServer({ port });
+
+    this.server.on("connection", (ws: WebSocket, req: IncomingMessage) => {
+      ws.on("message", async (data: RawData) => {
+        try {
+          const message = data.toString();
+          const extracted = WebSocketExtractor.extract(ws, req, message);
+          const event = EventNormalizer.normalizeWebSocket(extracted);
+
+          await this.router.dispatch(event);
+        } catch (err) {
+          this.logger.error("WebSocket error", err);
+        }
+      });
+    });
+
+    this.logger.info(`WebSocket Listener listening on port ${port}`);
+  }
+
+  stop() {
+    this.server.close();
+    this.logger.info("WebSocket Listener stopped");
+  }
+}

package/src/storage-adapters/adapters/__tests__/memory.storage.test.ts

@@ -1,75 +1,75 @@
-import { MemoryStorage } from "../memory.storage";
-import { describe, it, expect } from "@jest/globals";
-import { NormalizedHttpEvent } from "../../../types/event.types";
-
-describe("MemoryStorage", () => {
-  it("sauvegarde un événement", async () => {
-    const storage = new MemoryStorage();
-
-    const event: NormalizedHttpEvent = {
-      id: "1",
-      type: "http",
-      timestamp: 123,
-      sourceIp: "1.1.1.1",
-      request: {
-        method: "GET",
-        path: "/",
-        headers: {},
-        query: {},
-        body: {},
-      },
-    };
-
-    await storage.save(event);
-
-    const all = await storage.getAll();
-    expect(all).toEqual([event]);
-  });
-
-  it("retourne un événement par ID", async () => {
-    const storage = new MemoryStorage();
-
-    const event: NormalizedHttpEvent = {
-      id: "1",
-      type: "http",
-      timestamp: Date.now(),
-      sourceIp: "1.1.1.1",
-      request: {
-        method: "GET",
-        path: "/test",
-        headers: {},
-        query: {},
-        body: "",
-      },
-    };
-
-    await storage.save(event);
-
-    const found = await storage.getById("1");
-    expect(found).toEqual(event);
-  });
-
-  it("supprime un événement", async () => {
-    const storage = new MemoryStorage();
-
-    const event: NormalizedHttpEvent = {
-      id: "1",
-      type: "http",
-      timestamp: Date.now(),
-      sourceIp: "1.1.1.1",
-      request: {
-        method: "GET",
-        path: "/test",
-        headers: {},
-        query: {},
-        body: "",
-      },
-    };
-
-    await storage.save(event);
-    await storage.delete("1");
-
-    const all = await storage.getAll();
-    expect(all).toEqual([]);
-  });
-});
+import { MemoryStorage } from "../memory.storage";
+import { describe, it, expect } from "@jest/globals";
+import { NormalizedHttpEvent } from "../../../types/event.types";
+
+describe("MemoryStorage", () => {
+  it("sauvegarde un événement", async () => {
+    const storage = new MemoryStorage();
+
+    const event: NormalizedHttpEvent = {
+      id: "1",
+      type: "http",
+      timestamp: 123,
+      sourceIp: "1.1.1.1",
+      request: {
+        method: "GET",
+        path: "/",
+        headers: {},
+        query: {},
+        body: {},
+      },
+    };
+
+    await storage.save(event);
+
+    const all = await storage.getAll();
+    expect(all).toEqual([event]);
+  });
+
+  it("retourne un événement par ID", async () => {
+    const storage = new MemoryStorage();
+
+    const event: NormalizedHttpEvent = {
+      id: "1",
+      type: "http",
+      timestamp: Date.now(),
+      sourceIp: "1.1.1.1",
+      request: {
+        method: "GET",
+        path: "/test",
+        headers: {},
+        query: {},
+        body: "",
+      },
+    };
+
+    await storage.save(event);
+
+    const found = await storage.getById("1");
+    expect(found).toEqual(event);
+  });
+
+  it("supprime un événement", async () => {
+    const storage = new MemoryStorage();
+
+    const event: NormalizedHttpEvent = {
+      id: "1",
+      type: "http",
+      timestamp: Date.now(),
+      sourceIp: "1.1.1.1",
+      request: {
+        method: "GET",
+        path: "/test",
+        headers: {},
+        query: {},
+        body: "",
+      },
+    };
+
+    await storage.save(event);
+    await storage.delete("1");
+
+    const all = await storage.getAll();
+    expect(all).toEqual([]);
+  });
+});

package/src/storage-adapters/adapters/memory.storage.ts

@@ -1,64 +1,64 @@
-import { Storage } from "../storage.interface";
-import { AnyNormalizedEvent } from "../../types/event.types";
-
-export class MemoryStorage implements Storage {
-  private events = new Map<string, AnyNormalizedEvent>();
-
-  async save(event: AnyNormalizedEvent): Promise<void> {
-    this.events.set(event.id, event);
-  }
-
-  async getEvent(id: string): Promise<AnyNormalizedEvent | null> {
-    return this.events.get(id) ?? null;
-  }
-
-  async listEvents(params: {
-    type?: string;
-    page?: number;
-    limit?: number;
-  }): Promise<AnyNormalizedEvent[]> {
-    const { type, page = 1, limit = 50 } = params;
-
-    const all = Array.from(this.events.values());
-    const filtered = type ? all.filter((e) => e.type === type) : all;
-
-    const start = (page - 1) * limit;
-    return filtered.slice(start, start + limit);
-  }
-
-  async getAll(): Promise<AnyNormalizedEvent[]> {
-    return Array.from(this.events.values());
-  }
-
-  async deleteEvent(id: string): Promise<boolean> {
-    return this.events.delete(id);
-  }
-
-  async clearEvents(): Promise<void> {
-    this.events.clear();
-  }
-
-  async getStats(): Promise<{
-    total: number;
-    byType: Record<string, number>;
-  }> {
-    const all = Array.from(this.events.values());
-    const byType: Record<string, number> = {};
-
-    for (const e of all) {
-      byType[e.type] = (byType[e.type] ?? 0) + 1;
-    }
-
-    return {
-      total: all.length,
-      byType,
-    };
-  }
-  async getById(id: string) {
-    return this.getEvent(id);
-  }
-
-  async delete(id: string) {
-    return this.deleteEvent(id);
-  }
-}
+import { Storage } from "../storage.interface";
+import { AnyNormalizedEvent } from "../../types/event.types";
+
+export class MemoryStorage implements Storage {
+  private events = new Map<string, AnyNormalizedEvent>();
+
+  async save(event: AnyNormalizedEvent): Promise<void> {
+    this.events.set(event.id, event);
+  }
+
+  async getEvent(id: string): Promise<AnyNormalizedEvent | null> {
+    return this.events.get(id) ?? null;
+  }
+
+  async listEvents(params: {
+    type?: string;
+    page?: number;
+    limit?: number;
+  }): Promise<AnyNormalizedEvent[]> {
+    const { type, page = 1, limit = 50 } = params;
+
+    const all = Array.from(this.events.values());
+    const filtered = type ? all.filter((e) => e.type === type) : all;
+
+    const start = (page - 1) * limit;
+    return filtered.slice(start, start + limit);
+  }
+
+  async getAll(): Promise<AnyNormalizedEvent[]> {
+    return Array.from(this.events.values());
+  }
+
+  async deleteEvent(id: string): Promise<boolean> {
+    return this.events.delete(id);
+  }
+
+  async clearEvents(): Promise<void> {
+    this.events.clear();
+  }
+
+  async getStats(): Promise<{
+    total: number;
+    byType: Record<string, number>;
+  }> {
+    const all = Array.from(this.events.values());
+    const byType: Record<string, number> = {};
+
+    for (const e of all) {
+      byType[e.type] = (byType[e.type] ?? 0) + 1;
+    }
+
+    return {
+      total: all.length,
+      byType,
+    };
+  }
+  async getById(id: string) {
+    return this.getEvent(id);
+  }
+
+  async delete(id: string) {
+    return this.deleteEvent(id);
+  }
+}

package/src/storage-adapters/storage.interface.ts

@@ -1,26 +1,26 @@
-import { AnyNormalizedEvent } from "../types/event.types";
-
-export interface StorageListParams {
-  type?: string;
-  page?: number;
-  limit?: number;
-}
-
-export interface Storage {
-  save(event: AnyNormalizedEvent): Promise<void>;
-
-  getEvent(id: string): Promise<AnyNormalizedEvent | null>;
-
-  listEvents(params: StorageListParams): Promise<AnyNormalizedEvent[]>;
-
-  deleteEvent(id: string): Promise<boolean>;
-
-  clearEvents(): Promise<void>;
-
-  getAll(): Promise<AnyNormalizedEvent[]>;
-
-  getStats(): Promise<{
-    total: number;
-    byType: Record<string, number>;
-  }>;
-}
+import { AnyNormalizedEvent } from "../types/event.types";
+
+export interface StorageListParams {
+  type?: string;
+  page?: number;
+  limit?: number;
+}
+
+export interface Storage {
+  save(event: AnyNormalizedEvent): Promise<void>;
+
+  getEvent(id: string): Promise<AnyNormalizedEvent | null>;
+
+  listEvents(params: StorageListParams): Promise<AnyNormalizedEvent[]>;
+
+  deleteEvent(id: string): Promise<boolean>;
+
+  clearEvents(): Promise<void>;
+
+  getAll(): Promise<AnyNormalizedEvent[]>;
+
+  getStats(): Promise<{
+    total: number;
+    byType: Record<string, number>;
+  }>;
+}