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

package/lib/server/actions/nodes.js

@@ -1,269 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.create = create;
-exports.destroy = destroy;
-exports.update = update;
-function _actions() {
-  const data = require("@nocobase/actions");
-  _actions = function _actions() {
-    return data;
-  };
-  return data;
-}
-function _database() {
-  const data = require("@nocobase/database");
-  _database = function _database() {
-    return data;
-  };
-  return data;
-}
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-function create(_x, _x2) {
-  return _create.apply(this, arguments);
-}
-function _create() {
-  _create = _asyncToGenerator(function* (context, next) {
-    const db = context.db;
-    const repository = _actions().utils.getRepositoryFromParams(context);
-    const _context$action$param = context.action.params,
-      whitelist = _context$action$param.whitelist,
-      blacklist = _context$action$param.blacklist,
-      updateAssociationValues = _context$action$param.updateAssociationValues,
-      values = _context$action$param.values,
-      workflowId = _context$action$param.associatedIndex;
-    context.body = yield db.sequelize.transaction( /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator(function* (transaction) {
-        const workflow = yield repository.getSourceModel(transaction);
-        if (workflow.executed) {
-          context.throw(400, 'Node could not be created in executed workflow');
-        }
-        const instance = yield repository.create({
-          values,
-          whitelist,
-          blacklist,
-          updateAssociationValues,
-          context,
-          transaction
-        });
-        if (!instance.upstreamId) {
-          const previousHead = yield repository.findOne({
-            filter: {
-              id: {
-                $ne: instance.id
-              },
-              upstreamId: null
-            },
-            transaction
-          });
-          if (previousHead) {
-            yield previousHead.setUpstream(instance, {
-              transaction
-            });
-            yield instance.setDownstream(previousHead, {
-              transaction
-            });
-            instance.set('downstream', previousHead);
-          }
-          return instance;
-        }
-        const upstream = yield instance.getUpstream({
-          transaction
-        });
-        if (instance.branchIndex == null) {
-          const downstream = yield upstream.getDownstream({
-            transaction
-          });
-          if (downstream) {
-            yield downstream.setUpstream(instance, {
-              transaction
-            });
-            yield instance.setDownstream(downstream, {
-              transaction
-            });
-            instance.set('downstream', downstream);
-          }
-          yield upstream.update({
-            downstreamId: instance.id
-          }, {
-            transaction
-          });
-          upstream.set('downstream', instance);
-        } else {
-          const _yield$upstream$getBr = yield upstream.getBranches({
-              where: {
-                id: {
-                  [_database().Op.ne]: instance.id
-                },
-                branchIndex: instance.branchIndex
-              },
-              transaction
-            }),
-            _yield$upstream$getBr2 = _slicedToArray(_yield$upstream$getBr, 1),
-            downstream = _yield$upstream$getBr2[0];
-          if (downstream) {
-            yield downstream.update({
-              upstreamId: instance.id,
-              branchIndex: null
-            }, {
-              transaction
-            });
-            yield instance.setDownstream(downstream, {
-              transaction
-            });
-            instance.set('downstream', downstream);
-          }
-        }
-        instance.set('upstream', upstream);
-        return instance;
-      });
-      return function (_x7) {
-        return _ref.apply(this, arguments);
-      };
-    }());
-    yield next();
-  });
-  return _create.apply(this, arguments);
-}
-function searchBranchNodes(nodes, from) {
-  const branchHeads = nodes.filter(item => item.upstreamId === from.id && item.branchIndex != null);
-  return branchHeads.reduce((flatten, head) => flatten.concat(searchBranchDownstreams(nodes, head)), []);
-}
-function searchBranchDownstreams(nodes, from) {
-  let result = [];
-  for (let search = from; search; search = search.downstream) {
-    result = [...result, search, ...searchBranchNodes(nodes, search)];
-  }
-  return result;
-}
-function destroy(_x3, _x4) {
-  return _destroy.apply(this, arguments);
-}
-function _destroy() {
-  _destroy = _asyncToGenerator(function* (context, next) {
-    const db = context.db;
-    const repository = _actions().utils.getRepositoryFromParams(context);
-    const filterByTk = context.action.params.filterByTk;
-    context.body = yield db.sequelize.transaction( /*#__PURE__*/function () {
-      var _ref2 = _asyncToGenerator(function* (transaction) {
-        const workflow = yield repository.getSourceModel(transaction);
-        if (workflow.executed) {
-          context.throw(400, 'Nodes in executed workflow could not be deleted');
-        }
-        const fields = ['id', 'upstreamId', 'downstreamId', 'branchIndex'];
-        const instance = yield repository.findOne({
-          filterByTk,
-          fields: [...fields, 'workflowId'],
-          appends: ['upstream', 'downstream'],
-          transaction
-        });
-        const _instance$get = instance.get(),
-          upstream = _instance$get.upstream,
-          downstream = _instance$get.downstream;
-        if (upstream && upstream.downstreamId === instance.id) {
-          yield upstream.update({
-            downstreamId: instance.downstreamId
-          }, {
-            transaction
-          });
-        }
-        if (downstream) {
-          yield downstream.update({
-            upstreamId: instance.upstreamId,
-            branchIndex: instance.branchIndex
-          }, {
-            transaction
-          });
-        }
-        const nodes = yield repository.find({
-          filter: {
-            workflowId: instance.workflowId
-          },
-          fields,
-          transaction
-        });
-        const nodesMap = new Map();
-        // make map
-        nodes.forEach(item => {
-          nodesMap.set(item.id, item);
-        });
-        // overwrite
-        nodesMap.set(instance.id, instance);
-        // make linked list
-        nodes.forEach(item => {
-          if (item.upstreamId) {
-            item.upstream = nodesMap.get(item.upstreamId);
-          }
-          if (item.downstreamId) {
-            item.downstream = nodesMap.get(item.downstreamId);
-          }
-        });
-        const branchNodes = searchBranchNodes(nodes, instance);
-        yield repository.destroy({
-          filterByTk: [instance.id, ...branchNodes.map(item => item.id)],
-          transaction
-        });
-        return instance;
-      });
-      return function (_x8) {
-        return _ref2.apply(this, arguments);
-      };
-    }());
-    yield next();
-  });
-  return _destroy.apply(this, arguments);
-}
-function update(_x5, _x6) {
-  return _update.apply(this, arguments);
-}
-function _update() {
-  _update = _asyncToGenerator(function* (context, next) {
-    const db = context.db;
-    const repository = _actions().utils.getRepositoryFromParams(context);
-    const _context$action$param2 = context.action.params,
-      filterByTk = _context$action$param2.filterByTk,
-      values = _context$action$param2.values,
-      whitelist = _context$action$param2.whitelist,
-      blacklist = _context$action$param2.blacklist,
-      filter = _context$action$param2.filter,
-      updateAssociationValues = _context$action$param2.updateAssociationValues;
-    context.body = yield db.sequelize.transaction( /*#__PURE__*/function () {
-      var _ref3 = _asyncToGenerator(function* (transaction) {
-        // TODO(optimize): duplicated instance query
-        const _yield$repository$fin = yield repository.findOne({
-            filterByTk,
-            appends: ['workflow.executed'],
-            transaction
-          }),
-          workflow = _yield$repository$fin.workflow;
-        if (workflow.executed) {
-          context.throw(400, 'Nodes in executed workflow could not be reconfigured');
-        }
-        return repository.update({
-          filterByTk,
-          values,
-          whitelist,
-          blacklist,
-          filter,
-          updateAssociationValues,
-          context,
-          transaction
-        });
-      });
-      return function (_x9) {
-        return _ref3.apply(this, arguments);
-      };
-    }());
-    yield next();
-  });
-  return _update.apply(this, arguments);
-}

