@nocobase/plugin-workflow 0.11.1-alpha.5 → 0.12.0-alpha.2

package/dist/server/migrations/20230411034722-manual-multi-form.js

@@ -0,0 +1,252 @@
+'use strict';
+
+var server = require('@nocobase/server');
+var utils = require('@nocobase/utils');
+var lodash = require('lodash');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var lodash__default = /*#__PURE__*/_interopDefault(lodash);
+
+function findSchema(root, filter, onlyLeaf = false) {
+  const result = [];
+  if (!root) {
+    return result;
+  }
+  if (filter(root) && (!onlyLeaf || !root.properties)) {
+    result.push(root);
+    return result;
+  }
+  if (root.properties) {
+    Object.keys(root.properties).forEach((key) => {
+      result.push(...findSchema(root.properties[key], filter));
+    });
+  }
+  return result;
+}
+function findParent(root, node) {
+  return findSchema(root, (item) => item.properties && Object.values(item.properties).includes(node))[0];
+}
+function migrateConfig({ schema = {}, actions = [] }) {
+  const { blocks, collection } = schema;
+  if (!blocks) {
+    return {
+      forms: {}
+    };
+  }
+  const root = { properties: blocks };
+  const formBlocks = findSchema(root, (item) => {
+    return item["x-component"] === "CardItem" && item["x-designer"] === "SimpleDesigner" && item.properties.grid["x-initializer"] === "AddFormField";
+  });
+  if (!formBlocks.length) {
+    return {
+      schema: blocks,
+      forms: {}
+    };
+  }
+  formBlocks.forEach((formBlock2, i) => {
+    const formItems = findSchema(
+      formBlock2,
+      (item) => {
+        return item["x-component"] === "CollectionField" && item["x-decorator"] === "FormItem";
+      },
+      true
+    );
+    formItems.forEach((item) => {
+      Object.assign(item, {
+        "x-interface-options": collection.fields.find((field) => field.name === item.name)
+      });
+    });
+    if (!i) {
+      return;
+    }
+    Object.assign(formBlocks[0].properties.grid.properties, formBlock2.properties.grid.properties);
+    const col = findParent(root, formBlock2);
+    const row = findParent(root, col);
+    delete row.properties[col.name];
+    if (!Object.keys(row.properties).length) {
+      const grid = findParent(root, row);
+      delete grid.properties[row.name];
+    }
+  });
+  const [formBlock] = formBlocks;
+  Object.assign(formBlock, {
+    "x-decorator": "FormCollectionProvider",
+    "x-decorator-props": {
+      collection
+    },
+    "x-component-props": {
+      title: '{{t("Form")}}'
+    },
+    "x-designer-props": {
+      type: "customForm"
+    }
+  });
+  const formId = utils.uid();
+  const newFormBlock = {
+    [formId]: {
+      type: "void",
+      "x-component": "FormV2",
+      "x-component-props": {
+        useProps: "{{ useFormBlockProps }}"
+      },
+      properties: {
+        grid: Object.assign(formBlock.properties.grid, {
+          "x-initializer": "AddCustomFormField"
+        }),
+        // 7.
+        actions: {
+          type: "void",
+          "x-decorator": "ActionBarProvider",
+          "x-component": "ActionBar",
+          "x-component-props": {
+            layout: "one-column",
+            style: {
+              marginTop: "1.5em"
+            }
+          },
+          "x-initializer": "AddActionButton",
+          properties: schema.actions
+        }
+      }
+    }
+  };
+  delete formBlock.properties.grid;
+  Object.assign(formBlock.properties, newFormBlock);
+  return {
+    schema: blocks,
+    forms: {
+      [formId]: {
+        type: "custom",
+        title: '{{t("Form")}}',
+        actions,
+        collection
+      }
+    }
+  };
+}
+function migrateUsedConfig(config, manualForms) {
+  Object.keys(config).forEach((key) => {
+    const valueType = typeof config[key];
+    if (valueType === "string") {
+      config[key] = config[key].replace(/{{\s*\$jobsMapByNodeId\.(\d+)(\.[^}]+)?\s*}}/g, (matched, id, path) => {
+        if (!manualForms[id]) {
+          return matched;
+        }
+        return `{{$jobsMapByNodeId.${id}.${manualForms[id]}${path || ""}}}`;
+      });
+    } else if (valueType === "object" && config[key]) {
+      migrateUsedConfig(config[key], manualForms);
+    }
+  });
+  return config;
+}
+class manual_multi_form_default extends server.Migration {
+  async up() {
+    const match = await this.app.version.satisfies("<0.9.1-alpha.3");
+    if (!match) {
+      return;
+    }
+    const { db } = this.context;
+    const NodeRepo = db.getRepository("flow_nodes");
+    const UserJobRepo = db.getRepository("users_jobs");
+    await db.sequelize.transaction(async (transaction) => {
+      const nodes = await NodeRepo.find({
+        filter: {
+          type: "manual"
+        },
+        transaction
+      });
+      console.log("%d nodes need to be migrated.", nodes.length);
+      await nodes.reduce(
+        (promise, node) => promise.then(() => {
+          const { forms, schema, actions, ...config } = node.config;
+          if (forms) {
+            return;
+          }
+          return node.update(
+            {
+              config: {
+                ...config,
+                ...migrateConfig({ schema, actions })
+              }
+            },
+            {
+              silent: true,
+              transaction
+            }
+          );
+        }),
+        Promise.resolve()
+      );
+      const usersJobs = await UserJobRepo.find({
+        filter: {
+          nodeId: nodes.map((item) => item.id)
+        },
+        appends: ["job", "node"],
+        transaction
+      });
+      await usersJobs.reduce(
+        (promise, userJob) => promise.then(async () => {
+          const { result, job, node } = userJob;
+          const { forms } = node.config;
+          const [formId] = Object.keys(forms);
+          if (result) {
+            await userJob.update(
+              {
+                result: { [formId]: result }
+              },
+              {
+                silent: true,
+                transaction
+              }
+            );
+          }
+          if (job.result) {
+            await job.update(
+              {
+                result: { [formId]: result }
+              },
+              {
+                silent: true,
+                transaction
+              }
+            );
+          }
+        }),
+        Promise.resolve()
+      );
+      const usedNodes = await NodeRepo.find({
+        filter: {
+          type: {
+            $notIn: ["delay", "parallel"]
+          }
+        },
+        transaction
+      });
+      const nodeForms = {};
+      nodes.forEach((node) => {
+        const [form] = Object.keys(node.config.forms);
+        if (form) {
+          nodeForms[node.id] = form;
+        }
+      });
+      await usedNodes.reduce(
+        (promise, node) => promise.then(async () => {
+          await node.update(
+            {
+              config: migrateUsedConfig(lodash__default.default.cloneDeep(node.config ?? {}), nodeForms)
+            },
+            {
+              silent: true,
+              transaction
+            }
+          );
+        }),
+        Promise.resolve()
+      );
+    });
+  }
+}
+
+module.exports = manual_multi_form_default;

