@tachybase/module-event-source 1.6.15 → 1.6.17

package/dist/server/constants.js

@@ -18,13 +18,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var constants_exports = {};
 __export(constants_exports, {
   EVENT_SOURCE_COLLECTION: () => EVENT_SOURCE_COLLECTION,
+  EVENT_SOURCE_QUEUE_COLLECTION: () => EVENT_SOURCE_QUEUE_COLLECTION,
+  EVENT_SOURCE_QUEUE_STATUS: () => EVENT_SOURCE_QUEUE_STATUS,
   EVENT_SOURCE_REALTIME: () => EVENT_SOURCE_REALTIME
 });
 module.exports = __toCommonJS(constants_exports);
 const EVENT_SOURCE_COLLECTION = "webhooks";
 const EVENT_SOURCE_REALTIME = process.env.EVENT_SOURCE_REALTIME === "0" ? false : true;
+const EVENT_SOURCE_QUEUE_COLLECTION = "eventSourceQueueJobs";
+const EVENT_SOURCE_QUEUE_STATUS = {
+  PENDING: "pending",
+  PROCESSING: "processing",
+  SUCCESS: "success",
+  FAILED: "failed",
+  DEAD: "dead"
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EVENT_SOURCE_COLLECTION,
+  EVENT_SOURCE_QUEUE_COLLECTION,
+  EVENT_SOURCE_QUEUE_STATUS,
   EVENT_SOURCE_REALTIME
 });

package/dist/server/model/EventSourceModel.d.ts

@@ -11,6 +11,12 @@ export declare class EventSourceModel extends Model {
         actionName?: string;
         eventName?: string;
         triggerOnAssociation?: boolean;
+        useHttpContext?: boolean;
+        failurePolicy?: 'ignore' | 'block';
+        timeoutMs?: number;
+        executionMode?: 'inline' | 'queue';
+        maxAttempts?: number;
+        retryBackoffMs?: number;
         sort?: number;
     };
 }

package/dist/server/queue/EventSourceQueueWorker.d.ts

@@ -0,0 +1,31 @@
+import { Application } from '@tego/server';
+type QueueStage = 'beforeResource' | 'afterResource' | 'customAction';
+type QueueJobInput = {
+    sourceId: number;
+    stage: QueueStage;
+    resourceName?: string;
+    actionName?: string;
+    workflowKey?: string;
+    payload: any;
+    contextLite?: {
+        userId?: number;
+        roleName?: string;
+    };
+    maxAttempts?: number;
+    retryBackoffMs?: number;
+};
+export declare class EventSourceQueueWorker {
+    private app;
+    private timer;
+    private running;
+    private readonly pollMs;
+    private readonly batchSize;
+    constructor(app: Application);
+    enqueue(input: QueueJobInput): Promise<any>;
+    start(): void;
+    stop(): void;
+    private tick;
+    private processJob;
+    private createPseudoContext;
+}
+export {};

package/dist/server/queue/EventSourceQueueWorker.js

