@nocobase/flow-engine 2.0.0-alpha.7 → 2.0.0-alpha.71

package/src/__tests__/runjsContextRuntime.test.ts

@@ -0,0 +1,269 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { FlowContext } from '../flowContext';
+import { createJSRunnerWithVersion, getRunJSDocFor } from '..';
+import { setupRunJSContexts } from '../runjs-context/setup';
+
+describe('RunJS Context Runtime Behavior', () => {
+  beforeAll(async () => {
+    await setupRunJSContexts();
+  });
+
+  describe('JSBlockRunJSContext', () => {
+    it('should create JSBlock context successfully', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSBlockModel' } } });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return typeof ctx !== "undefined"');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should have element property in documentation', () => {
+      const ctx: any = { model: { constructor: { name: 'JSBlockModel' } } };
+      const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+      expect(doc?.properties?.element).toBeTruthy();
+      expect(doc?.properties?.React).toBeTruthy();
+      expect(doc?.properties?.antd).toBeTruthy();
+    });
+
+    it('should have onRefReady method in documentation', () => {
+      const ctx: any = { model: { constructor: { name: 'JSBlockModel' } } };
+      const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+      expect(doc?.methods?.onRefReady).toBeTruthy();
+      expect(doc?.methods?.requireAsync).toBeTruthy();
+    });
+  });
+
+  describe('JSFieldRunJSContext', () => {
+    it('should create JSField context successfully', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSFieldModel' } } });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return typeof ctx !== "undefined"');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should have field-specific properties in documentation', () => {
+      const ctx: any = { model: { constructor: { name: 'JSFieldModel' } } };
+      const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+      expect(doc?.properties?.element).toBeTruthy();
+      expect(doc?.properties?.value).toBeTruthy();
+      expect(doc?.properties?.record).toBeTruthy();
+      expect(doc?.properties?.collection).toBeTruthy();
+    });
+  });
+
+  describe('JSItemRunJSContext', () => {
+    it('should create JSItem context successfully', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSItemModel' } } });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return typeof ctx !== "undefined"');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should have item-specific properties in documentation', () => {
+      const ctx: any = { model: { constructor: { name: 'JSItemModel' } } };
+      const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+      expect(doc?.properties?.element).toBeTruthy();
+      expect(doc?.properties?.record).toBeTruthy();
+      expect(doc?.properties?.resource).toBeTruthy();
+    });
+  });
+
+  describe('JSColumnRunJSContext', () => {
+    it('should create JSColumn context successfully', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSColumnModel' } } });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return typeof ctx !== "undefined"');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should have column-specific properties in documentation', () => {
+      const ctx: any = { model: { constructor: { name: 'JSColumnModel' } } };
+      const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+      expect(doc?.properties?.element).toBeTruthy();
+      expect(doc?.properties?.record).toBeTruthy();
+      expect(doc?.properties?.recordIndex).toBeTruthy();
+      expect(doc?.properties?.collection).toBeTruthy();
+      expect(doc?.properties?.viewer).toBeTruthy();
+    });
+  });
+
+  describe('FormJSFieldItemRunJSContext', () => {
+    it('should create FormJSFieldItem context successfully', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', { value: { constructor: { name: 'FormJSFieldItemModel' } } });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return typeof ctx !== "undefined"');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should have form field-specific properties and methods in documentation', () => {
+      const ctx: any = { model: { constructor: { name: 'FormJSFieldItemModel' } } };
+      const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+      expect(doc?.properties?.element).toBeTruthy();
+      expect(doc?.properties?.value).toBeTruthy();
+      expect(doc?.properties?.record).toBeTruthy();
+      expect(doc?.methods?.setProps).toBeTruthy();
+    });
+  });
+
+  describe('JSRecordActionRunJSContext', () => {
+    it('should create JSRecordAction context successfully', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSRecordActionModel' } } });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return typeof ctx !== "undefined"');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should have record action-specific properties in documentation', () => {
+      const ctx: any = { model: { constructor: { name: 'JSRecordActionModel' } } };
+      const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+      expect(doc?.properties?.record).toBeTruthy();
+      expect(doc?.properties?.filterByTk).toBeTruthy();
+    });
+  });
+
+  describe('JSCollectionActionRunJSContext', () => {
+    it('should create JSCollectionAction context successfully', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSCollectionActionModel' } } });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return typeof ctx !== "undefined"');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should have collection action-specific properties in documentation', () => {
+      const ctx: any = { model: { constructor: { name: 'JSCollectionActionModel' } } };
+      const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+      expect(doc?.properties?.resource).toBeTruthy();
+    });
+  });
+
+  describe('Cross-context features', () => {
+    it('should provide React and antd in all contexts', async () => {
+      const contextTypes = [
+        'JSBlockModel',
+        'JSFieldModel',
+        'JSItemModel',
+        'JSColumnModel',
+        'FormJSFieldItemModel',
+        'JSRecordActionModel',
+        'JSCollectionActionModel',
+      ];
+
+      for (const modelName of contextTypes) {
+        const ctx = new FlowContext();
+        ctx.defineProperty('model', { value: { constructor: { name: modelName } } });
+
+        const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+        const result = await runner.run(`
+          return {
+            hasReact: typeof ctx.React !== "undefined",
+            hasAntd: typeof ctx.antd !== "undefined",
+            hasReactDOM: typeof ctx.ReactDOM !== "undefined"
+          }
+        `);
+
+        expect(result?.success).toBe(true);
+        expect(result?.value).toEqual({
+          hasReact: true,
+          hasAntd: true,
+          hasReactDOM: true,
+        });
+      }
+    });
+
+    it('should access base context properties in documentation', () => {
+      const contextTypes = ['JSBlockModel', 'JSFieldModel', 'JSColumnModel'];
+
+      for (const modelName of contextTypes) {
+        const ctx: any = { model: { constructor: { name: modelName } } };
+        const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+        // Base properties from FlowRunJSContext
+        expect(doc?.properties?.logger).toBeTruthy();
+        expect(doc?.properties?.message).toBeTruthy();
+        expect(doc?.properties?.api).toBeTruthy();
+        expect(doc?.methods?.t).toBeTruthy();
+        expect(doc?.methods?.requireAsync).toBeTruthy();
+      }
+    });
+  });
+
+  describe('Documentation completeness', () => {
+    it('should provide complete documentation for all context types', () => {
+      const contextTypes = [
+        'JSBlockModel',
+        'JSFieldModel',
+        'JSItemModel',
+        'JSColumnModel',
+        'FormJSFieldItemModel',
+        'JSRecordActionModel',
+        'JSCollectionActionModel',
+      ];
+
+      for (const modelName of contextTypes) {
+        const ctx: any = { model: { constructor: { name: modelName } } };
+        const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+        expect(doc).toBeTruthy();
+        expect(doc?.label).toBeTruthy();
+        expect(doc?.properties).toBeTruthy();
+        expect(typeof doc?.properties).toBe('object');
+      }
+    });
+
+    it('should provide locale-specific documentation', () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', { value: { constructor: { name: 'JSFieldModel' } } });
+      ctx.defineProperty('api', { value: { auth: { locale: 'zh-CN' } } });
+
+      const doc = getRunJSDocFor(ctx as any, { version: 'v1' });
+
+      expect(doc).toBeTruthy();
+      // Should have Chinese documentation
+      expect(doc?.label).toContain('JS');
+    });
+  });
+});

