@nocobase/plugin-workflow 0.10.1-alpha.1 → 0.11.1-alpha.1

package/src/server/migrations/20230221071831-calculation-expression.ts

@@ -0,0 +1,102 @@
+import { Migration } from '@nocobase/server';
+
+function addQuote(v) {
+  if (typeof v !== 'string') {
+    return v;
+  }
+
+  if (v.match(/^{{\s*([^{}]+)\s*}}$/)) {
+    return v;
+  }
+
+  return `'${v}'`;
+}
+
+const calculatorsMap = {
+  equal: '==',
+  '===': '==',
+  notEqual: '!=',
+  '!==': '!=',
+  gt: '>',
+  gte: '>=',
+  lt: '<',
+  lte: '<=',
+  add: '+',
+  minus: '-',
+  multiple: '*',
+  divide: '/',
+  mod: '%',
+  includes(a, b) {
+    return `SEARCH(${b}, ${a}) >= 0`;
+  },
+  notIncludes(a, b) {
+    return `SEARCH(${b}, ${a}) < 0`;
+  },
+  startsWith(a, b) {
+    return `SEARCH(${b}, ${a}) == 0`;
+  },
+  endsWith(a, b) {
+    return `RIGHT(${a}, LEN(${b})) == ${b}`;
+  },
+  notStartsWith(a, b) {
+    return `SEARCH(${b}, ${a}) != 0`;
+  },
+  notEndsWith(a, b) {
+    return `RIGHT(${a}, LEN(${b})) != ${b}`;
+  },
+  concat(a, b) {
+    return `CONCATENATE(${a}, ${b})`;
+  },
+};
+
+function migrateConfig({ calculation, ...config }: any = {}) {
+  if (!calculation?.calculator || !calculation?.operands?.length) {
+    return config;
+  }
+
+  const calculator = calculatorsMap[calculation.calculator];
+  const operands = (calculator.operands ?? []).map((operand) => addQuote(operand));
+
+  return {
+    engine: 'formula.js',
+    expression:
+      typeof calculator === 'function'
+        ? calculator(...operands)
+        : operands.join(` ${calculator ?? calculation.calculator} `),
+  };
+}
+
+export default class extends Migration {
+  async up() {
+    const match = await this.app.version.satisfies('<0.9.0-alpha.3');
+    if (!match) {
+      return;
+    }
+
+    const NodeRepo = this.context.db.getRepository('flow_nodes');
+    await this.context.db.sequelize.transaction(async (transaction) => {
+      const nodes = await NodeRepo.find({
+        filter: {
+          type: 'calculation',
+        },
+        transaction,
+      });
+      console.log('%d nodes need to be migrated.', nodes.length);
+
+      await nodes.reduce(
+        (promise, node) =>
+          promise.then(() => {
+            return node.update(
+              {
+                config: migrateConfig(node.config),
+              },
+              {
+                transaction,
+              },
+            );
+          }),
+        Promise.resolve(),
+      );
+    });
+  }
+}

package/src/server/migrations/20230221121203-condition-calculation.ts

@@ -0,0 +1,82 @@
+import { Migration } from '@nocobase/server';
+
+const calculatorsMap = {
+  equal: '==',
+  '===': '==',
+  notEqual: '!=',
+  '!==': '!=',
+  gt: '>',
+  gte: '>=',
+  lt: '<',
+  lte: '<=',
+  includes(a, b) {
+    return `SEARCH('${b}', '${a}') >= 0`;
+  },
+  notIncludes(a, b) {
+    return `SEARCH('${b}', '${a}') < 0`;
+  },
+  startsWith(a, b) {
+    return `SEARCH('${b}', '${a}') == 0`;
+  },
+  endsWith(a, b) {
+    return `RIGHT('${a}', LEN('${b}')) == '${b}'`;
+  },
+  notStartsWith(a, b) {
+    return `SEARCH('${b}', '${a}') != 0`;
+  },
+  notEndsWith(a, b) {
+    return `RIGHT('${a}', LEN('${b}')) != '${b}'`;
+  },
+};
+
+function migrateConfig({ group: { type = 'and', calculations = [] } }) {
+  return {
+    group: {
+      type,
+      calculations: calculations.map(({ calculator = '===', operands = [] }: any) => {
+        return `(${operands
+          .map((operand) => (operand?.group ? migrateConfig(operand) : operand))
+          .join(` ${calculatorsMap[calculator]} `)})`;
+      }),
+    },
+  };
+}
+
+export default class extends Migration {
+  async up() {
+    const match = await this.app.version.satisfies('<0.9.0-alpha.3');
+    if (!match) {
+      return;
+    }
+
+    const NodeRepo = this.context.db.getRepository('flow_nodes');
+    await this.context.db.sequelize.transaction(async (transaction) => {
+      const nodes = await NodeRepo.find({
+        filter: {
+          type: 'condition',
+        },
+        transaction,
+      });
+      console.log('%d nodes need to be migrated.', nodes.length);
+
+      await nodes.reduce(
+        (promise, node) =>
+          promise.then(() => {
+            return node.update(
+              {
+                config: {
+                  ...node.config,
+                  engine: 'basic',
+                  // calculation: migrateConfig(node.config.calculation)
+                },
+              },
+              {
+                transaction,
+              },
+            );
+          }),
+        Promise.resolve(),
+      );
+    });
+  }
+}

