@j3r3mcdev/oast-server 1.0.0 → 1.1.0

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

@@ -1,35 +1,35 @@
-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({});
-  });
-});
+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 +1,33 @@
-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 ?? {},
-    };
-  }
-}
+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 +1,33 @@
-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;
-  }
-}
+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 +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/__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;
+  }
+}