@j3r3mcdev/oast-server 1.1.5 → 1.1.7

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

@@ -1,74 +1,74 @@
-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 },
-    });
-  });
-});
+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 +1,10 @@
-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);
-  };
-}
+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 +1,7 @@
-import { Request, Response } from "express";
-
-export class HealthController {
-  check = (req: Request, res: Response) => {
-    res.json({ status: "ok", timestamp: Date.now() });
-  };
-}
+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 +1,41 @@
-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 } };
-  };
-}
+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 +1,41 @@
-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");
-  });
-});
+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 +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 }),
+    );
+  });
+});