@tachybase/module-event-source 0.23.41 → 0.23.47

package/dist/server/trigger/AppEventTrigger.js

@@ -0,0 +1,93 @@
+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 AppEventTrigger_exports = {};
+__export(AppEventTrigger_exports, {
+  AppEventTrigger: () => AppEventTrigger
+});
+module.exports = __toCommonJS(AppEventTrigger_exports);
+var import_module_workflow = require("@tachybase/module-workflow");
+var import_eval_simulate = require("../utils/eval-simulate");
+var import_Trigger = require("./Trigger");
+class AppEventTrigger extends import_Trigger.EventSourceTrigger {
+  constructor() {
+    super(...arguments);
+    this.eventMap = /* @__PURE__ */ new Map();
+  }
+  load(model) {
+    if (!model.options) {
+      return;
+    }
+    const {
+      options: { eventName },
+      workflowKey
+    } = model;
+    this.app.logger.info("Add application event listener", { meta: { eventName, workflowKey } });
+    const callback = this.getAppEvent(model).bind(this);
+    this.app.on(eventName, callback);
+    this.eventMap.set(model.id, callback);
+  }
+  afterCreate(model) {
+    this.load(model);
+  }
+  afterUpdate(model) {
+    if (model.enabled && !this.workSet.has(model.id)) {
+      this.load(model);
+    } else if (!model.enabled && this.workSet.has(model.id)) {
+      this.app.db.off(model.options.eventName, this.eventMap.get(model.id));
+      this.eventMap.delete(model.id);
+    }
+  }
+  afterDestroy(model) {
+    const callback = this.eventMap.get(model.id);
+    if (!callback) {
+      return;
+    }
+    this.app.db.off(model.options.eventName, callback);
+    this.eventMap.delete(model.id);
+  }
+  getAppEvent(model) {
+    const { code, workflowKey } = model;
+    return async () => {
+      const webhookCtx = {
+        body: ""
+      };
+      try {
+        await (0, import_eval_simulate.evalSimulate)(code, {
+          ctx: webhookCtx,
+          lib: {
+            JSON,
+            Math
+          }
+        });
+      } catch (err) {
+        this.app.logger.error(err);
+      }
+      if (!workflowKey) {
+        return;
+      }
+      const pluginWorkflow = this.app.getPlugin(import_module_workflow.PluginWorkflow);
+      const wfRepo = this.app.db.getRepository("workflows");
+      const wf = await wfRepo.findOne({ filter: { key: workflowKey, enabled: true } });
+      await pluginWorkflow.trigger(wf, { data: webhookCtx.body }, {});
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppEventTrigger
+});

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

@@ -0,0 +1,13 @@
+import { EventSourceModel } from '../model/EventSourceModel';
+import { EventSourceTrigger } from './Trigger';
+type IAPITriggerConfig = {
+    code: string;
+    workflowKey: string;
+};
+export declare class CustomActionTrigger extends EventSourceTrigger {
+    eventMap: Map<number, IAPITriggerConfig>;
+    load(model: EventSourceModel): void;
+    afterCreate(model: EventSourceModel): void;
+    afterUpdate(model: EventSourceModel): void;
+}
+export {};

package/dist/server/trigger/CustionActionTrigger.js

@@ -0,0 +1,76 @@
+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 CustionActionTrigger_exports = {};
+__export(CustionActionTrigger_exports, {
+  CustomActionTrigger: () => CustomActionTrigger
+});
+module.exports = __toCommonJS(CustionActionTrigger_exports);
+var import_webhooks = require("../webhooks/webhooks");
+var import_Trigger = require("./Trigger");
+class CustomActionTrigger extends import_Trigger.EventSourceTrigger {
+  constructor() {
+    super(...arguments);
+    this.eventMap = /* @__PURE__ */ new Map();
+  }
+  load(model) {
+    if (!model.options) {
+      return;
+    }
+    const app = this.app;
+    const {
+      options: { actionName, resourceName },
+      id,
+      code,
+      workflowKey
+    } = model;
+    this.eventMap.set(id, { code, workflowKey });
+    if (!app.resourcer.isDefined(resourceName)) {
+      app.resourcer.define({ name: resourceName });
+    }
+    if (app.resourcer.getResource(resourceName).actions.has(actionName)) {
+      app.logger.warn(`${resourceName}:${actionName} action handler exists`);
+      return;
+    }
+    app.logger.info(`Add ${resourceName}:${actionName} action handler`);
+    app.resourcer.getResource(resourceName).addAction(actionName, async (ctx) => {
+      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 });
+      await new import_webhooks.WebhookController().triggerWorkflow(ctx, { workflowKey: workflowKey2 }, body);
+    });
+    app.acl.allow(resourceName, actionName, "loggedIn");
+  }
+  afterCreate(model) {
+    this.load(model);
+  }
+  // TODO 很难修改和删除,目前实时刷新的时候间接修改
+  afterUpdate(model) {
+    const { enabled, code, workflowKey, id } = model;
+    if (enabled && !this.workSet.has(id)) {
+      this.load(model);
+    } else {
+      this.eventMap.set(id, { code, workflowKey });
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CustomActionTrigger
+});

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

