@nocobase/plugin-workflow 0.9.0-alpha.2 → 0.9.1-alpha.2

package/lib/server/instructions/condition.js

@@ -3,88 +3,160 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.calculators = void 0;
 
-var _calculators = _interopRequireWildcard(require("../calculators"));
+function _utils() {
+  const data = require("@nocobase/utils");
 
-var _constants = require("../constants");
+  _utils = function _utils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _evaluators() {
+  const data = _interopRequireDefault(require("@nocobase/evaluators"));
 
-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); }
+  _evaluators = function _evaluators() {
+    return data;
+  };
 
-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; }
+  return data;
+}
+
+var _constants = require("../constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 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); }); }; }
 
-// @calculation: {
-//   not: false,
-//   group: {
-//     type: 'and',
-//     calculations: [
-//       {
-//         calculator: 'time.equal',
-//         operands: [{ value: '{{$context.time}}' }, { value: '{{$fn.now}}' }]
-//       },
-//       {
-//         calculator: 'value.equal',
-//         operands: [{ value: '{{$jobsMapByNodeId.213}}' }, { value: 1 }]
-//       },
-//       {
-//         group: {
-//           type: 'or',
-//           calculations: [
-//             {
-//               calculator: 'value.equal',
-//               operands: [{ value: '{{$jobsMapByNodeId.213}}' }, { value: 1 }]
-//             }
-//           ]
-//         }
-//       }
-//     ]
-//   }
-// }
-function logicCalculate(calculation, input, processor) {
-  if (!calculation) {
-    return true;
-  }
+const calculators = new (_utils().Registry)(); // built-in functions
 
-  const not = calculation.not,
-        group = calculation.group;
-  let result;
+exports.calculators = calculators;
 
-  if (group) {
-    const method = group.type === 'and' ? 'every' : 'some';
-    result = group.calculations[method](item => logicCalculate(item, input, processor));
-  } else {
-    const args = calculation.operands.map(operand => (0, _calculators.calculate)(operand, input, processor));
+function equal(a, b) {
+  return a === b;
+}
 
-    const fn = _calculators.default.get(calculation.calculator);
+function notEqual(a, b) {
+  return a !== b;
+}
 
-    if (!fn) {
-      throw new Error(`no calculator function registered for "${calculation.calculator}"`);
-    }
+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);
+}
 
-    result = fn(...args);
+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 = {}) {
+  var _calculation$operands;
+
+  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 = calculation.operands) !== null && _calculation$operands !== void 0 ? _calculation$operands : [])));
+}
+
+function logicCalculate(calculation) {
+  if (!calculation) {
+    return true;
+  }
+
+  if (typeof calculation['group'] === 'object') {
+    var _calculation$group$ca;
+
+    const method = calculation['group'].type === 'and' ? 'every' : 'some';
+    return ((_calculation$group$ca = calculation['group'].calculations) !== null && _calculation$group$ca !== void 0 ? _calculation$group$ca : [])[method](item => logicCalculate(item));
   }
 
-  return not ? !result : result;
+  return calculate(calculation);
 }
 
 var _default = {
   run(node, prevJob, processor) {
     return _asyncToGenerator(function* () {
-      // TODO(optimize): loading of jobs could be reduced and turned into incrementally in processor
-      // const jobs = await processor.getJobs();
       const _ref = node.config || {},
+            engine = _ref.engine,
             calculation = _ref.calculation,
+            expression = _ref.expression,
             rejectOnFalse = _ref.rejectOnFalse;
 
-      const result = logicCalculate(processor.getParsedValue(calculation), prevJob, processor);
+      const evaluator = _evaluators().default.get(engine);
+
+      let result = true;
+
+      try {
+        result = evaluator ? evaluator(expression, processor.getScope()) : logicCalculate(processor.getParsedValue(calculation));
+      } catch (e) {
+        return {
+          result: e.toString(),
+          status: _constants.JOB_STATUS.ERROR
+        };
+      }
 
       if (!result && rejectOnFalse) {
         return {
-          status: _constants.JOB_STATUS.REJECTED,
+          status: _constants.JOB_STATUS.FAILED,
           result
         };
       }

package/lib/server/instructions/index.js

@@ -47,7 +47,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 function _default(plugin, more = {}) {
   const instructions = plugin.instructions;
-  const natives = ['calculation', 'condition', 'parallel', 'delay', 'prompt', 'query', 'create', 'update', 'destroy', 'request'].reduce((result, key) => Object.assign(result, {
+  const natives = ['calculation', 'condition', 'parallel', 'delay', 'manual', 'query', 'create', 'update', 'destroy', 'request'].reduce((result, key) => Object.assign(result, {
     [key]: (0, _utils().requireModule)(_path().default.isAbsolute(key) ? key : _path().default.join(__dirname, key))
   }), {});
 

package/lib/server/instructions/manual/actions.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.submit = submit;
+
+function _actions() {
+  const data = require("@nocobase/actions");
+
+  _actions = function _actions() {
+    return data;
+  };
+
+  return data;
+}
+
+var _constants = require("../../constants");
+
+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 submit(_x, _x2) {
+  return _submit.apply(this, arguments);
+}
+
+function _submit() {
+  _submit = _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;
+    const currentUser = context.state.currentUser;
+
+    if (!currentUser) {
+      return context.throw(401);
+    }
+
+    const plugin = context.app.pm.get('workflow');
+    const userJob = yield context.db.sequelize.transaction( /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (transaction) {
+        var _instance$node$config2;
+
+        const instance = yield repository.findOne({
+          filterByTk,
+          // filter: {
+          //   userId: currentUser?.id
+          // },
+          appends: ['job', 'node', 'execution', 'workflow'],
+          context,
+          transaction
+        });
+
+        if (!instance) {
+          return context.throw(404);
+        }
+
+        const _instance$node$config = instance.node.config.actions,
+              actions = _instance$node$config === void 0 ? [] : _instance$node$config; // NOTE: validate status
+
+        if (instance.status !== _constants.JOB_STATUS.PENDING || instance.job.status !== _constants.JOB_STATUS.PENDING || instance.execution.status !== _constants.EXECUTION_STATUS.STARTED || !instance.workflow.enabled || !actions.includes(values.status)) {
+          return context.throw(400);
+        }
+
+        instance.execution.workflow = instance.workflow;
+        const processor = plugin.createProcessor(instance.execution, {
+          transaction
+        });
+        yield processor.prepare();
+        const assignees = processor.getParsedValue((_instance$node$config2 = instance.node.config.assignees) !== null && _instance$node$config2 !== void 0 ? _instance$node$config2 : []);
+
+        if (!assignees.includes(currentUser.id) || instance.userId !== currentUser.id) {
+          return context.throw(403);
+        } // NOTE: validate assignee
+
+
+        yield instance.update({
+          status: values.status,
+          result: values.result
+        }, {
+          transaction
+        });
+        return instance;
+      });
+
+      return function (_x3) {
+        return _ref.apply(this, arguments);
+      };
+    }()); // await transaction.commit();
+
+    context.body = userJob;
+    context.status = 202;
+    yield next();
+    userJob.job.latestUserJob = userJob; // NOTE: resume the process and no `await` for quick returning
+
+    plugin.resume(userJob.job);
+  });
+  return _submit.apply(this, arguments);
+}

package/lib/server/{extensions/assignees/collections → instructions/manual/collecions}/jobs.d.ts

@@ -6,11 +6,13 @@ declare const _default: {
         through: string;
         target?: undefined;
         foreignKey?: undefined;
+        onDelete?: undefined;
     } | {
         type: string;
         name: string;
         target: string;
         foreignKey: string;
+        onDelete: string;
         through?: undefined;
     })[];
 };

package/lib/server/{extensions/assignees/collections → instructions/manual/collecions}/jobs.js

@@ -14,7 +14,8 @@ var _default = {
     type: 'hasMany',
     name: 'usersJobs',
     target: 'users_jobs',
-    foreignKey: 'jobId'
+    foreignKey: 'jobId',
+    onDelete: 'CASCADE'
   }]
 };
 exports.default = _default;

