@nocobase/plugin-workflow 0.11.0-alpha.1 → 0.11.1-alpha.2

package/src/server/__tests__/instructions/request.test.ts

@@ -213,5 +213,35 @@ describe('workflow > instructions > request', () => {
       expect(job.status).toEqual(JOB_STATUS.RESOLVED);
       expect(job.result.data).toEqual({ title });
     });
+
+    it('request inside loop',async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+        config: {
+          target: 2,
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'request',
+        upstreamId: n1.id,
+        branchIndex: 0,
+        config: {
+          url: URL_DATA,
+          method: 'GET',
+        }
+      });
+
+      await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toEqual(EXECUTION_STATUS.RESOLVED);
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(3);
+      expect(jobs.map(item => item.status)).toEqual(Array(3).fill(JOB_STATUS.RESOLVED));
+      expect(jobs[0].result).toBe(2);
+    });
   });
 });

package/src/server/__tests__/instructions/sql.test.ts

@@ -0,0 +1,162 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+import { EXECUTION_STATUS, JOB_STATUS } from '../../constants';
+
+describe('workflow > instructions > sql', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let PostCollection;
+  let ReplyRepo;
+  let WorkflowModel;
+  let workflow;
+
+  beforeEach(async () => {
+    app = await getApp();
+
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostCollection = db.getCollection('posts');
+    PostRepo = PostCollection.repository;
+    ReplyRepo = db.getCollection('replies').repository;
+
+    workflow = await WorkflowModel.create({
+      title: 'test workflow',
+      enabled: true,
+      type: 'collection',
+      config: {
+        mode: 1,
+        collection: 'posts',
+      },
+    });
+  });
+
+  afterEach(async () => await app.destroy());
+
+  describe('invalid', () => {
+    it('no sql', async () => {
+      const n1 = await workflow.createNode({
+        type: 'sql',
+        config: {},
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [sqlJob] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      expect(sqlJob.status).toBe(JOB_STATUS.RESOLVED);
+    });
+
+    it('empty sql', async () => {
+      const n1 = await workflow.createNode({
+        type: 'sql',
+        config: {
+          sql: '',
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [sqlJob] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      expect(sqlJob.status).toBe(JOB_STATUS.RESOLVED);
+    });
+
+    it('invalid sql', async () => {
+      const n1 = await workflow.createNode({
+        type: 'sql',
+        config: {
+          sql: '1',
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [sqlJob] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(execution.status).toBe(EXECUTION_STATUS.ERROR);
+      expect(sqlJob.status).toBe(JOB_STATUS.ERROR);
+    });
+  });
+
+  describe('sql with variables', () => {
+    it('update', async () => {
+      const queryInterface = db.sequelize.getQueryInterface();
+      const n1 = await workflow.createNode({
+        type: 'sql',
+        config: {
+          sql: `update ${PostCollection.quotedTableName()} set ${queryInterface.quoteIdentifier('read')}={{$context.data.id}} where ${queryInterface.quoteIdentifier('id')}={{$context.data.id}}`,
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              id: '{{ $context.data.id }}',
+            }
+          }
+        },
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n2);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [sqlJob, queryJob] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(sqlJob.status).toBe(JOB_STATUS.RESOLVED);
+      expect(queryJob.status).toBe(JOB_STATUS.RESOLVED);
+      expect(queryJob.result.read).toBe(post.id);
+    });
+
+    it('delete', async () => {
+      const queryInterface = db.sequelize.getQueryInterface();
+      const n1 = await workflow.createNode({
+        type: 'sql',
+        config: {
+          sql: `delete from ${PostCollection.quotedTableName()} where ${queryInterface.quoteIdentifier('id')}={{$context.data.id}};`,
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              id: '{{ $context.data.id }}',
+            }
+          }
+        },
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n2);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [sqlJob, queryJob] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(sqlJob.status).toBe(JOB_STATUS.RESOLVED);
+      expect(queryJob.status).toBe(JOB_STATUS.RESOLVED);
+      expect(queryJob.result).toBeNull();
+    });
+  });
+});

package/src/server/__tests__/triggers/collection.test.ts

@@ -294,5 +294,40 @@ describe('workflow > triggers > collection', () => {
       const [job] = await execution.getJobs();
       expect(job.result.data.tags.length).toBe(1);
     });
+
+    describe('appends depth > 1', () => {
+      it('create with associtions', async () => {
+        const workflow = await WorkflowModel.create({
+          enabled: true,
+          type: 'collection',
+          config: {
+            mode: 1,
+            collection: 'categories',
+            appends: ['posts.tags'],
+          },
+        });
+
+        const tags = await TagRepo.create({ values: [{}] });
+        const tagIds = tags.map((item) => item.id);
+
+        const category = await CategoryRepo.create({
+          values: {
+            title: 't1',
+            posts: [
+              { title: 't1', tags: tagIds },
+              { title: 't2', tags: tagIds },
+            ],
+          },
+        });
+
+        await sleep(500);
+
+        const [execution] = await workflow.getExecutions();
+        expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+        expect(execution.context.data.posts.length).toBe(2);
+        expect(execution.context.data.posts.map((item) => item.title)).toEqual(['t1', 't2']);
+        expect(execution.context.data.posts.map((item) => item.tags.map((tag) => tag.id))).toEqual([tagIds, tagIds]);
+      });
+    });
   });
 });

package/src/server/instructions/create.ts

@@ -1,4 +1,5 @@
 import { JOB_STATUS } from '../constants';
+import { toJSON } from '../utils';
 import type { FlowNodeModel } from '../types';
 
 export default {
@@ -7,7 +8,7 @@ export default {
 
     const { repository, model } = (<typeof FlowNodeModel>node.constructor).database.getCollection(collection);
     const options = processor.getParsedValue(params, node);
-    const result = await repository.create({
+    const created = await repository.create({
       ...options,
       context: {
         executionId: processor.execution.id,
@@ -15,22 +16,23 @@ export default {
       transaction: processor.transaction,
     });
 
-    if (result && appends.length) {
-      const includeFields = appends.filter((field) => !result.get(field) || !result[field]);
-      const included = await model.findByPk(result[model.primaryKeyAttribute], {
-        attributes: [model.primaryKeyAttribute],
-        include: includeFields,
+    let result = created;
+    if (created && appends.length) {
+      const includeFields = appends.reduce((set, field) => {
+        set.add(field.split('.')[0]);
+        set.add(field);
+        return set;
+      }, new Set());
+      result = await repository.findOne({
+        filterByTk: created[model.primaryKeyAttribute],
+        appends: Array.from(includeFields),
         transaction: processor.transaction,
       });
-      includeFields.forEach((field) => {
-        const value = included!.get(field);
-        result.set(field, Array.isArray(value) ? value.map((item) => item.toJSON()) : value.toJSON(), { raw: true });
-      });
     }
 
     return {
       // NOTE: get() for non-proxied instance (#380)
-      result: result?.toJSON(),
+      result: toJSON(result),
       status: JOB_STATUS.RESOLVED,
     };
   },

package/src/server/instructions/index.ts

@@ -46,6 +46,7 @@ export default function <T extends Instruction>(plugin, more: { [key: string]: T
     'destroy',
     'aggregate',
     'request',
+    'sql',
   ].reduce(
     (result, key) =>
       Object.assign(result, {

package/src/server/instructions/manual/actions.ts

@@ -30,15 +30,17 @@ export async function submit(context: Context, next) {
   }
 
   const { forms = {} } = userJob.node.config;
-  const [formKey] = Object.keys(values.result ?? {});
+  const [formKey] = Object.keys(values.result ?? {}).filter(key => key !== '_');
+  const actionKey = values.result?._;
 
+  const actionItem = forms[formKey]?.actions?.find((item) => item.key === actionKey);
   // NOTE: validate status
   if (
     userJob.status !== JOB_STATUS.PENDING ||
     userJob.job.status !== JOB_STATUS.PENDING ||
     userJob.execution.status !== EXECUTION_STATUS.STARTED ||
     !userJob.workflow.enabled ||
-    !forms[formKey]?.actions?.includes(values.status)
+    !actionKey || actionItem?.status == null
   ) {
     return context.throw(400);
   }
@@ -52,10 +54,17 @@ export async function submit(context: Context, next) {
   if (!assignees.includes(currentUser.id) || userJob.userId !== currentUser.id) {
     return context.throw(403);
   }
+  const presetValues = processor.getParsedValue(actionItem.values ?? {}, null, {
+    currentUser: currentUser.toJSON(),
+    currentRecord: values.result[formKey],
+    currentTime: new Date(),
+  });
 
   userJob.set({
-    status: values.status,
-    result: values.status ? values.result : Object.assign(userJob.result ?? {}, values.result),
+    status: actionItem.status,
+    result: actionItem.status > JOB_STATUS.PENDING
+      ? { [formKey]: Object.assign(values.result[formKey], presetValues), _: actionKey }
+      : Object.assign(userJob.result ?? {}, values.result),
   });
 
   const handler = instruction.formTypes.get(forms[formKey].type);
@@ -72,8 +81,11 @@ export async function submit(context: Context, next) {
 
   await next();
 
+  userJob.job.execution = userJob.execution;
   userJob.job.latestUserJob = userJob;
 
   // NOTE: resume the process and no `await` for quick returning
+  processor.logger.info(`manual node (${userJob.nodeId}) action trigger execution (${userJob.execution.id}) to resume`);
+
   plugin.resume(userJob.job);
 }

package/src/server/instructions/manual/forms/create.ts

@@ -7,7 +7,8 @@ export default async function (this: ManualInstruction, instance, { collection }
     throw new Error(`collection ${collection} for create data on manual node not found`);
   }
 
-  const [values] = Object.values(instance.result);
+  const { _, ...form } = instance.result;
+  const [values] = Object.values(form);
   await repo.create({
     values: {
       ...((values as { [key: string]: any }) ?? {}),

package/src/server/instructions/manual/forms/update.ts

@@ -7,11 +7,12 @@ export default async function (this: ManualInstruction, instance, { collection,
     throw new Error(`collection ${collection} for update data on manual node not found`);
   }
 
-  const [values] = Object.values(instance.result as { [formKey: string]: { [key: string]: any } });
+  const { _, ...form } = instance.result;
+  const [values] = Object.values(form);
   await repo.update({
     filter: processor.getParsedValue(filter),
     values: {
-      ...(values ?? {}),
+      ...((values as { [key: string]: any }) ?? {}),
       updatedBy: instance.userId,
     },
     context: {

package/src/server/instructions/query.ts

@@ -1,5 +1,6 @@
 import Processor from '../Processor';
 import { JOB_STATUS } from '../constants';
+import { toJSON } from '../utils';
 import type { FlowNodeModel } from '../types';
 
 export default {
@@ -8,8 +9,18 @@ export default {
 
     const repo = (<typeof FlowNodeModel>node.constructor).database.getRepository(collection);
     const options = processor.getParsedValue(params, node);
+    const appends = options.appends
+      ? Array.from(
+          options.appends.reduce((set, field) => {
+            set.add(field.split('.')[0]);
+            set.add(field);
+            return set;
+          }, new Set()),
+        )
+      : options.appends;
     const result = await (multiple ? repo.find : repo.findOne).call(repo, {
       ...options,
+      appends: appends,
       transaction: processor.transaction,
     });
 
@@ -24,7 +35,7 @@ export default {
     // e.g. Object.prototype.hasOwnProperty.call(result, 'id') // false
     // so the properties can not be get by json-templates(object-path)
     return {
-      result: multiple ? result.map((item) => item.toJSON()) : result?.toJSON(),
+      result: toJSON(result),
       status: JOB_STATUS.RESOLVED,
     };
   },

package/src/server/instructions/request.ts

@@ -45,10 +45,11 @@ async function request(config) {
 export default class implements Instruction {
   constructor(public plugin) {}
 
-  async run(node: FlowNodeModel, input, processor: Processor) {
+  async run(node: FlowNodeModel, prevJob, processor: Processor) {
     const job = await processor.saveJob({
       status: JOB_STATUS.PENDING,
       nodeId: node.id,
+      upstreamId: prevJob?.id ?? null,
     });
 
     const config = processor.getParsedValue(node.config, node) as RequestConfig;

package/src/server/instructions/sql.ts

@@ -0,0 +1,25 @@
+import { Processor, JOB_STATUS } from '..';
+import type { FlowNodeModel } from '../types';
+
+export default {
+  async run(node: FlowNodeModel, input, processor: Processor) {
+    const { sequelize } = (<typeof FlowNodeModel>node.constructor).database;
+    const sql = processor.getParsedValue(node.config.sql ?? '', node).trim();
+    if (!sql) {
+      return {
+        status: JOB_STATUS.RESOLVED,
+      }
+    }
+
+    const result = await sequelize.query(sql, {
+      transaction: processor.transaction,
+      // plain: true,
+      // model: db.getCollection(node.config.collection).model
+    });
+
+    return {
+      result,
+      status: JOB_STATUS.RESOLVED,
+    };
+  },
+};

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

@@ -1,5 +1,6 @@
 import { Collection, Model } from '@nocobase/database';
 import { Trigger } from '..';
+import { toJSON } from '../utils';
 import type { WorkflowModel } from '../types';
 
 export interface CollectionChangeTriggerConfig {
@@ -66,24 +67,27 @@ async function handler(this: CollectionTrigger, workflow: WorkflowModel, data: M
     }
   }
 
+  let result = data;
+
   if (appends?.length && !(mode & MODE_BITMAP.DESTROY)) {
-    const includeFields = appends.filter((field) => !data.get(field) || !data[field]);
-    const included = await model.findByPk(data[model.primaryKeyAttribute], {
-      attributes: [model.primaryKeyAttribute],
-      include: includeFields,
+    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,
     });
-    includeFields.forEach((field) => {
-      const value = included!.get(field);
-      data.set(field, Array.isArray(value) ? value.map((item) => item.toJSON()) : value ? value.toJSON() : null, {
-        raw: true,
-      });
-    });
   }
 
+  // TODO: `result.toJSON()` throws error
+  const json = toJSON(result);
+
   this.plugin.trigger(
     workflow,
-    { data: data.toJSON() },
+    { data: json },
     {
       context,
     },

package/src/server/utils.ts

@@ -0,0 +1,17 @@
+import { Model } from '@nocobase/database';
+
+export function toJSON(data: Model | Model[]): object {
+  if (typeof data !== 'object' || !data) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map(toJSON);
+  }
+  const result = data.get();
+  Object.keys((<typeof Model>data.constructor).associations).forEach((key) => {
+    if (result[key] != null) {
+      result[key] = toJSON(result[key]);
+    }
+  });
+  return result;
+}

package/lib/client/triggers/schedule/DateFieldsSelect.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare const DateFieldsSelect: React.FC<any>;

package/src/client/triggers/schedule/DateFieldsSelect.tsx

@@ -1,28 +0,0 @@
-import { observer, useForm } from '@formily/react';
-import { useCollectionManager, useCompile } from '@nocobase/client';
-import { Select } from 'antd';
-import React from 'react';
-import { useTranslation } from 'react-i18next';
-
-export const DateFieldsSelect: React.FC<any> = observer(
-  (props) => {
-    const { t } = useTranslation();
-    const compile = useCompile();
-    const { getCollectionFields } = useCollectionManager();
-    const { values } = useForm();
-    const fields = getCollectionFields(values?.collection);
-
-    return (
-      <Select popupMatchSelectWidth={false} placeholder={t('Select field')} {...props}>
-        {fields
-          .filter((field) => !field.hidden && (field.uiSchema ? field.type === 'date' : false))
-          .map((field) => (
-            <Select.Option key={field.name} value={field.name}>
-              {compile(field.uiSchema?.title)}
-            </Select.Option>
-          ))}
-      </Select>
-    );
-  },
-  { displayName: 'DateFieldsSelect' },
-);