@nocobase/plugin-workflow 0.19.0-alpha.8 → 0.19.0-alpha.9

package/dist/server/triggers/ScheduleTrigger/index.js

@@ -0,0 +1,74 @@
+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 ScheduleTrigger_exports = {};
+__export(ScheduleTrigger_exports, {
+  default: () => ScheduleTrigger
+});
+module.exports = __toCommonJS(ScheduleTrigger_exports);
+var import__ = __toESM(require(".."));
+var import_DateFieldScheduleTrigger = __toESM(require("./DateFieldScheduleTrigger"));
+var import_StaticScheduleTrigger = __toESM(require("./StaticScheduleTrigger"));
+var import_utils = require("./utils");
+class ScheduleTrigger extends import__.default {
+  sync = false;
+  modes = /* @__PURE__ */ new Map();
+  constructor(workflow) {
+    super(workflow);
+    this.modes.set(import_utils.SCHEDULE_MODE.STATIC, new import_StaticScheduleTrigger.default(workflow));
+    this.modes.set(import_utils.SCHEDULE_MODE.DATE_FIELD, new import_DateFieldScheduleTrigger.default(workflow));
+  }
+  getTrigger(mode) {
+    return this.modes.get(mode);
+  }
+  on(workflow) {
+    const mode = workflow.config.mode;
+    const trigger = this.getTrigger(mode);
+    if (trigger) {
+      trigger.on(workflow);
+    }
+  }
+  off(workflow) {
+    const mode = workflow.config.mode;
+    const trigger = this.getTrigger(mode);
+    if (trigger) {
+      trigger.off(workflow);
+    }
+  }
+  async validateEvent(workflow, context, options) {
+    if (!context.date) {
+      return false;
+    }
+    const existed = await workflow.countExecutions({
+      where: {
+        "context.date": context.date
+      },
+      transaction: options.transaction
+    });
+    return !existed;
+  }
+}

package/dist/server/triggers/ScheduleTrigger/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const SCHEDULE_MODE: {
+    readonly STATIC: 0;
+    readonly DATE_FIELD: 1;
+};
+export declare function parseDateWithoutMs(date: string): number;

package/dist/server/triggers/ScheduleTrigger/utils.js

@@ -0,0 +1,35 @@
+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 utils_exports = {};
+__export(utils_exports, {
+  SCHEDULE_MODE: () => SCHEDULE_MODE,
+  parseDateWithoutMs: () => parseDateWithoutMs
+});
+module.exports = __toCommonJS(utils_exports);
+const SCHEDULE_MODE = {
+  STATIC: 0,
+  DATE_FIELD: 1
+};
+function parseDateWithoutMs(date) {
+  return Math.floor(Date.parse(date) / 1e3) * 1e3;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SCHEDULE_MODE,
+  parseDateWithoutMs
+});

package/package.json

@@ -2,15 +2,15 @@
   "name": "@nocobase/plugin-workflow",
   "displayName": "Workflow",
   "displayName.zh-CN": "工作流",
-  "description": "A powerful workflow plugin designed to support business process management and automation.",
-  "description.zh-CN": "工作流插件，为业务流程管理和自动化提供支持。",
-  "version": "0.19.0-alpha.8",
+  "description": "A powerful BPM tool that provides foundational support for business automation, with the capability to extend unlimited triggers and nodes.",
+  "description.zh-CN": "一个强大的 BPM 工具，为业务自动化提供基础支持，并且可任意扩展更多的触发器和节点。",
+  "version": "0.19.0-alpha.9",
   "license": "AGPL-3.0",
   "main": "./dist/server/index.js",
   "homepage": "https://docs.nocobase.com/plugins/workflow",
   "homepage.zh-CN": "https://docs-cn.nocobase.com/plugins/workflow",
   "dependencies": {
-    "@nocobase/plugin-workflow-test": "0.19.0-alpha.8"
+    "@nocobase/plugin-workflow-test": "0.19.0-alpha.9"
   },
   "devDependencies": {
     "@ant-design/icons": "5.x",
@@ -45,7 +45,7 @@
     "@nocobase/test": "0.x",
     "@nocobase/utils": "0.x"
   },