package/lib/server/{extensions/assignees/collections → instructions/manual/collecions}/users_jobs.js

@@ -5,26 +5,26 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _default = {
+  namespace: 'workflow',
   name: 'users_jobs',
+  duplicator: 'optional',
   fields: [{
     type: 'bigInt',
     name: 'id',
     primaryKey: true,
     autoIncrement: true
-  }, {
-    type: 'bigInt',
-    name: 'userId',
-    primaryKey: false
-  }, {
-    type: 'bigInt',
-    name: 'jobId',
-    primaryKey: false
   }, {
     type: 'belongsTo',
-    name: 'job'
+    name: 'job',
+    target: 'jobs',
+    foreignKey: 'jobId',
+    primaryKey: false
   }, {
     type: 'belongsTo',
-    name: 'user'
+    name: 'user',
+    target: 'users',
+    foreignKey: 'userId',
+    primaryKey: false
   }, {
     type: 'belongsTo',
     name: 'execution'

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

@@ -0,0 +1,25 @@
+import Plugin from '../..';
+import { Instruction } from '..';
+export interface ManualConfig {
+    schema: {
+        collection: {
+            name: string;
+            fields: any[];
+        };
+        blocks: {
+            [key: string]: any;
+        };
+        actions: {
+            [key: string]: any;
+        };
+    };
+    actions: number[];
+    assignees?: number[];
+    mode?: number;
+}
+export default class implements Instruction {
+    protected plugin: Plugin;
+    constructor(plugin: Plugin);
+    run(node: any, prevJob: any, processor: any): Promise<any>;
+    resume(node: any, job: any, processor: any): Promise<any>;
+}

package/lib/server/instructions/manual/index.js

@@ -0,0 +1,200 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _actions() {
+  const data = _interopRequireDefault(require("@nocobase/actions"));
+
+  _actions = function _actions() {
+    return data;
+  };
+
+  return data;
+}
+
+var _constants = require("../../constants");
+
+var _jobs = _interopRequireDefault(require("./collecions/jobs"));
+
+var _users = _interopRequireDefault(require("./collecions/users"));
+
+var _users_jobs = _interopRequireDefault(require("./collecions/users_jobs"));
+
+var _actions2 = require("./actions");
+
+const _excluded = ["mode"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+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 MULTIPLE_ASSIGNED_MODE = {
+  SINGLE: Symbol('single'),
+  ALL: Symbol('all'),
+  ANY: Symbol('any'),
+  ALL_PERCENTAGE: Symbol('all percentage'),
+  ANY_PERCENTAGE: Symbol('any percentage')
+};
+const Modes = {
+  [MULTIPLE_ASSIGNED_MODE.SINGLE]: {
+    getStatus(distribution, assignees) {
+      const done = distribution.find(item => item.status !== _constants.JOB_STATUS.PENDING && item.count > 0);
+      return done ? done.status : null;
+    }
+
+  },
+  [MULTIPLE_ASSIGNED_MODE.ALL]: {
+    getStatus(distribution, assignees) {
+      const resolved = distribution.find(item => item.status === _constants.JOB_STATUS.RESOLVED);
+
+      if (resolved && resolved.count === assignees.length) {
+        return _constants.JOB_STATUS.RESOLVED;
+      }
+
+      const rejected = distribution.find(item => item.status < _constants.JOB_STATUS.PENDING);
+
+      if (rejected && rejected.count) {
+        return rejected.status;
+      }
+
+      return null;
+    }
+
+  },
+  [MULTIPLE_ASSIGNED_MODE.ANY]: {
+    getStatus(distribution, assignees) {
+      const resolved = distribution.find(item => item.status === _constants.JOB_STATUS.RESOLVED);
+
+      if (resolved && resolved.count) {
+        return _constants.JOB_STATUS.RESOLVED;
+      }
+
+      const rejectedCount = distribution.reduce((count, item) => item.status < _constants.JOB_STATUS.PENDING ? count + item.count : count, 0); // NOTE: all failures are considered as rejected for now
+
+      if (rejectedCount === assignees.length) {
+        return _constants.JOB_STATUS.REJECTED;
+      }
+
+      return null;
+    }
+
+  }
+};
+
+function getMode(mode) {
+  switch (true) {
+    case mode === 1:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ALL];
+
+    case mode === -1:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ANY];
+
+    case mode > 0:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ALL_PERCENTAGE];
+
+    case mode < 0:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ANY_PERCENTAGE];
+
+    default:
+      return Modes[MULTIPLE_ASSIGNED_MODE.SINGLE];
+  }
+}
+
+class _default {
+  constructor(plugin) {
+    this.plugin = void 0;
+    this.plugin = plugin;
+    plugin.db.collection(_users_jobs.default);
+    plugin.db.extendCollection(_users.default);
+    plugin.db.extendCollection(_jobs.default);
+    plugin.app.resource({
+      name: 'users_jobs',
+      actions: {
+        list: {
+          filter: {
+            $or: [{
+              'workflow.enabled': true
+            }, {
+              'workflow.enabled': false,
+              status: {
+                $ne: _constants.JOB_STATUS.PENDING
+              }
+            }]
+          },
+          handler: _actions().default.list
+        },
+        submit: _actions2.submit
+      }
+    });
+  }
+
+  run(node, prevJob, processor) {
+    return _asyncToGenerator(function* () {
+      var _prevJob$id;
+
+      const _node$config = node.config,
+            mode = _node$config.mode,
+            config = _objectWithoutProperties(_node$config, _excluded);
+
+      const assignees = [...new Set(processor.getParsedValue(config.assignees) || [])];
+      const job = yield processor.saveJob({
+        status: _constants.JOB_STATUS.PENDING,
+        result: mode ? [] : null,
+        nodeId: node.id,
+        upstreamId: (_prevJob$id = prevJob === null || prevJob === void 0 ? void 0 : prevJob.id) !== null && _prevJob$id !== void 0 ? _prevJob$id : null
+      }); // NOTE: batch create users jobs
+
+      const UserJobModel = processor.options.plugin.db.getModel('users_jobs');
+      yield UserJobModel.bulkCreate(assignees.map(userId => ({
+        userId,
+        jobId: job.id,
+        nodeId: node.id,
+        executionId: job.executionId,
+        workflowId: node.workflowId,
+        status: _constants.JOB_STATUS.PENDING
+      })), {
+        transaction: processor.transaction
+      });
+      return job;
+    })();
+  }
+
+  resume(node, job, processor) {
+    return _asyncToGenerator(function* () {
+      var _job$latestUserJob$re, _job$latestUserJob, _getMode$getStatus;
+
+      // NOTE: check all users jobs related if all done then continue as parallel
+      const _node$config2 = node.config,
+            _node$config2$assigne = _node$config2.assignees,
+            assignees = _node$config2$assigne === void 0 ? [] : _node$config2$assigne,
+            mode = _node$config2.mode;
+      const UserJobModel = processor.options.plugin.db.getModel('users_jobs');
+      const distribution = yield UserJobModel.count({
+        where: {
+          jobId: job.id
+        },
+        group: ['status']
+      });
+      const submitted = distribution.reduce((count, item) => item.status !== _constants.JOB_STATUS.PENDING ? count + item.count : count, 0);
+      const result = mode ? (submitted || 0) / assignees.length : (_job$latestUserJob$re = (_job$latestUserJob = job.latestUserJob) === null || _job$latestUserJob === void 0 ? void 0 : _job$latestUserJob.result) !== null && _job$latestUserJob$re !== void 0 ? _job$latestUserJob$re : job.result;
+      job.set({
+        status: job.status || ((_getMode$getStatus = getMode(mode).getStatus(distribution, assignees)) !== null && _getMode$getStatus !== void 0 ? _getMode$getStatus : _constants.JOB_STATUS.PENDING),
+        result
+      });
+      return job;
+    })();
+  }
+
+}
+
+exports.default = _default;
+;

