@nocobase/plugin-workflow 0.11.1-alpha.5 → 0.12.0-alpha.2

package/dist/server/collections/workflows.js

@@ -0,0 +1,90 @@
+'use strict';
+
+function workflows_default() {
+  return {
+    namespace: "workflow.workflowConfig",
+    duplicator: "required",
+    name: "workflows",
+    fields: [
+      {
+        name: "key",
+        type: "uid"
+      },
+      {
+        type: "string",
+        name: "title",
+        required: true
+      },
+      {
+        type: "boolean",
+        name: "enabled",
+        defaultValue: false
+      },
+      {
+        type: "text",
+        name: "description"
+      },
+      {
+        type: "string",
+        name: "type",
+        required: true
+      },
+      {
+        type: "json",
+        name: "config",
+        required: true,
+        defaultValue: {}
+      },
+      {
+        type: "boolean",
+        name: "useTransaction"
+        // defaultValue: true,
+      },
+      {
+        type: "hasMany",
+        name: "nodes",
+        target: "flow_nodes",
+        onDelete: "CASCADE"
+      },
+      {
+        type: "hasMany",
+        name: "executions",
+        onDelete: "CASCADE"
+      },
+      {
+        type: "integer",
+        name: "executed",
+        defaultValue: 0
+      },
+      {
+        type: "integer",
+        name: "allExecuted",
+        defaultValue: 0
+      },
+      {
+        type: "boolean",
+        name: "current",
+        defaultValue: false
+      },
+      {
+        type: "hasMany",
+        name: "revisions",
+        target: "workflows",
+        foreignKey: "key",
+        sourceKey: "key",
+        // NOTE: no constraints needed here because tricky self-referencing
+        constraints: false,
+        onDelete: "NO ACTION"
+      }
+    ],
+    // NOTE: use unique index for avoiding deadlock in mysql when setCurrent
+    indexes: [
+      {
+        unique: true,
+        fields: ["key", "current"]
+      }
+    ]
+  };
+}
+
+module.exports = workflows_default;

package/{lib → dist}/server/constants.js

@@ -1,9 +1,5 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.JOB_STATUS = exports.EXECUTION_STATUS = exports.BRANCH_INDEX = void 0;
 const EXECUTION_STATUS = {
   QUEUEING: null,
   STARTED: 0,
@@ -14,7 +10,6 @@ const EXECUTION_STATUS = {
   CANCELED: -4,
   REJECTED: -5
 };
-exports.EXECUTION_STATUS = EXECUTION_STATUS;
 const JOB_STATUS = {
   PENDING: 0,
   RESOLVED: 1,
@@ -24,10 +19,12 @@ const JOB_STATUS = {
   CANCELED: -4,
   REJECTED: -5
 };
-exports.JOB_STATUS = JOB_STATUS;
 const BRANCH_INDEX = {
   DEFAULT: null,
   ON_TRUE: 1,
   ON_FALSE: 0
 };
-exports.BRANCH_INDEX = BRANCH_INDEX;
+
+exports.BRANCH_INDEX = BRANCH_INDEX;
+exports.EXECUTION_STATUS = EXECUTION_STATUS;
+exports.JOB_STATUS = JOB_STATUS;

package/dist/server/fields/expression-field.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var database = require('@nocobase/database');
+
+class ExpressionField extends database.Field {
+  get dataType() {
+    return database.DataTypes.TEXT;
+  }
+}
+
+exports.ExpressionField = ExpressionField;

package/dist/server/fields/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var expressionField = require('./expression-field');
+
+function fields_default(plugin) {
+  plugin.db.registerFieldTypes({
+    expression: expressionField.ExpressionField
+  });
+}
+
+module.exports = fields_default;

package/dist/server/functions/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function now() {
+  return /* @__PURE__ */ new Date();
+}
+function functions_default({ functions }, more = {}) {
+  functions.register("now", now);
+  for (const [name, fn] of Object.entries(more)) {
+    functions.register(name, fn);
+  }
+}
+
+module.exports = functions_default;

package/dist/server/index.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('./constants');
+var triggers = require('./triggers');
+var Processor = require('./Processor');
+var Plugin = require('./Plugin');
+var types = require('./types');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Processor__default = /*#__PURE__*/_interopDefault(Processor);
+var Plugin__default = /*#__PURE__*/_interopDefault(Plugin);
+
+
+
+Object.defineProperty(exports, 'Trigger', {
+  enumerable: true,
+  get: function () { return triggers.Trigger; }
+});
+Object.defineProperty(exports, 'Processor', {
+  enumerable: true,
+  get: function () { return Processor__default.default; }
+});
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () { return Plugin__default.default; }
+});
+Object.keys(constants).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return constants[k]; }
+  });
+});
+Object.keys(types).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return types[k]; }
+  });
+});

