@j3r3mcdev/oast-server 1.0.0 → 1.1.0

package/src/core/logger.ts

@@ -1,113 +1,113 @@
-export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
-
-export interface LoggerOptions {
-  level?: LogLevel;
-  context?: string;
-  enabled?: boolean;
-  hooks?: Array<(entry: LogEntry) => void>;
-}
-
-export interface LogEntry {
-  timestamp: string;
-  level: LogLevel;
-  message: string;
-  context?: string;
-  data?: any;
-}
-
-const COLORS = {
-  reset: "\x1b[0m",
-  gray: "\x1b[90m",
-  blue: "\x1b[34m",
-  yellow: "\x1b[33m",
-  red: "\x1b[31m",
-  magenta: "\x1b[35m",
-};
-
-const LEVEL_COLORS: Record<LogLevel, string> = {
-  debug: COLORS.gray,
-  info: COLORS.blue,
-  warn: COLORS.yellow,
-  error: COLORS.red,
-  fatal: COLORS.magenta,
-};
-
-const LEVEL_ORDER: Record<LogLevel, number> = {
-  debug: 10,
-  info: 20,
-  warn: 30,
-  error: 40,
-  fatal: 50,
-};
-
-export class Logger {
-  private level: LogLevel;
-  private context?: string;
-  private enabled: boolean;
-  private hooks: Array<(entry: LogEntry) => void>;
-
-  constructor(options: LoggerOptions = {}) {
-    this.level = options.level ?? "info";
-    this.context = options.context;
-    this.enabled = options.enabled ?? true;
-    this.hooks = options.hooks ?? [];
-  }
-
-  private shouldLog(level: LogLevel): boolean {
-    return this.enabled && LEVEL_ORDER[level] >= LEVEL_ORDER[this.level];
-  }
-
-  private emit(level: LogLevel, message: string, data?: any) {
-    if (!this.shouldLog(level)) return;
-
-    const entry: LogEntry = {
-      timestamp: new Date().toISOString(),
-      level,
-      message,
-      context: this.context,
-      data,
-    };
-
-    // Console output
-    const color = LEVEL_COLORS[level];
-    const ctx = this.context ? `[${this.context}] ` : "";
-    const formatted = `${color}${entry.timestamp} ${level.toUpperCase()} ${ctx}${message}${COLORS.reset}`;
-
-    console.log(formatted);
-
-    // Hooks (dashboard, file, webhook…)
-    for (const hook of this.hooks) {
-      hook(entry);
-    }
-  }
-
-  debug(msg: string, data?: any) {
-    this.emit("debug", msg, data);
-  }
-
-  info(msg: string, data?: any) {
-    this.emit("info", msg, data);
-  }
-
-  warn(msg: string, data?: any) {
-    this.emit("warn", msg, data);
-  }
-
-  error(msg: string, data?: any) {
-    this.emit("error", msg, data);
-  }
-
-  fatal(msg: string, data?: any) {
-    this.emit("fatal", msg, data);
-  }
-
-  // Créer un logger enfant avec un contexte différent
-  withContext(context: string): Logger {
-    return new Logger({
-      level: this.level,
-      enabled: this.enabled,
-      hooks: this.hooks,
-      context,
-    });
-  }
-}
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
+
+export interface LoggerOptions {
+  level?: LogLevel;
+  context?: string;
+  enabled?: boolean;
+  hooks?: Array<(entry: LogEntry) => void>;
+}
+
+export interface LogEntry {
+  timestamp: string;
+  level: LogLevel;
+  message: string;
+  context?: string;
+  data?: any;
+}
+
+const COLORS = {
+  reset: "\x1b[0m",
+  gray: "\x1b[90m",
+  blue: "\x1b[34m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  magenta: "\x1b[35m",
+};
+
+const LEVEL_COLORS: Record<LogLevel, string> = {
+  debug: COLORS.gray,
+  info: COLORS.blue,
+  warn: COLORS.yellow,
+  error: COLORS.red,
+  fatal: COLORS.magenta,
+};
+
+const LEVEL_ORDER: Record<LogLevel, number> = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  fatal: 50,
+};
+
+export class Logger {
+  private level: LogLevel;
+  private context?: string;
+  private enabled: boolean;
+  private hooks: Array<(entry: LogEntry) => void>;
+
+  constructor(options: LoggerOptions = {}) {
+    this.level = options.level ?? "info";
+    this.context = options.context;
+    this.enabled = options.enabled ?? true;
+    this.hooks = options.hooks ?? [];
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return this.enabled && LEVEL_ORDER[level] >= LEVEL_ORDER[this.level];
+  }
+
+  private emit(level: LogLevel, message: string, data?: any) {
+    if (!this.shouldLog(level)) return;
+
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      context: this.context,
+      data,
+    };
+
+    // Console output
+    const color = LEVEL_COLORS[level];
+    const ctx = this.context ? `[${this.context}] ` : "";
+    const formatted = `${color}${entry.timestamp} ${level.toUpperCase()} ${ctx}${message}${COLORS.reset}`;
+
+    console.log(formatted);
+
+    // Hooks (dashboard, file, webhook…)
+    for (const hook of this.hooks) {
+      hook(entry);
+    }
+  }
+
+  debug(msg: string, data?: any) {
+    this.emit("debug", msg, data);
+  }
+
+  info(msg: string, data?: any) {
+    this.emit("info", msg, data);
+  }
+
+  warn(msg: string, data?: any) {
+    this.emit("warn", msg, data);
+  }
+
+  error(msg: string, data?: any) {
+    this.emit("error", msg, data);
+  }
+
+  fatal(msg: string, data?: any) {
+    this.emit("fatal", msg, data);
+  }
+
+  // Créer un logger enfant avec un contexte différent
+  withContext(context: string): Logger {
+    return new Logger({
+      level: this.level,
+      enabled: this.enabled,
+      hooks: this.hooks,
+      context,
+    });
+  }
+}

