@j3r3mcdev/oast-server 1.1.1 → 1.1.3

package/src/api/services/__tests__/tasks.service.test.ts

@@ -1,41 +1,41 @@
-import { describe, it, expect, jest } from "@jest/globals";
-import { TasksService } from "../tasks.service";
-import { EventsService } from "../events.service";
-import { EventStreamManager } from "../../sse/events.stream";
-
-describe("TasksService", () => {
-  it("émet un événement lors de la création d'une tâche", () => {
-    const stream = new EventStreamManager({ heartbeatInterval: 999999 });
-    const events = new EventsService(stream);
-
-    const spy = jest.spyOn(stream, "broadcast");
-
-    const service = new TasksService(events);
-
-    const task = service.create({ type: "x", payload: {} });
-
-    expect(spy).toHaveBeenCalledWith(
-      "tasks",
-      "task.created",
-      expect.objectContaining({ id: task.id }),
-    );
-  });
-
-  it("émet un événement lors de l'annulation d'une tâche", () => {
-    const stream = new EventStreamManager({ heartbeatInterval: 999999 });
-    const events = new EventsService(stream);
-
-    const spy = jest.spyOn(stream, "broadcast");
-
-    const service = new TasksService(events);
-
-    const task = service.create({ type: "x", payload: {} });
-    service.cancel(task.id);
-
-    expect(spy).toHaveBeenCalledWith(
-      "tasks",
-      "task.cancelled",
-      expect.objectContaining({ id: task.id }),
-    );
-  });
-});
+import { describe, it, expect, jest } from "@jest/globals";
+import { TasksService } from "../tasks.service";
+import { EventsService } from "../events.service";
+import { EventStreamManager } from "../../sse/events.stream";
+
+describe("TasksService", () => {
+  it("émet un événement lors de la création d'une tâche", () => {
+    const stream = new EventStreamManager({ heartbeatInterval: 999999 });
+    const events = new EventsService(stream);
+
+    const spy = jest.spyOn(stream, "broadcast");
+
+    const service = new TasksService(events);
+
+    const task = service.create({ type: "x", payload: {} });
+
+    expect(spy).toHaveBeenCalledWith(
+      "tasks",
+      "task.created",
+      expect.objectContaining({ id: task.id }),
+    );
+  });
+
+  it("émet un événement lors de l'annulation d'une tâche", () => {
+    const stream = new EventStreamManager({ heartbeatInterval: 999999 });
+    const events = new EventsService(stream);
+
+    const spy = jest.spyOn(stream, "broadcast");
+
+    const service = new TasksService(events);
+
+    const task = service.create({ type: "x", payload: {} });
+    service.cancel(task.id);
+
+    expect(spy).toHaveBeenCalledWith(
+      "tasks",
+      "task.cancelled",
+      expect.objectContaining({ id: task.id }),
+    );
+  });
+});

package/src/api/services/events.service.ts

@@ -1,17 +1,17 @@
-import { EventStreamManager } from "../sse/events.stream";
-
-export class EventsService {
-  constructor(private stream: EventStreamManager) {}
-
-  connect(res: any, channels: string[] = []) {
-    return this.stream.addClient(res, channels);
-  }
-
-  emit(channel: string, event: string, data: any) {
-    this.stream.broadcast(channel, event, data);
-  }
-
-  emitAll(event: string, data: any) {
-    this.stream.broadcastAll(event, data);
-  }
-}
+import { EventStreamManager } from "../sse/events.stream";
+
+export class EventsService {
+  constructor(private stream: EventStreamManager) {}
+
+  connect(res: any, channels: string[] = []) {
+    return this.stream.addClient(res, channels);
+  }
+
+  emit(channel: string, event: string, data: any) {
+    this.stream.broadcast(channel, event, data);
+  }
+
+  emitAll(event: string, data: any) {
+    this.stream.broadcastAll(event, data);
+  }
+}

package/src/api/services/tasks.service.ts