package/dist/server/migrations/20230612021134-manual-collection-block.js

@@ -0,0 +1,126 @@
+'use strict';
+
+var server = require('@nocobase/server');
+var utils = require('@nocobase/utils');
+
+function findSchema(root, filter, onlyLeaf = false) {
+  const result = [];
+  if (!root) {
+    return result;
+  }
+  if (filter(root) && (!onlyLeaf || !root.properties)) {
+    result.push(root);
+    return result;
+  }
+  if (root.properties) {
+    Object.keys(root.properties).forEach((key) => {
+      result.push(...findSchema(root.properties[key], filter));
+    });
+  }
+  return result;
+}
+function migrateSchema(schema = {}) {
+  const root = { properties: schema };
+  const collectionBlocks = findSchema(root, (item) => {
+    return item["x-component"] === "CardItem" && item["x-designer"] === "SimpleDesigner" && item["x-decorator"] === "CollectionProvider";
+  });
+  collectionBlocks.forEach((block) => {
+    const id = utils.uid();
+    const { grid } = block.properties;
+    delete block.properties.grid;
+    const fields = findSchema(grid, (item) => {
+      return item["x-decorator"] === "FormItem";
+    });
+    fields.forEach((field) => {
+      Object.assign(field, {
+        "x-component": "CollectionField",
+        "x-collection-field": `${block["x-decorator-props"].collection}.${field["x-collection-field"]}`
+      });
+    });
+    Object.assign(block, {
+      "x-decorator": "DetailsBlockProvider",
+      "x-decorator-props": {
+        ...block["x-decorator-props"],
+        dataSource: grid["x-context-datasource"]
+      },
+      properties: {
+        [id]: {
+          type: "void",
+          name: id,
+          "x-component": "FormV2",
+          "x-component-props": {
+            useProps: "{{useDetailsBlockProps}}"
+          },
+          properties: {
+            grid: {
+              type: "void",
+              name: "grid",
+              "x-component": "Grid",
+              "x-initializer": "ReadPrettyFormItemInitializers",
+              properties: grid.properties
+            }
+          }
+        }
+      }
+    });
+  });
+  const customForms = findSchema(root, (item) => {
+    return item["x-decorator"] === "FormCollectionProvider";
+  });
+  customForms.forEach((item) => {
+    Object.assign(item, {
+      "x-decorator": "CustomFormBlockProvider"
+    });
+  });
+  const customFormFields = findSchema(root, (item) => {
+    return item["x-interface-options"];
+  });
+  customFormFields.forEach((field) => {
+    const options = field["x-interface-options"];
+    delete field["x-interface-options"];
+    Object.assign(field, {
+      "x-component-props": {
+        field: options
+      }
+    });
+  });
+  return schema;
+}
+class manual_collection_block_default extends server.Migration {
+  async up() {
+    const match = await this.app.version.satisfies("<0.9.4-alpha.3");
+    if (!match) {
+      return;
+    }
+    const { db } = this.context;
+    const NodeRepo = db.getRepository("flow_nodes");
+    await db.sequelize.transaction(async (transaction) => {
+      const nodes = await NodeRepo.find({
+        filter: {
+          type: "manual"
+        },
+        transaction
+      });
+      console.log("%d nodes need to be migrated.", nodes.length);
+      await nodes.reduce(
+        (promise, node) => promise.then(() => {
+          const { schema, ...config } = node.config;
+          node.set("config", {
+            ...config,
+            schema: {
+              ...migrateSchema(schema)
+            }
+          });
+          node.changed("config", true);
+          return node.save({
+            silent: true,
+            transaction
+          });
+        }),
+        Promise.resolve()
+      );
+    });
+  }
+}
+
+module.exports = manual_collection_block_default;

