@j3r3mcdev/oast-server 1.1.8 → 1.1.9

package/src/core/http/router.ts

@@ -1,138 +1,138 @@
-// src/http/router.ts
-
-import { compilePath } from "./compile-path";
-import { Middleware } from "./middleware";
-
-export class Router {
-  private routes: Array<{
-    method: string;
-    path: string;
-    compiled: any[];
-    middlewares: Middleware[];
-    handler: Function;
-  }> = [];
-
-  /**
-   * Enregistre une route avec middlewares optionnels :
-   * router.get("/x", mw1, mw2, handler)
-   */
-  register(method: string, path: string, ...middlewaresAndHandler: any[]) {
-    const compiled = compilePath(path);
-
-    const handler = middlewaresAndHandler.pop();
-    const middlewares = middlewaresAndHandler as Middleware[];
-
-    this.routes.push({
-      method,
-      path,
-      compiled,
-      middlewares,
-      handler,
-    });
-  }
-
-  /**
-   * Trouve la route et extrait les params
-   */
-  match(method: string, urlPath: string) {
-    const urlSegments = urlPath.replace(/^\//, "").split("/");
-
-    for (const route of this.routes) {
-      if (route.method !== method) continue;
-
-      const params: Record<string, string> = {};
-      const compiled = route.compiled;
-
-      if (this.matchSegments(compiled, urlSegments, params)) {
-        return {
-          handler: route.handler,
-          middlewares: route.middlewares,
-          params,
-        };
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Ton moteur de matching existant — inchangé
-   */
-  private matchSegments(
-    compiled: any[],
-    urlSegments: string[],
-    params: Record<string, string>,
-  ) {
-    let i = 0;
-
-    for (let j = 0; j < compiled.length; j++) {
-      const segment = compiled[j];
-      const part = urlSegments[i];
-
-      if (!part && segment.type !== "wildcard") {
-        return false;
-      }
-
-      if (segment.type === "static") {
-        if (segment.value !== part) return false;
-        i++;
-        continue;
-      }
-
-      if (segment.type === "param") {
-        if (!part) return false;
-        params[segment.name] = part;
-        i++;
-        continue;
-      }
-
-      if (segment.type === "wildcard") {
-        if (!part) return false;
-
-        const next = compiled[j + 1];
-        if (!next) return true;
-
-        while (i < urlSegments.length) {
-          if (next.type === "static" && urlSegments[i] === next.value) {
-            break;
-          }
-          i++;
-        }
-
-        if (i >= urlSegments.length) return false;
-
-        continue;
-      }
-    }
-
-    return i === urlSegments.length;
-  }
-
-  get(path: string, ...middlewaresAndHandler: any[]) {
-    this.register("GET", path, ...middlewaresAndHandler);
-  }
-
-  post(path: string, ...middlewaresAndHandler: any[]) {
-    this.register("POST", path, ...middlewaresAndHandler);
-  }
-
-  put(path: string, ...middlewaresAndHandler: any[]) {
-    this.register("PUT", path, ...middlewaresAndHandler);
-  }
-
-  delete(path: string, ...middlewaresAndHandler: any[]) {
-    this.register("DELETE", path, ...middlewaresAndHandler);
-  }
-
-  patch(path: string, ...middlewaresAndHandler: any[]) {
-    this.register("PATCH", path, ...middlewaresAndHandler);
-  }
-
-  options(path: string, ...middlewaresAndHandler: any[]) {
-    this.register("OPTIONS", path, ...middlewaresAndHandler);
-  }
-
-  head(path: string, ...middlewaresAndHandler: any[]) {
-    this.register("HEAD", path, ...middlewaresAndHandler);
-  }
-}
+// src/http/router.ts
+
+import { compilePath } from "./compile-path";
+import { Middleware } from "./middleware";
+
+export class Router {
+  private routes: Array<{
+    method: string;
+    path: string;
+    compiled: any[];
+    middlewares: Middleware[];
+    handler: Function;
+  }> = [];
+
+  /**
+   * Enregistre une route avec middlewares optionnels :
+   * router.get("/x", mw1, mw2, handler)
+   */
+  register(method: string, path: string, ...middlewaresAndHandler: any[]) {
+    const compiled = compilePath(path);
+
+    const handler = middlewaresAndHandler.pop();
+    const middlewares = middlewaresAndHandler as Middleware[];
+
+    this.routes.push({
+      method,
+      path,
+      compiled,
+      middlewares,
+      handler,
+    });
+  }
+
+  /**
+   * Trouve la route et extrait les params
+   */
+  match(method: string, urlPath: string) {
+    const urlSegments = urlPath.replace(/^\//, "").split("/");
+
+    for (const route of this.routes) {
+      if (route.method !== method) continue;
+
+      const params: Record<string, string> = {};
+      const compiled = route.compiled;
+
+      if (this.matchSegments(compiled, urlSegments, params)) {
+        return {
+          handler: route.handler,
+          middlewares: route.middlewares,
+          params,
+        };
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Ton moteur de matching existant — inchangé
+   */
+  private matchSegments(
+    compiled: any[],
+    urlSegments: string[],
+    params: Record<string, string>,
+  ) {
+    let i = 0;
+
+    for (let j = 0; j < compiled.length; j++) {
+      const segment = compiled[j];
+      const part = urlSegments[i];
+
+      if (!part && segment.type !== "wildcard") {
+        return false;
+      }
+
+      if (segment.type === "static") {
+        if (segment.value !== part) return false;
+        i++;
+        continue;
+      }
+
+      if (segment.type === "param") {
+        if (!part) return false;
+        params[segment.name] = part;
+        i++;
+        continue;
+      }
+
+      if (segment.type === "wildcard") {
+        if (!part) return false;
+
+        const next = compiled[j + 1];
+        if (!next) return true;
+
+        while (i < urlSegments.length) {
+          if (next.type === "static" && urlSegments[i] === next.value) {
+            break;
+          }
+          i++;
+        }
+
+        if (i >= urlSegments.length) return false;
+
+        continue;
+      }
+    }
+
+    return i === urlSegments.length;
+  }
+
+  get(path: string, ...middlewaresAndHandler: any[]) {
+    this.register("GET", path, ...middlewaresAndHandler);
+  }
+
+  post(path: string, ...middlewaresAndHandler: any[]) {
+    this.register("POST", path, ...middlewaresAndHandler);
+  }
+
+  put(path: string, ...middlewaresAndHandler: any[]) {
+    this.register("PUT", path, ...middlewaresAndHandler);
+  }
+
+  delete(path: string, ...middlewaresAndHandler: any[]) {
+    this.register("DELETE", path, ...middlewaresAndHandler);
+  }
+
+  patch(path: string, ...middlewaresAndHandler: any[]) {
+    this.register("PATCH", path, ...middlewaresAndHandler);
+  }
+
+  options(path: string, ...middlewaresAndHandler: any[]) {
+    this.register("OPTIONS", path, ...middlewaresAndHandler);
+  }
+
+  head(path: string, ...middlewaresAndHandler: any[]) {
+    this.register("HEAD", path, ...middlewaresAndHandler);
+  }
+}

package/src/core/id-generator.ts

@@ -1,8 +1,8 @@
-import crypto from "crypto";
-
-export class IdGenerator {
-  static generate(): string {
-    // Token long, alphanumérique, très difficile à deviner
-    return crypto.randomBytes(16).toString("hex");
-  }
-}
+import crypto from "crypto";
+
+export class IdGenerator {
+  static generate(): string {
+    // Token long, alphanumérique, très difficile à deviner
+    return crypto.randomBytes(16).toString("hex");
+  }
+}

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> {
-    this.logger.info(`Event received (${event.type})`, { id: event.id });
-    await this.storage.save(event);
-
-    for (const hook of this.hooks) {
-      try {
-        await hook(event);
-      } catch (err) {
-        this.logger.error("Hook error", err);
-      }
-    }
-  }
-
-  async route(event: AnyNormalizedEvent): Promise<void> {
-    return this.dispatch(event);
-  }
-
-  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> {
+    this.logger.info(`Event received (${event.type})`, { id: event.id });
+    await this.storage.save(event);
+
+    for (const hook of this.hooks) {
+      try {
+        await hook(event);
+      } catch (err) {
+        this.logger.error("Hook error", err);
+      }
+    }
+  }
+
+  async route(event: AnyNormalizedEvent): Promise<void> {
+    return this.dispatch(event);
+  }
+
+  addHook(hook: RouterHook) {
+    this.hooks.push(hook);
+  }
+}