-  "gitHead": "b8fbe613e320e40ebf2da1bf64907eab0197b589",
+  "gitHead": "975f9c58a1995df6a8d7a4d191a0dc4a9769ebc5",
   "keywords": [
     "Workflow"
   ]

package/dist/server/triggers/ScheduleTrigger.d.ts

@@ -1,42 +0,0 @@
-import type Plugin from '../Plugin';
-import Trigger from '.';
-export type ScheduleOnField = string | {
-    field: string;
-    offset?: number;
-    unit?: 1000 | 60000 | 3600000 | 86400000;
-};
-export interface ScheduleTriggerConfig {
-    mode: number;
-    repeat?: string | number | null;
-    limit?: number;
-    startsOn?: ScheduleOnField;
-    endsOn?: ScheduleOnField;
-}
-export declare const SCHEDULE_MODE: {
-    readonly CONSTANT: 0;
-    readonly COLLECTION_FIELD: 1;
-};
-declare function matchNext(this: ScheduleTrigger, workflow: any, now: Date, range?: number): boolean;
-export default class ScheduleTrigger extends Trigger {
-    sync: boolean;
-    static CacheRules: (typeof matchNext | ((workflow: any, now: any) => any))[];
-    static TriggerRules: ((workflow: any, now: any) => any)[];
-    events: Map<any, any>;
-    private timer;
-    private cache;
-    interval: number;
-    cacheCycle: number;
-    constructor(workflow: Plugin);
-    init(): void;
-    run: () => void;
-    onTick(now: any): Promise<any>;
-    reload(): Promise<void>;
-    inspect(workflows: any): void;
-    setCache(workflow: any, out?: boolean): void;
-    shouldCache(workflow: any, now: any): Promise<boolean>;
-    shouldTrigger(workflow: any, now: any): boolean;
-    trigger(workflow: any, date: Date): Promise<any>;
-    on(workflow: any): void;
-    off(workflow: any): void;
-}
-export {};

package/dist/server/triggers/ScheduleTrigger.js

