@j3r3mcdev/oast-server 1.1.1 → 1.1.2

package/src/core/http/response.ts

@@ -1,93 +1,93 @@
-// src/http/response.ts
-
-export class Response {
-  private _status = 200;
-  private _headers: Record<string, string> = {};
-  private _sent = false;
-  private _raw: any; // Node ServerResponse ou autre selon l'adaptateur
-
-  constructor(raw: any) {
-    this._raw = raw;
-  }
-
-  status(code: number): this {
-    this._status = code;
-    return this;
-  }
-
-  header(name: string, value: string): this {
-    this._headers[name.toLowerCase()] = value;
-    return this;
-  }
-
-  json(data: any): void {
-    this.ensureNotSent();
-    this.header("content-type", "application/json");
-    this.send(JSON.stringify(data));
-  }
-
-  text(data: string): void {
-    this.ensureNotSent();
-    this.header("content-type", "text/plain");
-    this.send(data);
-  }
-
-  send(data: any): void {
-    this.ensureNotSent();
-
-    for (const [name, value] of Object.entries(this._headers)) {
-      this._raw.setHeader(name, value);
-    }
-
-    this._raw.statusCode = this._status;
-    this._raw.end(data);
-
-    this._sent = true;
-  }
-
-  stream(readable: NodeJS.ReadableStream): void {
-    this.ensureNotSent();
-
-    for (const [name, value] of Object.entries(this._headers)) {
-      this._raw.setHeader(name, value);
-    }
-
-    this._raw.statusCode = this._status;
-    readable.pipe(this._raw);
-
-    this._sent = true;
-  }
-
-  sse(): void {
-    this.ensureNotSent();
-
-    this.header("content-type", "text/event-stream");
-    this.header("cache-control", "no-cache");
-    this.header("connection", "keep-alive");
-
-    for (const [name, value] of Object.entries(this._headers)) {
-      this._raw.setHeader(name, value);
-    }
-
-    this._raw.flushHeaders?.();
-
-    this._sent = false; // SSE reste ouvert
-  }
-
-  write(data: string): void {
-    this._raw.write(data);
-  }
-
-  end(): void {
-    if (!this._sent) {
-      this._raw.end();
-      this._sent = true;
-    }
-  }
-
-  private ensureNotSent() {
-    if (this._sent) {
-      throw new Error("Response already sent");
-    }
-  }
-}
+// src/http/response.ts
+
+export class Response {
+  private _status = 200;
+  private _headers: Record<string, string> = {};
+  private _sent = false;
+  private _raw: any; // Node ServerResponse ou autre selon l'adaptateur
+
+  constructor(raw: any) {
+    this._raw = raw;
+  }
+
+  status(code: number): this {
+    this._status = code;
+    return this;
+  }
+
+  header(name: string, value: string): this {
+    this._headers[name.toLowerCase()] = value;
+    return this;
+  }
+
+  json(data: any): void {
+    this.ensureNotSent();
+    this.header("content-type", "application/json");
+    this.send(JSON.stringify(data));
+  }
+
+  text(data: string): void {
+    this.ensureNotSent();
+    this.header("content-type", "text/plain");
+    this.send(data);
+  }
+
+  send(data: any): void {
+    this.ensureNotSent();
+
+    for (const [name, value] of Object.entries(this._headers)) {
+      this._raw.setHeader(name, value);
+    }
+
+    this._raw.statusCode = this._status;
+    this._raw.end(data);
+
+    this._sent = true;
+  }
+
+  stream(readable: NodeJS.ReadableStream): void {
+    this.ensureNotSent();
+
+    for (const [name, value] of Object.entries(this._headers)) {
+      this._raw.setHeader(name, value);
+    }
+
+    this._raw.statusCode = this._status;
+    readable.pipe(this._raw);
+
+    this._sent = true;
+  }
+
+  sse(): void {
+    this.ensureNotSent();
+
+    this.header("content-type", "text/event-stream");
+    this.header("cache-control", "no-cache");
+    this.header("connection", "keep-alive");
+
+    for (const [name, value] of Object.entries(this._headers)) {
+      this._raw.setHeader(name, value);
+    }
+
+    this._raw.flushHeaders?.();
+
+    this._sent = false; // SSE reste ouvert
+  }
+
+  write(data: string): void {
+    this._raw.write(data);
+  }
+
+  end(): void {
+    if (!this._sent) {
+      this._raw.end();
+      this._sent = true;
+    }
+  }
+
+  private ensureNotSent() {
+    if (this._sent) {
+      throw new Error("Response already sent");
+    }
+  }
+}

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