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

package/lib/client/variable.js

@@ -3,47 +3,39 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TypeSets = void 0;
+exports.BaseTypeSets = void 0;
 exports.filterTypedFields = filterTypedFields;
 exports.useCollectionFieldOptions = useCollectionFieldOptions;
 exports.useWorkflowVariableOptions = useWorkflowVariableOptions;
-
 function _client() {
   const data = require("@nocobase/client");
-
   _client = function _client() {
     return data;
   };
-
   return data;
 }
-
-var _nodes = require("./nodes");
-
 var _FlowContext = require("./FlowContext");
-
-var _triggers = require("./triggers");
-
 var _locale = require("./locale");
-
+var _nodes = require("./nodes");
+var _triggers = require("./triggers");
+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); }
 const VariableTypes = [{
   title: `{{t("Node result", { ns: "${_locale.NAMESPACE}" })}}`,
   value: '$jobsMapByNodeId',
-
   options(types) {
     const current = (0, _nodes.useNodeContext)();
     const upstreams = (0, _nodes.useAvailableUpstreams)(current);
     const options = [];
     upstreams.forEach(node => {
       var _instruction$getOptio;
-
       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);
-
       if (subOptions) {
         var _node$title;
-
         options.push({
           key: node.id.toString(),
           value: node.id.toString(),
@@ -54,94 +46,163 @@ const VariableTypes = [{
     });
     return options;
   }
-
 }, {
   title: `{{t("Trigger variables", { ns: "${_locale.NAMESPACE}" })}}`,
   value: '$context',
-
   options(types) {
     var _trigger$getOptions, _trigger$getOptions2;
-
     const _useFlowContext = (0, _FlowContext.useFlowContext)(),
-          workflow = _useFlowContext.workflow;
-
+      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;
   }
-
 }, {
   title: `{{t("System variables", { ns: "${_locale.NAMESPACE}" })}}`,
   value: '$system',
-  options: [{
-    key: 'now',
-    value: 'now',
-    label: `{{t("Current time", { ns: "${_locale.NAMESPACE}" })}}`
-  }]
+  options(types) {
+    return [...(!types || types.includes('date') ? [{
+      key: 'now',
+      value: 'now',
+      label: `{{t("System time")}}`
+    }] : [])];
+  }
 }];
-const TypeSets = {
-  boolean: new Set(['boolean']),
-  number: new Set(['integer', 'bigInt', 'float', 'double', 'real', 'decimal']),
-  string: new Set(['string', 'text', 'password']),
-  date: new Set(['date', 'time'])
+const BaseTypeSets = {
+  boolean: new Set(['checkbox']),
+  number: new Set(['number', 'percent']),
+  string: new Set(['input', 'password', 'email', 'phone', 'select', 'radioGroup', 'text', 'markdown', 'richText', 'expression', 'time']),
+  date: new Set(['date', 'createdAt', 'updatedAt'])
 };
-exports.TypeSets = TypeSets;
-
+// { type: 'reference', options: { collection: 'users', multiple: false } }
+// { type: 'reference', options: { collection: 'attachments', multiple: false } }
+// { type: 'reference', options: { collection: 'myExpressions', entity: false } }
+exports.BaseTypeSets = BaseTypeSets;
 function matchFieldType(field, type) {
-  if (typeof type === 'string') {
-    var _TypeSets$type;
-
-    return Boolean((_TypeSets$type = TypeSets[type]) === null || _TypeSets$type === void 0 ? void 0 : _TypeSets$type.has(field.type));
+  const inputType = typeof type;
+  if (inputType === 'string') {
+    var _BaseTypeSets$type;
+    return Boolean((_BaseTypeSets$type = BaseTypeSets[type]) === null || _BaseTypeSets$type === void 0 ? void 0 : _BaseTypeSets$type.has(field.interface));
   }
-
-  if (typeof type === 'object' && type.type === 'reference') {
-    var _type$options, _type$options2;
-
-    return field.collectionName === ((_type$options = type.options) === null || _type$options === void 0 ? void 0 : _type$options.collection) && field.name === 'id' || field.type === 'belongsTo' && field.target === ((_type$options2 = type.options) === null || _type$options2 === void 0 ? void 0 : _type$options2.collection);
+  if (inputType === 'object' && type.type === 'reference') {
+    if (isAssociationField(field)) {
+      var _type$options, _type$options2, _type$options3;
+      return ((_type$options = type.options) === null || _type$options === void 0 ? void 0 : _type$options.entity) && (field.collectionName === ((_type$options2 = type.options) === null || _type$options2 === void 0 ? void 0 : _type$options2.collection) || ((_type$options3 = type.options) === null || _type$options3 === void 0 ? void 0 : _type$options3.collection) === '*');
+    } else if (field.isForeignKey) {
+      var _type$options4, _type$options5;
+      return field.collectionName === ((_type$options4 = type.options) === null || _type$options4 === void 0 ? void 0 : _type$options4.collection) && field.name === 'id' || field.target === ((_type$options5 = type.options) === null || _type$options5 === void 0 ? void 0 : _type$options5.collection);
+    } else {
+      return false;
+    }
+  }
+  if (inputType === 'function') {
+    return type(field);
   }
-
   return false;
 }
-
-function filterTypedFields(fields, types) {
-  return types ? fields.filter(field => types.some(type => matchFieldType(field, type))) : fields;
+function isAssociationField(field) {
+  return ['belongsTo', 'hasOne', 'hasMany', 'belongsToMany'].includes(field.type);
 }
-
-function useWorkflowVariableOptions() {
+function filterTypedFields(fields, types, depth = 1) {
+  if (!types) {
+    return fields;
+  }
+  return fields.filter(field => {
+    if (isAssociationField(field) && depth && filterTypedFields(useNormallizedFields(field.target), types, depth - 1).length) {
+      return true;
+    }
+    return types.some(type => matchFieldType(field, type));
+  });
+}
+function useWorkflowVariableOptions(types) {
   const compile = (0, _client().useCompile)();
   const options = VariableTypes.map(item => {
-    const options = typeof item.options === 'function' ? item.options().filter(Boolean) : item.options;
+    const opts = typeof item.options === 'function' ? item.options(types).filter(Boolean) : item.options;
     return {
       label: compile(item.title),
       value: item.value,
       key: item.value,
-      children: compile(options),
-      disabled: options && !options.length
+      children: compile(opts),
+      disabled: opts && !opts.length
     };
   });
   return options;
 }
-
-function useCollectionFieldOptions(props) {
-  const fields = props.fields,
-        collection = props.collection,
-        types = props.types;
+function useNormallizedFields(collectionName) {
   const compile = (0, _client().useCompile)();
-
   const _useCollectionManager = (0, _client().useCollectionManager)(),
-        getCollectionFields = _useCollectionManager.getCollectionFields;
-
-  return filterTypedFields(fields !== null && fields !== void 0 ? fields : getCollectionFields(collection), types).filter(field => field.interface && (!field.target || field.type === 'belongsTo')).map(field => {
-    var _field$uiSchema, _field$uiSchema2;
-
-    return field.type === 'belongsTo' ? {
-      label: `${compile(((_field$uiSchema = field.uiSchema) === null || _field$uiSchema === void 0 ? void 0 : _field$uiSchema.title) || field.name)} ID`,
-      key: field.foreignKey,
-      value: field.foreignKey
-    } : {
-      label: compile(((_field$uiSchema2 = field.uiSchema) === null || _field$uiSchema2 === void 0 ? void 0 : _field$uiSchema2.title) || field.name),
+    getCollection = _useCollectionManager.getCollection;
+  const collection = getCollection(collectionName);
+  if (!collection) {
+    return [];
+  }
+  const fields = collection.fields;
+  const foreignKeyFields = [];
+  const otherFields = [];
+  fields.forEach(field => {
+    if (field.isForeignKey) {
+      foreignKeyFields.push(field);
+    } else {
+      otherFields.push(field);
+    }
+  });
+  for (let i = otherFields.length - 1; i >= 0; i--) {
+    const field = otherFields[i];
+    if (field.type === 'belongsTo') {
+      const foreignKeyField = foreignKeyFields.find(f => f.name === field.foreignKey);
+      if (foreignKeyField) {
+        var _field$uiSchema, _field$uiSchema2;
+        otherFields.splice(i, 0, _objectSpread(_objectSpread({}, foreignKeyField), {}, {
+          uiSchema: _objectSpread(_objectSpread({}, field.uiSchema), {}, {
+            title: ((_field$uiSchema = field.uiSchema) === null || _field$uiSchema === void 0 ? void 0 : _field$uiSchema.title) ? `${compile((_field$uiSchema2 = field.uiSchema) === null || _field$uiSchema2 === void 0 ? void 0 : _field$uiSchema2.title)} ID` : foreignKeyField.name
+          })
+        }));
+      } else {
+        var _field$uiSchema3, _field$uiSchema4;
+        otherFields.splice(i, 0, _objectSpread(_objectSpread({}, field), {}, {
+          name: field.foreignKey,
+          type: 'bigInt',
+          isForeignKey: true,
+          interface: field.interface,
+          uiSchema: _objectSpread(_objectSpread({}, field.uiSchema), {}, {
+            title: ((_field$uiSchema3 = field.uiSchema) === null || _field$uiSchema3 === void 0 ? void 0 : _field$uiSchema3.title) ? `${compile((_field$uiSchema4 = field.uiSchema) === null || _field$uiSchema4 === void 0 ? void 0 : _field$uiSchema4.title)} ID` : field.name
+          })
+        }));
+      }
+    } else if (field.type === 'context' && field.collectionName === 'users') {
+      var _otherFields$find, _belongsToField$uiSch, _belongsToField$uiSch2;
+      const belongsToField = (_otherFields$find = otherFields.find(f => f.type === 'belongsTo' && f.target === 'users' && f.foreignKey === field.name)) !== null && _otherFields$find !== void 0 ? _otherFields$find : {};
+      otherFields.splice(i, 0, _objectSpread(_objectSpread({}, field), {}, {
+        type: field.dataType,
+        interface: belongsToField.interface,
+        uiSchema: _objectSpread(_objectSpread({}, belongsToField.uiSchema), {}, {
+          title: ((_belongsToField$uiSch = belongsToField.uiSchema) === null || _belongsToField$uiSch === void 0 ? void 0 : _belongsToField$uiSch.title) ? `${compile((_belongsToField$uiSch2 = belongsToField.uiSchema) === null || _belongsToField$uiSch2 === void 0 ? void 0 : _belongsToField$uiSch2.title)} ID` : field.name
+        })
+      }));
+    }
+  }
+  return otherFields.filter(field => field.interface && !field.hidden);
+}
+function useCollectionFieldOptions(options) {
+  const fields = options.fields,
+    collection = options.collection,
+    types = options.types,
+    _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 : useNormallizedFields(collection);
+  const result = filterTypedFields(normalizedFields, 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 {
+      label,
       key: field.name,
-      value: field.name
+      value: field.name,
+      children: isAssociationField(field) && depth ? useCollectionFieldOptions({
+        collection: field.target,
+        types,
+        depth: depth - 1
+      }) : null
     };
   });
+  return result;
 }

package/lib/index.js

@@ -9,7 +9,5 @@ Object.defineProperty(exports, "default", {
     return _server.default;
   }
 });
-
 var _server = _interopRequireDefault(require("./server"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/server/Plugin.d.ts

@@ -2,20 +2,20 @@ import { Plugin } from '@nocobase/server';
 import { Registry } from '@nocobase/utils';
 import { Instruction } from './instructions';
 import ExecutionModel from './models/Execution';
-import JobModel from './models/Job';
 import WorkflowModel from './models/Workflow';
 import Processor from './Processor';
 import { Trigger } from './triggers';
-declare type Pending = [ExecutionModel, JobModel?];
+import { Logger } from '@nocobase/logger';
+declare type ID = number | string;
 export default class WorkflowPlugin extends Plugin {
     instructions: Registry<Instruction>;
     triggers: Registry<Trigger>;
     functions: Registry<Function>;
-    executing: ExecutionModel | null;
-    pending: Pending[];
-    events: [WorkflowModel, any, {
-        context?: any;
-    }][];
+    private executing;
+    private pending;
+    private events;
+    private loggerCache;
+    getLogger(workflowId: ID): Logger;
     onBeforeSave: (instance: WorkflowModel, options: any) => Promise<void>;
     load(): Promise<void>;
     toggle(workflow: WorkflowModel, enable?: boolean): void;