package/dist/server/migrations/20230710115902-manual-action-values.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var server = require('@nocobase/server');
+
+function findSchema(root, filter, onlyLeaf = false) {
+  const result = [];
+  if (!root) {
+    return result;
+  }
+  if (filter(root) && (!onlyLeaf || !root.properties)) {
+    result.push(root);
+    return result;
+  }
+  if (root.properties) {
+    Object.keys(root.properties).forEach((key) => {
+      result.push(...findSchema(root.properties[key], filter));
+    });
+  }
+  return result;
+}
+function migrateConfig(config) {
+  const { forms = {}, schema = {} } = config;
+  const root = { properties: schema };
+  Object.keys(forms).forEach((key) => {
+    const form = forms[key];
+    const formSchema = findSchema(root, (item) => item.name === key);
+    const actions = findSchema(formSchema[0], (item) => item["x-component"] === "Action");
+    form.actions = actions.map((action) => {
+      action["x-designer"] = "ManualActionDesigner";
+      action["x-action-settings"] = {};
+      delete action["x-action"];
+      return {
+        status: action["x-decorator-props"].value,
+        values: {},
+        key: action.name
+      };
+    });
+  });
+  return config;
+}
+class manual_action_values_default extends server.Migration {
+  async up() {
+    const match = await this.app.version.satisfies("<0.11.0-alpha.2");
+    if (!match) {
+      return;
+    }
+    const { db } = this.context;
+    const NodeRepo = db.getRepository("flow_nodes");
+    await db.sequelize.transaction(async (transaction) => {
+      const nodes = await NodeRepo.find({
+        filter: {
+          type: "manual"
+        },
+        transaction
+      });
+      console.log("%d nodes need to be migrated.", nodes.length);
+      await nodes.reduce(
+        (promise, node) => promise.then(() => {
+          node.set("config", {
+            ...migrateConfig(node.config)
+          });
+          node.changed("config", true);
+          return node.save({
+            silent: true,
+            transaction
+          });
+        }),
+        Promise.resolve()
+      );
+    });
+  }
+}
+
+module.exports = manual_action_values_default;

