@nocobase/flow-engine 2.1.0-alpha.1 → 2.1.0-alpha.11

package/src/__tests__/JSRunner.test.ts

@@ -8,7 +8,8 @@
  */
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { JSRunner } from '../JSRunner';
+import { JSRunner, shouldPreprocessRunJSTemplates } from '../JSRunner';
+import { createSafeWindow } from '../utils';
 
 describe('JSRunner', () => {
   let originalSearch: string;
@@ -29,6 +30,18 @@ describe('JSRunner', () => {
     vi.restoreAllMocks();
   });
 
+  it('shouldPreprocessRunJSTemplates: explicit option has highest priority', () => {
+    expect(shouldPreprocessRunJSTemplates({ version: 'v2', preprocessTemplates: true })).toBe(true);
+    expect(shouldPreprocessRunJSTemplates({ version: 'v1', preprocessTemplates: false })).toBe(false);
+  });
+
+  it('shouldPreprocessRunJSTemplates: falls back to version policy', () => {
+    expect(shouldPreprocessRunJSTemplates({ version: 'v1' })).toBe(true);
+    expect(shouldPreprocessRunJSTemplates({ version: 'v2' })).toBe(false);
+    expect(shouldPreprocessRunJSTemplates({})).toBe(true);
+    expect(shouldPreprocessRunJSTemplates()).toBe(true);
+  });
+
   it('executes simple code and returns value', async () => {
     const runner = new JSRunner();
     const result = await runner.run('return 1 + 2 + 3');
@@ -48,6 +61,69 @@ describe('JSRunner', () => {
     expect(res2.value).toBe('baz');
   });
 
+  it('auto-lifts Blob from injected window to top-level globals', async () => {
+    if (typeof Blob === 'undefined') {
+      return;
+    }
+
+    const runner = new JSRunner({
+      globals: {
+        window: createSafeWindow(),
+      },
+    });
+
+    const result = await runner.run('return new Blob(["x"]).size');
+    expect(result.success).toBe(true);
+    expect(result.value).toBe(1);
+  });
+
+  it('keeps explicit globals.Blob higher priority than auto-lifted Blob', async () => {
+    const explicitBlob = function ExplicitBlob(this: any, chunks: any[]) {
+      this.size = Array.isArray(chunks) ? chunks.length : 0;
+    } as any;
+
+    const runner = new JSRunner({
+      globals: {
+        window: createSafeWindow(),
+        Blob: explicitBlob,
+      },
+    });
+
+    const result = await runner.run('const b = new Blob([1,2,3]); return b.size;');
+    expect(result.success).toBe(true);
+    expect(result.value).toBe(3);
+  });
+
+  it('auto-lifts URL from injected window to top-level globals', async () => {
+    const runner = new JSRunner({
+      globals: {
+        window: createSafeWindow(),
+      },
+    });
+
+    const result = await runner.run('return typeof URL.createObjectURL === "function"');
+    expect(result.success).toBe(true);
+    expect(result.value).toBe(true);
+  });
+
+  it('keeps explicit globals.URL higher priority than auto-lifted URL', async () => {
+    const explicitURL = {
+      createObjectURL: () => 'explicit://url',
+      revokeObjectURL: (_url: string) => undefined,
+    };
+
+    const runner = new JSRunner({
+      globals: {
+        window: createSafeWindow(),
+        URL: explicitURL,
+      },
+    });
+
+    const result = await runner.run('return URL.createObjectURL(new Blob(["x"]))');
+    expect(result.success).toBe(true);
+    expect(result.value).toBe('explicit://url');
+  });
+
   it('exposes console in sandbox by default', async () => {
     const runner = new JSRunner();
     const result = await runner.run('return typeof console !== "undefined"');
@@ -88,6 +164,20 @@ describe('JSRunner', () => {
     expect((result.error as Error).message).toBe('Execution timed out');
   });
 
+  it('returns friendly hint when bare {{ctx.xxx}} appears in syntax error', async () => {
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const runner = new JSRunner();
+    const result = await runner.run('const z = {{ctx.user.id}}');
+    expect(result.success).toBe(false);
+    expect(result.error).toBeInstanceOf(SyntaxError);
+    const msg = String((result.error as any)?.message || '');
+    expect(msg).toContain('"{{ctx.user.id}}" has been deprecated');
+    expect(msg).toContain('await ctx.getVar("ctx.user.id")');
+    expect(msg).not.toContain('(at ');
+    expect((result.error as any)?.__runjsHideLocation).toBe(true);
+    expect(spy).toHaveBeenCalled();
+  });
+
   it('skips execution when URL contains skipRunJs=true', async () => {
     // 模拟预览模式下通过 URL 参数跳过代码执行
     if (typeof window !== 'undefined' && typeof window.history?.pushState === 'function') {

package/src/__tests__/createViewMeta.popup.test.ts

@@ -13,7 +13,7 @@ import { FlowEngine } from '../flowEngine';
 import type { FlowView } from '../views/FlowView';
 import { createPopupMeta } from '../views/createViewMeta';
 
-describe('createViewMeta - popup variables', () => {
+describe('createPopupMeta - popup variables', () => {
   function makeCtx() {
     const engine = new FlowEngine();
     const ctx = new FlowContext();
@@ -139,4 +139,65 @@ describe('createViewMeta - popup variables', () => {
     expect((props.record as any).title).toBe('Current popup record');
     expect((props.record as any).hasChildren).toBe(true);
   });
+
+  it('treats views with openerUids as popup (meta visible)', async () => {
+    const { ctx } = makeCtx();
+
+    // openerUids 作为路由栈缺失时的兜底标记：即使没有 navigation.viewStack，也应展示 ctx.popup 元信息
+    const anchorView: FlowView = {
+      type: 'dialog',
+      inputArgs: {
+        openerUids: ['opener-uid-1'],
+        viewUid: 'popup-uid',
+        dataSourceKey: 'main',
+        collectionName: 'posts',
+        filterByTk: 1,
+      },
+      Header: null,
+      Footer: null,
+      close: () => void 0,
+      update: () => void 0,
+    } as any;
+
+    const meta = (await createPopupMeta(ctx, anchorView)())!;
+    expect(typeof meta.hidden).toBe('function');
+    expect((meta.hidden as any)()).toBe(false);
+    expect(typeof meta.disabled).toBe('function');
+    expect((meta.disabled as any)()).toBe(false);
+
+    const vars = (await meta.buildVariablesParams!(ctx)) as any;
+    expect(vars).toBeTruthy();
+    expect(vars.record).toEqual({
+      collection: 'posts',
+      dataSourceKey: 'main',
+      filterByTk: 1,
+      associationName: undefined,
+      sourceId: undefined,
+    });
+  });
+
+  it('does not expose popup.record without filterByTk', async () => {
+    const { ctx } = makeCtx();
+
+    const anchorView: FlowView = {
+      type: 'dialog',
+      inputArgs: {
+        openerUids: ['opener-uid-1'],
+        viewUid: 'popup-uid',
+        dataSourceKey: 'main',
+        collectionName: 'posts',
+        // filterByTk 缺失：不应展示“当前弹窗记录”变量
+      },
+      Header: null,
+      Footer: null,
+      close: () => void 0,
+      update: () => void 0,
+    } as any;
+
+    ctx.defineProperty('view', { value: anchorView });
+
+    const meta = (await createPopupMeta(ctx, anchorView)())!;
+    const props = typeof meta.properties === 'function' ? await (meta.properties as any)() : meta.properties || {};
+    expect(props.record).toBeUndefined();
+  });
 });

package/src/__tests__/flow-engine.test.ts

@@ -89,7 +89,13 @@ describe('FlowEngine', () => {
     class MockFlowModelRepository implements IFlowModelRepository {
       // 使用可配置返回值，便于不同用例控制 findOne 行为
       findOneResult: any = null;
+      ensureResult: any = null;
+      ensureCalls = 0;
       save = vi.fn(async (model: FlowModel) => ({ success: true, uid: model.uid }));
+      async ensure() {
+        this.ensureCalls += 1;
+        return this.ensureResult ? JSON.parse(JSON.stringify(this.ensureResult)) : null;
+      }
       async findOne() {
         // 返回深拷贝，避免被测试过程修改
         return this.findOneResult ? JSON.parse(JSON.stringify(this.findOneResult)) : null;
@@ -188,5 +194,47 @@ describe('FlowEngine', () => {
       expect(Array.isArray(mounted)).toBe(false);
       expect(mounted?.uid).toBe('c3');
     });
+
+    it('should call repository.ensure with repository context preserved', async () => {
+      const parent = engine.createModel({ uid: 'p4', use: 'FlowModel' });
+
+      repo.ensureResult = {
+        uid: 'c4',
+        use: 'FlowModel',
+        parentId: parent.uid,
+        subKey: 'page',
+        subType: 'object',
+      };
+
+      const child = await engine.loadOrCreateModel({
+        parentId: parent.uid,
+        subKey: 'page',
+        subType: 'object',
+        use: 'FlowModel',
+        async: true,
+      });
+
+      expect(child).toBeTruthy();
+      expect(repo.ensureCalls).toBe(1);
+      expect((parent.subModels as any).page).toBe(child);
+      expect(repo.save).not.toHaveBeenCalled();
+    });
+
+    it('should not persist through ensure when skipSave is true', async () => {
+      repo.findOneResult = null;
+
+      const model = await engine.loadOrCreateModel(
+        {
+          uid: 'c5',
+          use: 'FlowModel',
+        },
+        { skipSave: true },
+      );
+
+      expect(model).toBeTruthy();
+      expect(model?.uid).toBe('c5');
+      expect(repo.ensureCalls).toBe(0);
+      expect(repo.save).not.toHaveBeenCalled();
+    });
   });
 });