package/src/__tests__/runjsEdgeCases.test.ts

@@ -0,0 +1,281 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { FlowContext, FlowEngineContext, FlowRunJSContext } from '../flowContext';
+import { FlowEngine } from '../flowEngine';
+import { createJSRunnerWithVersion, RunJSContextRegistry } from '..';
+import { setupRunJSContexts } from '../runjs-context/setup';
+
+describe('RunJS Edge Cases and Error Handling', () => {
+  let engine: FlowEngine;
+  let engineCtx: FlowEngineContext;
+
+  beforeAll(async () => {
+    await setupRunJSContexts();
+    engine = new FlowEngine();
+    engineCtx = new FlowEngineContext(engine);
+  });
+
+  describe('Missing or invalid model scenarios', () => {
+    it('should handle undefined model', async () => {
+      const ctx = new FlowEngineContext(engine);
+      const runner = await ctx.createJSRunner();
+
+      expect(runner).toBeDefined();
+      const result = await runner.run('return typeof ctx !== "undefined"');
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should handle null model', async () => {
+      const ctx = new FlowEngineContext(engine);
+      (ctx as any).defineProperty('model', { value: null });
+
+      const runner = await ctx.createJSRunner();
+      expect(runner).toBeDefined();
+    });
+
+    it('should handle model without constructor', async () => {
+      const ctx = new FlowEngineContext(engine);
+      (ctx as any).defineProperty('model', { value: {} });
+
+      const runner = await ctx.createJSRunner();
+      expect(runner).toBeDefined();
+    });
+
+    it('should handle unrecognized model type', async () => {
+      const ctx = new FlowEngineContext(engine);
+      (ctx as any).defineProperty('model', {
+        value: { constructor: { name: 'UnknownModelType' } },
+      });
+
+      const runner = await ctx.createJSRunner();
+      expect(runner).toBeDefined();
+
+      const result = await runner.run('return typeof ctx !== "undefined"');
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+  });
+
+  describe('Invalid version handling', () => {
+    it('should handle missing version gracefully', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', {
+        value: { constructor: { name: 'JSBlockModel' } },
+      });
+
+      const runner = createJSRunnerWithVersion.call(ctx, {} as any);
+      expect(runner).toBeDefined();
+    });
+
+    it('should throw error for invalid version string', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', {
+        value: { constructor: { name: 'JSBlockModel' } },
+      });
+
+      expect(() => {
+        createJSRunnerWithVersion.call(ctx, {
+          version: 'invalid-version',
+        } as any);
+      }).toThrow();
+    });
+  });
+
+  describe('Code execution edge cases', () => {
+    it('should handle empty code', async () => {
+      const runner = await engineCtx.createJSRunner();
+      const result = await runner.run('');
+
+      expect(result).toBeDefined();
+    });
+
+    it('should handle whitespace-only code', async () => {
+      const runner = await engineCtx.createJSRunner();
+      const result = await runner.run('   \n\n\t\t   ');
+
+      expect(result).toBeDefined();
+    });
+
+    it('should handle syntax errors', async () => {
+      const runner = await engineCtx.createJSRunner();
+      const result = await runner.run('return {invalid: syntax');
+
+      expect(result?.success).toBe(false);
+      expect(result?.error).toBeDefined();
+    });
+
+    it('should handle rejected promises', async () => {
+      const runner = await engineCtx.createJSRunner();
+      const result = await runner.run(`
+        return Promise.reject(new Error('Rejected'));
+      `);
+
+      expect(result?.success).toBe(false);
+      expect(result?.error).toBeDefined();
+    });
+
+    it('should handle code that returns undefined', async () => {
+      const runner = await engineCtx.createJSRunner();
+      const result = await runner.run('return undefined');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBeUndefined();
+    });
+
+    it('should handle code that returns null', async () => {
+      const runner = await engineCtx.createJSRunner();
+      const result = await runner.run('return null');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBeNull();
+    });
+  });
+
+  describe('Context property edge cases', () => {
+    it('should handle value of 0', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', {
+        value: {
+          constructor: { name: 'JSFieldModel' },
+        },
+      });
+      ctx.defineProperty('value', { value: 0 });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return typeof ctx !== "undefined"');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should handle empty string value', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', {
+        value: {
+          constructor: { name: 'JSFieldModel' },
+        },
+      });
+      ctx.defineProperty('value', { value: '' });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return typeof ctx !== "undefined"');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+
+    it('should handle false boolean value', async () => {
+      const ctx = new FlowContext();
+      ctx.defineProperty('model', {
+        value: {
+          constructor: { name: 'JSFieldModel' },
+        },
+      });
+      ctx.defineProperty('value', { value: false });
+
+      const runner = createJSRunnerWithVersion.call(ctx, { version: 'v1' });
+      const result = await runner.run('return typeof ctx !== "undefined"');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(true);
+    });
+  });
+
+  describe('Registry edge cases', () => {
+    it('should handle repeated setup calls idempotently', async () => {
+      await setupRunJSContexts();
+      await setupRunJSContexts();
+      await setupRunJSContexts();
+
+      const ctor = RunJSContextRegistry['resolve']('v1' as any, 'JSBlockModel');
+      expect(ctor).toBeDefined();
+    });
+
+    it('should handle context creation with minimal delegate', () => {
+      const minimalCtx = new FlowContext();
+      const runCtx = new FlowRunJSContext(minimalCtx);
+
+      expect(runCtx).toBeDefined();
+      expect((runCtx as any).React).toBeDefined();
+      expect((runCtx as any).antd).toBeDefined();
+      expect((runCtx as any).ReactDOM).toBeDefined();
+    });
+
+    it('should handle context creation with null delegate', () => {
+      expect(() => {
+        new FlowRunJSContext(null as any);
+      }).toThrow();
+    });
+
+    it('should handle context creation with undefined delegate', () => {
+      expect(() => {
+        new FlowRunJSContext(undefined as any);
+      }).toThrow();
+    });
+  });
+
+  describe('Timeout edge cases', () => {
+    it('should handle very large timeout', async () => {
+      const runner = await engineCtx.createJSRunner({ timeoutMs: 999999999 });
+      const result = await runner.run('return 1 + 1');
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(2);
+    });
+
+    it('should handle code that completes before timeout', async () => {
+      const runner = await engineCtx.createJSRunner({ timeoutMs: 200 });
+      const result = await runner.run(`
+        return new Promise(resolve => {
+          setTimeout(() => resolve('done'), 50);
+        });
+      `);
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe('done');
+    });
+  });
+
+  describe('Complex scenarios', () => {
+    it('should handle multiple concurrent runners', async () => {
+      const runners = await Promise.all([
+        engineCtx.createJSRunner(),
+        engineCtx.createJSRunner(),
+        engineCtx.createJSRunner(),
+      ]);
+
+      const results = await Promise.all([
+        runners[0].run('return 1'),
+        runners[1].run('return 2'),
+        runners[2].run('return 3'),
+      ]);
+
+      expect(results[0]?.value).toBe(1);
+      expect(results[1]?.value).toBe(2);
+      expect(results[2]?.value).toBe(3);
+    });
+
+    it('should handle recursive code execution', async () => {
+      const runner = await engineCtx.createJSRunner({ timeoutMs: 1000 });
+      const result = await runner.run(`
+        function factorial(n) {
+          if (n <= 1) return 1;
+          return n * factorial(n - 1);
+        }
+        return factorial(10);
+      `);
+
+      expect(result?.success).toBe(true);
+      expect(result?.value).toBe(3628800);
+    });
+  });
+});