@nocobase/plugin-workflow 0.11.1-alpha.4 → 0.12.0-alpha.1

package/dist/server/instructions/query.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var constants = require('../constants');
+var utils = require('../utils');
+
+var query_default = {
+  async run(node, input, processor) {
+    const { collection, multiple, params = {}, failOnEmpty = false } = node.config;
+    const repo = node.constructor.database.getRepository(collection);
+    const options = processor.getParsedValue(params, node);
+    const appends = options.appends ? Array.from(
+      options.appends.reduce((set, field) => {
+        set.add(field.split(".")[0]);
+        set.add(field);
+        return set;
+      }, /* @__PURE__ */ new Set())
+    ) : options.appends;
+    const result = await (multiple ? repo.find : repo.findOne).call(repo, {
+      ...options,
+      appends,
+      transaction: processor.transaction
+    });
+    if (failOnEmpty && (multiple ? !result.length : !result)) {
+      return {
+        result,
+        status: constants.JOB_STATUS.FAILED
+      };
+    }
+    return {
+      result: utils.toJSON(result),
+      status: constants.JOB_STATUS.RESOLVED
+    };
+  }
+};
+
+module.exports = query_default;

package/dist/server/instructions/request.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var axios = require('axios');
+var constants = require('../constants');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+async function request(config) {
+  const { url, method = "POST", data, timeout = 5e3 } = config;
+  const headers = (config.headers ?? []).reduce((result, header) => {
+    if (header.name.toLowerCase() === "content-type") {
+      return result;
+    }
+    return Object.assign(result, { [header.name]: header.value });
+  }, {});
+  const params = (config.params ?? []).reduce(
+    (result, param) => Object.assign(result, { [param.name]: param.value }),
+    {}
+  );
+  headers["Content-Type"] = "application/json";
+  return axios__default.default.request({
+    url,
+    method,
+    headers,
+    params,
+    data,
+    timeout
+  });
+}
+class request_default {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  async run(node, prevJob, processor) {
+    const job = await processor.saveJob({
+      status: constants.JOB_STATUS.PENDING,
+      nodeId: node.id,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    const config = processor.getParsedValue(node.config, node);
+    request(config).then((response) => {
+      job.set({
+        status: constants.JOB_STATUS.RESOLVED,
+        result: response.data
+      });
+    }).catch((error) => {
+      job.set({
+        status: constants.JOB_STATUS.FAILED,
+        result: error.isAxiosError ? error.toJSON() : error.message
+      });
+    }).finally(() => {
+      processor.logger.info(`request (#${node.id}) response received, status: ${job.get("status")}`);
+      this.plugin.resume(job);
+    });
+    processor.logger.info(`request (#${node.id}) sent to "${config.url}", waiting for response...`);
+    return processor.exit();
+  }
+  async resume(node, job, processor) {
+    const { ignoreFail } = node.config;
+    if (ignoreFail) {
+      job.set("status", constants.JOB_STATUS.RESOLVED);
+    }
+    return job;
+  }
+}
+
+module.exports = request_default;

package/dist/server/instructions/sql.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var __ = require('..');
+
+var sql_default = {
+  async run(node, input, processor) {
+    const { sequelize } = node.constructor.database;
+    const sql = processor.getParsedValue(node.config.sql ?? "", node).trim();
+    if (!sql) {
+      return {
+        status: __.JOB_STATUS.RESOLVED
+      };
+    }
+    const result = await sequelize.query(sql, {
+      transaction: processor.transaction
+      // plain: true,
+      // model: db.getCollection(node.config.collection).model
+    });
+    return {
+      result,
+      status: __.JOB_STATUS.RESOLVED
+    };
+  }
+};
+
+module.exports = sql_default;

package/dist/server/instructions/update.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var constants = require('../constants');
+
+var update_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.update({
+      ...options,
+      context: {
+        executionId: processor.execution.id
+      },
+      transaction: processor.transaction
+    });
+    return {
+      result: result.length ?? result,
+      status: constants.JOB_STATUS.RESOLVED
+    };
+  }
+};
+
+module.exports = update_default;

package/{src/server/migrations/20221129153547-calculation-variables.ts → dist/server/migrations/20221129153547-calculation-variables.js}

@@ -1,4 +1,6 @@
-import { Migration } from '@nocobase/server';
+'use strict';
+
+var server = require('@nocobase/server');
 
 const VTypes = {
   constant(operand) {
@@ -6,18 +8,17 @@ const VTypes = {
   },
   $jobsMapByNodeId({ options }) {
     const paths = [options.nodeId, options.path].filter(Boolean);
-    return paths ? `{{$jobsMapByNodeId.${paths.join('.')}}}` : null;
+    return paths ? `{{$jobsMapByNodeId.${paths.join(".")}}}` : null;
   },
   $context({ options }) {
     return `{{$context.${options.path}}}`;
-  },
+  }
 };