package/lib/server/instructions/parallel.js

@@ -20,12 +20,14 @@ exports.PARALLEL_MODE = PARALLEL_MODE;
 const Modes = {
   [PARALLEL_MODE.ALL]: {
     next(previous) {
-      return previous.status !== _constants.JOB_STATUS.REJECTED;
+      return previous.status >= _constants.JOB_STATUS.PENDING;
     },
 
     getStatus(result) {
-      if (result.some(status => status != null && status === _constants.JOB_STATUS.REJECTED)) {
-        return _constants.JOB_STATUS.REJECTED;
+      const failedStatus = result.find(status => status != null && status < _constants.JOB_STATUS.PENDING);
+
+      if (typeof failedStatus !== 'undefined') {
+        return failedStatus;
       }
 
       if (result.every(status => status != null && status === _constants.JOB_STATUS.RESOLVED)) {
@@ -38,7 +40,7 @@ const Modes = {
   },
   [PARALLEL_MODE.ANY]: {
     next(previous) {
-      return previous.status !== _constants.JOB_STATUS.RESOLVED;
+      return previous.status <= _constants.JOB_STATUS.PENDING;
     },
 
     getStatus(result) {
@@ -50,7 +52,7 @@ const Modes = {
         return _constants.JOB_STATUS.PENDING;
       }
 
-      return _constants.JOB_STATUS.REJECTED;
+      return _constants.JOB_STATUS.FAILED;
     }
 
   },
@@ -64,8 +66,10 @@ const Modes = {
         return _constants.JOB_STATUS.RESOLVED;
       }
 
-      if (result.some(status => status != null && status === _constants.JOB_STATUS.REJECTED)) {
-        return _constants.JOB_STATUS.REJECTED;
+      const failedStatus = result.find(status => status != null && status < _constants.JOB_STATUS.PENDING);
+
+      if (typeof failedStatus !== 'undefined') {
+        return failedStatus;
       }
 
       return _constants.JOB_STATUS.PENDING;

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

@@ -1,17 +1,18 @@
 import { AxiosRequestConfig } from 'axios';
 import { Instruction } from './index';
+import Processor from '../Processor';
+import FlowNodeModel from '../models/FlowNode';
 export interface Header {
     name: string;
     value: string;
 }
-export declare type RequestConfig = Pick<AxiosRequestConfig, 'url' | 'method' | 'data' | 'timeout'> & {
+export declare type RequestConfig = Pick<AxiosRequestConfig, 'url' | 'method' | 'params' | 'data' | 'timeout'> & {
     headers: Array<Header>;
     ignoreFail: boolean;
 };
 export default class implements Instruction {
     plugin: any;
     constructor(plugin: any);
-    request: (node: any, job: any, processor: any) => Promise<any>;
-    run(node: any, input: any, processor: any): Promise<any>;
-    resume(node: any, job: any, processor: any): Promise<any>;
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<any>;
+    resume(node: FlowNodeModel, job: any, processor: Processor): Promise<any>;
 }