@nocobase/plugin-async-task-manager 1.9.0-beta.4 → 1.9.0-beta.6

package/dist/server/base-task-manager.js

@@ -39,119 +39,227 @@ __export(base_task_manager_exports, {
   BaseTaskManager: () => BaseTaskManager
 });
 module.exports = __toCommonJS(base_task_manager_exports);
-var import_events = require("events");
-var import_p_queue = __toESM(require("p-queue"));
-class BaseTaskManager extends import_events.EventEmitter {
+var import_lodash = require("lodash");
+var import_constants = require("../common/constants");
+var import_crypto = require("crypto");
+var import_plugin = __toESM(require("./plugin"));
+const WORKER_JOB_ASYNC_TASK_PROCESS = "async-task:process";
+class BaseTaskManager {
   taskTypes = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
   // Clean up completed tasks after 30 minutes by default
   cleanupDelay = 30 * 60 * 1e3;
+  cleanupTimer;
   logger;
   app;
-  queue;
-  queueOptions;
+  progressThrottles = /* @__PURE__ */ new Map();
+  concurrency = process.env.ASYNC_TASK_MAX_CONCURRENCY ? Number.parseInt(process.env.ASYNC_TASK_MAX_CONCURRENCY, 10) : 3;
+  idle = () => {
+    return this.app.serving(WORKER_JOB_ASYNC_TASK_PROCESS) && this.tasks.size < this.concurrency;
+  };
+  onQueueTask = async ({ id }) => {
+    const task = await this.prepareTask(id);
+    await this.runTask(task);
+  };
+  onTaskProgress = (item) => {
+    const userId = item.createdById;
+    this.logger.trace(`Task ${item.id} of user(${userId}) progress: ${item.progressCurrent} / ${item.progressTotal}`);
+    if (userId) {
+      const throttledEmit = this.getThrottledProgressEmitter(item.id, userId);
+      throttledEmit(item);
+    }
+  };
+  onTaskAfterCreate = (task) => {
+    const userId = task.createdById;
+    if (userId) {
+      this.app.emit("ws:sendToUser", {
+        userId,
+        message: {
+          type: "async-tasks:created",
+          payload: task.toJSON()
+        }
+      });
+    }
+  };
+  onTaskStatusChanged = (task) => {
+    if (!task.changed("status")) return;
+    const userId = task.createdById;
+    if (!userId) return;
+    this.app.emit("ws:sendToUser", {
+      userId,
+      message: {
+        type: "async-tasks:status",
+        payload: {
+          taskId: task.id,
+          status: task.status
+        }
+      }
+    });
+    if ([import_constants.TASK_STATUS.RUNNING, import_constants.TASK_STATUS.PENDING].includes(task.status)) {
+      const throttled = this.progressThrottles.get(task.id);
+      if (throttled) {
+        throttled.cancel();
+        this.progressThrottles.delete(task.id);
+      }
+    }
+    if (task.doneAt) {
+      this.progressThrottles.delete(task.id);
+      this.tasks.delete(task.id);
+    }
+    if (task.status === import_constants.TASK_STATUS.SUCCEEDED) {
+      this.app.emit("workflow:dispatch");
+    }
+  };
+  onTaskAfterDelete = (task) => {
+    this.tasks.delete(task.id);
+    this.progressThrottles.delete(task.id);
+    const userId = task.createdById;
+    if (userId) {
+      this.app.emit("ws:sendToUser", {
+        userId,
+        message: {
+          type: "async-tasks:deleted",
+          payload: { id: task.id }
+        }
+      });
+    }
+  };
+  onTaskCancelSignal = async (data) => {
+    return this.cancelTask(data.id, true);
+  };
+  cleanup = async () => {
+    this.logger.debug("Running cleanup for completed tasks...");
+    const TaskRepo = this.app.db.getRepository("asyncTasks");
+    const tasksToCleanup = await TaskRepo.find({
+      fields: ["id"],
+      filter: {
+        $or: [
+          {
+            status: [import_constants.TASK_STATUS.SUCCEEDED, import_constants.TASK_STATUS.FAILED],
+            doneAt: {
+              $lt: new Date(Date.now() - this.cleanupDelay)
+            }
+          },
+          {
+            status: import_constants.TASK_STATUS.CANCELED
+          }
+        ]
+      }
+    });
+    this.logger.debug(`Found ${tasksToCleanup.length} tasks to cleanup`);
+    for (const task of tasksToCleanup) {
+      this.tasks.delete(task.id);
+      this.progressThrottles.delete(task.id);
+    }
+    await TaskRepo.destroy({
+      filterByTk: tasksToCleanup.map((task) => task.id),
+      individualHooks: true
+    });
+  };
+  getThrottledProgressEmitter(taskId, userId) {
+    if (!this.progressThrottles.has(taskId)) {
+      this.progressThrottles.set(
+        taskId,
+        (0, import_lodash.throttle)(
+          (record) => {
+            this.app.emit("ws:sendToUser", {
+              userId,
+              message: {
+                type: "async-tasks:progress",
+                payload: record.toJSON()
+              }
+            });
+          },
+          500,
+          { leading: true, trailing: true }
+        )
+      );
+    }
+    return this.progressThrottles.get(taskId);
+  }
   setLogger(logger) {
     this.logger = logger;
   }
   setApp(app) {
     this.app = app;
-  }
-  scheduleCleanup(taskId) {
-    setTimeout(() => {
-      this.tasks.delete(taskId);
-      this.logger.debug(`Task ${taskId} cleaned up after ${this.cleanupDelay}ms`);
-    }, this.cleanupDelay);
-  }
-  constructor() {
-    super();
-    this.queueOptions = {
-      concurrency: process.env.ASYNC_TASK_MAX_CONCURRENCY ? parseInt(process.env.ASYNC_TASK_MAX_CONCURRENCY) : 3,
-      autoStart: true
-    };
-    this.queue = new import_p_queue.default(this.queueOptions);
-    this.queue.on("idle", () => {
-      this.logger.debug("Task queue is idle");
-      this.emit("queueIdle");
-    });
-    this.queue.on("add", () => {
-      this.logger.debug(`Task added to queue. Size: ${this.queue.size}, Pending: ${this.queue.pending}`);
-      this.emit("queueAdd", { size: this.queue.size, pending: this.queue.pending });
+    const plugin = this.app.pm.get(import_plugin.default);
+    this.app.on("afterStart", () => {
+      this.app.eventQueue.subscribe(`${plugin.name}.task`, {
+        idle: this.idle,
+        process: this.onQueueTask,
+        concurrency: this.concurrency
+      });
+      this.app.pubSubManager.subscribe(`${plugin.name}.task.cancel`, this.onTaskCancelSignal);
+      if (!this.cleanupTimer) {
+        this.cleanupTimer = setInterval(this.cleanup, 60 * 1e3);
+      }
     });
-  }
-  enqueueTask(task) {
-    const taskHandler = async () => {
-      if (task.status.type === "pending") {
-        try {
-          this.logger.debug(`Starting execution of task ${task.taskId} from queue`);
-          await task.run();
-        } catch (error) {
-          this.logger.error(`Error executing task ${task.taskId} from queue: ${error.message}`);
-        }
+    this.app.on("beforeStop", () => {
+      if (this.cleanupTimer) {
+        clearInterval(this.cleanupTimer);
+        this.cleanupTimer = null;
       }
-    };
-    this.queue.add(taskHandler);
-  }
-  pauseQueue() {
-    this.logger.info("Pausing task queue");
-    this.queue.pause();
-    this.emit("queuePaused");
+      this.app.eventQueue.unsubscribe(`${plugin.name}.task`);
+      this.app.pubSubManager.unsubscribe(`${plugin.name}.task.cancel`, this.onTaskCancelSignal);
+    });
+    this.app.db.on("asyncTasks.afterCreate", this.onTaskAfterCreate);
+    this.app.db.on("asyncTasks.afterUpdate", this.onTaskStatusChanged);
+    this.app.db.on("asyncTasks.afterDestroy", this.onTaskAfterDelete);
   }
-  resumeQueue() {
-    this.logger.info("Resuming task queue");
-    this.queue.start();
-    this.emit("queueResumed");
+  enqueueTask(task, queueOptions) {
+    const plugin = this.app.pm.get(import_plugin.default);
+    this.app.eventQueue.publish(`${plugin.name}.task`, { id: task.record.id }, queueOptions);
   }
-  async cancelTask(taskId) {
+  async cancelTask(taskId, externally = false) {
     const task = this.tasks.get(taskId);
-    if (!task) {
-      this.logger.warn(`Attempted to cancel non-existent task ${taskId}`);
-      return false;
-    }
-    this.logger.info(`Cancelling task ${taskId}, type: ${task.constructor.name}, tags: ${JSON.stringify(task.tags)}`);
-    if (task.status.type === "pending") {
-      await task.statusChange({ type: "cancelled" });
-      return true;
+    if (task) {
+      this.logger.info(`Cancelling task ${taskId}, type: ${task.constructor.name}`);
+      this.progressThrottles.delete(taskId);
+      task.cancel();
+      await task.record.update({
+        status: import_constants.TASK_STATUS.CANCELED,
+        doneAt: /* @__PURE__ */ new Date()
+      });
+    } else {
+      if (externally) {
+        this.logger.info(`Task ${taskId} not found on this instance, skip`);
+        return;
+      }
+      this.logger.warn(`Task ${taskId} not found on this instance, broadcasting to other instances...`);
+      const plugin = this.app.pm.get(import_plugin.default);
+      this.app.pubSubManager.publish(`${plugin.name}.task.cancel`, { id: taskId }, { skipSelf: true });
+      const TaskRepo = this.app.db.getRepository("asyncTasks");
+      await TaskRepo.update({
+        filterByTk: taskId,
+        values: {
+          status: import_constants.TASK_STATUS.CANCELED,
+          doneAt: /* @__PURE__ */ new Date()
+        }
+      });
     }
-    return task.cancel();
   }
-  createTask(options) {
-    const taskType = this.taskTypes.get(options.type);
+  async createTask(data, { useQueue, ...options } = {}) {
+    const taskType = this.taskTypes.get(data.type);
     if (!taskType) {
-      this.logger.error(`Task type not found: ${options.type}, params: ${JSON.stringify(options.params)}`);
-      throw new Error(`Task type ${options.type} not found`);
+      this.logger.error(`Task type not found: ${data.type}, params: ${JSON.stringify(data.params)}`);
+      throw new Error(`Task type ${data.type} not found`);
     }
-    this.logger.info(
-      `Creating task of type: ${options.type}, params: ${JSON.stringify(options.params)}, tags: ${JSON.stringify(
-        options.tags
-      )}`
-    );
-    const task = new taskType(options.params, options.tags);
-    task.title = options.title;
-    task.setLogger(this.logger);
-    task.setApp(this.app);
-    task.setContext(options.context);
-    this.tasks.set(task.taskId, task);
-    this.logger.info(
-      `Created new task ${task.taskId} of type ${options.type}, params: ${JSON.stringify(
-        options.params
-      )}, tags: ${JSON.stringify(options.tags)}, title: ${task.title}`
-    );
-    this.emit("taskCreated", { task });
-    if (options.useQueue) {
-      this.enqueueTask(task);
-    }
-    task.on("progress", (progress) => {
-      this.logger.debug(`Task ${task.taskId} progress: ${progress}`);
-      this.emit("taskProgress", { task, progress });
-    });
-    task.on("statusChange", (status) => {
-      if (["success", "failed"].includes(status.type)) {
-        this.scheduleCleanup(task.taskId);
-      } else if (status.type === "cancelled") {
-        this.tasks.delete(task.taskId);
-      }
-      this.emit("taskStatusChange", { task, status });
+    const values = taskType.defaults({
+      id: (0, import_crypto.randomUUID)(),
+      status: import_constants.TASK_STATUS.PENDING,
+      ...data
     });
+    const DBTaskModel = this.app.db.getModel("asyncTasks");
+    const record = await DBTaskModel.create(values, options);
+    this.logger.debug(`Creating task of type: ${data.type}`);
+    this.logger.debug(`Task data: ${JSON.stringify(data)}`);
+    const task = new taskType(record);
+    this.logger.info(`New task of type: ${data.type} created as ${record.id}`);
+    if (useQueue) {
+      this.logger.debug(`New task ${record.id} will be sent to queue for processing`);
+      const queueOptions = typeof useQueue === "object" ? useQueue : {};
+      this.enqueueTask(task, queueOptions);
+    }
     return task;
   }
   getTask(taskId) {
@@ -160,7 +268,7 @@ class BaseTaskManager extends import_events.EventEmitter {
       this.logger.debug(`Task not found: ${taskId}`);
       return void 0;
     }
-    this.logger.debug(`Retrieved task ${taskId}, type: ${task.constructor.name}, status: ${task.status.type}`);
+    this.logger.debug(`Retrieved task ${taskId}, type: ${task.constructor.name}, status: ${task.record.status}`);
     return task;
   }
   async getTaskStatus(taskId) {
@@ -169,20 +277,41 @@ class BaseTaskManager extends import_events.EventEmitter {
       this.logger.warn(`Attempted to get status of non-existent task ${taskId}`);
       throw new Error(`Task ${taskId} not found`);
     }
-    this.logger.debug(`Getting status for task ${taskId}, current status: ${task.status.type}`);
-    return task.status;
+    this.logger.debug(`Getting status for task ${taskId}, current status: ${task.record.status}`);
+    return task.record.status;
   }
   registerTaskType(taskType) {
     this.logger.debug(`Registering task type: ${taskType.type}`);
     this.taskTypes.set(taskType.type, taskType);
   }
-  async getTasksByTag(tagKey, tagValue) {
-    this.logger.debug(`Getting tasks by tag - key: ${tagKey}, value: ${tagValue}`);
-    const tasks = Array.from(this.tasks.values()).filter((task) => {
-      return task.tags[tagKey] == tagValue;
+  async prepareTask(id) {
+    const TaskRepo = this.app.db.getRepository("asyncTasks");
+    const record = await TaskRepo.findOne({
+      filterByTk: id
     });
-    this.logger.debug(`Found ${tasks.length} tasks with tag ${tagKey}=${tagValue}`);
-    return tasks;
+    const taskType = this.taskTypes.get(record.type);
+    if (!taskType) {
+      this.logger.error(`Task type not found: ${record.type} (#${id})`);
+      throw new Error(`Task type ${record.type} not found`);
+    }
+    const task = new taskType(record);
+    return task;
+  }
+  async runTask(task) {
+    if (task.record.status === import_constants.TASK_STATUS.PENDING) {
+      task.setLogger(this.logger);
+      task.setApp(this.app);
+      task.onProgress = this.onTaskProgress;
+      this.tasks.set(task.record.id, task);
+      try {
+        this.logger.debug(`Starting execution of task ${task.record.id} from queue`);
+        await task.run();
+      } catch (error) {
+        this.logger.error(`Error executing task ${task.record.id} from queue: ${error.message}`);
+      } finally {
+        this.tasks.delete(task.record.id);
+      }
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/collections/asyncTasks.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { CollectionOptions } from '@nocobase/database';
+declare const _default: CollectionOptions;
+export default _default;

package/dist/server/collections/asyncTasks.js

@@ -0,0 +1,43 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var asyncTasks_exports = {};
+__export(asyncTasks_exports, {
+  default: () => asyncTasks_default
+});
+module.exports = __toCommonJS(asyncTasks_exports);
+var import_asyncTasks = __toESM(require("../../common/collections/asyncTasks"));
+var asyncTasks_default = import_asyncTasks.default;

package/dist/server/command-task-type.d.ts

@@ -1,8 +1,17 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
 /// <reference types="node" />
 import { Worker } from 'worker_threads';
 import { TaskType } from './task-type';
 export declare class CommandTaskType extends TaskType {
     static type: string;
     workerThread: Worker;
+    static defaults(data: any): any;
     execute(): Promise<unknown>;
 }

package/dist/server/command-task-type.js

@@ -47,9 +47,14 @@ var import_task_type = require("./task-type");
 class CommandTaskType extends import_task_type.TaskType {
   static type = "command";
   workerThread;
+  static defaults(data) {
+    var _a;
+    (_a = data.argv) == null ? void 0 : _a.push(`--taskId=${data.id}`);
+    return data;
+  }
   async execute() {
     var _a;
-    const { argv } = this.options;
+    const { argv } = this.record.params;
     const isDev = (((_a = import_node_process.default.argv[1]) == null ? void 0 : _a.endsWith(".ts")) || import_node_process.default.argv[1].includes("tinypool")) ?? false;
     const appRoot = import_node_process.default.env.APP_PACKAGE_ROOT || "packages/core/app";
     const workerPath = import_path.default.resolve(import_node_process.default.cwd(), appRoot, isDev ? "src/index.ts" : "lib/index.js");
@@ -57,7 +62,7 @@ class CommandTaskType extends import_task_type.TaskType {
       var _a2, _b;
       try {
         (_a2 = this.logger) == null ? void 0 : _a2.info(
-          `Creating worker for task ${this.taskId} - path: ${workerPath}, argv: ${JSON.stringify(
+          `Creating worker for task ${this.record.id} - path: ${workerPath}, argv: ${JSON.stringify(
             argv
           )}, isDev: ${isDev}`
         );
@@ -65,38 +70,44 @@ class CommandTaskType extends import_task_type.TaskType {
           execArgv: isDev ? ["--require", "tsx/cjs"] : [],
           workerData: {
             argv
+          },
+          env: {
+            ...import_node_process.default.env,
+            WORKER_MODE: "-"
           }
         });
         this.workerThread = worker;
-        (_b = this.logger) == null ? void 0 : _b.debug(`Worker created successfully for task ${this.taskId}`);
+        (_b = this.logger) == null ? void 0 : _b.debug(`Worker created successfully for task ${this.record.id}`);
         let isCancelling = false;
         this.abortController.signal.addEventListener("abort", () => {
           var _a3;
           isCancelling = true;
-          (_a3 = this.logger) == null ? void 0 : _a3.info(`Terminating worker for task ${this.taskId} due to cancellation`);
+          (_a3 = this.logger) == null ? void 0 : _a3.info(`Terminating worker for task ${this.record.id} due to cancellation`);
           worker.terminate();
         });
         worker.on("message", (message) => {
           var _a3, _b2;
-          (_a3 = this.logger) == null ? void 0 : _a3.debug(`Worker message received for task ${this.taskId} - type: ${message.type}`);
+          (_a3 = this.logger) == null ? void 0 : _a3.trace(`Worker message received for task ${this.record.id} - type: ${message.type}`);
           if (message.type === "progress") {
             this.reportProgress(message.payload);
           }
           if (message.type === "success") {
             (_b2 = this.logger) == null ? void 0 : _b2.info(
-              `Worker completed successfully for task ${this.taskId} with payload: ${JSON.stringify(message.payload)}`
+              `Worker completed successfully for task ${this.record.id} with payload: ${JSON.stringify(
+                message.payload
+              )}`
             );
             resolve(message.payload);
           }
         });
         worker.on("error", (error) => {
           var _a3;
-          (_a3 = this.logger) == null ? void 0 : _a3.error(`Worker error for task ${this.taskId}`, error);
+          (_a3 = this.logger) == null ? void 0 : _a3.error(`Worker error for task ${this.record.id}`, error);
           reject(error);
         });
         worker.on("exit", (code) => {
           var _a3;
-          (_a3 = this.logger) == null ? void 0 : _a3.info(`Worker exited for task ${this.taskId} with code ${code}`);
+          (_a3 = this.logger) == null ? void 0 : _a3.info(`Worker exited for task ${this.record.id} with code ${code}`);
           if (isCancelling) {
             reject(new import_async_task_manager.CancelError());
           } else if (code !== 0) {

package/dist/server/interfaces/async-task-manager.d.ts

@@ -6,62 +6,25 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-/// <reference types="node" />
 import { Logger } from '@nocobase/logger';
-import { ITask, TaskConstructor } from './task';
-import { Application } from '@nocobase/server';
-import { EventEmitter } from 'events';
-export type TaskOptions = any;
-export interface CreateTaskOptions {
-    type: string;
-    params: TaskOptions;
-    tags?: Record<string, string>;
-    title?: {
-        actionType: string;
-        collection: string;
-        dataSource: string;
-    };
+import { ITask, TaskConstructor, TaskModel } from './task';
+import { Application, QueueMessageOptions } from '@nocobase/server';
+import { TaskId, TaskStatus } from '../../common/types';
+import { Transactionable } from '@nocobase/database';
+export interface CreateTaskOptions extends Transactionable {
+    useQueue?: boolean | QueueMessageOptions;
     context?: any;
-    useQueue?: boolean;
 }
-export type TaskId = string;
-export type TaskStatus = PendingStatus | SuccessStatus<any> | RunningStatus | FailedStatus | CancelledStatus;
-export type ProgressIndicator = 'spinner' | 'progress' | 'success' | 'error';
-export interface PendingStatus {
-    type: 'pending';
-    indicator?: 'spinner';
-}
-export interface SuccessStatus<T = any> {
-    type: 'success';
-    indicator?: 'success';
-    resultType?: 'file' | 'data';
-    payload?: T;
-}
-export interface RunningStatus {
-    type: 'running';
-    indicator: 'progress';
-}
-export interface FailedStatus {
-    type: 'failed';
-    indicator?: 'error';
-    errors: Array<{
-        message: string;
-        code?: number;
-    }>;
-}
-export interface CancelledStatus {
-    type: 'cancelled';
-}
-export interface AsyncTasksManager extends EventEmitter {
-    queue: any;
+export interface AsyncTasksManager {
+    concurrency: number;
     setLogger(logger: Logger): void;
     setApp(app: Application): void;
     registerTaskType(taskType: TaskConstructor): void;
-    createTask<T>(options: CreateTaskOptions): ITask;
-    getTasksByTag(tagKey: string, tagValue: string): Promise<ITask[]>;
-    cancelTask(taskId: TaskId): Promise<boolean>;
+    createTask(data: Omit<TaskModel, 'id'>, options?: CreateTaskOptions): Promise<ITask>;
+    cancelTask(taskId: TaskId): Promise<void>;
     getTaskStatus(taskId: TaskId): Promise<TaskStatus>;
     getTask(taskId: TaskId): ITask | undefined;
+    runTask(task: ITask): Promise<void>;
 }
 export declare class CancelError extends Error {
     constructor(message?: string);

package/dist/server/interfaces/task.d.ts

@@ -6,41 +6,43 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-/// <reference types="node" />
 import { Logger } from '@nocobase/logger';
-import { TaskStatus } from './async-task-manager';
-import { EventEmitter } from 'events';
 import { Application } from '@nocobase/server';
-export interface ITask extends EventEmitter {
-    taskId: string;
+import { Model } from '@nocobase/database';
+import { TaskId, TaskStatus } from '../../common/types';
+export declare class TaskModel extends Model {
+    id: TaskId;
+    origin: string;
+    type: string;
+    title?: string;
+    params: Record<string, any>;
+    tags?: Record<string, string>;
     status: TaskStatus;
-    progress: {
-        total: number;
-        current: number;
-    };
-    startedAt: Date;
-    fulfilledAt: Date;
-    tags: Record<string, string>;
-    createdAt: Date;
-    title?: any;
-    isCancelled: boolean;
-    context?: any;
+    progressTotal?: number;
+    progressCurrent?: number;
+    createdAt?: Date;
+    startedAt?: Date;
+    doneAt?: Date;
+    createdById?: number;
+}
+export interface ITask {
+    record: TaskModel;
+    onProgress: (record: TaskModel) => void;
     setLogger(logger: Logger): void;
     setApp(app: Application): void;
-    setContext(context: any): void;
-    cancel(): Promise<boolean>;
-    statusChange: (status: TaskStatus) => Promise<void>;
+    isCanceled: boolean;
+    cancel(options?: {
+        silent?: boolean;
+    }): any;
     execute(): Promise<any>;
     reportProgress(progress: {
         total: number;
         current: number;
     }): void;
     run(): Promise<void>;
-    toJSON(options?: {
-        raw?: boolean;
-    }): any;
+    toJSON<TaskModelAttributes>(): TaskModelAttributes;
 }
 export interface TaskConstructor {
     type: string;
-    new (options: any, tags?: Record<string, string>): ITask;
+    new (model: TaskModel): ITask;
 }