@j3r3mcdev/oast-server 1.1.1 → 1.1.2

package/src/api/sse/events.stream.ts

@@ -1,90 +1,90 @@
-// src/api/sse/event-stream.ts
-
-export interface EventStreamConfig {
-  retry?: number;
-  heartbeatInterval?: number;
-  logger?: { info: Function; error: Function };
-}
-
-export interface StreamClient {
-  id: string;
-  res: any;
-  channels: Set<string>;
-  connectedAt: number;
-}
-
-export class EventStreamManager {
-  private clients = new Map<string, StreamClient>();
-  private config: Required<EventStreamConfig>;
-  private heartbeatTimer: NodeJS.Timeout | null = null;
-
-  constructor(config: EventStreamConfig = {}) {
-    this.config = {
-      retry: config.retry ?? 2000,
-      heartbeatInterval: config.heartbeatInterval ?? 15000,
-      logger: config.logger ?? console,
-    };
-
-    this.startHeartbeat();
-  }
-
-  private startHeartbeat() {
-    if (process.env.NODE_ENV === "test") return;
-
-    this.heartbeatTimer = setInterval(() => {
-      for (const client of this.clients.values()) {
-        client.res.write(`: heartbeat\n\n`);
-      }
-    }, this.config.heartbeatInterval);
-  }
-
-  addClient(res: any, channels: string[] = []): string {
-    const id = crypto.randomUUID();
-
-    const client: StreamClient = {
-      id,
-      res,
-      channels: new Set(channels),
-      connectedAt: Date.now(),
-    };
-
-    this.clients.set(id, client);
-
-    res.write(`retry: ${this.config.retry}\n`);
-    res.write(`event: connected\ndata: {"id":"${id}"}\n\n`);
-
-    res.on("close", () => this.removeClient(id));
-
-    this.config.logger.info(`SSE client connected: ${id}`);
-
-    return id;
-  }
-
-  removeClient(id: string) {
-    if (this.clients.has(id)) {
-      this.clients.delete(id);
-      this.config.logger.info(`SSE client disconnected: ${id}`);
-    }
-  }
-
-  broadcast(channel: string, event: string, data: any) {
-    const payload =
-      `event: ${event}\n` +
-      `data: ${JSON.stringify(data)}\n` +
-      `channel: ${channel}\n\n`;
-
-    for (const client of this.clients.values()) {
-      if (client.channels.has(channel)) {
-        client.res.write(payload);
-      }
-    }
-  }
-
-  broadcastAll(event: string, data: any) {
-    const payload = `event: ${event}\n` + `data: ${JSON.stringify(data)}\n\n`;
-
-    for (const client of this.clients.values()) {
-      client.res.write(payload);
-    }
-  }
-}
+// src/api/sse/event-stream.ts
+
+export interface EventStreamConfig {
+  retry?: number;
+  heartbeatInterval?: number;
+  logger?: { info: Function; error: Function };
+}
+
+export interface StreamClient {
+  id: string;
+  res: any;
+  channels: Set<string>;
+  connectedAt: number;
+}
+
+export class EventStreamManager {
+  private clients = new Map<string, StreamClient>();
+  private config: Required<EventStreamConfig>;
+  private heartbeatTimer: NodeJS.Timeout | null = null;
+
+  constructor(config: EventStreamConfig = {}) {
+    this.config = {
+      retry: config.retry ?? 2000,
+      heartbeatInterval: config.heartbeatInterval ?? 15000,
+      logger: config.logger ?? console,
+    };
+
+    this.startHeartbeat();
+  }
+
+  private startHeartbeat() {
+    if (process.env.NODE_ENV === "test") return;
+
+    this.heartbeatTimer = setInterval(() => {
+      for (const client of this.clients.values()) {
+        client.res.write(`: heartbeat\n\n`);
+      }
+    }, this.config.heartbeatInterval);
+  }
+
+  addClient(res: any, channels: string[] = []): string {
+    const id = crypto.randomUUID();
+
+    const client: StreamClient = {
+      id,
+      res,
+      channels: new Set(channels),
+      connectedAt: Date.now(),
+    };
+
+    this.clients.set(id, client);
+
+    res.write(`retry: ${this.config.retry}\n`);
+    res.write(`event: connected\ndata: {"id":"${id}"}\n\n`);
+
+    res.on("close", () => this.removeClient(id));
+
+    this.config.logger.info(`SSE client connected: ${id}`);
+
+    return id;
+  }
+
+  removeClient(id: string) {
+    if (this.clients.has(id)) {
+      this.clients.delete(id);
+      this.config.logger.info(`SSE client disconnected: ${id}`);
+    }
+  }
+
+  broadcast(channel: string, event: string, data: any) {
+    const payload =
+      `event: ${event}\n` +
+      `data: ${JSON.stringify(data)}\n` +
+      `channel: ${channel}\n\n`;
+
+    for (const client of this.clients.values()) {
+      if (client.channels.has(channel)) {
+        client.res.write(payload);
+      }
+    }
+  }
+
+  broadcastAll(event: string, data: any) {
+    const payload = `event: ${event}\n` + `data: ${JSON.stringify(data)}\n\n`;
+
+    for (const client of this.clients.values()) {
+      client.res.write(payload);
+    }
+  }
+}

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