package/dist/server/instructions/aggregate.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var database = require('@nocobase/database');
+var constants = require('../constants');
+
+const aggregators = {
+  count: "count",
+  sum: "sum",
+  avg: "avg",
+  min: "min",
+  max: "max"
+};
+var aggregate_default = {
+  async run(node, input, processor) {
+    const { aggregator, associated, collection, association = {}, params = {} } = node.config;
+    const options = processor.getParsedValue(params);
+    const { database: database$1 } = node.constructor;
+    const repo = associated ? database$1.getRepository(
+      `${association == null ? void 0 : association.associatedCollection}.${association.name}`,
+      processor.getParsedValue(association == null ? void 0 : association.associatedKey)
+    ) : database$1.getRepository(collection);
+    if (!options.dataType && aggregator === "avg") {
+      options.dataType = database.DataTypes.DOUBLE;
+    }
+    const result = await repo.aggregate({
+      ...options,
+      method: aggregators[aggregator],
+      transaction: processor.transaction
+    });
+    return {
+      result: options.dataType === database.DataTypes.DOUBLE ? Number(result) : result,
+      status: constants.JOB_STATUS.RESOLVED
+    };
+  }
+};
+
+module.exports = aggregate_default;

package/dist/server/instructions/calculation.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var evaluators = require('@nocobase/evaluators');
+var utils = require('@nocobase/utils');
+var constants = require('../constants');
+
+var calculation_default = {
+  async run(node, prevJob, processor) {
+    const { dynamic = false } = node.config || {};
+    let { engine = "math.js", expression = "" } = node.config;
+    let scope = processor.getScope(node);
+    if (dynamic) {
+      const parsed = utils.parse(dynamic)(scope) ?? {};
+      engine = parsed.engine;
+      expression = parsed.expression;
+      scope = utils.parse(node.config.scope ?? "")(scope) ?? {};
+    }
+    const evaluator = evaluators.evaluators.get(engine);
+    try {
+      const result = evaluator && expression ? evaluator(expression, scope) : null;
+      return {
+        result,
+        status: constants.JOB_STATUS.RESOLVED
+      };
+    } catch (e) {
+      return {
+        result: e.toString(),
+        status: constants.JOB_STATUS.ERROR
+      };
+    }
+  }
+};
+
+module.exports = calculation_default;

package/dist/server/instructions/condition.js