@@ -0,0 +1,168 @@
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EventSourceQueueWorker_exports = {};
+__export(EventSourceQueueWorker_exports, {
+  EventSourceQueueWorker: () => EventSourceQueueWorker
+});
+module.exports = __toCommonJS(EventSourceQueueWorker_exports);
+var import_constants = require("../constants");
+var import_webhooks = require("../webhooks/webhooks");
+class EventSourceQueueWorker {
+  constructor(app) {
+    this.app = app;
+    this.timer = null;
+    this.running = false;
+    this.pollMs = Number(process.env.EVENT_SOURCE_QUEUE_POLL_MS || 1e3);
+    this.batchSize = Number(process.env.EVENT_SOURCE_QUEUE_BATCH_SIZE || 20);
+  }
+  async enqueue(input) {
+    const repo = this.app.db.getRepository(import_constants.EVENT_SOURCE_QUEUE_COLLECTION);
+    return repo.create({
+      values: {
+        sourceId: input.sourceId,
+        stage: input.stage,
+        resourceName: input.resourceName,
+        actionName: input.actionName,
+        workflowKey: input.workflowKey,
+        payload: input.payload,
+        contextLite: input.contextLite || {},
+        status: import_constants.EVENT_SOURCE_QUEUE_STATUS.PENDING,
+        attempt: 0,
+        maxAttempts: input.maxAttempts ?? 3,
+        retryBackoffMs: input.retryBackoffMs ?? 3e3,
+        nextRunAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  start() {
+    if (this.timer) {
+      return;
+    }
+    this.timer = setInterval(() => {
+      this.tick().catch((error) => {
+        this.app.logger.error("[event-source-queue] tick failed", error);
+      });
+    }, this.pollMs);
+  }
+  stop() {
+    if (!this.timer) {
+      return;
+    }
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+  async tick() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    try {
+      const repo = this.app.db.getRepository(import_constants.EVENT_SOURCE_QUEUE_COLLECTION);
+      const jobs = await repo.find({
+        filter: {
+          status: {
+            $in: [import_constants.EVENT_SOURCE_QUEUE_STATUS.PENDING, import_constants.EVENT_SOURCE_QUEUE_STATUS.FAILED]
+          },
+          nextRunAt: {
+            $lte: /* @__PURE__ */ new Date()
+          }
+        },
+        sort: ["createdAt"],
+        limit: this.batchSize
+      });
+      for (const job of jobs) {
+        await this.processJob(job);
+      }
+    } finally {
+      this.running = false;
+    }
+  }
+  async processJob(job) {
+    const repo = this.app.db.getRepository(import_constants.EVENT_SOURCE_QUEUE_COLLECTION);
+    const attempt = (job.attempt || 0) + 1;
+    try {
+      await repo.update({
+        filter: { id: job.id },
+        values: {
+          status: import_constants.EVENT_SOURCE_QUEUE_STATUS.PROCESSING,
+          lockedAt: /* @__PURE__ */ new Date(),
+          lockedBy: this.app.name,
+          attempt
+        }
+      });
+      const pseudoCtx = await this.createPseudoContext(job.contextLite);
+      const controller = new import_webhooks.WebhookController();
+      await controller.triggerWorkflow(
+        pseudoCtx,
+        {
+          workflowKey: job.workflowKey,
+          options: {
+            useHttpContext: false
+          }
+        },
+        job.payload
+      );
+      await repo.update({
+        filter: { id: job.id },
+        values: {
+          status: import_constants.EVENT_SOURCE_QUEUE_STATUS.SUCCESS,
+          lastError: null
+        }
+      });
+    } catch (error) {
+      const maxAttempts = Number(job.maxAttempts || 3);
+      const retryBackoffMs = Number(job.retryBackoffMs || 3e3);
+      const dead = attempt >= maxAttempts;
+      await repo.update({
+        filter: { id: job.id },
+        values: {
+          status: dead ? import_constants.EVENT_SOURCE_QUEUE_STATUS.DEAD : import_constants.EVENT_SOURCE_QUEUE_STATUS.FAILED,
+          nextRunAt: dead ? null : new Date(Date.now() + retryBackoffMs),
+          lastError: (error == null ? void 0 : error.stack) || `${error}`
+        }
+      });
+      this.app.logger.error(
+        `[event-source-queue] process failed, jobId=${job.id}, sourceId=${job.sourceId}, attempt=${attempt}, dead=${dead}`,
+        error
+      );
+    }
+  }
+  async createPseudoContext(contextLite) {
+    var _a;
+    let currentUser = null;
+    if (contextLite == null ? void 0 : contextLite.userId) {
+      const userRepo = this.app.db.getRepository("users");
+      currentUser = await userRepo.findOne({
+        filter: { id: contextLite.userId }
+      });
+      currentUser = ((_a = currentUser == null ? void 0 : currentUser.toJSON) == null ? void 0 : _a.call(currentUser)) || currentUser;
+    }
+    return {
+      db: this.app.db,
+      tego: this.app,
+      state: {
+        currentUser,
+        currentRole: (contextLite == null ? void 0 : contextLite.roleName) || null
+      }
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventSourceQueueWorker
+});

package/dist/server/trigger/CustomctionTrigger.d.ts

@@ -3,9 +3,17 @@ import { EventSourceTrigger } from './Trigger';
 type IAPITriggerConfig = {
     code: string;
     workflowKey: string;
+    options?: EventSourceModel['options'];
 };
 export declare class CustomActionTrigger extends EventSourceTrigger {
     eventMap: Map<number, IAPITriggerConfig>;
+    /** 未设置 failurePolicy 时与 main 一致：工作流失败则 500 */
+    private getFailurePolicy;
+    private getExecutionMode;
+    private getMaxAttempts;
+    private getRetryBackoffMs;
+    private getTimeoutMs;
+    private withTimeout;
     load(model: EventSourceModel): void;
     afterCreate(model: EventSourceModel): void;
     afterUpdate(model: EventSourceModel): void;

package/dist/server/trigger/CustomctionTrigger.js

@@ -27,6 +27,49 @@ class CustomActionTrigger extends import_Trigger.EventSourceTrigger {
     super(...arguments);
     this.eventMap = /* @__PURE__ */ new Map();
   }
+  /** 未设置 failurePolicy 时与 main 一致：工作流失败则 500 */
+  getFailurePolicy(config) {
+    var _a;
+    return ((_a = config == null ? void 0 : config.options) == null ? void 0 : _a.failurePolicy) === "ignore" ? "ignore" : "block";
+  }
+  getExecutionMode(config) {
+    var _a;
+    return ((_a = config == null ? void 0 : config.options) == null ? void 0 : _a.executionMode) === "queue" ? "queue" : "inline";
+  }
+  getMaxAttempts(config) {
+    var _a;
+    const value = Number(((_a = config == null ? void 0 : config.options) == null ? void 0 : _a.maxAttempts) || 3);
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : 3;
+  }
+  getRetryBackoffMs(config) {
+    var _a;
+    const value = Number(((_a = config == null ? void 0 : config.options) == null ? void 0 : _a.retryBackoffMs) || 3e3);
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : 3e3;
+  }
+  getTimeoutMs(config) {
+    var _a;
+    const timeoutMs = Number(((_a = config == null ? void 0 : config.options) == null ? void 0 : _a.timeoutMs) || 0);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      return 0;
+    }
+    return timeoutMs;
+  }
+  async withTimeout(executor, timeoutMs, errorMessage) {
+    if (!timeoutMs) {
+      return executor();
+    }
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(errorMessage)), timeoutMs);
+    });
+    try {
+      return await Promise.race([executor(), timeoutPromise]);
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    }
+  }
   load(model) {
     if (!model.options) {
       return;
@@ -38,7 +81,7 @@ class CustomActionTrigger extends import_Trigger.EventSourceTrigger {
       code,
       workflowKey
     } = model;
-    this.eventMap.set(id, { code, workflowKey });
+    this.eventMap.set(id, { code, workflowKey, options: model.options });
     if (!app.resourcer.isDefined(resourceName)) {
       app.resourcer.define({ name: resourceName });
     }
@@ -48,15 +91,62 @@ class CustomActionTrigger extends import_Trigger.EventSourceTrigger {
     }
     app.logger.info(`Add ${resourceName}:${actionName} action handler`);
     app.resourcer.getResource(resourceName).addAction(actionName, async (ctx) => {
+      var _a, _b, _c, _d, _e;
       if (this.realTimeRefresh && !this.workSet.has(id)) {
         ctx.throw(404, "Not found");
       }
-      const { code: code2, workflowKey: workflowKey2 } = this.eventMap.get(id);
-      const body = await new import_webhooks.WebhookController().action(ctx, { code: code2 });
-      const res = await new import_webhooks.WebhookController().triggerWorkflow(ctx, { workflowKey: workflowKey2 }, body);
-      const lastSavedJob = res.lastSavedJob;
-      if (lastSavedJob.get("status") < 0) {
-        ctx.throw(500, lastSavedJob.get("result"));
+      const config = this.eventMap.get(id);
+      if (!config) {
+        ctx.throw(404, "Not found");
+        return;
+      }
+      const failurePolicy = this.getFailurePolicy(config);
+      const executionMode = this.getExecutionMode(config);
+      const timeoutMs = this.getTimeoutMs(config);
+      try {
+        if (executionMode === "queue") {
+          const body = await new import_webhooks.WebhookController().action(ctx, { code: config.code });
+          const queueWorker = this.app.eventSourceQueueWorker;
+          if (!queueWorker) {
+            throw new Error("eventSourceQueueWorker is not available");
+          }
+          await queueWorker.enqueue({
+            sourceId: id,
+            stage: "customAction",
+            resourceName: (_a = ctx == null ? void 0 : ctx.action) == null ? void 0 : _a.resourceName,
+            actionName: (_b = ctx == null ? void 0 : ctx.action) == null ? void 0 : _b.actionName,
+            workflowKey: config.workflowKey,
+            payload: body,
+            contextLite: {
+              userId: (_d = (_c = ctx == null ? void 0 : ctx.state) == null ? void 0 : _c.currentUser) == null ? void 0 : _d.id,
+              roleName: (_e = ctx == null ? void 0 : ctx.state) == null ? void 0 : _e.currentRole
+            },
+            maxAttempts: this.getMaxAttempts(config),
+            retryBackoffMs: this.getRetryBackoffMs(config)
+          });
+          ctx.withoutDataWrapping = true;
+          ctx.body = { queued: true };
+          return;
+        }
+        const res = await this.withTimeout(
+          async () => {
+            const body = await new import_webhooks.WebhookController().action(ctx, { code: config.code });
+            return await new import_webhooks.WebhookController().triggerWorkflow(ctx, config, body);
+          },
+          timeoutMs,
+          `[event-source] custom action timeout, sourceId=${id}, timeoutMs=${timeoutMs}`
+        );
+        const lastSavedJob = res == null ? void 0 : res.lastSavedJob;
+        if ((lastSavedJob == null ? void 0 : lastSavedJob.get("status")) < 0) {
+          throw new Error(`${lastSavedJob.get("result")}`);
+        }
+      } catch (error) {
+        app.logger.error(
+          `[event-source] custom action execution failed. policy=${failurePolicy}, sourceId=${id}, workflowKey=${config == null ? void 0 : config.workflowKey}, error=${(error == null ? void 0 : error.stack) || error}`
+        );
+        if (failurePolicy === "block") {
+          ctx.throw(500, (error == null ? void 0 : error.message) || "Custom action execution failed");
+        }
       }
     });
     app.acl.allow(resourceName, actionName, "loggedIn");
@@ -66,11 +156,11 @@ class CustomActionTrigger extends import_Trigger.EventSourceTrigger {
   }
   // TODO 很难修改和删除,目前实时刷新的时候间接修改
   afterUpdate(model) {
-    const { enabled, code, workflowKey, id } = model;
+    const { enabled, code, workflowKey, id, options } = model;
     if (enabled && !this.workSet.has(id)) {
       this.load(model);
     } else {
-      this.eventMap.set(id, { code, workflowKey });
+      this.eventMap.set(id, { code, workflowKey, options });
     }
   }
 }

package/dist/server/trigger/ResourceEventTrigger.d.ts

@@ -5,6 +5,20 @@ export declare class ResourceEventTrigger extends EventSourceTrigger {
     private afterList;
     load(model: EventSourceModel): void;
     afterAllLoad(): void;
+    /**
+     * failurePolicy 未设置：与 main 分支一致（遗留行为）
+     * - beforeResource：工作流 ERROR 时阻断（原 400）
+     * - afterResource：不因工作流 ERROR 状态阻断（原逻辑未校验）
+     * 显式 ignore：失败不阻断主请求
+     * 显式 block：任意失败均阻断
+     */
+    private getFailurePolicy;
+    private getExecutionMode;
+    private getMaxAttempts;
+    private getRetryBackoffMs;
+    private getTimeoutMs;
+    private withTimeout;
+    private executeByPolicy;
     private getMatchList;
     afterCreate(model: EventSourceModel): void;
     afterUpdate(model: EventSourceModel): void;

package/dist/server/trigger/ResourceEventTrigger.js

@@ -55,21 +55,133 @@ class ResourceEventTrigger extends import_Trigger.EventSourceTrigger {
           return next();
         }
         for (const model of matchBefore) {
-          const body = await new import_webhooks.WebhookController().action(ctx, model);
-          const result = await new import_webhooks.WebhookController().triggerWorkflow(ctx, model, body);
-          if (result && result.lastSavedJob.status === import_module_workflow.JOB_STATUS.ERROR) {
-            ctx.throw(400, result.lastSavedJob.result);
-          }
+          await this.executeByPolicy(ctx, model, "beforeResource");
         }
         await next();
         for (const model of matchAfter) {
-          const body = await new import_webhooks.WebhookController().action(ctx, model);
-          await new import_webhooks.WebhookController().triggerWorkflow(ctx, model, body);
+          await this.executeByPolicy(ctx, model, "afterResource");
         }
       },
       { tag: "event-source-resource" }
     );
   }
+  /**
+   * failurePolicy 未设置：与 main 分支一致（遗留行为）
+   * - beforeResource：工作流 ERROR 时阻断（原 400）
+   * - afterResource：不因工作流 ERROR 状态阻断（原逻辑未校验）
+   * 显式 ignore：失败不阻断主请求
+   * 显式 block：任意失败均阻断
+   */
+  getFailurePolicy(model) {
+    var _a;
+    const fp = (_a = model == null ? void 0 : model.options) == null ? void 0 : _a.failurePolicy;
+    if (fp === "ignore") {
+      return "ignore";
+    }
+    if (fp === "block") {
+      return "block";
+    }
+    return "legacy";
+  }
+  getExecutionMode(model) {
+    var _a;
+    return ((_a = model == null ? void 0 : model.options) == null ? void 0 : _a.executionMode) === "queue" ? "queue" : "inline";
+  }
+  getMaxAttempts(model) {
+    var _a;
+    const value = Number(((_a = model == null ? void 0 : model.options) == null ? void 0 : _a.maxAttempts) || 3);
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : 3;
+  }
+  getRetryBackoffMs(model) {
+    var _a;
+    const value = Number(((_a = model == null ? void 0 : model.options) == null ? void 0 : _a.retryBackoffMs) || 3e3);
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : 3e3;
+  }
+  getTimeoutMs(model) {
+    var _a;
+    const timeoutMs = Number(((_a = model == null ? void 0 : model.options) == null ? void 0 : _a.timeoutMs) || 0);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      return 0;
+    }
+    return timeoutMs;
+  }
+  async withTimeout(executor, timeoutMs, errorMessage) {
+    if (!timeoutMs) {
+      return executor();
+    }
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(errorMessage)), timeoutMs);
+    });
+    try {
+      return await Promise.race([executor(), timeoutPromise]);
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    }
+  }
+  async executeByPolicy(ctx, model, stage) {
+    var _a, _b, _c, _d, _e;
+    const failurePolicy = this.getFailurePolicy(model);
+    const executionMode = this.getExecutionMode(model);
+    const timeoutMs = this.getTimeoutMs(model);
+    try {
+      if (executionMode === "queue") {
+        const body = await new import_webhooks.WebhookController().action(ctx, model);
+        const queueWorker = this.app.eventSourceQueueWorker;
+        if (!queueWorker) {
+          throw new Error("eventSourceQueueWorker is not available");
+        }
+        await queueWorker.enqueue({
+          sourceId: model.id,
+          stage,
+          resourceName: (_a = model == null ? void 0 : model.options) == null ? void 0 : _a.resourceName,
+          actionName: (_b = model == null ? void 0 : model.options) == null ? void 0 : _b.actionName,
+          workflowKey: model.workflowKey,
+          payload: body,
+          contextLite: {
+            userId: (_d = (_c = ctx == null ? void 0 : ctx.state) == null ? void 0 : _c.currentUser) == null ? void 0 : _d.id,
+            roleName: (_e = ctx == null ? void 0 : ctx.state) == null ? void 0 : _e.currentRole
+          },
+          maxAttempts: this.getMaxAttempts(model),
+          retryBackoffMs: this.getRetryBackoffMs(model)
+        });
+        return;
+      }
+      const result = await this.withTimeout(
+        async () => {
+          const body = await new import_webhooks.WebhookController().action(ctx, model);
+          return await new import_webhooks.WebhookController().triggerWorkflow(ctx, model, body);
+        },
+        timeoutMs,
+        `[event-source] ${stage} timeout, sourceId=${model.id}, timeoutMs=${timeoutMs}`
+      );
+      if (result && result.lastSavedJob.status === import_module_workflow.JOB_STATUS.ERROR) {
+        if (failurePolicy === "ignore") {
+          return;
+        }
+        if (failurePolicy === "block") {
+          throw new Error(`${result.lastSavedJob.result}`);
+        }
+        if (stage === "beforeResource") {
+          ctx.throw(400, result.lastSavedJob.result);
+        }
+        return;
+      }
+    } catch (error) {
+      this.app.logger.error(
+        `[event-source] ${stage} execution failed. policy=${failurePolicy}, sourceId=${model.id}, workflowKey=${model.workflowKey}, error=${(error == null ? void 0 : error.stack) || error}`
+      );
+      if (failurePolicy === "ignore") {
+        return;
+      }
+      if (failurePolicy === "block") {
+        throw error;
+      }
+      throw error;
+    }
+  }
   getMatchList(list, resourceName, actionName) {
     const matchList = [];
     list.sort((a, b) => {

package/dist/server/webhooks/Plugin.d.ts

@@ -1,8 +1,10 @@
 import { Plugin, Registry, WSServer } from '@tego/server';
+import { EventSourceQueueWorker } from '../queue/EventSourceQueueWorker';
 import { EventSourceTrigger } from '../trigger/Trigger';
 export declare class PluginWebhook extends Plugin {
     triggers: Registry<EventSourceTrigger>;
     ws: WSServer;
+    queueWorker: EventSourceQueueWorker;
     refreshRealTime: boolean;
     changed: boolean;
     beforeLoad(): Promise<void>;

package/dist/server/webhooks/Plugin.js

@@ -24,6 +24,7 @@ var import_server = require("@tego/server");
 var import_constants = require("../constants");
 var import_EventSourceModel = require("../model/EventSourceModel");
 var import_WebhookCategories = require("../model/WebhookCategories");
+var import_EventSourceQueueWorker = require("../queue/EventSourceQueueWorker");
 var import_AppEventTrigger = require("../trigger/AppEventTrigger");
 var import_CustomctionTrigger = require("../trigger/CustomctionTrigger");
 var import_DatabaseEventTrigger = require("../trigger/DatabaseEventTrigger");
@@ -80,6 +81,13 @@ class PluginWebhook extends import_server.Plugin {
       },
       { tag: "webhooks-show-effect" }
     );
+    this.queueWorker = new import_EventSourceQueueWorker.EventSourceQueueWorker(this.app);
+    this.app.eventSourceQueueWorker = this.queueWorker;
+    this.queueWorker.start();
+    this.app.on("beforeStop", async () => {
+      var _a;
+      (_a = this.queueWorker) == null ? void 0 : _a.stop();
+    });
     this.triggers.register("resource", new import_CustomctionTrigger.CustomActionTrigger(this.app, this.refreshRealTime));
     this.triggers.register("beforeResource", new import_ResourceEventTrigger.ResourceEventTrigger(this.app, this.refreshRealTime));
     this.triggers.register("afterResource", new import_ResourceEventTrigger.ResourceEventTrigger(this.app, this.refreshRealTime));

package/dist/server/webhooks/webhooks.js

@@ -253,19 +253,23 @@ class WebhookController {
     }
   }
   async triggerWorkflow(ctx, action, body) {
-    const { currentUser, currentRole } = ctx.state;
-    const { model: UserModel } = ctx.db.getCollection("users");
+    var _a;
+    const { currentUser, currentRole } = (ctx == null ? void 0 : ctx.state) || {};
+    const userCollection = ctx.db.getCollection("users");
+    const { model: UserModel } = userCollection;
     if (!action.workflowKey) {
       return;
     }
     const userInfo = {
-      user: UserModel.build(currentUser).desensitize(),
+      user: currentUser ? UserModel.build(currentUser).desensitize() : null,
       roleName: currentRole
     };
     const pluginWorkflow = ctx.tego.getPlugin(import_module_workflow.PluginWorkflow);
     const wfRepo = ctx.db.getRepository("workflows");
     const wf = await wfRepo.findOne({ filter: { key: action.workflowKey, enabled: true } });
-    return await pluginWorkflow.trigger(wf, { data: body, ...userInfo }, { httpContext: ctx });
+    const useHttpContext = ((_a = action == null ? void 0 : action.options) == null ? void 0 : _a.useHttpContext) !== false;
+    const triggerOptions = useHttpContext ? { httpContext: ctx } : void 0;
+    return await pluginWorkflow.trigger(wf, { data: body, ...userInfo }, triggerOptions);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tachybase/module-event-source",
   "displayName": "Event Source",
-  "version": "1.6.15",
+  "version": "1.6.17",
   "description": "Registering and managing custom event sources.",
   "keywords": [
     "System management"
@@ -29,8 +29,8 @@
     "dayjs": "1.11.13",
     "lodash": "4.17.21",
     "sequelize": "6.37.5",
-    "@tachybase/client": "1.6.15",
-    "@tachybase/module-workflow": "1.6.15"
+    "@tachybase/client": "1.6.17",
+    "@tachybase/module-workflow": "1.6.17"
   },
   "description.zh-CN": "注册和管理自定义事件源",
   "displayName.zh-CN": "事件源",