@nocobase/plugin-workflow 0.9.3-alpha.1 → 0.9.4-alpha.1

package/lib/client/triggers/index.js

@@ -126,7 +126,7 @@ function TriggerExecution() {
       'x-component-props': {
         title: _react().default.createElement(_icons().InfoOutlined, null),
         shape: 'circle',
-        className: 'workflow-node-job-button',
+        className: (0, _css().cx)(_style.nodeJobButtonClass, 'workflow-node-job-button'),
         type: 'primary'
       },
       properties: {
@@ -187,8 +187,10 @@ const TriggerConfig = () => {
     editingConfig = _useState4[0],
     setEditingConfig = _useState4[1];
   (0, _react().useEffect)(() => {
-    var _workflow$title;
-    setEditingTitle((_workflow$title = workflow.title) !== null && _workflow$title !== void 0 ? _workflow$title : typeTitle);
+    if (workflow) {
+      var _workflow$title;
+      setEditingTitle((_workflow$title = workflow.title) !== null && _workflow$title !== void 0 ? _workflow$title : typeTitle);
+    }
   }, [workflow]);
   if (!workflow || !workflow.type) {
     return null;

package/lib/client/triggers/schedule/index.d.ts

@@ -37,7 +37,9 @@ declare const _default: {
         ScheduleConfig: () => JSX.Element;
         FieldsSelect: import("react").MemoExoticComponent<import("react").FunctionComponent<Pick<any, string | number | symbol>>>;
     };
-    getOptions(config: any, types: any): any[];
+    useVariables(config: any, { types }: {
+        types: any;
+    }): any[];
     useInitializers(config: any): SchemaInitializerItemOptions | null;
     initializers: {
         CollectionFieldInitializers: typeof CollectionFieldInitializers;

package/lib/client/triggers/schedule/index.js

@@ -51,7 +51,9 @@ var _default = {
     ScheduleConfig: _ScheduleConfig.ScheduleConfig,
     FieldsSelect: _FieldsSelect.FieldsSelect
   },
-  getOptions(config, types) {
+  useVariables(config, {
+    types
+  }) {
     const _useWorkflowTranslati = (0, _locale.useWorkflowTranslation)(),
       t = _useWorkflowTranslati.t;
     const options = [];
@@ -62,10 +64,10 @@ var _default = {
         label: t('Trigger time')
       });
     }
+    const fieldOptions = (0, _variable.useCollectionFieldOptions)({
+      collection: config.collection
+    });
     if (config.mode === _constants.SCHEDULE_MODE.COLLECTION_FIELD) {
-      const fieldOptions = (0, _variable.useCollectionFieldOptions)({
-        collection: config.collection
-      });
       if (fieldOptions.length) {
         options.push({
           key: 'data',

package/lib/client/variable.d.ts

@@ -5,6 +5,32 @@ export declare type VariableOption = {
     children?: VariableOptions;
 };
 export declare type VariableOptions = VariableOption[] | null;
+export declare const nodesOptions: {
+    label: string;
+    value: string;
+    useOptions(options: any): VariableOption[];
+};
+export declare const triggerOptions: {
+    label: string;
+    value: string;
+    useOptions(options: any): VariableOption[];
+};
+export declare const scopeOptions: {
+    label: string;
+    value: string;
+    useOptions(options: any): VariableOption[];
+};
+export declare const systemOptions: {
+    label: string;
+    value: string;
+    useOptions({ types }: {
+        types: any;
+    }): {
+        key: string;
+        value: string;
+        label: string;
+    }[];
+};
 export declare const BaseTypeSets: {
     boolean: Set<string>;
     number: Set<string>;
@@ -12,7 +38,7 @@ export declare const BaseTypeSets: {
     date: Set<string>;
 };
 export declare function filterTypedFields(fields: any, types: any, depth?: number): any;
-export declare function useWorkflowVariableOptions(types?: any): {
+export declare function useWorkflowVariableOptions(options?: {}): {
     label: any;
     value: any;
     key: any;

package/lib/client/variable.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.BaseTypeSets = void 0;
 exports.filterTypedFields = filterTypedFields;
+exports.triggerOptions = exports.systemOptions = exports.scopeOptions = exports.nodesOptions = void 0;
 exports.useCollectionFieldOptions = useCollectionFieldOptions;
 exports.useWorkflowVariableOptions = useWorkflowVariableOptions;
 function _client() {
@@ -23,20 +24,20 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 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); }
-const VariableTypes = [{
-  title: `{{t("Node result", { ns: "${_locale.NAMESPACE}" })}}`,
+const nodesOptions = {
+  label: `{{t("Node result", { ns: "${_locale.NAMESPACE}" })}}`,
   value: '$jobsMapByNodeId',
-  options(types) {
+  useOptions(options) {
     const current = (0, _nodes.useNodeContext)();
     const upstreams = (0, _nodes.useAvailableUpstreams)(current);
-    const options = [];
+    const result = [];
     upstreams.forEach(node => {
-      var _instruction$getOptio;
+      var _instruction$useVaria;
       const instruction = _nodes.instructions.get(node.type);
-      const subOptions = (_instruction$getOptio = instruction.getOptions) === null || _instruction$getOptio === void 0 ? void 0 : _instruction$getOptio.call(instruction, node.config, types);
+      const subOptions = (_instruction$useVaria = instruction.useVariables) === null || _instruction$useVaria === void 0 ? void 0 : _instruction$useVaria.call(instruction, node, options);
       if (subOptions) {
         var _node$title;
-        options.push({
+        result.push({
           key: node.id.toString(),
           value: node.id.toString(),
           label: (_node$title = node.title) !== null && _node$title !== void 0 ? _node$title : `#${node.id}`,
@@ -44,29 +45,61 @@ const VariableTypes = [{
         });
       }
     });
-    return options;
+    return result;
   }
-}, {
-  title: `{{t("Trigger variables", { ns: "${_locale.NAMESPACE}" })}}`,
+};
+exports.nodesOptions = nodesOptions;
+const triggerOptions = {
+  label: `{{t("Trigger variables", { ns: "${_locale.NAMESPACE}" })}}`,
   value: '$context',
-  options(types) {
-    var _trigger$getOptions, _trigger$getOptions2;
+  useOptions(options) {
+    var _trigger$useVariables, _trigger$useVariables2;
     const _useFlowContext = (0, _FlowContext.useFlowContext)(),
       workflow = _useFlowContext.workflow;
     const trigger = _triggers.triggers.get(workflow.type);
-    return (_trigger$getOptions = trigger === null || trigger === void 0 ? void 0 : (_trigger$getOptions2 = trigger.getOptions) === null || _trigger$getOptions2 === void 0 ? void 0 : _trigger$getOptions2.call(trigger, workflow.config, types)) !== null && _trigger$getOptions !== void 0 ? _trigger$getOptions : null;
+    return (_trigger$useVariables = trigger === null || trigger === void 0 ? void 0 : (_trigger$useVariables2 = trigger.useVariables) === null || _trigger$useVariables2 === void 0 ? void 0 : _trigger$useVariables2.call(trigger, workflow.config, options)) !== null && _trigger$useVariables !== void 0 ? _trigger$useVariables : null;
+  }
+};
+exports.triggerOptions = triggerOptions;
+const scopeOptions = {
+  label: `{{t("Scope variables", { ns: "${_locale.NAMESPACE}" })}}`,
+  value: '$scopes',
+  useOptions(options) {
+    const current = (0, _nodes.useNodeContext)();
+    const scopes = (0, _nodes.useUpstreamScopes)(current);
+    const result = [];
+    scopes.forEach(node => {
+      var _instruction$useScope;
+      const instruction = _nodes.instructions.get(node.type);
+      const subOptions = (_instruction$useScope = instruction.useScopeVariables) === null || _instruction$useScope === void 0 ? void 0 : _instruction$useScope.call(instruction, node, options);
+      if (subOptions) {
+        var _node$title2;
+        result.push({
+          key: node.id.toString(),
+          value: node.id.toString(),
+          label: (_node$title2 = node.title) !== null && _node$title2 !== void 0 ? _node$title2 : `#${node.id}`,
+          children: subOptions
+        });
+      }
+    });
+    return result;
   }
-}, {
-  title: `{{t("System variables", { ns: "${_locale.NAMESPACE}" })}}`,
+};
+exports.scopeOptions = scopeOptions;
+const systemOptions = {
+  label: `{{t("System variables", { ns: "${_locale.NAMESPACE}" })}}`,
   value: '$system',
-  options(types) {
+  useOptions({
+    types
+  }) {
     return [...(!types || types.includes('date') ? [{
       key: 'now',
       value: 'now',
       label: `{{t("System time")}}`
     }] : [])];
   }
-}];
+};
+exports.systemOptions = systemOptions;
 const BaseTypeSets = {
   boolean: new Set(['checkbox']),
   number: new Set(['number', 'percent']),
@@ -77,7 +110,7 @@ const BaseTypeSets = {
 // { type: 'reference', options: { collection: 'attachments', multiple: false } }
 // { type: 'reference', options: { collection: 'myExpressions', entity: false } }
 exports.BaseTypeSets = BaseTypeSets;
-function matchFieldType(field, type) {
+function matchFieldType(field, type, depth) {
   const inputType = typeof type;
   if (inputType === 'string') {
     var _BaseTypeSets$type;
@@ -95,7 +128,7 @@ function matchFieldType(field, type) {
     }
   }
   if (inputType === 'function') {
-    return type(field);
+    return type(field, depth);
   }
   return false;
 }
@@ -110,32 +143,28 @@ function filterTypedFields(fields, types, depth = 1) {
     if (isAssociationField(field) && depth && filterTypedFields(useNormalizedFields(field.target), types, depth - 1).length) {
       return true;
     }
-    return types.some(type => matchFieldType(field, type));
+    return types.some(type => matchFieldType(field, type, depth));
   });
 }
-function useWorkflowVariableOptions(types) {
+function useWorkflowVariableOptions(options = {}) {
   const compile = (0, _client().useCompile)();
-  const options = VariableTypes.map(item => {
-    const opts = typeof item.options === 'function' ? item.options(types).filter(Boolean) : item.options;
+  const result = [scopeOptions, nodesOptions, triggerOptions, systemOptions].map(item => {
+    const opts = typeof item.useOptions === 'function' ? item.useOptions(options).filter(Boolean) : null;
     return {
-      label: compile(item.title),
+      label: compile(item.label),
       value: item.value,
       key: item.value,
       children: compile(opts),
       disabled: opts && !opts.length
     };
   });
-  return options;
+  return result;
 }
 function useNormalizedFields(collectionName) {
   const compile = (0, _client().useCompile)();
   const _useCollectionManager = (0, _client().useCollectionManager)(),
-    getCollection = _useCollectionManager.getCollection;
-  const collection = getCollection(collectionName);
-  if (!collection) {
-    return [];
-  }
-  const fields = collection.fields;
+    getCollectionFields = _useCollectionManager.getCollectionFields;
+  const fields = getCollectionFields(collectionName);
   const foreignKeyFields = [];
   const otherFields = [];
   fields.forEach(field => {
@@ -189,8 +218,9 @@ function useCollectionFieldOptions(options) {
     _options$depth = options.depth,
     depth = _options$depth === void 0 ? 1 : _options$depth;
   const compile = (0, _client().useCompile)();
-  const normalizedFields = fields !== null && fields !== void 0 ? fields : useNormalizedFields(collection);
-  const result = filterTypedFields(normalizedFields, types, depth).filter(field => !isAssociationField(field) || depth).map(field => {
+  const normalizedFields = useNormalizedFields(collection);
+  const computedFields = fields !== null && fields !== void 0 ? fields : normalizedFields;
+  const result = filterTypedFields(computedFields, types, depth).filter(field => !isAssociationField(field) || depth).map(field => {
     var _field$uiSchema5;
     const label = compile(((_field$uiSchema5 = field.uiSchema) === null || _field$uiSchema5 === void 0 ? void 0 : _field$uiSchema5.title) || field.name);
     return {
@@ -201,7 +231,8 @@ function useCollectionFieldOptions(options) {
         collection: field.target,
         types,
         depth: depth - 1
-      }) : null
+      }) : null,
+      field
     };
   });
   return result;

package/lib/server/Plugin.js

@@ -169,25 +169,13 @@ class WorkflowPlugin extends _server().Plugin {
               transaction
             });
             // NOTE: not to trigger afterUpdate hook here
-            yield workflow.update({
-              executed
-            }, {
-              transaction,
-              hooks: false
-            });
-            const allExecuted = yield execution.constructor.count({
-              where: {
-                key: workflow.key
-              },
+            yield workflow.increment('executed', {
               transaction
             });
-            yield workflow.constructor.update({
-              allExecuted
-            }, {
+            yield workflow.constructor.increment('allExecuted', {
               where: {
                 key: workflow.key
               },
-              individualHooks: true,
               transaction
             });
             execution.workflow = workflow;

package/lib/server/Processor.d.ts

@@ -38,13 +38,16 @@ export default class Processor {
     getBranches(node: FlowNodeModel): FlowNodeModel[];
     findBranchStartNode(node: FlowNodeModel, parent?: FlowNodeModel): FlowNodeModel | null;
     findBranchParentNode(node: FlowNodeModel): FlowNodeModel | null;
+    findBranchEndNode(node: FlowNodeModel): FlowNodeModel | null;
     findBranchParentJob(job: JobModel, node: FlowNodeModel): JobModel | null;
+    findBranchLastJob(node: FlowNodeModel): JobModel | null;
     getScope(node?: any): {
         $context: any;
         $jobsMapByNodeId: {
             [key: number]: any;
         };
         $system: {};
+        $scopes: {};
     };
     getParsedValue(value: any, node?: any): any;
 }

package/lib/server/Processor.js

@@ -193,7 +193,7 @@ class Processor {
       });
       if (savedJob.status === _constants.JOB_STATUS.RESOLVED && node.downstream) {
         // run next node
-        _this6.logger.debug(`run next node (${node.id})`);
+        _this6.logger.debug(`run next node (${node.downstreamId})`);
         return _this6.run(node.downstream, savedJob);
       }
       // all nodes in scope have been executed
@@ -215,7 +215,7 @@ class Processor {
   end(node, job) {
     var _this8 = this;
     return _asyncToGenerator(function* () {
-      _this8.logger.debug(`branch ended at node (${node.id})})`);
+      _this8.logger.debug(`branch ended at node (${node.id})`);
       const parentNode = _this8.findBranchParentNode(node);
       // no parent, means on main flow
       if (parentNode) {
@@ -314,6 +314,14 @@ class Processor {
     }
     return null;
   }
+  findBranchEndNode(node) {
+    for (let n = node; n; n = n.downstream) {
+      if (!n.downstream) {
+        return n;
+      }
+    }
+    return null;
+  }
   findBranchParentJob(job, node) {
     for (let j = job; j; j = this.jobsMap.get(j.upstreamId)) {
       if (j.nodeId === node.id) {
@@ -322,6 +330,15 @@ class Processor {
     }
     return null;
   }
+  findBranchLastJob(node) {
+    for (let n = this.findBranchEndNode(node); n && n !== node.upstream; n = n.upstream) {
+      const jobs = Array.from(this.jobsMap.values()).filter(item => item.nodeId === n.id).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      if (jobs.length) {
+        return jobs[jobs.length - 1];
+      }
+    }
+    return null;
+  }
   getScope(node) {
     const systemFns = {};
     const scope = {
@@ -342,10 +359,20 @@ class Processor {
     } finally {
       _iterator.f();
     }
+    const $scopes = {};
+    if (node) {
+      for (let n = this.findBranchParentNode(node); n; n = this.findBranchParentNode(n)) {
+        const instruction = this.options.plugin.instructions.get(n.type);
+        if (typeof instruction.getScope === 'function') {
+          $scopes[n.id] = instruction.getScope(n, this.jobsMapByNodeId[n.id], this);
+        }
+      }
+    }
     return {
       $context: this.execution.context,
       $jobsMapByNodeId: this.jobsMapByNodeId,
-      $system: systemFns
+      $system: systemFns,
+      $scopes
     };
   }
   getParsedValue(value, node) {

package/lib/server/actions/workflows.js

@@ -132,12 +132,12 @@ function migrateConfig(config, oldToNew) {
       case 'array':
         return value.map(item => migrate(item));
       case 'string':
-        return value.replace(/(\{\{\$jobsMapByNodeId\.)([\w-]+)/g, (_, jobVar, oldNodeId) => {
+        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 `{{$jobsMapByNodeId.${newNode.id}`;
+          return `${jobVar}.${newNode.id}`;
         });
       default:
         return value;

package/lib/server/collections/workflows.js

@@ -64,7 +64,8 @@ function _default() {
       foreignKey: 'key',
       sourceKey: 'key',
       // NOTE: no constraints needed here because tricky self-referencing
-      constraints: false
+      constraints: false,
+      onDelete: 'NO ACTION'
     }],
     // NOTE: use unique index for avoiding deadlock in mysql when setCurrent
     indexes: [{

package/lib/server/instructions/aggregate.d.ts

@@ -0,0 +1,9 @@
+import FlowNodeModel from '../models/FlowNode';
+import Processor from '../Processor';
+declare const _default: {
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<{
+        result: any;
+        status: number;
+    }>;
+};
+export default _default;

package/lib/server/instructions/aggregate.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _sequelize() {
+  const data = require("sequelize");
+  _sequelize = function _sequelize() {
+    return data;
+  };
+  return data;
+}
+var _constants = require("../constants");
+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); }); }; }
+const aggregators = {
+  count: 'count',
+  sum: 'sum',
+  avg: 'avg',
+  min: 'min',
+  max: 'max'
+};
+var _default = {
+  run(node, input, processor) {
+    return _asyncToGenerator(function* () {
+      const _node$config = node.config,
+        aggregator = _node$config.aggregator,
+        associated = _node$config.associated,
+        collection = _node$config.collection,
+        _node$config$associat = _node$config.association,
+        association = _node$config$associat === void 0 ? {} : _node$config$associat,
+        _node$config$params = _node$config.params,
+        params = _node$config$params === void 0 ? {} : _node$config$params;
+      const options = processor.getParsedValue(params);
+      const database = node.constructor.database;
+      const repo = associated ? database.getRepository(`${association === null || association === void 0 ? void 0 : association.associatedCollection}.${association.name}`, processor.getParsedValue(association === null || association === void 0 ? void 0 : association.associatedKey)) : database.getRepository(collection);
+      if (!options.dataType && aggregator === 'avg') {
+        options.dataType = _sequelize().DataTypes.DOUBLE;
+      }
+      const result = yield repo.aggregate(_objectSpread(_objectSpread({}, options), {}, {
+        method: aggregators[aggregator],
+        transaction: processor.transaction
+      }));
+      return {
+        result: options.dataType === _sequelize().DataTypes.DOUBLE ? Number(result) : result,
+        status: _constants.JOB_STATUS.RESOLVED
+      };
+    })();
+  }
+};
+exports.default = _default;

package/lib/server/instructions/calculation.js

@@ -32,7 +32,7 @@ var _default = {
         engine = _node$config$engine === void 0 ? 'math.js' : _node$config$engine,
         _node$config$expressi = _node$config.expression,
         expression = _node$config$expressi === void 0 ? '' : _node$config$expressi;
-      let scope = processor.getScope();
+      let scope = processor.getScope(node);
       if (dynamic) {
         var _parse, _parse2, _node$config$scope;
         const parsed = (_parse = (0, _utils().parse)(dynamic)(scope)) !== null && _parse !== void 0 ? _parse : {};

package/lib/server/instructions/condition.js

@@ -108,7 +108,7 @@ var _default = {
       const evaluator = _evaluators().evaluators.get(engine);
       let result = true;
       try {
-        result = evaluator ? evaluator(expression, processor.getScope()) : logicCalculate(processor.getParsedValue(calculation));
+        result = evaluator ? evaluator(expression, processor.getScope()) : logicCalculate(processor.getParsedValue(calculation, node));
       } catch (e) {
         return {
           result: e.toString(),

package/lib/server/instructions/create.js

@@ -28,7 +28,7 @@ var _default = {
       const _node$constructor$dat = node.constructor.database.getCollection(collection),
         repository = _node$constructor$dat.repository,
         model = _node$constructor$dat.model;
-      const options = processor.getParsedValue(params);
+      const options = processor.getParsedValue(params, node);
       const result = yield repository.create(_objectSpread(_objectSpread({}, options), {}, {
         context: {
           executionId: processor.execution.id

package/lib/server/instructions/destroy.js

@@ -20,7 +20,7 @@ var _default = {
         _node$config$params = _node$config.params,
         params = _node$config$params === void 0 ? {} : _node$config$params;
       const repo = node.constructor.database.getRepository(collection);
-      const options = processor.getParsedValue(params);
+      const options = processor.getParsedValue(params, node);
       const result = yield repo.destroy(_objectSpread(_objectSpread({}, options), {}, {
         context: {
           executionId: processor.execution.id

package/lib/server/instructions/index.d.ts

@@ -11,6 +11,7 @@ export declare type Runner = (node: FlowNodeModel, input: any, processor: Proces
 export interface Instruction {
     run: Runner;
     resume?: Runner;
+    getScope?: (node: FlowNodeModel, job: any, processor: Processor) => any;
 }
 declare type InstructionConstructor<T> = {
     new (p: Plugin): T;

package/lib/server/instructions/index.js

@@ -32,7 +32,7 @@ function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typ
 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 _default(plugin, more = {}) {
   const instructions = plugin.instructions;
-  const natives = ['calculation', 'condition', 'parallel', 'delay', 'manual', 'query', 'create', 'update', 'destroy', 'request'].reduce((result, key) => Object.assign(result, {
+  const natives = ['calculation', 'condition', 'parallel', 'loop', 'delay', 'manual', 'query', 'create', 'update', 'destroy', 'aggregate', 'request'].reduce((result, key) => Object.assign(result, {
     [key]: (0, _utils().requireModule)(_path().default.isAbsolute(key) ? key : _path().default.join(__dirname, key))
   }), {});
   for (var _i = 0, _Object$entries = Object.entries(_objectSpread(_objectSpread({}, more), natives)); _i < _Object$entries.length; _i++) {

package/lib/server/instructions/loop.d.ts

@@ -0,0 +1,16 @@
+import FlowNodeModel from '../models/FlowNode';
+import JobModel from '../models/Job';
+import Processor from '../Processor';
+declare const _default: {
+    run(node: FlowNodeModel, prevJob: JobModel, processor: Processor): Promise<{
+        status: number;
+        result: number;
+    }>;
+    resume(node: FlowNodeModel, branchJob: any, processor: Processor): Promise<JobModel>;
+    getScope(node: any, index: any, processor: any): {
+        item: any;
+        index: any;
+        length: number;
+    };
+};
+export default _default;