package/{src/server/triggers/collection.ts → dist/server/triggers/collection.js}

@@ -1,110 +1,79 @@
-import { Collection, Model } from '@nocobase/database';
-import { Trigger } from '..';
-import { toJSON } from '../utils';
-import type { WorkflowModel } from '../types';
+'use strict';
 
-export interface CollectionChangeTriggerConfig {
-  collection: string;
-  mode: number;
-  // TODO: ICondition
-  condition: any;
-}
+var __ = require('..');
+var utils = require('../utils');
 
 const MODE_BITMAP = {
   CREATE: 1,
   UPDATE: 2,
-  DESTROY: 4,
+  DESTROY: 4
 };
-
-const MODE_BITMAP_EVENTS = new Map();
-MODE_BITMAP_EVENTS.set(MODE_BITMAP.CREATE, 'afterCreateWithAssociations');
-MODE_BITMAP_EVENTS.set(MODE_BITMAP.UPDATE, 'afterUpdateWithAssociations');
-MODE_BITMAP_EVENTS.set(MODE_BITMAP.DESTROY, 'afterDestroy');
-
+const MODE_BITMAP_EVENTS = /* @__PURE__ */ new Map();
+MODE_BITMAP_EVENTS.set(MODE_BITMAP.CREATE, "afterCreateWithAssociations");
+MODE_BITMAP_EVENTS.set(MODE_BITMAP.UPDATE, "afterUpdateWithAssociations");
+MODE_BITMAP_EVENTS.set(MODE_BITMAP.DESTROY, "afterDestroy");
 function getHookId(workflow, type) {
   return `${type}#${workflow.id}`;
 }