@@ -0,0 +1,10 @@
+import { EventSourceModel } from '../model/EventSourceModel';
+import { EventSourceTrigger } from './Trigger';
+export declare class DatabaseEventTrigger extends EventSourceTrigger {
+    eventMap: Map<number, (...args: any[]) => void>;
+    load(model: EventSourceModel): void;
+    getDbEvent(model: EventSourceModel): (model: any, options: any) => Promise<void>;
+    afterCreate(model: EventSourceModel): void;
+    afterUpdate(model: EventSourceModel): void;
+    afterDestroy(model: EventSourceModel): void;
+}

package/dist/server/trigger/DatabaseEventTrigger.js

@@ -0,0 +1,104 @@
+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 DatabaseEventTrigger_exports = {};
+__export(DatabaseEventTrigger_exports, {
+  DatabaseEventTrigger: () => DatabaseEventTrigger
+});
+module.exports = __toCommonJS(DatabaseEventTrigger_exports);
+var import_module_workflow = require("@tachybase/module-workflow");
+var import_eval_simulate = require("../utils/eval-simulate");
+var import_Trigger = require("./Trigger");
+class DatabaseEventTrigger extends import_Trigger.EventSourceTrigger {
+  constructor() {
+    super(...arguments);
+    this.eventMap = /* @__PURE__ */ new Map();
+  }
+  load(model) {
+    if (!model.options) {
+      return;
+    }
+    const {
+      options: { eventName },
+      workflowKey,
+      code
+    } = model;
+    this.app.logger.info("Add database event listener", { meta: { eventName, workflowKey } });
+    const callback = this.getDbEvent(model).bind(this);
+    this.app.db.on(eventName, callback);
+    this.eventMap.set(model.id, callback);
+  }
+  getDbEvent(model) {
+    const { code, workflowKey } = model;
+    return async (model2, options) => {
+      var _a;
+      const webhookCtx = {
+        body: "",
+        model: model2,
+        options
+      };
+      try {
+        await (0, import_eval_simulate.evalSimulate)(code, {
+          ctx: webhookCtx,
+          lib: {
+            JSON,
+            Math
+          }
+        });
+      } catch (err) {
+        this.app.logger.error(err);
+      }
+      if (!workflowKey) {
+        return;
+      }
+      const pluginWorkflow = this.app.getPlugin(import_module_workflow.PluginWorkflow);
+      const wfRepo = this.app.db.getRepository("workflows");
+      const wf = await wfRepo.findOne({ filter: { key: workflowKey, enabled: true } });
+      const result = await pluginWorkflow.trigger(
+        wf,
+        { data: webhookCtx.body },
+        { dbModel: model2, dbOptions: options, ...options }
+      );
+      if ((result == null ? void 0 : result.lastSavedJob.status) === import_module_workflow.JOB_STATUS.ERROR) {
+        throw new Error((_a = result.lastSavedJob) == null ? void 0 : _a.result);
+      }
+    };
+  }
+  afterCreate(model) {
+    this.load(model);
+  }
+  afterUpdate(model) {
+    if (model.enabled && !this.workSet.has(model.id)) {
+      this.load(model);
+    } else if (!model.enabled && this.workSet.has(model.id)) {
+      this.app.db.off(model.options.eventName, this.eventMap.get(model.id));
+      this.eventMap.delete(model.id);
+    }
+  }
+  afterDestroy(model) {
+    const callback = this.eventMap.get(model.id);
+    if (!callback) {
+      return;
+    }
+    this.app.db.off(model.options.eventName, callback);
+    this.eventMap.delete(model.id);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseEventTrigger
+});

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