package/lib/server/actions/workflows.js

@@ -1,273 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.destroy = destroy;
-exports.revision = revision;
-exports.update = update;
-function _actions() {
-  const data = _interopRequireWildcard(require("@nocobase/actions"));
-  _actions = function _actions() {
-    return data;
-  };
-  return data;
-}
-function _database() {
-  const data = require("@nocobase/database");
-  _database = function _database() {
-    return data;
-  };
-  return data;
-}
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-function _asyncIterator(iterable) { var method, async, sync, retry = 2; for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) { if (async && null != (method = iterable[async])) return method.call(iterable); if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable)); async = "@@asyncIterator", sync = "@@iterator"; } throw new TypeError("Object is not async iterable"); }
-function AsyncFromSyncIterator(s) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var done = r.done; return Promise.resolve(r.value).then(function (value) { return { value: value, done: done }; }); } return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) { this.s = s, this.n = s.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, return: function _return(value) { var ret = this.s.return; return void 0 === ret ? Promise.resolve({ value: value, done: !0 }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments)); }, throw: function _throw(value) { var thr = this.s.return; return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(s); }
-function update(_x, _x2) {
-  return _update.apply(this, arguments);
-}
-function _update() {
-  _update = _asyncToGenerator(function* (context, next) {
-    const repository = _actions().utils.getRepositoryFromParams(context);
-    const _context$action$param = context.action.params,
-      filterByTk = _context$action$param.filterByTk,
-      values = _context$action$param.values;
-    context.action.mergeParams({
-      whitelist: ['title', 'description', 'enabled', 'config']
-    });
-    // only enable/disable
-    if (Object.keys(values).includes('config')) {
-      const workflow = yield repository.findById(filterByTk);
-      if (workflow.get('executed')) {
-        return context.throw(400, 'config of executed workflow can not be updated');
-      }
-    }
-    return _actions().default.update(context, next);
-  });
-  return _update.apply(this, arguments);
-}
-function destroy(_x3, _x4) {
-  return _destroy.apply(this, arguments);
-}
-function _destroy() {
-  _destroy = _asyncToGenerator(function* (context, next) {
-    const repository = _actions().utils.getRepositoryFromParams(context);
-    const _context$action$param2 = context.action.params,
-      filterByTk = _context$action$param2.filterByTk,
-      filter = _context$action$param2.filter;
-    yield context.db.sequelize.transaction( /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator(function* (transaction) {
-        const items = yield repository.find({
-          filterByTk,
-          filter,
-          fields: ['id', 'key', 'current'],
-          transaction
-        });
-        const ids = new Set(items.map(item => item.id));
-        const keysSet = new Set(items.filter(item => item.current).map(item => item.key));
-        const revisions = yield repository.find({
-          filter: {
-            key: Array.from(keysSet),
-            current: {
-              [_database().Op.not]: true
-            }
-          },
-          fields: ['id'],
-          transaction
-        });
-        revisions.forEach(item => ids.add(item.id));
-        context.body = yield repository.destroy({
-          filterByTk: Array.from(ids),
-          individualHooks: true,
-          transaction
-        });
-      });
-      return function (_x7) {
-        return _ref.apply(this, arguments);
-      };
-    }());
-    next();
-  });
-  return _destroy.apply(this, arguments);
-}
-function typeOf(value) {
-  if (Array.isArray(value)) {
-    return 'array';
-  } else if (value instanceof Date) {
-    return 'date';
-  } else if (value === null) {
-    return 'null';
-  }
-  return typeof value;
-}
-function migrateConfig(config, oldToNew) {
-  function migrate(value) {
-    switch (typeOf(value)) {
-      case 'object':
-        if (value.type === '$jobsMapByNodeId') {
-          var _oldToNew$get, _value$options;
-          return _objectSpread(_objectSpread({}, value), {}, {
-            options: _objectSpread(_objectSpread({}, value.options), {}, {
-              nodeId: (_oldToNew$get = oldToNew.get((_value$options = value.options) === null || _value$options === void 0 ? void 0 : _value$options.nodeId)) === null || _oldToNew$get === void 0 ? void 0 : _oldToNew$get.id
-            })
-          });
-        }
-        return Object.keys(value).reduce((result, key) => _objectSpread(_objectSpread({}, result), {}, {
-          [key]: migrate(value[key])
-        }), {});
-      case 'array':
-        return value.map(item => migrate(item));
-      case 'string':
-        return value.replace(/({{\$jobsMapByNodeId|{{\$scopes)\.([\w-]+)/g, (_, jobVar, oldNodeId) => {
-          const newNode = oldToNew.get(Number.parseInt(oldNodeId, 10));
-          if (!newNode) {
-            throw new Error('node configurated for result is not existed');
-          }
-          return `${jobVar}.${newNode.id}`;
-        });
-      default:
-        return value;
-    }
-  }
-  return migrate(config);
-}
-function revision(_x5, _x6) {
-  return _revision.apply(this, arguments);
-}
-function _revision() {
-  _revision = _asyncToGenerator(function* (context, next) {
-    const db = context.db;
-    const repository = _actions().utils.getRepositoryFromParams(context);
-    const _context$action$param3 = context.action.params,
-      filterByTk = _context$action$param3.filterByTk,
-      _context$action$param4 = _context$action$param3.filter,
-      filter = _context$action$param4 === void 0 ? {} : _context$action$param4;
-    context.body = yield db.sequelize.transaction( /*#__PURE__*/function () {
-      var _ref2 = _asyncToGenerator(function* (transaction) {
-        const origin = yield repository.findOne({
-          filterByTk,
-          filter,
-          appends: ['nodes'],
-          context,
-          transaction
-        });
-        const revisionData = filter.key ? {
-          key: filter.key,
-          title: origin.title,
-          allExecuted: origin.allExecuted
-        } : {};
-        const instance = yield repository.create({
-          values: _objectSpread({
-            title: `${origin.title} copy`,
-            description: origin.description,
-            type: origin.type,
-            config: origin.config
-          }, revisionData),
-          transaction
-        });
-        const originalNodesMap = new Map();
-        origin.nodes.forEach(node => {
-          originalNodesMap.set(node.id, node);
-        });
-        const oldToNew = new Map();
-        const newToOld = new Map();
-        var _iteratorAbruptCompletion = false;
-        var _didIteratorError = false;
-        var _iteratorError;
-        try {
-          for (var _iterator = _asyncIterator(origin.nodes), _step; _iteratorAbruptCompletion = !(_step = yield _iterator.next()).done; _iteratorAbruptCompletion = false) {
-            const node = _step.value;
-            {
-              const newNode = yield instance.createNode({
-                type: node.type,
-                config: node.config,
-                title: node.title,
-                branchIndex: node.branchIndex
-              }, {
-                transaction
-              });
-              // NOTE: keep original node references for later replacement
-              oldToNew.set(node.id, newNode);
-              newToOld.set(newNode.id, node);
-            }
-          }
-        } catch (err) {
-          _didIteratorError = true;
-          _iteratorError = err;
-        } finally {
-          try {
-            if (_iteratorAbruptCompletion && _iterator.return != null) {
-              yield _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
-          }
-        }
-        var _iteratorAbruptCompletion2 = false;
-        var _didIteratorError2 = false;
-        var _iteratorError2;
-        try {
-          for (var _iterator2 = _asyncIterator(oldToNew.entries()), _step2; _iteratorAbruptCompletion2 = !(_step2 = yield _iterator2.next()).done; _iteratorAbruptCompletion2 = false) {
-            const _step2$value = _slicedToArray(_step2.value, 2),
-              oldId = _step2$value[0],
-              newNode = _step2$value[1];
-            {
-              var _newUpstream$id, _newDownstream$id;
-              const oldNode = originalNodesMap.get(oldId);
-              const newUpstream = oldNode.upstreamId ? oldToNew.get(oldNode.upstreamId) : null;
-              const newDownstream = oldNode.downstreamId ? oldToNew.get(oldNode.downstreamId) : null;
-              let migratedConfig;
-              try {
-                migratedConfig = migrateConfig(oldNode.config, oldToNew);
-              } catch (err) {
-                return context.throw(400, err.message);
-              }
-              yield newNode.update({
-                upstreamId: (_newUpstream$id = newUpstream === null || newUpstream === void 0 ? void 0 : newUpstream.id) !== null && _newUpstream$id !== void 0 ? _newUpstream$id : null,
-                downstreamId: (_newDownstream$id = newDownstream === null || newDownstream === void 0 ? void 0 : newDownstream.id) !== null && _newDownstream$id !== void 0 ? _newDownstream$id : null,
-                config: migratedConfig
-              }, {
-                transaction
-              });
-            }
-          }
-        } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
-        } finally {
-          try {
-            if (_iteratorAbruptCompletion2 && _iterator2.return != null) {
-              yield _iterator2.return();
-            }
-          } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
-            }
-          }
-        }
-        return instance;
-      });
-      return function (_x8) {
-        return _ref2.apply(this, arguments);
-      };
-    }());
-    yield next();
-  });
-  return _revision.apply(this, arguments);
-}

package/lib/server/collections/executions.js

@@ -1,33 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _default = {
-  namespace: 'workflow.executionLogs',
-  duplicator: 'optional',
-  name: 'executions',
-  fields: [{
-    type: 'belongsTo',
-    name: 'workflow'
-  }, {
-    type: 'uid',
-    name: 'key'
-  }, {
-    type: 'boolean',
-    name: 'useTransaction',
-    defaultValue: false
-  }, {
-    type: 'hasMany',
-    name: 'jobs',
-    onDelete: 'CASCADE'
-  }, {
-    type: 'json',
-    name: 'context'
-  }, {
-    type: 'integer',
-    name: 'status'
-  }]
-};
-exports.default = _default;

package/lib/server/collections/flow_nodes.js

@@ -1,53 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _default = {
-  namespace: 'workflow.workflowConfig',
-  duplicator: 'required',
-  name: 'flow_nodes',
-  fields: [{
-    type: 'string',
-    name: 'title'
-  },
-  // which workflow belongs to
-  {
-    name: 'workflow',
-    type: 'belongsTo'
-  }, {
-    name: 'upstream',
-    type: 'belongsTo',
-    target: 'flow_nodes'
-  }, {
-    name: 'branches',
-    type: 'hasMany',
-    target: 'flow_nodes',
-    sourceKey: 'id',
-    foreignKey: 'upstreamId'
-  },
-  // only works when upstream node is branching type, such as condition and parallel.
-  // put here because the design of flow-links model is not really necessary for now.
-  // or it should be put into flow-links model.
-  {
-    name: 'branchIndex',
-    type: 'integer'
-  },
-  // Note: for reasons:
-  // 1. redirect type node to solve cycle flow.
-  // 2. recognize as real next node after branches.
-  {
-    name: 'downstream',
-    type: 'belongsTo',
-    target: 'flow_nodes'
-  }, {
-    type: 'string',
-    name: 'type'
-  }, {
-    type: 'json',
-    name: 'config',
-    defaultValue: {}
-  }]
-};
-exports.default = _default;

package/lib/server/collections/jobs.js

@@ -1,30 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _default = {
-  namespace: 'workflow.executionLogs',
-  duplicator: 'optional',
-  name: 'jobs',
-  fields: [{
-    type: 'belongsTo',
-    name: 'execution'
-  }, {
-    type: 'belongsTo',
-    name: 'node',
-    target: 'flow_nodes'
-  }, {
-    type: 'belongsTo',
-    name: 'upstream',
-    target: 'jobs'
-  }, {
-    type: 'integer',
-    name: 'status'
-  }, {
-    type: 'json',
-    name: 'result'
-  }]
-};
-exports.default = _default;