@@ -0,0 +1,123 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var evaluators = require('@nocobase/evaluators');
+var utils = require('@nocobase/utils');
+var constants = require('../constants');
+
+const calculators = new utils.Registry();
+function equal(a, b) {
+  return a == b;
+}
+function notEqual(a, b) {
+  return a != b;
+}
+function gt(a, b) {
+  return a > b;
+}
+function gte(a, b) {
+  return a >= b;
+}
+function lt(a, b) {
+  return a < b;
+}
+function lte(a, b) {
+  return a <= b;
+}
+calculators.register("equal", equal);
+calculators.register("notEqual", notEqual);
+calculators.register("gt", gt);
+calculators.register("gte", gte);
+calculators.register("lt", lt);
+calculators.register("lte", lte);
+calculators.register("==", equal);
+calculators.register("!=", notEqual);
+calculators.register(">", gt);
+calculators.register(">=", gte);
+calculators.register("<", lt);
+calculators.register("<=", lte);
+function includes(a, b) {
+  return a.includes(b);
+}
+function notIncludes(a, b) {
+  return !a.includes(b);
+}
+function startsWith(a, b) {
+  return a.startsWith(b);
+}
+function notStartsWith(a, b) {
+  return !a.startsWith(b);
+}
+function endsWith(a, b) {
+  return a.endsWith(b);
+}
+function notEndsWith(a, b) {
+  return !a.endsWith(b);
+}
+calculators.register("includes", includes);
+calculators.register("notIncludes", notIncludes);
+calculators.register("startsWith", startsWith);
+calculators.register("notStartsWith", notStartsWith);
+calculators.register("endsWith", endsWith);
+calculators.register("notEndsWith", notEndsWith);
+function calculate(calculation = {}) {
+  let fn;
+  if (!(calculation.calculator && (fn = calculators.get(calculation.calculator)))) {
+    throw new Error(`no calculator function registered for "${calculation.calculator}"`);
+  }
+  return Boolean(fn(...calculation.operands ?? []));
+}
+function logicCalculate(calculation) {
+  if (!calculation) {
+    return true;
+  }
+  if (typeof calculation["group"] === "object") {
+    const method = calculation["group"].type === "and" ? "every" : "some";
+    return (calculation["group"].calculations ?? [])[method]((item) => logicCalculate(item));
+  }
+  return calculate(calculation);
+}
+var condition_default = {
+  async run(node, prevJob, processor) {
+    const { engine, calculation, expression, rejectOnFalse } = node.config || {};
+    const evaluator = evaluators.evaluators.get(engine);
+    let result = true;
+    try {
+      result = evaluator ? evaluator(expression, processor.getScope()) : logicCalculate(processor.getParsedValue(calculation, node));
+    } catch (e) {
+      return {
+        result: e.toString(),
+        status: constants.JOB_STATUS.ERROR
+      };
+    }
+    if (!result && rejectOnFalse) {
+      return {
+        status: constants.JOB_STATUS.FAILED,
+        result
+      };
+    }
+    const job = {
+      status: constants.JOB_STATUS.RESOLVED,
+      result,
+      // TODO(optimize): try unify the building of job
+      nodeId: node.id,
+      upstreamId: prevJob && prevJob.id || null
+    };
+    const branchNode = processor.nodes.find((item) => item.upstream === node && Boolean(item.branchIndex) === result);
+    if (!branchNode) {
+      return job;
+    }
+    const savedJob = await processor.saveJob(job);
+    return processor.run(branchNode, savedJob);
+  },
+  async resume(node, branchJob, processor) {
+    if (branchJob.status === constants.JOB_STATUS.RESOLVED) {
+      return branchJob;
+    }
+    return processor.end(node, branchJob);
+  }
+};
+
+exports.calculators = calculators;
+exports.default = condition_default;

package/{src/server/instructions/create.ts → dist/server/instructions/create.js}

@@ -1,39 +1,39 @@
-import { JOB_STATUS } from '../constants';
-import { toJSON } from '../utils';
-import type { FlowNodeModel } from '../types';
+'use strict';
 
-export default {
-  async run(node: FlowNodeModel, input, processor) {
-    const { collection, params: { appends = [], ...params } = {} } = node.config;
+var constants = require('../constants');
+var utils = require('../utils');
 
-    const { repository, model } = (<typeof FlowNodeModel>node.constructor).database.getCollection(collection);
+var create_default = {
+  async run(node, input, processor) {
+    const { collection, params: { appends = [], ...params } = {} } = node.config;
+    const { repository, model } = node.constructor.database.getCollection(collection);
     const options = processor.getParsedValue(params, node);
     const created = await repository.create({
       ...options,
       context: {
-        executionId: processor.execution.id,
+        executionId: processor.execution.id
       },
-      transaction: processor.transaction,
+      transaction: processor.transaction
     });
-
     let result = created;
     if (created && appends.length) {
       const includeFields = appends.reduce((set, field) => {
-        set.add(field.split('.')[0]);
+        set.add(field.split(".")[0]);
         set.add(field);
         return set;
-      }, new Set());
+      }, /* @__PURE__ */ new Set());
       result = await repository.findOne({
         filterByTk: created[model.primaryKeyAttribute],
         appends: Array.from(includeFields),
-        transaction: processor.transaction,
+        transaction: processor.transaction
       });
     }
-
     return {
       // NOTE: get() for non-proxied instance (#380)
-      result: toJSON(result),
-      status: JOB_STATUS.RESOLVED,
+      result: utils.toJSON(result),
+      status: constants.JOB_STATUS.RESOLVED
     };
-  },
+  }
 };
