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

package/src/server/migrations/20230710115902-manual-action-values.ts

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

package/src/server/triggers/collection.ts

@@ -0,0 +1,146 @@
+import { Collection, Model } from '@nocobase/database';
+import { Trigger } from '..';
+import { toJSON } from '../utils';
+import type { WorkflowModel } from '../types';
+
+export interface CollectionChangeTriggerConfig {
+  collection: string;
+  mode: number;
+  // TODO: ICondition
+  condition: any;
+}
+
+const MODE_BITMAP = {
+  CREATE: 1,
+  UPDATE: 2,
+  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');
+
+function getHookId(workflow, type) {
+  return `${type}#${workflow.id}`;
+}
+
+function getFieldRawName(collection: Collection, name: string) {
+  const field = collection.getField(name);
+  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) {
+  const { collection: collectionName, condition, changed, mode, appends } = workflow.config;
+  const collection = (<typeof Model>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)))
+  ) {
+    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);
+    const count = await repository.count({
+      filter: {
+        $and: [condition, { [model.primaryKeyAttribute]: data[model.primaryKeyAttribute] }],
+      },
+      context,
+      transaction,
+    });
+
+    if (!count) {
+      return;
+    }
+  }
+
+  let result = data;
+
+  if (appends?.length && !(mode & MODE_BITMAP.DESTROY)) {
+    const includeFields = appends.reduce((set, field) => {
+      set.add(field.split('.')[0]);
+      set.add(field);
+      return set;
+    }, new Set());
+    result = await repository.findOne({
+      filterByTk: data[model.primaryKeyAttribute],
+      appends: Array.from(includeFields),
+      transaction,
+    });
+  }
+
+  // TODO: `result.toJSON()` throws error
+  const json = toJSON(result);
+
+  this.plugin.trigger(
+    workflow,
+    { data: json },
+    {
+      context,
+    },
+  );
+}
+
+export default class CollectionTrigger extends Trigger {
+  events = new Map();
+
+  on(workflow: WorkflowModel) {
+    const { db } = this.plugin.app;
+    const { collection, mode } = workflow.config;
+    const Collection = db.getCollection(collection);
+    if (!Collection) {
+      return;
+    }
+
+    for (const [key, type] of MODE_BITMAP_EVENTS.entries()) {
+      const event = `${collection}.${type}`;
+      const name = getHookId(workflow, event);
+      if (mode & key) {
+        if (!this.events.has(name)) {
+          const listener = handler.bind(this, workflow);
+          this.events.set(name, listener);
+          db.on(event, listener);
+        }
+      } else {
+        const listener = this.events.get(name);
+        if (listener) {
+          db.off(event, listener);
+          this.events.delete(name);
+        }
+      }
+    }
+  }
+
+  off(workflow: WorkflowModel) {
+    const { db } = this.plugin.app;
+    const { collection, mode } = workflow.config;
+    const Collection = db.getCollection(collection);
+    if (!Collection) {
+      return;
+    }
+    for (const [key, type] of MODE_BITMAP_EVENTS.entries()) {
+      const event = `${collection}.${type}`;
+      const name = getHookId(workflow, event);
+      if (mode & key) {
+        const listener = this.events.get(name);
+        if (listener) {
+          db.off(event, listener);
+          this.events.delete(name);
+        }
+      }
+    }
+  }
+}

package/src/server/triggers/index.ts

@@ -0,0 +1,22 @@
+import path from 'path';
+import { requireModule } from '@nocobase/utils';
+
+import Plugin from '..';
+import type { WorkflowModel } from '../types';
+
+export abstract class Trigger {
+  constructor(public readonly plugin: Plugin) {}
+  abstract on(workflow: WorkflowModel): void;
+  abstract off(workflow: WorkflowModel): void;
+}
+
+export default function <T extends Trigger>(plugin, more: { [key: string]: { new (p: Plugin): T } } = {}) {
+  const { triggers } = plugin;
+
+  triggers.register('collection', new (requireModule(path.join(__dirname, 'collection')))(plugin));
+  triggers.register('schedule', new (requireModule(path.join(__dirname, 'schedule')))(plugin));
+
+  for (const [name, TClass] of Object.entries(more)) {
+    triggers.register(name, new TClass(plugin));
+  }
+}