@j3r3mcdev/oast-server 1.1.13 → 1.1.14

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@j3r3mcdev/oast-server",
-  "version": "1.1.13",
+  "version": "1.1.14",
   "description": "Modular OAST callback server for security auditing",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
   "scripts": {
     "dev": "ts-node-dev --respawn --transpile-only src/core/server.ts",
     "build": "tsc -p tsconfig.json",

package/.github/workflows/ci.yml

@@ -1,29 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-
-jobs:
-  build-and-test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Run tests
-        run: npm test
-
-      - name: Build project
-        run: npm run build

package/.github/workflows/publish.yml

@@ -1,31 +0,0 @@
-name: Publish to npm
-
-on:
-  push:
-    tags:
-      - "v*.*.*"
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: "https://registry.npmjs.org"
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Build project
-        run: npm run build
-
-      - name: Publish package
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: npm publish --access public

package/jest.config.js

@@ -1,14 +0,0 @@
-const { createDefaultPreset } = require("ts-jest");
-
-const tsJestTransformCfg = createDefaultPreset().transform;
-
-/** @type {import("jest").Config} **/
-module.exports = {
-  testEnvironment: "node",
-  transform: {
-    ...tsJestTransformCfg,
-  },
-
-  // 🔥 Empêche Jest d'exécuter les tests compilés dans dist/
-  testPathIgnorePatterns: ["/dist/"],
-};

package/sadmin list shadows

@@ -1,9 +0,0 @@
-8faa343 (HEAD -> feat/core-event, origin/main, main) HEAD@{0}: checkout: moving from main to feat/core-event
-8faa343 (HEAD -> feat/core-event, origin/main, main) HEAD@{1}: commit: ADD FULL architecture
-8f8f441 HEAD@{2}: commit: ADD CI/CD
-0c987a0 HEAD@{3}: commit: ADD CI/CD
-8aad148 HEAD@{4}: commit: ADD CI/CD
-e1f2959 HEAD@{5}: commit: ADD CI/CD
-271e3b1 HEAD@{6}: commit: ADD Architecture & package.json & tsconfig.json
-b840cd3 HEAD@{7}: Branch: renamed refs/heads/master to refs/heads/main
-b840cd3 HEAD@{9}: commit (initial): Initial project structure

package/src/api/controllers/__tests__/tasks.controller.test.ts

@@ -1,74 +0,0 @@
-import { describe, it, expect, jest, beforeEach } from "@jest/globals";
-import { TasksController } from "../tasks.controller";
-import { TasksService } from "../../services/tasks.service";
-
-describe("TasksController", () => {
-  let service: jest.Mocked<TasksService>;
-  let controller: TasksController;
-
-  beforeEach(() => {
-    service = {
-      create: jest.fn() as jest.MockedFunction<TasksService["create"]>,
-      get: jest.fn() as jest.MockedFunction<TasksService["get"]>,
-      list: jest.fn() as jest.MockedFunction<TasksService["list"]>,
-      cancel: jest.fn() as jest.MockedFunction<TasksService["cancel"]>,
-    } as unknown as jest.Mocked<TasksService>;
-
-    controller = new TasksController(service);
-  });
-
-  it("crée une tâche", async () => {
-    const fakeTask = {
-      id: "123",
-      type: "x",
-      payload: {},
-      priority: "normal",
-      metadata: {},
-      status: "pending",
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    } as const;
-
-    service.create.mockReturnValue(fakeTask);
-
-    const req = { body: { type: "x", payload: {} } };
-
-    const result = await controller.create({ req, res: {}, params: {} });
-
-    expect(service.create).toHaveBeenCalled();
-    expect(result).toEqual({
-      status: 201,
-      body: fakeTask,
-    });
-  });
-
-  it("retourne 404 si tâche absente", async () => {
-    service.get.mockReturnValue(undefined);
-
-    const result = await controller.getOne({
-      req: {},
-      res: {},
-      params: { id: "123" },
-    });
-
-    expect(result).toEqual({
-      status: 404,
-      body: { error: "Task not found" },
-    });
-  });
-
-  it("annule une tâche", async () => {
-    service.cancel.mockReturnValue(true);
-
-    const result = await controller.cancel({
-      req: {},
-      res: {},
-      params: { id: "123" },
-    });
-
-    expect(result).toEqual({
-      status: 200,
-      body: { cancelled: true },
-    });
-  });
-});

package/src/api/controllers/events.controller.ts

@@ -1,10 +0,0 @@
-import { EventsService } from "../services/events.service";
-
-export class EventsController {
-  constructor(private readonly events: EventsService) {}
-
-  stream = async ({ res, query }: any) => {
-    const channels = query.channels?.split(",") ?? [];
-    return this.events.connect(res, channels);
-  };
-}

package/src/api/controllers/health.controller.ts

@@ -1,7 +0,0 @@
-import { Request, Response } from "express";
-
-export class HealthController {
-  check = (req: Request, res: Response) => {
-    res.json({ status: "ok", timestamp: Date.now() });
-  };
-}

package/src/api/controllers/tasks.controller.ts

@@ -1,41 +0,0 @@
-import { TasksService } from "../services/tasks.service";
-import { CreateTaskDtoValidator } from "../dto/create-task.dto";
-import { FilterTasksDtoValidator } from "../dto/filter-tasks.dto";
-
-export interface HandlerContext {
-  params: Record<string, string>;
-  req: any;
-  res: any;
-}
-
-export class TasksController {
-  constructor(private readonly tasks: TasksService) {}
-
-  list = async ({ req }: HandlerContext) => {
-    const dto = FilterTasksDtoValidator.validate(req.query);
-    const result = await this.tasks.list(dto);
-    return { status: 200, body: result };
-  };
-
-  create = async ({ req }: HandlerContext) => {
-    const dto = CreateTaskDtoValidator.validate(req.body);
-    const task = await this.tasks.create(dto);
-    return { status: 201, body: task };
-  };
-
-  getOne = async ({ params }: HandlerContext) => {
-    const task = await this.tasks.get(params.id);
-    if (!task) {
-      return { status: 404, body: { error: "Task not found" } };
-    }
-    return { status: 200, body: task };
-  };
-
-  cancel = async ({ params }: HandlerContext) => {
-    const ok = await this.tasks.cancel(params.id);
-    if (!ok) {
-      return { status: 404, body: { error: "Task not found" } };
-    }
-    return { status: 200, body: { cancelled: true } };
-  };
-}

package/src/api/dto/__tests__/create-task.dto.test.ts

@@ -1,41 +0,0 @@
-import { describe, it, expect } from "@jest/globals";
-import { CreateTaskDtoValidator } from "../create-task.dto";
-
-describe("CreateTaskDtoValidator", () => {
-  it("valide un DTO correct", () => {
-    const dto = CreateTaskDtoValidator.validate({
-      type: "crawl:api",
-      payload: { url: "https://example.com" },
-      priority: "high",
-    });
-
-    expect(dto).toEqual({
-      type: "crawl:api",
-      payload: { url: "https://example.com" },
-      priority: "high",
-      metadata: {},
-    });
-  });
-
-  it("applique les valeurs par défaut", () => {
-    const dto = CreateTaskDtoValidator.validate({
-      type: "ping",
-      payload: {},
-    });
-
-    expect(dto.priority).toBe("normal");
-    expect(dto.metadata).toEqual({});
-  });
-
-  it("rejette un type invalide", () => {
-    expect(() => CreateTaskDtoValidator.validate({ payload: {} })).toThrow(
-      "Invalid type",
-    );
-  });
-
-  it("rejette un payload invalide", () => {
-    expect(() =>
-      CreateTaskDtoValidator.validate({ type: "x", payload: null }),
-    ).toThrow("Invalid payload");
-  });
-});

package/src/api/dto/__tests__/filter-tasks.dto.test.ts

@@ -1,35 +0,0 @@
-import { describe, it, expect } from "@jest/globals";
-import { FilterTasksDtoValidator } from "../filter-tasks.dto";
-
-describe("FilterTasksDtoValidator", () => {
-  it("valide un query correct", () => {
-    const dto = FilterTasksDtoValidator.validate({
-      status: "running",
-      limit: "10",
-      type: "crawl:api",
-    });
-
-    expect(dto).toEqual({
-      status: "running",
-      limit: 10,
-      type: "crawl:api",
-    });
-  });
-
-  it("rejette un status invalide", () => {
-    expect(() =>
-      FilterTasksDtoValidator.validate({ status: "unknown" }),
-    ).toThrow("Invalid status");
-  });
-
-  it("rejette un limit invalide", () => {
-    expect(() => FilterTasksDtoValidator.validate({ limit: "-5" })).toThrow(
-      "Invalid limit",
-    );
-  });
-
-  it("accepte un query vide", () => {
-    const dto = FilterTasksDtoValidator.validate({});
-    expect(dto).toEqual({});
-  });
-});

package/src/api/dto/create-task.dto.ts

@@ -1,33 +0,0 @@
-export interface CreateTaskDto {
-  type: string;
-  payload: Record<string, any>;
-  priority?: "low" | "normal" | "high";
-  metadata?: Record<string, any>;
-}
-
-export class CreateTaskDtoValidator {
-  static validate(input: any): CreateTaskDto {
-    if (!input || typeof input !== "object") {
-      throw new Error("Invalid body: expected object");
-    }
-
-    if (!input.type || typeof input.type !== "string") {
-      throw new Error("Invalid type: expected non-empty string");
-    }
-
-    if (!input.payload || typeof input.payload !== "object") {
-      throw new Error("Invalid payload: expected object");
-    }
-
-    if (input.priority && !["low", "normal", "high"].includes(input.priority)) {
-      throw new Error("Invalid priority: must be low, normal or high");
-    }
-
-    return {
-      type: input.type,
-      payload: input.payload,
-      priority: input.priority ?? "normal",
-      metadata: input.metadata ?? {},
-    };
-  }
-}

package/src/api/dto/filter-tasks.dto.ts

@@ -1,33 +0,0 @@
-export interface FilterTasksDto {
-  status?: "pending" | "running" | "completed" | "failed";
-  limit?: number;
-  type?: string;
-}
-
-export class FilterTasksDtoValidator {
-  static validate(query: any): FilterTasksDto {
-    const dto: FilterTasksDto = {};
-
-    if (query.status) {
-      const allowed = ["pending", "running", "completed", "failed"];
-      if (!allowed.includes(query.status)) {
-        throw new Error("Invalid status");
-      }
-      dto.status = query.status;
-    }
-
-    if (query.limit) {
-      const n = Number(query.limit);
-      if (isNaN(n) || n <= 0) {
-        throw new Error("Invalid limit");
-      }
-      dto.limit = n;
-    }
-
-    if (query.type) {
-      dto.type = String(query.type);
-    }
-
-    return dto;
-  }
-}

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

@@ -1,41 +0,0 @@
-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/__tests__/tasks.service.test.ts

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