feat: add create and delete functionality for cron tasks in API and UI

- Implemented create and delete endpoints in CronController and CronService, allowing for management of cron tasks.
- Updated cron.controller.spec.ts to include tests for the new create and delete functionalities.
- Enhanced cron.vue to provide UI elements for creating and deleting cron tasks, with permission checks for user actions.
- Improved error handling for task deletion when the specified task does not exist.

Author: tacxou

apps/api/src/core/cron/cron.controller.ts

@@ -3,6 +3,7 @@ import {
   ConflictException,
   Controller,
   DefaultValuePipe,
+  Delete,
   Get,
   HttpStatus,
   NotFoundException,
@@ -20,7 +21,7 @@ import { UseRoles } from '~/_common/decorators/use-roles.decorator';
 import { AC_ACTIONS, AC_DEFAULT_POSSESSION } from '~/_common/types/ac-types';
 import { ApiPaginatedDecorator } from '~/_common/decorators/api-paginated.decorator';
 import { PickProjectionHelper } from '~/_common/helpers/pick-projection.helper';
-import { CronDto, CronUpdateDto } from './_dto/cron.dto';
+import { CronCreateDto, CronDto, CronUpdateDto } from './_dto/cron.dto';
 import { PartialProjectionType } from '~/_common/types/partial-projection.type';
 import { ApiReadResponseDecorator } from '~/_common/decorators/api-read-response.decorator';
 import { IsBoolean } from 'class-validator';
@@ -93,6 +94,22 @@ export class CronController {
     });
   }
 
+  @Post()
+  @UseRoles({
+    resource: '/core/cron',
+    action: AC_ACTIONS.CREATE,
+    possession: AC_DEFAULT_POSSESSION,
+  })
+  @ApiReadResponseDecorator(CronDto)
+  public async create(@Body() body: CronCreateDto, @Res() res: Response): Promise<Response> {
+    const data = await this.cronService.create(body);
+
+    return res.status(HttpStatus.CREATED).json({
+      statusCode: HttpStatus.CREATED,
+      data,
+    });
+  }
+
   @Get(':name')
   @UseRoles({
     resource: '/core/cron',
@@ -200,4 +217,25 @@ export class CronController {
       },
     });
   }
+
+  @Delete(':name')
+  @UseRoles({
+    resource: '/core/cron',
+    action: AC_ACTIONS.DELETE,
+    possession: AC_DEFAULT_POSSESSION,
+  })
+  public async delete(@Param('name') name: string, @Res() res: Response): Promise<Response> {
+    const deleted = await this.cronService.delete(name);
+    if (!deleted) {
+      throw new NotFoundException(`Cron task <${name}> not found`);
+    }
+
+    return res.json({
+      statusCode: HttpStatus.OK,
+      data: {
+        name,
+        deleted: true,
+      },
+    });
+  }
 }

apps/api/src/core/cron/cron.service.ts

@@ -1,12 +1,23 @@
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, ConflictException, Injectable, Logger } from '@nestjs/common';
 import { SchedulerRegistry } from '@nestjs/schedule';
 import { CronHooksService } from './cron-hooks.service';
 import { pick } from 'radash';
 import { ConfigTaskDTO, CronTaskDTO } from './_dto/config-task.dto';
-import { CronUpdateDto } from './_dto/cron.dto';
+import { CronCreateDto, CronUpdateDto } from './_dto/cron.dto';
 import { CronJob } from 'cron';
 import path from 'node:path';
-import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  readSync,
+  readdirSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs';
 import { ConfigService } from '@nestjs/config';
 import { toSafeHandlerName } from '~/_common/functions/handler-logger';
 import { formatValidationErrors } from '~/_common/functions/format-validation-errors.function';
@@ -118,6 +129,55 @@ export class CronService {
     return this.update(name, { enabled });
   }
 
+  public async create(payload: CronCreateDto): Promise<(CronTaskDTO & { _job: Partial<CronJob> }) | null> {
+    const existing = this.cronHooksService.getCronTasks().find((task) => task.name === payload.name);
+    if (existing) {
+      throw new ConflictException(`Cron task <${payload.name}> already exists`);
+    }
+
+    try {
+      if (payload.options !== undefined) {
+        validateCronTaskOptions(payload.handler, payload.options);
+      }
+    } catch (error) {
+      if (error instanceof BadRequestException) {
+        throw error;
+      }
+      throw new BadRequestException(`Options invalides pour le handler "${payload.handler}".`);
+    }
+
+    const task = plainToInstance(CronTaskDTO, payload);
+
+    try {
+      await validateOrReject(task, { whitelist: true });
+    } catch (errors) {
+      throw new BadRequestException(formatValidationErrors(errors, payload.name));
+    }
+
+    const created = this.createTaskInConfig(task);
+    if (!created) {
+      throw new BadRequestException(`Impossible de créer la tâche cron <${payload.name}> dans la configuration.`);
+    }
+
+    await this.cronHooksService.syncCronJobs();
+    return this.read(payload.name);
+  }
+
+  public async delete(name: string): Promise<boolean> {
+    const current = this.cronHooksService.getCronTasks().find((task) => task.name === name);
+    if (!current) {
+      return false;
+    }
+
+    const deleted = this.deleteTaskFromConfig(name);
+    if (!deleted) {
+      return false;
+    }
+
+    await this.cronHooksService.syncCronJobs();
+    return true;
+  }
+
   public async update(
     name: string,
     payload: CronUpdateDto,
@@ -278,16 +338,72 @@ export class CronService {
     };
   }
 