package/src/server/migrations/20230221162902-jsonb-to-json.ts

@@ -0,0 +1,51 @@
+import { DataTypes } from '@nocobase/database';
+
+import { Migration } from '@nocobase/server';
+
+export default class extends Migration {
+  async up() {
+    const match = await this.app.version.satisfies('<0.9.0-alpha.3');
+    if (!match) {
+      return;
+    }
+
+    const sequelize = this.sequelize;
+    const queryInterface = this.queryInterface;
+
+    const { db } = this.app;
+    await sequelize.transaction(async (transaction) => {
+      await queryInterface.changeColumn(
+        db.getCollection('workflows').model.getTableName(),
+        'config',
+        {
+          type: DataTypes.JSON,
+        },
+        { transaction },
+      );
+      await queryInterface.changeColumn(
+        db.getCollection('flow_nodes').model.getTableName(),
+        'config',
+        {
+          type: DataTypes.JSON,
+        },
+        { transaction },
+      );
+      await queryInterface.changeColumn(
+        db.getCollection('executions').model.getTableName(),
+        'context',
+        {
+          type: DataTypes.JSON,
+        },
+        { transaction },
+      );
+      await queryInterface.changeColumn(
+        db.getCollection('jobs').model.getTableName(),
+        'result',
+        {
+          type: DataTypes.JSON,
+        },
+        { transaction },
+      );
+    });
+  }
+}

package/src/server/migrations/20230411034722-manual-multi-form.ts

@@ -0,0 +1,282 @@
+import { Migration } from '@nocobase/server';
+import { lodash, uid } from '@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 findParent(root, node) {
+  return findSchema(root, (item) => item.properties && Object.values(item.properties).includes(node))[0];
+}
+
+// 1. all form blocks combine into one, at first form block position
+// 2. add fields move to the form
+// 3. remove all other form blocks except first (should remove ancestors till grid)
+// 4. add 'x-interface-options' property to all fields as collection field
+// 5. make collection fields decorator as `FormCollectionProvider` for form block
+// 6. add form component wrapper for form grid
+// 7. move action footer to form block
+function migrateConfig({ schema = {}, actions = [] }: { schema: any; actions: number[] }): object {
+  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: {},
+    };
+  }
+
+  // 1.
+  formBlocks.forEach((formBlock, i) => {
+    const formItems = findSchema(
+      formBlock,
+      (item) => {
+        return item['x-component'] === 'CollectionField' && item['x-decorator'] === 'FormItem';
+      },
+      true,
+    );
+    // 4.
+    formItems.forEach((item) => {
+      Object.assign(item, {
+        'x-interface-options': collection.fields.find((field) => field.name === item.name),
+      });
+    });
+    // skip first form block
+    if (!i) {
+      return;
+    }
+    // 2.
+    Object.assign(formBlocks[0].properties.grid.properties, formBlock.properties.grid.properties);
+
+    // 3.
+    const col = findParent(root, formBlock);
+    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];
+    }
+  });
+
+  // 5.
+  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 = uid();
+  // 6.
+  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;
+}
+
+export default class extends 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,
+      });
+      // update all results
+      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.cloneDeep(node.config ?? {}), nodeForms),
+              },
+              {
+                silent: true,
+                transaction,
+              },
+            );
+          }),
+        Promise.resolve(),
+      );
+    });
+  }
+}

package/src/server/migrations/20230612021134-manual-collection-block.ts

@@ -0,0 +1,138 @@
+import { Migration } from '@nocobase/server';
+import { uid } from '@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 = {}): object {
+  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 = 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;
+}
+
+export default class extends 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(),
+      );
+    });
+  }
+}