@tachybase/plugin-workflow-test 0.23.8

package/src/e2e/index.ts

@@ -0,0 +1,4 @@
+export * from './e2eCollectionModel';
+export * from './e2ePageObjectModel';
+export { default } from './e2ePageObjectModel';
+export * from './e2eUtils';

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './server';
+export { default } from './server';

package/src/server/collections/categories.ts

@@ -0,0 +1,15 @@
+import { CollectionOptions } from '@tachybase/database';
+
+export default {
+  name: 'categories',
+  fields: [
+    {
+      type: 'string',
+      name: 'title',
+    },
+    {
+      type: 'hasMany',
+      name: 'posts',
+    },
+  ],
+} as CollectionOptions;

package/src/server/collections/comments.ts

@@ -0,0 +1,24 @@
+import { CollectionOptions } from '@tachybase/database';
+
+export default {
+  name: 'comments',
+  fields: [
+    {
+      type: 'belongsTo',
+      name: 'post',
+    },
+    {
+      type: 'text',
+      name: 'content',
+    },
+    {
+      type: 'integer',
+      name: 'status',
+      defaultValue: 0,
+    },
+    {
+      type: 'hasMany',
+      name: 'replies',
+    },
+  ],
+} as CollectionOptions;

package/src/server/collections/posts.ts

@@ -0,0 +1,40 @@
+import { CollectionOptions } from '@tachybase/database';
+
+export default {
+  name: 'posts',
+  createdBy: true,
+  updatedBy: true,
+  fields: [
+    {
+      type: 'string',
+      name: 'title',
+    },
+    {
+      type: 'boolean',
+      name: 'published',
+      defaultValue: false,
+    },
+    {
+      type: 'integer',
+      name: 'read',
+      defaultValue: 0,
+    },
+    {
+      type: 'belongsTo',
+      name: 'category',
+    },
+    {
+      type: 'hasMany',
+      name: 'comments',
+    },
+    {
+      type: 'belongsToMany',
+      name: 'tags',
+    },
+    {
+      type: 'integer',
+      name: 'read',
+      defaultValue: 0,
+    },
+  ],
+} as CollectionOptions;

package/src/server/collections/replies.ts

@@ -0,0 +1,9 @@
+export default {
+  name: 'replies',
+  fields: [
+    {
+      type: 'string',
+      name: 'content',
+    },
+  ],
+};

package/src/server/collections/tags.ts

@@ -0,0 +1,15 @@
+import { CollectionOptions } from '@tachybase/database';
+
+export default {
+  name: 'tags',
+  fields: [
+    {
+      type: 'belongsToMany',
+      name: 'posts',
+    },
+    {
+      type: 'string',
+      name: 'name',
+    },
+  ],
+} as CollectionOptions;

package/src/server/functions.ts

@@ -0,0 +1,3 @@
+export default {
+  no1: () => 1,
+};

package/src/server/index.ts

@@ -0,0 +1,84 @@
+import path from 'path';
+import { SequelizeDataSource } from '@tachybase/data-source';
+import { Resourcer } from '@tachybase/resourcer';
+import { ApplicationOptions, Plugin } from '@tachybase/server';
+import { createMockServer, mockDatabase, MockServer } from '@tachybase/test';
+import { uid } from '@tachybase/utils';
+
+import functions from './functions';
+import instructions from './instructions';
+import triggers from './triggers';
+
+export interface MockServerOptions extends ApplicationOptions {
+  collectionsPath?: string;
+}
+
+// async function createMockServer(options: MockServerOptions) {
+//   const app = mockServer(options);
+//   await app.cleanDb();
+//   await app.runCommand('start', '--quickstart');
+//   return app;
+// }
+
+export function sleep(ms: number) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+export async function getApp(options: MockServerOptions = {}): Promise<MockServer> {
+  const { plugins = [], collectionsPath, ...others } = options;
+  class TestCollectionPlugin extends Plugin {
+    async load() {
+      if (collectionsPath) {
+        await this.db.import({ directory: collectionsPath });
+      }
+    }
+  }
+  const app = await createMockServer({
+    ...others,
+    plugins: [
+      [
+        'workflow',
+        {
+          triggers,
+          instructions,
+          functions,
+        },
+      ],
+      'workflow-test',
+      TestCollectionPlugin,
+      ...plugins,
+    ],
+  });
+
+  await app.dataSourceManager.add(
+    new SequelizeDataSource({
+      name: 'another',
+      collectionManager: {
+        database: mockDatabase({
+          tablePrefix: `t${uid(5)}`,
+        }),
+      },
+      resourceManager: {},
+    }),
+  );
+  const another = app.dataSourceManager.dataSources.get('another');
+  // @ts-ignore
+  const anotherDB = another.collectionManager.db;
+
+  await anotherDB.import({
+    directory: path.resolve(__dirname, 'collections'),
+  });
+  await anotherDB.sync();
+
+  another.acl.allow('*', '*');
+
+  return app;
+}
+
+export default class WorkflowTestPlugin extends Plugin {
+  async load() {
+    await this.importCollections(path.resolve(__dirname, 'collections'));
+  }
+}

package/src/server/instructions.ts

@@ -0,0 +1,67 @@
+import { lodash } from '@tachybase/utils';
+
+export default {
+  echo: {
+    run({ config = {} }: any, { result }, processor) {
+      return {
+        status: 1,
+        result: config.path == null ? result : lodash.get(result, config.path),
+      };
+    },
+  },
+
+  error: {
+    run(node, input, processor) {
+      throw new Error('definite error');
+    },
+  },
+
+  pending: {
+    run(node, input, processor) {
+      return {
+        status: 0,
+      };
+    },
+  },
+
+  prompt: {
+    run(node, input, processor) {
+      return {
+        status: 0,
+      };
+    },
+    resume(node, job, processor) {
+      return job.set({
+        status: 1,
+      });
+    },
+  },
+
+  'prompt->error': {
+    run(node, input, processor) {
+      return {
+        status: 0,
+      };
+    },
+    resume(node, input, processor) {
+      throw new Error('input failed');
+      return null;
+    },
+  },
+
+  customizedSuccess: {
+    run(node, input, processor) {
+      return {
+        status: 100,
+      };
+    },
+  },
+
+  customizedError: {
+    run(node, input, processor) {
+      return {
+        status: -100,
+      };
+    },
+  },
+};

package/src/server/triggers.ts

@@ -0,0 +1,19 @@
+export default {
+  syncTrigger: class {
+    constructor(public readonly workflow) {}
+    on() {}
+    off() {}
+    sync = true;
+    validateEvent() {
+      return true;
+    }
+  },
+  asyncTrigger: class {
+    constructor(public readonly workflow) {}
+    on() {}
+    off() {}
+    validateEvent() {
+      return true;
+    }
+  },
+};