@nocobase/flow-engine 2.1.0-alpha.4 → 2.1.0-alpha.45

package/src/__tests__/JSRunner.test.ts

@@ -8,7 +8,7 @@
  */
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { JSRunner } from '../JSRunner';
+import { JSRunner, shouldPreprocessRunJSTemplates } from '../JSRunner';
 import { createSafeWindow } from '../utils';
 
 describe('JSRunner', () => {
@@ -30,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');
@@ -152,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

@@ -11,7 +11,7 @@ import { describe, it, expect, vi } from 'vitest';
 import { FlowContext } from '../flowContext';
 import { FlowEngine } from '../flowEngine';
 import type { FlowView } from '../views/FlowView';
-import { createPopupMeta } from '../views/createViewMeta';
+import { buildPopupRuntime, createPopupMeta } from '../views/createViewMeta';
 
 describe('createPopupMeta - popup variables', () => {
   function makeCtx() {
@@ -23,6 +23,62 @@ describe('createPopupMeta - popup variables', () => {
     return { engine, ctx };
   }
 
+  function makeNestedPopupView(viewUid: string, filterByTk: number): FlowView {
+    return {
+      type: 'drawer',
+      inputArgs: {
+        viewUid,
+        filterByTk,
+        sourceId: 13,
+      },
+      Header: null,
+      Footer: null,
+      close: () => void 0,
+      update: () => void 0,
+      navigation: {
+        viewStack: [
+          { viewUid: 'base-page-uid' },
+          { viewUid: 'parent-popup-uid', filterByTk: 13, sourceId: 13 },
+          { viewUid: 'child-popup-uid', filterByTk: 24, sourceId: 13 },
+        ],
+      } as any,
+    } as any;
+  }
+
+  function mockNestedPopupModels(engine: FlowEngine) {
+    vi.spyOn(engine as any, 'getModel').mockImplementation((uid: string) => {
+      if (uid === 'parent-popup-uid') {
+        return {
+          getStepParams: vi.fn((_fk: string, sk: string) =>
+            sk === 'openView'
+              ? {
+                  collectionName: 'users',
+                  dataSourceKey: 'main',
+                  associationName: 'users.orgs',
+                }
+              : undefined,
+          ),
+        };
+      }
+      if (uid === 'child-popup-uid') {
+        return {
+          getStepParams: vi.fn((_fk: string, sk: string) =>
+            sk === 'openView'
+              ? {
+                  collectionName: 'orgs',
+                  dataSourceKey: 'main',
+                  associationName: 'users.orgs',
+                }
+              : undefined,
+          ),
+        };
+      }
+      return {
+        getStepParams: vi.fn(() => undefined),
+      };
+    });
+  }
+
   it('buildVariablesParams(record) uses anchor view instead of ctx.view', async () => {
     const { engine, ctx } = makeCtx();
 
@@ -108,6 +164,64 @@ describe('createPopupMeta - popup variables', () => {
     expect(vars.record.collection).not.toBe('comments');
   });
 
+  it('buildPopupRuntime anchors current popup even when the navigation stack already has a child popup', async () => {
+    const { engine, ctx } = makeCtx();
+    const parentView = makeNestedPopupView('parent-popup-uid', 13);
+    mockNestedPopupModels(engine);
+
+    const popup = await buildPopupRuntime(ctx, parentView);
+
+    expect(popup?.uid).toBe('parent-popup-uid');
+    expect(popup?.resource).toEqual({
+      dataSourceKey: 'main',
+      collectionName: 'users',
+      associationName: 'users.orgs',
+      filterByTk: 13,
+      sourceId: 13,
+    });
+  });
+
+  it('buildVariablesParams(record) keeps the parent view record when a child popup is open', async () => {
+    const { engine, ctx } = makeCtx();
+    const parentView = makeNestedPopupView('parent-popup-uid', 13);
+    mockNestedPopupModels(engine);
+
+    const meta = (await createPopupMeta(ctx, parentView)())!;
+    const vars = (await meta.buildVariablesParams!(ctx)) as any;
+
+    expect(vars.record).toEqual({
+      collection: 'users',
+      dataSourceKey: 'main',
+      filterByTk: 13,
+      associationName: 'users.orgs',
+      sourceId: 13,
+    });
+  });
+
+  it('buildVariablesParams(parent.record) is still relative to the child popup view', async () => {
+    const { engine, ctx } = makeCtx();
+    const childView = makeNestedPopupView('child-popup-uid', 24);
+    mockNestedPopupModels(engine);
+
+    const meta = (await createPopupMeta(ctx, childView)())!;
+    const vars = (await meta.buildVariablesParams!(ctx)) as any;
+
+    expect(vars.record).toEqual({
+      collection: 'orgs',
+      dataSourceKey: 'main',
+      filterByTk: 24,
+      associationName: 'users.orgs',
+      sourceId: 13,
+    });
+    expect(vars.parent.record).toEqual({
+      collection: 'users',
+      dataSourceKey: 'main',
+      filterByTk: 13,
+      sourceId: 13,
+      associationName: 'users.orgs',
+    });
+  });
+
   it('properties() provides a record factory node (lazy) with title', async () => {
     const { engine, ctx } = makeCtx();
     // 只要能通过 anchorView 推断到集合名和主键即可；集合详情在懒加载时再取

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

@@ -189,4 +189,170 @@ describe('FlowEngine', () => {
       expect(mounted?.uid).toBe('c3');
     });
   });
+
+  describe('getSubclassesOfAsync', () => {
+    it('should return async-loaded subclasses matching extends declaration', async () => {
+      class AsyncSubModelD extends BaseModel {}
+      class AsyncSubModelE extends BaseModel {}
+
+      engine.registerModelLoaders({
+        AsyncSubModelD: {
+          extends: 'BaseModel',
+          loader: async () => ({ AsyncSubModelD }),
+        },
+        AsyncSubModelE: {
+          extends: 'BaseModel',
+          loader: async () => ({ AsyncSubModelE }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync(BaseModel);
+
+      // Sync-registered subclasses
+      expect(result.has('SubModelA')).toBe(true);
+      expect(result.has('SubModelB')).toBe(true);
+      expect(result.has('SubModelC')).toBe(true);
+      // Async-loaded subclasses
+      expect(result.has('AsyncSubModelD')).toBe(true);
+      expect(result.has('AsyncSubModelE')).toBe(true);
+      // Base class excluded
+      expect(result.has('BaseModel')).toBe(false);
+    });
+
+    it('should merge sync-registered and async-loaded subclasses', async () => {
+      class AsyncSubModel extends BaseModel {}
+
+      engine.registerModelLoaders({
+        AsyncSubModel: {
+          extends: 'BaseModel',
+          loader: async () => ({ AsyncSubModel }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync('BaseModel');
+
+      // Sync: SubModelA, SubModelB, SubModelC
+      expect(result.has('SubModelA')).toBe(true);
+      expect(result.has('SubModelB')).toBe(true);
+      expect(result.has('SubModelC')).toBe(true);
+      // Async
+      expect(result.has('AsyncSubModel')).toBe(true);
+      expect(result.size).toBe(4);
+    });
+
+    it('should support extends as string array (multiple parents)', async () => {
+      class AnotherBase extends FlowModel {}
+      class MultiParentModel extends BaseModel {}
+
+      engine.registerModels({ AnotherBase });
+      engine.registerModelLoaders({
+        MultiParentModel: {
+          extends: ['BaseModel', 'AnotherBase'],
+          loader: async () => ({ MultiParentModel }),
+        },
+      });
+
+      const resultBase = await engine.getSubclassesOfAsync(BaseModel);
+      expect(resultBase.has('MultiParentModel')).toBe(true);
+
+      // Also found by AnotherBase (even though actual inheritance is from BaseModel, not AnotherBase)
+      // The extends declaration triggers loading, but isInheritedFrom validation will exclude it from AnotherBase results
+      const resultAnother = await engine.getSubclassesOfAsync(AnotherBase);
+      expect(resultAnother.has('MultiParentModel')).toBe(false);
+    });
+
+    it('should support extends as ModelConstructor', async () => {
+      class AsyncCtorSubModel extends BaseModel {}
+
+      engine.registerModelLoaders({
+        AsyncCtorSubModel: {
+          extends: BaseModel,
+          loader: async () => ({ AsyncCtorSubModel }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync(BaseModel);
+      expect(result.has('AsyncCtorSubModel')).toBe(true);
+    });
+
+    it('should validate actual inheritance and warn on mismatch', async () => {
+      class UnrelatedModel extends FlowModel {}
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      engine.registerModelLoaders({
+        UnrelatedModel: {
+          extends: 'BaseModel',
+          loader: async () => ({ UnrelatedModel }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync(BaseModel);
+      expect(result.has('UnrelatedModel')).toBe(false);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("declares extends 'BaseModel' but does not actually inherit from it"),
+      );
+
+      warnSpy.mockRestore();
+    });
+
+    it('should resolve base class from loaders if not in _modelClasses', async () => {
+      const freshEngine = new FlowEngine();
+
+      class LazyBase extends FlowModel {}
+      class LazySub extends LazyBase {}
+
+      freshEngine.registerModelLoaders({
+        LazyBase: {
+          loader: async () => ({ LazyBase }),
+        },
+        LazySub: {
+          extends: 'LazyBase',
+          loader: async () => ({ LazySub }),
+        },
+      });
+
+      const result = await freshEngine.getSubclassesOfAsync('LazyBase');
+      expect(result.has('LazySub')).toBe(true);
+      expect(result.size).toBe(1);
+    });
+
+    it('should return empty Map when base class cannot be found', async () => {
+      const result = await engine.getSubclassesOfAsync('NonExistentModel');
+      expect(result.size).toBe(0);
+    });
+
+    it('should support filter parameter on both sync and async sources', async () => {
+      class FilteredAsyncModel extends BaseModel {}
+
+      engine.registerModelLoaders({
+        FilteredAsyncModel: {
+          extends: 'BaseModel',
+          loader: async () => ({ FilteredAsyncModel }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync(BaseModel, (_ModelClass, name) => name.startsWith('SubModelA'));
+
+      // Only SubModelA passes the filter (SubModelB, SubModelC, FilteredAsyncModel excluded)
+      expect(result.has('SubModelA')).toBe(true);
+      expect(result.has('SubModelB')).toBe(false);
+      expect(result.has('SubModelC')).toBe(false);
+      expect(result.has('FilteredAsyncModel')).toBe(false);
+    });
+
+    it('should not include loaders without extends declaration', async () => {
+      class NoExtendsModel extends BaseModel {}
+
+      engine.registerModelLoaders({
+        NoExtendsModel: {
+          loader: async () => ({ NoExtendsModel }),
+        },
+      });
+
+      const result = await engine.getSubclassesOfAsync(BaseModel);
+      // Only sync-registered subclasses; NoExtendsModel has no extends, so not discovered
+      expect(result.has('NoExtendsModel')).toBe(false);
+      expect(result.has('SubModelA')).toBe(true);
+    });
+  });
 });

package/src/__tests__/flowContext.test.ts

@@ -7,7 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { describe, expect, it, vi } from 'vitest';
+import axios from 'axios';
+import { describe, expect, it, vi, afterEach } from 'vitest';
 import { FlowContext, FlowRuntimeContext, FlowRunJSContext, type PropertyMetaFactory } from '../flowContext';
 import { FlowEngine } from '../flowEngine';
 import { FlowModel } from '../models/flowModel';
@@ -159,6 +160,23 @@ describe('FlowContext properties and methods', () => {
     expect(ctx.shared).toBe('from delegate');
   });
 
+  it('should expose current language as a top-level variable', async () => {
+    const engine = new FlowEngine();
+    const ctx = engine.context;
+    ctx.defineProperty('api', { value: { auth: { locale: 'zh-CN' } } });
+    ctx.defineProperty('i18n', { value: { language: 'en-US' } });
+
+    expect(ctx.locale).toBe('zh-CN');
+    await expect(ctx.resolveJsonTemplate('{{ ctx.locale }}')).resolves.toBe('zh-CN');
+
+    const localeNode = ctx.getPropertyMetaTree().find((node) => node.name === 'locale');
+    expect(localeNode).toMatchObject({
+      name: 'locale',
+      title: '{{t("Current language")}}',
+      paths: ['locale'],
+    });
+  });
+
   it('should throw sync error in get', () => {
     const ctx = new FlowContext();
     ctx.defineProperty('error', {
@@ -1630,6 +1648,69 @@ describe('runAction delegation from runtime context', () => {
   });
 });
 
+describe('FlowContext request defaults', () => {
+  class RequestModel extends FlowModel {}
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const createRequestContext = () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ RequestModel });
+
+    const apiRequest = vi.fn(async (options) => options);
+    const app = {
+      getApiUrl(pathname = '') {
+        return 'https://app.example.com/api/'.replace(/\/$/g, '') + '/' + pathname.replace(/^\//g, '');
+      },
+    };
+
+    engine.context.defineProperty('api', { value: { request: apiRequest } as any });
+    engine.context.defineProperty('app', { value: app });
+
+    const model = engine.createModel({ use: 'RequestModel' });
+    const ctx = new FlowRuntimeContext(model, 'flow');
+    const directAxiosRequest = vi.spyOn(axios, 'request').mockResolvedValue({ data: {} } as any);
+
+    return { ctx, apiRequest, directAxiosRequest };
+  };
+
+  it.each([
+    ['apiClient', 'users:list', 'api'],
+    ['apiClient', '/api/users:list', 'api'],
+    ['apiClient', 'https://app.example.com/api/users:list', 'api'],
+    ['direct axios', 'https://app.example.com/custom-api/users', 'axios'],
+  ])('should use %s for %s', async (_target, url, expected) => {
+    const { ctx, apiRequest, directAxiosRequest } = createRequestContext();
+
+    await ctx.request({ url, method: 'get' });
+
+    if (expected === 'api') {
+      expect(apiRequest).toHaveBeenCalledTimes(1);
+      expect(directAxiosRequest).not.toHaveBeenCalled();
+      return;
+    }
+
+    expect(directAxiosRequest).toHaveBeenCalledTimes(1);
+    expect(apiRequest).not.toHaveBeenCalled();
+  });
+
+  it('should use direct axios for cross-origin absolute urls', async () => {
+    const { ctx, apiRequest, directAxiosRequest } = createRequestContext();
+
+    await ctx.request({ url: 'https://api.example.com/users', method: 'get', skipAuth: false });
+
+    expect(directAxiosRequest).toHaveBeenCalledTimes(1);
+    expect(apiRequest).not.toHaveBeenCalled();
+    expect(directAxiosRequest.mock.calls[0][0]).toMatchObject({
+      url: 'https://api.example.com/users',
+      method: 'get',
+      skipAuth: false,
+    });
+  });
+});
+
 describe('FlowContext delayed meta loading', () => {
   // 测试场景：属性定义时 meta 为异步函数，首次访问时延迟加载
   // 输入：属性带有异步 meta 函数