package/src/core/router.ts

@@ -1,44 +1,44 @@
-import { Storage } from "../storage-adapters/storage.interface";
-import { Logger } from "./logger";
-import { AnyNormalizedEvent } from "../types/event.types";
-
-export type RouterHook = (event: AnyNormalizedEvent) => void | Promise<void>;
-
-export interface RouterOptions {
-  logger?: Logger;
-  hooks?: RouterHook[];
-}
-
-export class CoreRouter {
-  private logger: Logger;
-  private hooks: RouterHook[];
-
-  constructor(
-    private storage: Storage,
-    options: RouterOptions = {},
-  ) {
-    this.logger = options.logger ?? new Logger({ context: "CoreRouter" });
-    this.hooks = options.hooks ?? [];
-  }
-
-  async dispatch(event: AnyNormalizedEvent): Promise<void> {
-    // 1. Log
-    this.logger.info(`Event received (${event.type})`, { id: event.id });
-
-    // 2. Save
-    await this.storage.save(event);
-
-    // 3. Hooks
-    for (const hook of this.hooks) {
-      try {
-        await hook(event);
-      } catch (err) {
-        this.logger.error("Hook error", err);
-      }
-    }
-  }
-
-  addHook(hook: RouterHook) {
-    this.hooks.push(hook);
-  }
-}
+import { Storage } from "../storage-adapters/storage.interface";
+import { Logger } from "./logger";
+import { AnyNormalizedEvent } from "../types/event.types";
+
+export type RouterHook = (event: AnyNormalizedEvent) => void | Promise<void>;
+
+export interface RouterOptions {
+  logger?: Logger;
+  hooks?: RouterHook[];
+}
+
+export class CoreRouter {
+  private logger: Logger;
+  private hooks: RouterHook[];
+
+  constructor(
+    private storage: Storage,
+    options: RouterOptions = {},
+  ) {
+    this.logger = options.logger ?? new Logger({ context: "CoreRouter" });
+    this.hooks = options.hooks ?? [];
+  }
+
+  async dispatch(event: AnyNormalizedEvent): Promise<void> {
+    // 1. Log
+    this.logger.info(`Event received (${event.type})`, { id: event.id });
+
+    // 2. Save
+    await this.storage.save(event);
+
+    // 3. Hooks
+    for (const hook of this.hooks) {
+      try {
+        await hook(event);
+      } catch (err) {
+        this.logger.error("Hook error", err);
+      }
+    }
+  }
+
+  addHook(hook: RouterHook) {
+    this.hooks.push(hook);
+  }
+}

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