-
-function getFieldRawName(collection: Collection, name: string) {
+function getFieldRawName(collection, name) {
   const field = collection.getField(name);
-  if (field && field.type === 'belongsTo') {
+  if (field && field.type === "belongsTo") {
     return field.foreignKey;
   }
   return name;
 }
-
-// async function, should return promise
-async function handler(this: CollectionTrigger, workflow: WorkflowModel, data: Model, options) {
+async function handler(workflow, data, options) {
+  var _a;
   const { collection: collectionName, condition, changed, mode, appends } = workflow.config;
-  const collection = (<typeof Model>data.constructor).database.getCollection(collectionName);
+  const collection = data.constructor.database.getCollection(collectionName);
   const { transaction, context } = options;
   const { repository, model } = collection;
-
-  // NOTE: if no configured fields changed, do not trigger
-  if (
-    changed &&
-    changed.length &&
-    changed
-      .filter((name) => !['linkTo', 'hasOne', 'hasMany', 'belongsToMany'].includes(collection.getField(name).type))
-      .every((name) => !data.changedWithAssociations(getFieldRawName(collection, name)))
-  ) {
+  if (changed && changed.length && changed.filter((name) => !["linkTo", "hasOne", "hasMany", "belongsToMany"].includes(collection.getField(name).type)).every((name) => !data.changedWithAssociations(getFieldRawName(collection, name)))) {
     return;
   }
-  // NOTE: if no configured condition match, do not trigger
-  if (condition && condition.$and?.length) {
-    // TODO: change to map filter format to calculation format
-    // const calculation = toCalculation(condition);
+  if (condition && ((_a = condition.$and) == null ? void 0 : _a.length)) {
     const count = await repository.count({
       filter: {
-        $and: [condition, { [model.primaryKeyAttribute]: data[model.primaryKeyAttribute] }],
+        $and: [condition, { [model.primaryKeyAttribute]: data[model.primaryKeyAttribute] }]
       },
       context,
-      transaction,
+      transaction
     });
-
     if (!count) {
       return;
     }
   }
-
   let result = data;
-
-  if (appends?.length && !(mode & MODE_BITMAP.DESTROY)) {
+  if ((appends == null ? void 0 : appends.length) && !(mode & MODE_BITMAP.DESTROY)) {
     const includeFields = appends.reduce((set, field) => {
-      set.add(field.split('.')[0]);
+      set.add(field.split(".")[0]);
       set.add(field);
       return set;
-    }, new Set());
+    }, /* @__PURE__ */ new Set());
     result = await repository.findOne({
       filterByTk: data[model.primaryKeyAttribute],
       appends: Array.from(includeFields),
-      transaction,
+      transaction
     });
   }
-
-  // TODO: `result.toJSON()` throws error
-  const json = toJSON(result);
-
+  const json = utils.toJSON(result);
   this.plugin.trigger(
     workflow,
     { data: json },
     {
-      context,
-    },
+      context
+    }
   );
 }
-
-export default class CollectionTrigger extends Trigger {
-  events = new Map();
-
-  on(workflow: WorkflowModel) {
+class CollectionTrigger extends __.Trigger {
+  events = /* @__PURE__ */ new Map();
+  on(workflow) {
     const { db } = this.plugin.app;
     const { collection, mode } = workflow.config;
-    const Collection = db.getCollection(collection);
-    if (!Collection) {
+    const Collection2 = db.getCollection(collection);
+    if (!Collection2) {
       return;
     }
-
     for (const [key, type] of MODE_BITMAP_EVENTS.entries()) {
       const event = `${collection}.${type}`;
       const name = getHookId(workflow, event);
@@ -123,12 +92,11 @@ export default class CollectionTrigger extends Trigger {
       }
     }
   }
-
-  off(workflow: WorkflowModel) {
+  off(workflow) {
     const { db } = this.plugin.app;
     const { collection, mode } = workflow.config;
-    const Collection = db.getCollection(collection);
-    if (!Collection) {
+    const Collection2 = db.getCollection(collection);
+    if (!Collection2) {
       return;
     }
     for (const [key, type] of MODE_BITMAP_EVENTS.entries()) {
@@ -144,3 +112,5 @@ export default class CollectionTrigger extends Trigger {
     }
   }
 }
+
+module.exports = CollectionTrigger;

package/dist/server/triggers/index.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('path');
+var utils = require('@nocobase/utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+class Trigger {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+}
+function triggers_default(plugin, more = {}) {
+  const { triggers } = plugin;
+  triggers.register("collection", new (utils.requireModule(path__default.default.join(__dirname, "collection")))(plugin));
+  triggers.register("schedule", new (utils.requireModule(path__default.default.join(__dirname, "schedule")))(plugin));
+  for (const [name, TClass] of Object.entries(more)) {
+    triggers.register(name, new TClass(plugin));
+  }
+}
+
+exports.Trigger = Trigger;
+exports.default = triggers_default;