@j3r3mcdev/oast-server 1.1.6 → 1.1.8

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

package/src/api/sse/events.stream.ts

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