-  private updateTaskInConfig(name: string, updater: (task: CronTaskDTO) => void): boolean {
-    const configDir = path.join(process.cwd(), 'configs', 'cron');
+  private getConfigDir(): string {
+    return path.join(process.cwd(), 'configs', 'cron');
+  }
+
+  private listConfigFiles(): string[] {
+    const configDir = this.getConfigDir();
     if (!existsSync(configDir)) {
-      return false;
+      return [];
+    }
+
+    return readdirSync(configDir).filter((file) => file.endsWith('.yml') || file.endsWith('.yaml'));
+  }
+
+  private createTaskInConfig(task: CronTaskDTO): boolean {
+    const configDir = this.getConfigDir();
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+
+    const fileName = `${toSafeHandlerName(task.name)}.yml`;
+    const filePath = path.join(configDir, fileName);
+
+    if (existsSync(filePath)) {
+      const raw = readFileSync(filePath, 'utf-8');
+      const parsed = parse(raw) as ConfigTaskDTO;
+      if (parsed?.tasks?.length) {
+        throw new ConflictException(`Le fichier de configuration <${fileName}> existe déjà.`);
+      }
+    }
+
+    writeFileSync(filePath, stringify({ tasks: [task] } satisfies ConfigTaskDTO));
+    return true;
+  }
+
+  private deleteTaskFromConfig(name: string): boolean {
+    for (const file of this.listConfigFiles()) {
+      const filePath = path.join(this.getConfigDir(), file);
+      const raw = readFileSync(filePath, 'utf-8');
+      const parsed = parse(raw) as ConfigTaskDTO;
+      const tasks = parsed?.tasks;
+
+      if (!tasks || !Array.isArray(tasks)) {
+        continue;
+      }
+
+      const taskIndex = tasks.findIndex((task) => task.name === name);
+      if (taskIndex === -1) {
+        continue;
+      }
+
+      tasks.splice(taskIndex, 1);
+      if (tasks.length === 0) {
+        unlinkSync(filePath);
+      } else {
+        writeFileSync(filePath, stringify(parsed));
+      }
+
+      return true;
     }
 
-    const files = readdirSync(configDir).filter((file) => file.endsWith('.yml') || file.endsWith('.yaml'));
+    return false;
+  }
 
-    for (const file of files) {
-      const filePath = path.join(configDir, file);
+  private updateTaskInConfig(name: string, updater: (task: CronTaskDTO) => void): boolean {
+    for (const file of this.listConfigFiles()) {
+      const filePath = path.join(this.getConfigDir(), file);
       const raw = readFileSync(filePath, 'utf-8');
       const parsed = parse(raw) as ConfigTaskDTO;
       const tasks = parsed?.tasks;

apps/api/tests/unit/core/cron/cron.controller.spec.ts

@@ -9,6 +9,8 @@ describe('CronController', () => {
   const update = jest.fn();
   const getConsoleHandlers = jest.fn();
   const runImmediately = jest.fn();
+  const create = jest.fn();
+  const deleteTask = jest.fn();
 
   const cronService = {
     search,
@@ -18,6 +20,8 @@ describe('CronController', () => {
     update,
     getConsoleHandlers,
     runImmediately,
+    create,
+    delete: deleteTask,
   };
 
   const createRes = () => {
@@ -160,4 +164,58 @@ describe('CronController', () => {
       },
     });
   });
+
+  it('should return created task on create', async () => {
+    create.mockResolvedValue({ name: 'task-new', enabled: false });
+    const res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    };
+
+    await controller.create(
+      {
+        name: 'task-new',
+        description: 'new task',
+        enabled: false,
+        schedule: '0 * * * *',
+        handler: 'agents-list',
+      } as any,
+      res as any,
+    );
+
+    expect(create).toHaveBeenCalledWith({
+      name: 'task-new',
+      description: 'new task',
+      enabled: false,
+      schedule: '0 * * * *',
+      handler: 'agents-list',
+    });
+    expect(res.status).toHaveBeenCalledWith(201);
+    expect(res.json).toHaveBeenCalledWith({
+      statusCode: 201,
+      data: { name: 'task-new', enabled: false },
+    });
+  });
+
+  it('should throw NotFoundException when deleting missing task', async () => {
+    deleteTask.mockResolvedValue(false);
+
+    await expect(controller.delete('missing-task', {} as any)).rejects.toThrow(NotFoundException);
+  });
+
+  it('should return deleted payload on delete', async () => {
+    deleteTask.mockResolvedValue(true);
+    const res = createRes();
+
+    await controller.delete('task-1', res as any);
+
+    expect(deleteTask).toHaveBeenCalledWith('task-1');
+    expect(res.json).toHaveBeenCalledWith({
+      statusCode: 200,
+      data: {
+        name: 'task-1',
+        deleted: true,
+      },
+    });
+  });
 });