@@ -0,0 +1,14 @@
+import { EventSourceModel } from '../model/EventSourceModel';
+import { EventSourceTrigger } from './Trigger';
+export declare class ResourceEventTrigger extends EventSourceTrigger {
+    private beforeList;
+    private afterList;
+    load(model: EventSourceModel): void;
+    afterAllLoad(): void;
+    private getMatchList;
+    afterCreate(model: EventSourceModel): void;
+    afterUpdate(model: EventSourceModel): void;
+    private afterUpdateList;
+    afterDestroy(model: EventSourceModel): void;
+    private afterDestroyList;
+}

package/dist/server/trigger/ResourceEventTrigger.js

@@ -0,0 +1,149 @@
+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 ResourceEventTrigger_exports = {};
+__export(ResourceEventTrigger_exports, {
+  ResourceEventTrigger: () => ResourceEventTrigger
+});
+module.exports = __toCommonJS(ResourceEventTrigger_exports);
+var import_module_workflow = require("@tachybase/module-workflow");
+var import_webhooks = require("../webhooks/webhooks");
+var import_Trigger = require("./Trigger");
+class ResourceEventTrigger extends import_Trigger.EventSourceTrigger {
+  constructor() {
+    super(...arguments);
+    // 优先级越小越靠前
+    this.beforeList = [];
+    this.afterList = [];
+  }
+  load(model) {
+    if (!model.options) {
+      return;
+    }
+    const { type } = model;
+    const prefix = type.substring(0, type.indexOf("Resource"));
+    if (prefix === "before") {
+      this.beforeList.push(model.toJSON());
+    } else {
+      this.afterList.push(model.toJSON());
+    }
+  }
+  afterAllLoad() {
+    this.app.resourcer.use(
+      async (ctx, next) => {
+        const { resourceName, actionName } = ctx.action;
+        if (!this.beforeList.length && !this.afterList.length) {
+          return next();
+        }
+        const matchBefore = this.getMatchList(this.beforeList, resourceName, actionName);
+        const matchAfter = this.getMatchList(this.afterList, resourceName, actionName);
+        if (!matchBefore.length && !matchAfter.length) {
+          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 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);
+        }
+      },
+      { tag: "event-source-resource" }
+    );
+  }
+  getMatchList(list, resourceName, actionName) {
+    let targetResource = resourceName || "";
+    const matchList = [];
+    list.sort((a, b) => {
+      let diffSort = a.options.sort - b.options.sort;
+      if (diffSort !== 0) {
+        return diffSort;
+      }
+      return a.id - b.id;
+    });
+    for (const item of list) {
+      targetResource = item.options.resourceName;
+      if (item.options.triggerOnAssociation) {
+        const parts = resourceName.split(".");
+        if (parts.length === 2) {
+          const collection = this.app.db.getCollection(resourceName);
+          targetResource = collection == null ? void 0 : collection.name;
+        }
+      }
+      if (targetResource === resourceName && item.options.actionName === actionName) {
+        matchList.push(item);
+      }
+    }
+    return matchList;
+  }
+  afterCreate(model) {
+    const { type } = model;
+    const prefix = type.substring(0, type.indexOf("Resource"));
+    if (prefix === "before") {
+      this.beforeList.push(model);
+    } else {
+      this.afterList.push(model);
+    }
+  }
+  afterUpdate(model) {
+    const { type } = model;
+    const prefix = type.substring(0, type.indexOf("Resource"));
+    if (prefix === "before") {
+      this.afterUpdateList(this.beforeList, model);
+    } else {
+      this.afterUpdateList(this.afterList, model);
+    }
+  }
+  afterUpdateList(list, model) {
+    const index = list.findIndex((item) => item.id === model.id);
+    if (!model.enabled) {
+      if (index !== -1) {
+        list.splice(index, 1);
+      }
+      return;
+    }
+    if (index !== -1) {
+      list[index] = model.toJSON();
+    } else {
+      list.push(model.toJSON());
+    }
+  }
+  afterDestroy(model) {
+    const { type } = model;
+    const prefix = type.substring(0, type.indexOf("Resource"));
+    if (prefix === "before") {
+      this.afterDestroyList(this.beforeList, model);
+    } else {
+      this.afterDestroyList(this.afterList, model);
+    }
+  }
+  afterDestroyList(list, model) {
+    const index = list.findIndex((item) => item.id === model.id);
+    if (index !== -1) {
+      list.splice(index, 1);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResourceEventTrigger
+});

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