+
+module.exports = create_default;

package/dist/server/instructions/delay.js

@@ -0,0 +1,87 @@
+'use strict';
+
+var constants = require('../constants');
+
+class delay_default {
+  constructor(plugin) {
+    this.plugin = plugin;
+    plugin.app.on("beforeStart", this.load);
+    plugin.app.on("beforeStop", this.unload);
+  }
+  timers = /* @__PURE__ */ new Map();
+  load = async () => {
+    const { model } = this.plugin.db.getCollection("jobs");
+    const jobs = await model.findAll({
+      where: {
+        status: constants.JOB_STATUS.PENDING
+      },
+      include: [
+        {
+          association: "execution",
+          attributes: [],
+          where: {
+            status: constants.EXECUTION_STATUS.STARTED
+          },
+          required: true
+        },
+        {
+          association: "node",
+          attributes: ["config"],
+          where: {
+            type: "delay"
+          },
+          required: true
+        }
+      ]
+    });
+    jobs.forEach((job) => {
+      this.schedule(job);
+    });
+  };
+  unload = () => {
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers = /* @__PURE__ */ new Map();
+  };
+  schedule(job) {
+    const now = /* @__PURE__ */ new Date();
+    const createdAt = Date.parse(job.createdAt);
+    const delay = createdAt + job.node.config.duration - now.getTime();
+    if (delay > 0) {
+      const trigger = this.trigger.bind(this, job);
+      this.timers.set(job.id, setTimeout(trigger, delay));
+    } else {
+      this.trigger(job);
+    }
+  }
+  async trigger(job) {
+    if (!job.execution) {
+      job.execution = await job.getExecution();
+    }
+    if (job.execution.status === constants.EXECUTION_STATUS.STARTED) {
+      this.plugin.resume(job);
+    }
+    if (this.timers.get(job.id)) {
+      this.timers.delete(job.id);
+    }
+  }
+  run = async (node, prevJob, processor) => {
+    const job = await processor.saveJob({
+      status: constants.JOB_STATUS.PENDING,
+      result: null,
+      nodeId: node.id,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    job.node = node;
+    this.schedule(job);
+    return processor.exit();
+  };
+  resume = async (node, prevJob, processor) => {
+    const { endStatus } = node.config;
+    prevJob.set("status", endStatus);
+    return prevJob;
+  };
+}
+
+module.exports = delay_default;

package/dist/server/instructions/destroy.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var constants = require('../constants');
+
+var destroy_default = {
+  async run(node, input, processor) {
+    const { collection, params = {} } = node.config;
+    const repo = node.constructor.database.getRepository(collection);
+    const options = processor.getParsedValue(params, node);
+    const result = await repo.destroy({
+      ...options,
+      context: {
+        executionId: processor.execution.id
+      },
+      transaction: processor.transaction
+    });
+    return {
+      result,
+      status: constants.JOB_STATUS.RESOLVED
+    };
+  }
+};
+
+module.exports = destroy_default;

package/dist/server/instructions/index.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var path = require('path');
+var utils = require('@nocobase/utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+function instructions_default(plugin, more = {}) {
+  const { instructions } = plugin;
+  const natives = [
+    "calculation",
+    "condition",
+    "parallel",
+    "loop",
+    "delay",
+    "manual",
+    "query",
+    "create",
+    "update",
+    "destroy",
+    "aggregate",
+    "request",
+    "sql"
+  ].reduce(
+    (result, key) => Object.assign(result, {
+      [key]: utils.requireModule(path__default.default.isAbsolute(key) ? key : path__default.default.join(__dirname, key))
+    }),
+    {}
+  );
+  for (const [name, instruction] of Object.entries({ ...more, ...natives })) {
+    instructions.register(
+      name,
+      typeof instruction === "function" ? new instruction(plugin) : instruction
+    );
+  }
+}
+
+module.exports = instructions_default;