@@ -1,79 +1,79 @@
-import { CreateTaskDto } from "../dto/create-task.dto";
-import { FilterTasksDto } from "../dto/filter-tasks.dto";
-import { EventsService } from "./events.service";
-
-export interface Task {
-  id: string;
-  type: string;
-  payload: Record<string, any>;
-  priority: "low" | "normal" | "high";
-  metadata: Record<string, any>;
-  status: "pending" | "running" | "completed" | "failed";
-  createdAt: number;
-  updatedAt: number;
-}
-
-export class TasksService {
-  private tasks = new Map<string, Task>();
-  private events: EventsService;
-
-  constructor(events: EventsService) {
-    this.events = events;
-  }
-
-  create(dto: CreateTaskDto): Task {
-    const id = crypto.randomUUID();
-    const now = Date.now();
-
-    const task: Task = {
-      id,
-      type: dto.type,
-      payload: dto.payload,
-      priority: dto.priority ?? "normal",
-      metadata: dto.metadata ?? {},
-      status: "pending",
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    this.tasks.set(id, task);
-
-    this.events.emit("tasks", "task.created", task);
-
-    return task;
-  }
-
-  get(id: string): Task | undefined {
-    return this.tasks.get(id);
-  }
-
-  list(filters: FilterTasksDto): Task[] {
-    let results = Array.from(this.tasks.values());
-
-    if (filters.status) {
-      results = results.filter((t) => t.status === filters.status);
-    }
-
-    if (filters.type) {
-      results = results.filter((t) => t.type === filters.type);
-    }
-
-    if (filters.limit) {
-      results = results.slice(0, filters.limit);
-    }
-
-    return results;
-  }
-
-  cancel(id: string): boolean {
-    const task = this.tasks.get(id);
-    if (!task) return false;
-
-    task.status = "failed";
-    task.updatedAt = Date.now();
-
-    this.events.emit("tasks", "task.cancelled", task);
-
-    return true;
-  }
-}
+import { CreateTaskDto } from "../dto/create-task.dto";
+import { FilterTasksDto } from "../dto/filter-tasks.dto";
+import { EventsService } from "./events.service";
+
+export interface Task {
+  id: string;
+  type: string;
+  payload: Record<string, any>;
+  priority: "low" | "normal" | "high";
+  metadata: Record<string, any>;
+  status: "pending" | "running" | "completed" | "failed";
+  createdAt: number;
+  updatedAt: number;
+}
+
+export class TasksService {
+  private tasks = new Map<string, Task>();
+  private events: EventsService;
+
+  constructor(events: EventsService) {
+    this.events = events;
+  }
+
+  create(dto: CreateTaskDto): Task {
+    const id = crypto.randomUUID();
+    const now = Date.now();
+
+    const task: Task = {
+      id,
+      type: dto.type,
+      payload: dto.payload,
+      priority: dto.priority ?? "normal",
+      metadata: dto.metadata ?? {},
+      status: "pending",
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    this.tasks.set(id, task);
+
+    this.events.emit("tasks", "task.created", task);
+
+    return task;
+  }
+
+  get(id: string): Task | undefined {
+    return this.tasks.get(id);
+  }
+
+  list(filters: FilterTasksDto): Task[] {
+    let results = Array.from(this.tasks.values());
+
+    if (filters.status) {
+      results = results.filter((t) => t.status === filters.status);
+    }
+
+    if (filters.type) {
+      results = results.filter((t) => t.type === filters.type);
+    }
+
+    if (filters.limit) {
+      results = results.slice(0, filters.limit);
+    }
+
+    return results;
+  }
+
+  cancel(id: string): boolean {
+    const task = this.tasks.get(id);
+    if (!task) return false;
+
+    task.status = "failed";
+    task.updatedAt = Date.now();
+
+    this.events.emit("tasks", "task.cancelled", task);
+
+    return true;
+  }
+}

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/bootstrap.ts

@@ -0,0 +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);
+});

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