@@ -0,0 +1,21 @@
+import Application from '@tachybase/server';
+import { EventSourceModel } from '../model/EventSourceModel';
+import { IEventSourceTrigger } from '../types';
+export declare class EventSourceTrigger implements IEventSourceTrigger {
+    protected app: Application;
+    protected realTimeRefresh: boolean;
+    protected workSet: Set<number>;
+    protected effectConfigMap: Map<number, any>;
+    getRealTimeRefresh(): boolean;
+    constructor(app: Application, realTimeRefresh?: boolean);
+    load(model: EventSourceModel): void;
+    afterAllLoad(): void;
+    workSetAdd(id: number): void;
+    workSetDelete(id: number): void;
+    effectConfigSet(id: number, config: any): void;
+    getEffect(model: EventSourceModel): boolean;
+    afterCreate(model: EventSourceModel): void;
+    afterUpdate(model: EventSourceModel): void;
+    afterDestroy(model: EventSourceModel): void;
+    getEffectConfig(id: number): string;
+}

package/dist/server/trigger/Trigger.js

@@ -0,0 +1,71 @@
+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 Trigger_exports = {};
+__export(Trigger_exports, {
+  EventSourceTrigger: () => EventSourceTrigger
+});
+module.exports = __toCommonJS(Trigger_exports);
+class EventSourceTrigger {
+  constructor(app, realTimeRefresh = false) {
+    this.realTimeRefresh = false;
+    this.workSet = /* @__PURE__ */ new Set();
+    this.effectConfigMap = /* @__PURE__ */ new Map();
+    this.app = app;
+    this.realTimeRefresh = realTimeRefresh;
+  }
+  getRealTimeRefresh() {
+    return this.realTimeRefresh;
+  }
+  // 加载到中间件|事件(app,db,API)|API
+  load(model) {
+  }
+  // 加载到中间件|事件(app,db,API)|API
+  afterAllLoad() {
+  }
+  workSetAdd(id) {
+    this.workSet.add(id);
+  }
+  workSetDelete(id) {
+    this.workSet.delete(id);
+  }
+  effectConfigSet(id, config) {
+    this.effectConfigMap.set(id, config);
+  }
+  // 判断是否生效(中间件中执行)
+  getEffect(model) {
+    return this.workSet.has(model.id);
+  }
+  afterCreate(model) {
+  }
+  afterUpdate(model) {
+  }
+  afterDestroy(model) {
+  }
+  getEffectConfig(id) {
+    const model = this.effectConfigMap.get(id);
+    if (!model) {
+      return null;
+    }
+    const { enabled, type, options, workflowKey } = model;
+    return JSON.stringify({ enabled, type, options, workflowKey }, null, 2);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventSourceTrigger
+});

package/dist/server/types.d.ts

@@ -0,0 +1,6 @@
+import { Application } from '@tachybase/server';
+import { EventSourceModel } from './model/EventSourceModel';
+export interface IEventSourceTrigger {
+    load: (model: EventSourceModel, app: Application) => void;
+    getEffect: (model: EventSourceModel) => boolean;
+}

package/dist/server/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -1,4 +1,9 @@
 import { Plugin } from '@tachybase/server';
+import { Registry } from '@tachybase/utils';
+import { EventSourceTrigger } from '../trigger/Trigger';
 export declare class PluginWebhook extends Plugin {
+    triggers: Registry<EventSourceTrigger>;
+    beforeLoad(): Promise<void>;
     load(): Promise<void>;
+    loadEventSources(): Promise<void>;
 }