-
 function migrateConfig(config) {
   if (Array.isArray(config)) {
     return config.map((item) => migrateConfig(item));
   }
-  if (typeof config !== 'object') {
+  if (typeof config !== "object") {
     return config;
   }
   if (!config) {
@@ -28,37 +29,37 @@ function migrateConfig(config) {
   }
   return Object.keys(config).reduce((memo, key) => ({ ...memo, [key]: migrateConfig(config[key]) }), {});
 }
-
-export default class extends Migration {
+class calculation_variables_default extends server.Migration {
   async up() {
-    const match = await this.app.version.satisfies('<=0.8.0-alpha.13');
+    const match = await this.app.version.satisfies("<=0.8.0-alpha.13");
     if (!match) {
       return;
     }
-    const NodeRepo = this.context.db.getRepository('flow_nodes');
+    const NodeRepo = this.context.db.getRepository("flow_nodes");
     await this.context.db.sequelize.transaction(async (transaction) => {
       const nodes = await NodeRepo.find({
         filter: {
           type: {
-            $or: ['calculation', 'condition'],
-          },
+            $or: ["calculation", "condition"]
+          }
         },
-        transaction,
+        transaction
       });
-      console.log('%d nodes need to be migrated.', nodes.length);
-
+      console.log("%d nodes need to be migrated.", nodes.length);
       await nodes.reduce((promise, node) => {
         return node.update(
           {
-            config: migrateConfig(node.config),
+            config: migrateConfig(node.config)
           },
           {
-            transaction,
-          },
+            transaction
+          }
         );
       }, Promise.resolve());
     });
   }
-
-  async down() {}
+  async down() {
+  }
 }
+
+module.exports = calculation_variables_default;

package/dist/server/migrations/20230221032941-change-request-body-type.js

@@ -0,0 +1,71 @@
+'use strict';
+
+var server = require('@nocobase/server');
+
+const EJS_RE = /"?<%=\s*(ctx|node)([\w\.\[\]-]+)\s*.*%>"?/;
+function migrateData(input) {
+  if (typeof input !== "string") {
+    return input;
+  }
+  if (!input) {
+    return null;
+  }
+  return input.replace(EJS_RE, (_, type, path) => {
+    if (type === "ctx") {
+      return `"{{$context${path}}}"`;
+    }
+    if (type === "node") {
+      return `"{{$jobsMapByNodeId${path.replace("[", ".").replace("]", ".").replace(/\.$/, "")}}}"`;
+    }
+    return _;
+  });
+}
+class change_request_body_type_default extends server.Migration {
+  async up() {
+    const match = await this.app.version.satisfies("<0.9.0-alpha.3");
+    if (!match) {
+      return;
+    }
+    const NodeRepo = this.context.db.getRepository("flow_nodes");
+    await this.context.db.sequelize.transaction(async (transaction) => {
+      const nodes = await NodeRepo.find({
+        filter: {
+          type: "request"
+        },
+        transaction
+      });
+      console.log("%d nodes need to be migrated.", nodes.length);
+      await nodes.reduce(
+        (promise, node) => promise.then(async () => {
+          if (typeof node.config.data !== "string") {
+            return;
+          }
+          let data = migrateData(node.config.data);
+          try {
+            data = JSON.parse(node.config.data);
+            return node.update(
+              {
+                config: {
+                  ...node.config,
+                  data
+                }
+              },
+              {
+                transaction
+              }
+            );
+          } catch (error) {
+            console.error(
+              `flow_node #${node.id} config migrating failed! you should migrate its format from ejs to json-templates manually in your db.`
+            );
+          }
+        }),
+        Promise.resolve()
+      );
+    });
+  }
+  async down() {
+  }
+}
+
+module.exports = change_request_body_type_default;

package/dist/server/migrations/20230221071831-calculation-expression.js

@@ -0,0 +1,94 @@
+'use strict';
+
+var server = require('@nocobase/server');
+
+function addQuote(v) {
+  if (typeof v !== "string") {
+    return v;
+  }
+  if (v.match(/^{{\s*([^{}]+)\s*}}$/)) {
+    return v;
+  }
+  return `'${v}'`;
+}
+const calculatorsMap = {
+  equal: "==",
+  "===": "==",
+  notEqual: "!=",
+  "!==": "!=",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<=",
+  add: "+",
+  minus: "-",
+  multiple: "*",
+  divide: "/",
+  mod: "%",
+  includes(a, b) {
+    return `SEARCH(${b}, ${a}) >= 0`;
+  },
+  notIncludes(a, b) {
+    return `SEARCH(${b}, ${a}) < 0`;
+  },
+  startsWith(a, b) {
+    return `SEARCH(${b}, ${a}) == 0`;
+  },
+  endsWith(a, b) {
+    return `RIGHT(${a}, LEN(${b})) == ${b}`;
+  },
+  notStartsWith(a, b) {
+    return `SEARCH(${b}, ${a}) != 0`;
+  },
+  notEndsWith(a, b) {
+    return `RIGHT(${a}, LEN(${b})) != ${b}`;
+  },
+  concat(a, b) {
+    return `CONCATENATE(${a}, ${b})`;
+  }
+};
+function migrateConfig({ calculation, ...config } = {}) {
+  var _a;
+  if (!(calculation == null ? void 0 : calculation.calculator) || !((_a = calculation == null ? void 0 : calculation.operands) == null ? void 0 : _a.length)) {
+    return config;
+  }
+  const calculator = calculatorsMap[calculation.calculator];
+  const operands = (calculator.operands ?? []).map((operand) => addQuote(operand));
+  return {
+    engine: "formula.js",
+    expression: typeof calculator === "function" ? calculator(...operands) : operands.join(` ${calculator ?? calculation.calculator} `)
+  };
+}
+class calculation_expression_default extends server.Migration {
+  async up() {
+    const match = await this.app.version.satisfies("<0.9.0-alpha.3");
+    if (!match) {
+      return;
+    }
+    const NodeRepo = this.context.db.getRepository("flow_nodes");
+    await this.context.db.sequelize.transaction(async (transaction) => {
+      const nodes = await NodeRepo.find({
+        filter: {
+          type: "calculation"
+        },
+        transaction
+      });
+      console.log("%d nodes need to be migrated.", nodes.length);
+      await nodes.reduce(
+        (promise, node) => promise.then(() => {
+          return node.update(
+            {
+              config: migrateConfig(node.config)
+            },
+            {
+              transaction
+            }
+          );
+        }),
+        Promise.resolve()
+      );
+    });
+  }
+}
+
+module.exports = calculation_expression_default;

package/dist/server/migrations/20230221121203-condition-calculation.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var server = require('@nocobase/server');
+
+class condition_calculation_default extends server.Migration {
+  async up() {
+    const match = await this.app.version.satisfies("<0.9.0-alpha.3");
+    if (!match) {
+      return;
+    }
+    const NodeRepo = this.context.db.getRepository("flow_nodes");
+    await this.context.db.sequelize.transaction(async (transaction) => {
+      const nodes = await NodeRepo.find({
+        filter: {
+          type: "condition"
+        },
+        transaction
+      });
+      console.log("%d nodes need to be migrated.", nodes.length);
+      await nodes.reduce(
+        (promise, node) => promise.then(() => {
+          return node.update(
+            {
+              config: {
+                ...node.config,
+                engine: "basic"
+                // calculation: migrateConfig(node.config.calculation)
+              }
+            },
+            {
+              transaction
+            }
+          );
+        }),
+        Promise.resolve()
+      );
+    });
+  }
+}
+
+module.exports = condition_calculation_default;

package/dist/server/migrations/20230221162902-jsonb-to-json.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var database = require('@nocobase/database');
+var server = require('@nocobase/server');
+
+class jsonb_to_json_default extends server.Migration {
+  async up() {
+    const match = await this.app.version.satisfies("<0.9.0-alpha.3");
+    if (!match) {
+      return;
+    }
+    const sequelize = this.sequelize;
+    const queryInterface = this.queryInterface;
+    const { db } = this.app;
+    await sequelize.transaction(async (transaction) => {
+      await queryInterface.changeColumn(
+        db.getCollection("workflows").model.getTableName(),
+        "config",
+        {
+          type: database.DataTypes.JSON
+        },
+        { transaction }
+      );
+      await queryInterface.changeColumn(
+        db.getCollection("flow_nodes").model.getTableName(),
+        "config",
+        {
+          type: database.DataTypes.JSON
+        },
+        { transaction }
+      );
+      await queryInterface.changeColumn(
+        db.getCollection("executions").model.getTableName(),
+        "context",
+        {
+          type: database.DataTypes.JSON
+        },
+        { transaction }
+      );
+      await queryInterface.changeColumn(
+        db.getCollection("jobs").model.getTableName(),
+        "result",
+        {
+          type: database.DataTypes.JSON
+        },
+        { transaction }
+      );
+    });
+  }
+}
+
+module.exports = jsonb_to_json_default;