@nocobase/plugin-async-task-manager 1.9.0-beta.5 → 1.9.0-beta.7

package/dist/server/interfaces/task.js

@@ -11,6 +11,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 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))
@@ -21,4 +25,28 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var task_exports = {};
+__export(task_exports, {
+  TaskModel: () => TaskModel
+});
 module.exports = __toCommonJS(task_exports);
+var import_database = require("@nocobase/database");
+class TaskModel extends import_database.Model {
+  id;
+  origin;
+  type;
+  title;
+  params;
+  tags;
+  status;
+  progressTotal;
+  progressCurrent;
+  createdAt;
+  startedAt;
+  doneAt;
+  createdById;
+  // Additional fields can be added as needed
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TaskModel
+});

package/dist/server/plugin.d.ts

@@ -7,11 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Plugin } from '@nocobase/server';
-export declare class PluginAsyncExportServer extends Plugin {
-    private progressThrottles;
-    afterAdd(): Promise<void>;
+export declare class PluginAsyncTaskManagerServer extends Plugin {
     beforeLoad(): Promise<void>;
-    getThrottledProgressEmitter(taskId: string, userId: string): Function;
     load(): Promise<void>;
 }
-export default PluginAsyncExportServer;
+export default PluginAsyncTaskManagerServer;

package/dist/server/plugin.js

@@ -36,149 +36,35 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var plugin_exports = {};
 __export(plugin_exports, {
-  PluginAsyncExportServer: () => PluginAsyncExportServer,
+  PluginAsyncTaskManagerServer: () => PluginAsyncTaskManagerServer,
   default: () => plugin_default
 });
 module.exports = __toCommonJS(plugin_exports);
 var import_server = require("@nocobase/server");
-var import_lodash = require("lodash");
 var import_base_task_manager = require("./base-task-manager");
 var import_command_task_type = require("./command-task-type");
 var import_async_tasks = __toESM(require("./resourcers/async-tasks"));
-class PluginAsyncExportServer extends import_server.Plugin {
-  progressThrottles = /* @__PURE__ */ new Map();
-  async afterAdd() {
-  }
+class PluginAsyncTaskManagerServer extends import_server.Plugin {
   async beforeLoad() {
-    this.app.container.register("AsyncTaskManager", () => {
-      const manager = new import_base_task_manager.BaseTaskManager();
-      manager.setLogger(this.app.logger);
-      manager.setApp(this.app);
-      return manager;
-    });
-    this.app.container.get("AsyncTaskManager").registerTaskType(import_command_task_type.CommandTaskType);
-    this.app.acl.allow("asyncTasks", ["list", "get", "fetchFile", "cancel"], "loggedIn");
-  }
-  getThrottledProgressEmitter(taskId, userId) {
-    if (!this.progressThrottles.has(taskId)) {
-      this.progressThrottles.set(
-        taskId,
-        (0, import_lodash.throttle)(
-          (progress) => {
-            this.app.emit("ws:sendToTag", {
-              tagKey: "userId",
-              tagValue: userId,
-              message: {
-                type: "async-tasks:progress",
-                payload: {
-                  taskId,
-                  progress
-                }
-              }
-            });
-          },
-          500,
-          { leading: true, trailing: true }
-        )
-      );
+    const existed = this.app.container.get("AsyncTaskManager");
+    if (existed) {
+      this.app.logger.warn("AsyncTaskManager already exists, skipping initialization.");
+      return;
     }
-    return this.progressThrottles.get(taskId);
+    const manager = new import_base_task_manager.BaseTaskManager();
+    this.app.container.register("AsyncTaskManager", manager);
   }
   async load() {
+    const manager = this.app.container.get("AsyncTaskManager");
+    manager.setLogger(this.app.logger);
+    manager.setApp(this.app);
+    manager.registerTaskType(import_command_task_type.CommandTaskType);
     this.app.resourceManager.define(import_async_tasks.default);
-    const asyncTaskManager = this.app.container.get("AsyncTaskManager");
-    this.app.on(`ws:message:request:async-tasks:list`, async (message) => {
-      const { tags, clientId } = message;
-      this.app.logger.info(`Received request for async tasks with tags: ${JSON.stringify(tags)}`);
-      const userTag = tags == null ? void 0 : tags.find((tag) => tag.startsWith("userId#"));
-      const userId = userTag ? userTag.split("#")[1] : null;
-      if (userId) {
-        this.app.logger.info(`Fetching tasks for userId: ${userId}`);
-        const tasks = await asyncTaskManager.getTasksByTag("userId", userId);
-        this.app.logger.info(`Found ${tasks.length} tasks for userId: ${userId}`);
-        this.app.emit("ws:sendToClient", {
-          clientId,
-          message: {
-            type: "async-tasks",
-            payload: tasks.map((task) => task.toJSON())
-          }
-        });
-      } else {
-        this.app.logger.warn(`No userId found in message tags: ${JSON.stringify(tags)}`);
-      }
-    });
-    asyncTaskManager.on("taskCreated", ({ task }) => {
-      const userId = task.tags["userId"];
-      if (userId) {
-        this.app.emit("ws:sendToTag", {
-          tagKey: "userId",
-          tagValue: userId,
-          message: {
-            type: "async-tasks:created",
-            payload: task.toJSON()
-          }
-        });
-      }
-    });
-    asyncTaskManager.on("taskProgress", ({ task, progress }) => {
-      const userId = task.tags["userId"];
-      if (userId) {
-        const throttledEmit = this.getThrottledProgressEmitter(task.taskId, userId);
-        throttledEmit(progress);
-      }
-    });
-    asyncTaskManager.on("taskStatusChange", ({ task, status }) => {
-      const userId = task.tags["userId"];
-      if (!userId) return;
-      this.app.emit("ws:sendToTag", {
-        tagKey: "userId",
-        tagValue: userId,
-        message: {
-          type: "async-tasks:status",
-          payload: {
-            taskId: task.taskId,
-            status: task.toJSON().status
-          }
-        }
-      });
-      if (status.type !== "running" && status.type !== "pending") {
-        const throttled = this.progressThrottles.get(task.taskId);
-        if (throttled) {
-          throttled.cancel();
-          this.progressThrottles.delete(task.taskId);
-        }
-      }
-      if (status.type === "success") {
-        this.app.emit("workflow:dispatch");
-      }
-    });
-    this.app.on("ws:message:request:async-tasks:cancel", async (message) => {
-      const { payload, tags } = message;
-      const { taskId } = payload;
-      const userTag = tags == null ? void 0 : tags.find((tag) => tag.startsWith("userId#"));
-      const userId = userTag ? userTag.split("#")[1] : null;
-      if (userId) {
-        const task = asyncTaskManager.getTask(taskId);
-        if (task.tags["userId"] != userId) {
-          return;
-        }
-        const cancelled = await asyncTaskManager.cancelTask(taskId);
-        if (cancelled) {
-          this.app.emit("ws:sendToTag", {
-            tagKey: "userId",
-            tagValue: userId,
-            message: {
-              type: "async-tasks:cancelled",
-              payload: { taskId }
-            }
-          });
-        }
-      }
-    });
+    this.app.acl.allow("asyncTasks", ["list", "get", "fetchFile", "stop"], "loggedIn");
   }
 }
-var plugin_default = PluginAsyncExportServer;
+var plugin_default = PluginAsyncTaskManagerServer;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PluginAsyncExportServer
+  PluginAsyncTaskManagerServer
 });

package/dist/server/resourcers/async-tasks.d.ts

@@ -6,13 +6,14 @@
  * 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 { Context } from '@nocobase/actions';
 declare const _default: {
     name: string;
     actions: {
         list(ctx: any, next: any): Promise<void>;
         get(ctx: any, next: any): Promise<void>;
-        cancel(ctx: any, next: any): Promise<void>;
-        fetchFile(ctx: any, next: any): Promise<void>;
+        stop(ctx: Context, next: any): Promise<never>;
+        fetchFile(ctx: any, next: any): Promise<any>;
     };
 };
 export default _default;

package/dist/server/resourcers/async-tasks.js

@@ -39,53 +39,70 @@ __export(async_tasks_exports, {
   default: () => async_tasks_default
 });
 module.exports = __toCommonJS(async_tasks_exports);
+var import_actions = __toESM(require("@nocobase/actions"));
 var import_fs = __toESM(require("fs"));
-var import_lodash = __toESM(require("lodash"));
 var import_path = require("path");
+var import_constants = require("../../common/constants");
 var async_tasks_default = {
   name: "asyncTasks",
   actions: {
     async list(ctx, next) {
-      const userId = ctx.auth.user.id;
-      const asyncTaskManager = ctx.app.container.get("AsyncTaskManager");
-      const tasks = await asyncTaskManager.getTasksByTag("userId", userId);
-      ctx.body = import_lodash.default.orderBy(tasks, "createdAt", "desc");
-      await next();
+      ctx.action.mergeParams({
+        filter: {
+          createdById: ctx.auth.user.id
+        },
+        blacklist: ["params"]
+      });
+      await import_actions.default.list(ctx, next);
     },
     async get(ctx, next) {
-      const { filterByTk } = ctx.action.params;
-      const taskManager = ctx.app.container.get("AsyncTaskManager");
-      const taskStatus = await taskManager.getTaskStatus(filterByTk);
-      ctx.body = taskStatus;
-      await next();
+      ctx.action.mergeParams({
+        filter: {
+          createdById: ctx.auth.user.id
+        }
+      });
+      await import_actions.default.get(ctx, next);
     },
-    async cancel(ctx, next) {
+    async stop(ctx, next) {
       const { filterByTk } = ctx.action.params;
       const userId = ctx.auth.user.id;
-      const asyncTaskManager = ctx.app.container.get("AsyncTaskManager");
-      const task = asyncTaskManager.getTask(filterByTk);
+      const TaskRepo = ctx.app.db.getRepository("asyncTasks");
+      const task = await TaskRepo.findOne({
+        where: {
+          id: filterByTk,
+          createdById: userId
+        }
+      });
       if (!task) {
-        ctx.body = "ok";
-        await next();
-        return;
+        return ctx.throw(404, "Task not found");
       }
-      if (task.tags["userId"] != userId) {
-        ctx.throw(403);
+      if (!task.cancelable) {
+        return ctx.throw(400, "Task cannot be canceled");
       }
-      const cancelled = await asyncTaskManager.cancelTask(filterByTk);
-      ctx.body = cancelled;
+      const taskManager = ctx.app.container.get("AsyncTaskManager");
+      await taskManager.cancelTask(task.id);
+      ctx.status = 202;
       await next();
     },
     async fetchFile(ctx, next) {
       const { filterByTk, filename } = ctx.action.params;
-      const taskManager = ctx.app.container.get("AsyncTaskManager");
-      const taskStatus = await taskManager.getTaskStatus(filterByTk);
-      if (taskStatus.type !== "success") {
-        throw new Error("Task is not success status");
+      const userId = ctx.auth.user.id;
+      const TaskRepo = ctx.app.db.getRepository("asyncTasks");
+      const task = await TaskRepo.findOne({
+        where: {
+          id: filterByTk,
+          createdById: userId
+        }
+      });
+      if (!task) {
+        return ctx.throw(404, "Task not found");
+      }
+      if (task.status !== import_constants.TASK_STATUS.SUCCEEDED) {
+        return ctx.throw(400, "Task is not success status");
       }
-      const { filePath } = taskStatus.payload;
+      const { filePath } = task.result || {};
       if (!filePath) {
-        throw new Error("not a file task");
+        return ctx.throw(400, "not a file task");
       }
       ctx.body = import_fs.default.createReadStream(filePath);
       let finalFileName = filename ? filename : (0, import_path.basename)(filePath);

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

@@ -6,47 +6,31 @@
  * 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 EventEmitter from 'events';
 import { Logger } from '@nocobase/logger';
-import { TaskOptions, TaskStatus } from './interfaces/async-task-manager';
-import { ITask } from './interfaces/task';
+import { ITask, TaskModel } from './interfaces/task';
 import Application from '@nocobase/server';
-export declare abstract class TaskType extends EventEmitter implements ITask {
-    protected options: TaskOptions;
+export declare class TaskType implements ITask {
+    record: TaskModel;
     static type: string;
     static cancelable: boolean;
-    status: TaskStatus;
+    static defaults(data: any): any;
     protected logger: Logger;
     protected app: Application;
-    progress: {
-        total: number;
-        current: number;
-    };
-    startedAt: Date;
-    fulfilledAt: Date;
-    taskId: string;
-    tags: Record<string, string>;
-    createdAt: Date;
-    context?: any;
-    title: any;
     protected abortController: AbortController;
-    private _isCancelled;
-    get isCancelled(): boolean;
-    constructor(options: TaskOptions, tags?: Record<string, string>);
+    onProgress: (record: TaskModel) => void;
+    get isCanceled(): boolean;
+    constructor(record: TaskModel);
     setLogger(logger: Logger): void;
     setApp(app: Application): void;
-    setContext(context: any): void;
     /**
      * Cancel the task
      */
-    cancel(): Promise<boolean>;
-    statusChange(status: TaskStatus): Promise<void>;
+    cancel(): Promise<this>;
     /**
      * Execute the task implementation
      * @returns Promise that resolves with the task result
      */
-    abstract execute(): Promise<any>;
+    execute(): Promise<any>;
     /**
      * Report task progress
      * @param progress Progress information containing total and current values
@@ -64,41 +48,5 @@ export declare abstract class TaskType extends EventEmitter implements ITask {
      * - Event emission
      */
     run(): Promise<void>;
-    private renderErrorMessage;
-    toJSON(options?: {
-        raw?: boolean;
-    }): {
-        cancelable: boolean;
-        taskId: string;
-        status: {
-            type: "pending";
-            indicator?: "spinner";
-        } | {
-            type: "success";
-            indicator?: "success";
-            resultType?: "file" | "data";
-            payload?: any;
-        } | {
-            type: "running";
-            indicator: "progress";
-        } | {
-            type: "failed";
-            indicator?: "error";
-            errors: {
-                message: string;
-                code?: number;
-            }[];
-        } | {
-            type: "cancelled";
-        };
-        progress: {
-            total: number;
-            current: number;
-        };
-        tags: Record<string, string>;
-        createdAt: Date;
-        startedAt: Date;
-        fulfilledAt: Date;
-        title: any;
-    };
+    toJSON(): any;
 }