@@ -1,481 +0,0 @@
-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 ScheduleTrigger_exports = {};
-__export(ScheduleTrigger_exports, {
-  SCHEDULE_MODE: () => SCHEDULE_MODE,
-  default: () => ScheduleTrigger
-});
-module.exports = __toCommonJS(ScheduleTrigger_exports);
-var import_database = require("@nocobase/database");
-var import_cron_parser = __toESM(require("cron-parser"));
-var import__ = __toESM(require("."));
-const SCHEDULE_MODE = {
-  CONSTANT: 0,
-  COLLECTION_FIELD: 1
-};
-const ScheduleModes = /* @__PURE__ */ new Map();
-function parseDateWithoutMs(date) {
-  return Math.floor(Date.parse(date) / 1e3) * 1e3;
-}
-ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
-  shouldCache(workflow, now) {
-    const { startsOn, endsOn, repeat } = workflow.config;
-    const timestamp = now.getTime();
-    const startTime = parseDateWithoutMs(startsOn);
-    if (!startTime || startTime > timestamp + this.cacheCycle) {
-      return false;
-    }
-    if (repeat) {
-      if (typeof repeat === "number") {
-        const next = timestamp - (timestamp - startTime) % repeat + repeat;
-        if (next <= timestamp || next > timestamp + this.cacheCycle) {
-          return false;
-        }
-      }
-      if (endsOn) {
-        const endTime = parseDateWithoutMs(endsOn);
-        if (!endTime || endTime <= timestamp) {
-          return false;
-        }
-      }
-    } else {
-      if (startTime <= timestamp) {
-        return false;
-      }
-    }
-    return true;
-  },
-  trigger(workflow, now) {
-    const { startsOn, endsOn, repeat } = workflow.config;
-    const timestamp = now.getTime();
-    const startTime = parseDateWithoutMs(startsOn);
-    if (!startTime || startTime > timestamp) {
-      return 0;
-    }
-    if (repeat) {
-      if (typeof repeat === "number") {
-        if (Math.round(timestamp - startTime) % repeat) {
-          return 0;
-        }
-      }
-      if (endsOn) {
-        const endTime = parseDateWithoutMs(endsOn);
-        if (!endTime || endTime < timestamp) {
-          return 0;
-        }
-      }
-    } else {
-      if (startTime !== timestamp) {
-        return 0;
-      }
-    }
-    this.workflow.trigger(workflow, { date: now });
-    return 1;
-  }
-});
-function getOnTimestampWithOffset(on, now) {
-  switch (typeof on) {
-    case "string":
-      return parseDateWithoutMs(on);
-    case "object": {
-      const { field, offset = 0, unit = 1e3 } = on;
-      if (!field) {
-        return null;
-      }
-      const timestamp = now.getTime();
-      return timestamp - offset * unit;
-    }
-    default:
-      return null;
-  }
-}
-function getDataOptionTime(data, on, dir = 1) {
-  if (!on) {
-    return null;
-  }
-  switch (typeof on) {
-    case "string": {
-      const time = parseDateWithoutMs(on);
-      return time ? time : null;
-    }
-    case "object": {
-      const { field, offset = 0, unit = 1e3 } = on;
-      return data.get(field) ? data.get(field).getTime() - offset * unit * dir : null;
-    }
-    default:
-      return null;
-  }
-}
-function getHookId(workflow, type) {
-  return `${type}#${workflow.id}`;
-}
-const DialectTimestampFnMap = {
-  postgres(col) {
-    return `CAST(FLOOR(extract(epoch from "${col}")) AS INTEGER)`;
-  },
-  mysql(col) {
-    return `CAST(FLOOR(UNIX_TIMESTAMP(\`${col}\`)) AS SIGNED INTEGER)`;
-  },
-  sqlite(col) {
-    return `CAST(FLOOR(unixepoch(${col})) AS INTEGER)`;
-  }
-};
-DialectTimestampFnMap.mariadb = DialectTimestampFnMap.mysql;
-ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
-  on(workflow) {
-    const { collection, startsOn, endsOn, repeat } = workflow.config;
-    const event = `${collection}.afterSave`;
-    const name = getHookId(workflow, event);
-    if (this.events.has(name)) {
-      return;
-    }
-    const listener = async (data, options) => {
-      const now = /* @__PURE__ */ new Date();
-      now.setMilliseconds(0);
-      const timestamp = now.getTime();
-      const startTime = getDataOptionTime(data, startsOn);
-      const endTime = getDataOptionTime(data, endsOn, -1);
-      if (!startTime) {
-        return;
-      }
-      if (startTime && startTime > timestamp + this.cacheCycle) {
-        return;
-      }
-      if (endTime && endTime <= timestamp) {
-        return;
-      }
-      if (!matchNext.call(this, workflow, now)) {
-        return;
-      }
-      if (typeof repeat === "number" && repeat > this.cacheCycle && (timestamp - startTime) % repeat > this.cacheCycle) {
-        return;
-      }
-      this.setCache(workflow);
-    };
-    this.events.set(name, listener);
-    this.workflow.app.db.on(event, listener);
-  },
-  off(workflow) {
-    const { collection } = workflow.config;
-    const event = `${collection}.afterSave`;
-    const name = getHookId(workflow, event);
-    if (this.events.has(name)) {
-      const listener = this.events.get(name);
-      this.events.delete(name);
-      this.workflow.app.db.off(event, listener);
-    }
-  },
-  async shouldCache(workflow, now) {
-    const { db } = this.workflow.app;
-    const { startsOn, endsOn, repeat, collection } = workflow.config;
-    const timestamp = now.getTime();
-    const startTimestamp = getOnTimestampWithOffset(startsOn, now);
-    if (!startTimestamp) {
-      return false;
-    }
-    const conditions = [
-      {
-        [startsOn.field]: {
-          [import_database.Op.lt]: new Date(startTimestamp + this.cacheCycle)
-        }
-      }
-    ];
-    if (repeat) {
-      const tsFn = DialectTimestampFnMap[db.options.dialect];
-      if (typeof repeat === "number" && repeat > this.cacheCycle && tsFn) {
-        const modExp = (0, import_database.fn)(
-          "MOD",
-          (0, import_database.literal)(`${Math.round(timestamp / 1e3)} - ${tsFn(startsOn.field)}`),
-          Math.round(repeat / 1e3)
-        );
-        conditions.push((0, import_database.where)(modExp, { [import_database.Op.lt]: Math.round(this.cacheCycle / 1e3) }));
-      }
-      if (endsOn) {
-        const endTimestamp = getOnTimestampWithOffset(endsOn, now);
-        if (!endTimestamp) {
-          return false;
-        }
-        if (typeof endsOn === "string") {
-          if (endTimestamp <= timestamp) {
-            return false;
-          }
-        } else {
-          conditions.push({
-            [endsOn.field]: {
-              [import_database.Op.gte]: new Date(endTimestamp + this.interval)
-            }
-          });
-        }
-      }
-    } else {
-      conditions.push({
-        [startsOn.field]: {
-          [import_database.Op.gte]: new Date(startTimestamp)
-        }
-      });
-    }
-    const { model } = db.getCollection(collection);
-    const count = await model.count({
-      where: { [import_database.Op.and]: conditions }
-    });
-    return Boolean(count);
-  },
-  async trigger(workflow, now) {
-    const { startsOn, repeat, endsOn, collection, appends } = workflow.config;
-    const timestamp = now.getTime();
-    const startTimestamp = getOnTimestampWithOffset(startsOn, now);
-    if (!startTimestamp) {
-      return 0;
-    }
-    const conditions = [
-      {
-        [startsOn.field]: {
-          [import_database.Op.lt]: new Date(startTimestamp + this.interval)
-        }
-      }
-    ];
-    if (repeat) {
-      conditions.push({
-        [startsOn.field]: {
-          [import_database.Op.lt]: new Date(startTimestamp)
-        }
-      });
-      const tsFn = DialectTimestampFnMap[this.workflow.app.db.options.dialect];
-      if (typeof repeat === "number" && tsFn) {
-        const modExp = (0, import_database.fn)(
-          "MOD",
-          (0, import_database.literal)(`${Math.round(timestamp / 1e3)} - ${tsFn(startsOn.field)}`),
-          Math.round(repeat / 1e3)
-        );
-        conditions.push((0, import_database.where)(modExp, { [import_database.Op.eq]: 0 }));
-      }
-      if (endsOn) {
-        const endTimestamp = getOnTimestampWithOffset(endsOn, now);
-        if (!endTimestamp) {
-          return 0;
-        }
-        if (typeof endsOn === "string") {
-          if (endTimestamp <= timestamp) {
-            return 0;
-          }
-        } else {
-          conditions.push({
-            [endsOn.field]: {
-              [import_database.Op.gte]: new Date(endTimestamp + this.interval)
-            }
-          });
-        }
-      }
-    } else {
-      conditions.push({
-        [startsOn.field]: {
-          [import_database.Op.gte]: new Date(startTimestamp)
-        }
-      });
-    }
-    const repo = this.workflow.app.db.getRepository(collection);
-    const instances = await repo.find({
-      where: {
-        [import_database.Op.and]: conditions
-      },
-      appends,
-      ...workflow.config.limit ? {
-        limit: Math.max(workflow.config.limit - workflow.allExecuted, 0)
-      } : {}
-    });
-    instances.forEach((item) => {
-      this.workflow.trigger(workflow, {
-        date: now,
-        data: item.toJSON()
-      });
-    });
-    return instances.length;
-  }
-});
-function matchNext(workflow, now, range = this.cacheCycle) {
-  const { repeat } = workflow.config;
-  if (typeof repeat !== "string") {
-    return true;
-  }
-  const currentDate = new Date(now);
-  currentDate.setMilliseconds(-1);
-  const timestamp = now.getTime();
-  const interval = import_cron_parser.default.parseExpression(repeat, { currentDate });
-  const next = interval.next();
-  if (next.getTime() - timestamp <= range) {
-    return true;
-  }
-  return false;
-}
-class ScheduleTrigger extends import__.default {
-  sync = false;
-  static CacheRules = [
-    ({ config, allExecuted }) => (config.limit ? allExecuted < config.limit : true) && config.startsOn,
-    matchNext,
-    function(workflow, now) {
-      const { mode } = workflow.config;
-      const modeHandlers = ScheduleModes.get(mode);
-      if (!modeHandlers) {
-        return false;
-      }
-      return modeHandlers.shouldCache.call(this, workflow, now);
-    }
-  ];
-  static TriggerRules = [
-    ({ config, allExecuted }) => (config.limit ? allExecuted < config.limit : true) && config.startsOn,
-    function(workflow, now) {
-      return matchNext.call(this, workflow, now, 0);
-    }
-  ];
-  events = /* @__PURE__ */ new Map();
-  timer = null;
-  cache = /* @__PURE__ */ new Map();
-  // running interval, default to 1s
-  interval = 1e3;
-  // caching workflows in range, default to 1min
-  cacheCycle = 6e4;
-  constructor(workflow) {
-    super(workflow);
-    workflow.app.on("beforeStop", () => {
-      if (this.timer) {
-        clearInterval(this.timer);
-      }
-    });
-  }
-  init() {
-    var _a;
-    if (((_a = this.workflow.app.getPlugin("multi-app-share-collection")) == null ? void 0 : _a.enabled) && this.workflow.app.name !== "main") {
-      return;
-    }
-    if (this.timer) {
-      return;
-    }
-    const now = /* @__PURE__ */ new Date();
-    this.timer = setTimeout(
-      this.run,
-      // NOTE:
-      //  try to align to system time on each second starts,
-      //  after at least 1 second initialized for everything to get ready.
-      //  so jobs in 2 seconds will be missed at first start.
-      1e3 - now.getMilliseconds()
-    );
-  }
-  run = () => {
-    const now = /* @__PURE__ */ new Date();
-    const nextInterval = 1001 - now.getMilliseconds();
-    now.setMilliseconds(0);
-    this.onTick(now);
-    if (!(now.getTime() % this.cacheCycle)) {
-      this.reload();
-    }
-    this.timer = setTimeout(this.run, nextInterval);
-  };
-  async onTick(now) {
-    const isSqlite = this.workflow.app.db.options.dialect === "sqlite";
-    return Array.from(this.cache.values()).reduce(
-      (prev, workflow) => {
-        if (!this.shouldTrigger(workflow, now)) {
-          return prev;
-        }
-        if (isSqlite) {
-          return prev.then(() => this.trigger(workflow, now));
-        }
-        this.trigger(workflow, now);
-        return null;
-      },
-      isSqlite ? Promise.resolve() : null
-    );
-  }
-  async reload() {
-    const WorkflowRepo = this.workflow.app.db.getRepository("workflows");
-    const workflows = await WorkflowRepo.find({
-      filter: { enabled: true, type: "schedule" }
-    });
-    this.cache = /* @__PURE__ */ new Map();
-    this.inspect(workflows);
-  }
-  inspect(workflows) {
-    const now = /* @__PURE__ */ new Date();
-    now.setMilliseconds(0);
-    workflows.forEach(async (workflow) => {
-      const should = await this.shouldCache(workflow, now);
-      if (should) {
-        this.workflow.getLogger(workflow.id).info("caching scheduled workflow will run in next minute");
-      }
-      this.setCache(workflow, !should);
-    });
-  }
-  setCache(workflow, out = false) {
-    out ? this.cache.delete(workflow.id) : this.cache.set(workflow.id, workflow);
-  }
-  async shouldCache(workflow, now) {
-    for await (const rule of this.constructor.CacheRules) {
-      if (!await rule.call(this, workflow, now)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  shouldTrigger(workflow, now) {
-    for (const rule of this.constructor.TriggerRules) {
-      if (!rule.call(this, workflow, now)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  async trigger(workflow, date) {
-    const { mode } = workflow.config;
-    const modeHandlers = ScheduleModes.get(mode);
-    if (!modeHandlers) {
-      return;
-    }
-    return modeHandlers.trigger.call(this, workflow, date);
-  }
-  on(workflow) {
-    this.init();
-    const { mode } = workflow.config;
-    const modeHandlers = ScheduleModes.get(mode);
-    if (modeHandlers && modeHandlers.on) {
-      modeHandlers.on.call(this, workflow);
-    }
-    this.inspect([workflow]);
-  }
-  off(workflow) {
-    const { mode } = workflow.config;
-    const modeHandlers = ScheduleModes.get(mode);
-    if (modeHandlers && modeHandlers.off) {
-      modeHandlers.off.call(this, workflow);
-    }
-    this.cache.delete(workflow.id);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  SCHEDULE_MODE
-});