@nocobase/flow-engine 2.1.0-alpha.3 → 2.1.0-alpha.30

package/src/__tests__/flowEngine.modelLoaders.test.ts

@@ -0,0 +1,245 @@
+/**
+ * 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 { beforeEach, describe, expect, it, vi } from 'vitest';
+import { FlowEngine } from '../flowEngine';
+import { ErrorFlowModel, FlowModel } from '../models';
+import type { IFlowModelRepository } from '../types';
+
+class MockFlowModelRepository implements IFlowModelRepository {
+  findOneResult: any = null;
+  save = vi.fn(async (model: FlowModel) => ({ success: true, uid: model.uid }));
+
+  async findOne() {
+    return this.findOneResult ? JSON.parse(JSON.stringify(this.findOneResult)) : null;
+  }
+
+  async destroy() {
+    return true;
+  }
+
+  async move() {}
+
+  async duplicate() {
+    return null;
+  }
+}
+
+describe('FlowEngine model loaders', () => {
+  let engine: FlowEngine;
+  let repo: MockFlowModelRepository;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    repo = new MockFlowModelRepository();
+    engine.setModelRepository(repo);
+  });
+
+  it('resolves explicit and meta-default model trees before synchronous creation', async () => {
+    class ParentModel extends FlowModel {}
+    class ChildModel extends FlowModel {}
+    class DefaultChildModel extends FlowModel {}
+
+    ParentModel.define({
+      createModelOptions: {
+        subModels: {
+          defaultChild: {
+            use: 'DefaultChildModel',
+          },
+        },
+      },
+    });
+
+    const parentLoader = vi.fn(async () => ({ ParentModel }));
+    const childLoader = vi.fn(async () => ({ ChildModel }));
+    const defaultChildLoader = vi.fn(async () => ({ DefaultChildModel }));
+
+    engine.registerModelLoaders({
+      ParentModel: { loader: parentLoader },
+      ChildModel: { loader: childLoader },
+      DefaultChildModel: { loader: defaultChildLoader },
+    });
+
+    const model = await engine.loadOrCreateModel({
+      uid: 'parent-model',
+      use: 'ParentModel',
+      subModels: {
+        child: {
+          use: 'ChildModel',
+        },
+      },
+    });
+
+    expect(model).toBeInstanceOf(ParentModel);
+    expect(model?.subModels.child).toBeInstanceOf(ChildModel);
+    expect(model?.subModels.defaultChild).toBeInstanceOf(DefaultChildModel);
+    expect(parentLoader).toHaveBeenCalledTimes(1);
+    expect(childLoader).toHaveBeenCalledTimes(1);
+    expect(defaultChildLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('resolves repository-loaded model trees before loadModel creates instances', async () => {
+    class RepoRootModel extends FlowModel {}
+    class RepoChildModel extends FlowModel {}
+
+    const rootLoader = vi.fn(async () => ({ RepoRootModel }));
+    const childLoader = vi.fn(async () => ({ RepoChildModel }));
+
+    engine.registerModelLoaders({
+      RepoRootModel: { loader: rootLoader },
+      RepoChildModel: { loader: childLoader },
+    });
+
+    repo.findOneResult = {
+      uid: 'repo-root',
+      use: 'RepoRootModel',
+      subModels: {
+        child: {
+          use: 'RepoChildModel',
+        },
+      },
+    };
+
+    const model = await engine.loadModel({ uid: 'repo-root' });
+
+    expect(model).toBeInstanceOf(RepoRootModel);
+    expect(model?.subModels.child).toBeInstanceOf(RepoChildModel);
+    expect(rootLoader).toHaveBeenCalledTimes(1);
+    expect(childLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('supports async model creation and async getters', async () => {
+    class AsyncRootModel extends FlowModel {}
+    class AsyncChildModel extends FlowModel {}
+
+    const rootLoader = vi.fn(async () => ({ AsyncRootModel }));
+    const childLoader = vi.fn(async () => ({ AsyncChildModel }));
+
+    engine.registerModelLoaders({
+      AsyncRootModel: { loader: rootLoader },
+      AsyncChildModel: { loader: childLoader },
+    });
+
+    const rootClass = await engine.getModelClassAsync('AsyncRootModel');
+    const classes = await engine.getModelClassesAsync();
+    const model = await engine.createModelAsync({
+      uid: 'async-root',
+      use: 'AsyncRootModel',
+      subModels: {
+        child: {
+          use: 'AsyncChildModel',
+        },
+      },
+    });
+
+    expect(rootClass).toBe(AsyncRootModel);
+    expect(classes.get('AsyncRootModel')).toBe(AsyncRootModel);
+    expect(classes.get('AsyncChildModel')).toBe(AsyncChildModel);
+    expect(model).toBeInstanceOf(AsyncRootModel);
+    expect(model.subModels.child).toBeInstanceOf(AsyncChildModel);
+    expect(rootLoader).toHaveBeenCalledTimes(1);
+    expect(childLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('createModelAsync degrades unresolved loader failures to ErrorFlowModel', async () => {
+    const invalidLoader = vi.fn(async () => ({ notAModel: {} }));
+
+    engine.registerModelLoaders({
+      BrokenRootModel: { loader: invalidLoader as any },
+    });
+
+    const model = await engine.createModelAsync({
+      uid: 'broken-root',
+      use: 'BrokenRootModel',
+    });
+
+    expect(model).toBeInstanceOf(ErrorFlowModel);
+    expect(invalidLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps loader resolution idempotent across resolveModelTree and flow settings preload', async () => {
+    class RuntimeResolvedModel extends FlowModel {}
+    class DesignResolvedModel extends FlowModel {}
+
+    const runtimeLoader = vi.fn(async () => ({ RuntimeResolvedModel }));
+    const designLoader = vi.fn(async () => ({ DesignResolvedModel }));
+
+    engine.registerModelLoaders({
+      RuntimeResolvedModel: { loader: runtimeLoader },
+      DesignResolvedModel: { loader: designLoader },
+    });
+
+    await engine.resolveModelTree({
+      use: 'RuntimeResolvedModel',
+    });
+
+    const firstPreload = await engine.preloadModelLoaders();
+    const secondPreload = await engine.preloadModelLoaders();
+
+    expect(runtimeLoader).toHaveBeenCalledTimes(1);
+    expect(designLoader).toHaveBeenCalledTimes(1);
+    expect(firstPreload.loaded).toContain('DesignResolvedModel');
+    expect(firstPreload.loaded).not.toContain('RuntimeResolvedModel');
+    expect(secondPreload.loaded).toHaveLength(0);
+    expect(secondPreload.failed).toHaveLength(0);
+  });
+
+  it('picks up newly registered loaders after preload has already completed', async () => {
+    class FirstModel extends FlowModel {}
+    class SecondModel extends FlowModel {}
+
+    const firstLoader = vi.fn(async () => ({ FirstModel }));
+    const secondLoader = vi.fn(async () => ({ SecondModel }));
+
+    engine.registerModelLoaders({
+      FirstModel: { loader: firstLoader },
+    });
+
+    await engine.preloadModelLoaders();
+    expect(firstLoader).toHaveBeenCalledTimes(1);
+    expect(engine.getModelClass('FirstModel')).toBe(FirstModel);
+
+    engine.registerModelLoaders({
+      SecondModel: { loader: secondLoader },
+    });
+
+    const result = await engine.preloadModelLoaders();
+
+    expect(secondLoader).toHaveBeenCalledTimes(1);
+    expect(result.loaded).toContain('SecondModel');
+    expect(engine.getModelClass('SecondModel')).toBe(SecondModel);
+  });
+
+  it('degrades unresolved loader failures to ErrorFlowModel instead of crashing runtime creation', async () => {
+    class ParentModel extends FlowModel {}
+
+    const parentLoader = vi.fn(async () => ({ ParentModel }));
+    const invalidChildLoader = vi.fn(async () => ({ notAModel: {} }));
+
+    engine.registerModelLoaders({
+      ParentModel: { loader: parentLoader },
+      BrokenChildModel: { loader: invalidChildLoader as any },
+    });
+
+    const model = await engine.loadOrCreateModel({
+      uid: 'parent-with-broken-child',
+      use: 'ParentModel',
+      subModels: {
+        child: {
+          use: 'BrokenChildModel',
+        },
+      },
+    });
+
+    expect(model).toBeInstanceOf(ParentModel);
+    expect(model?.subModels.child).toBeInstanceOf(ErrorFlowModel);
+    expect(parentLoader).toHaveBeenCalledTimes(1);
+    expect(invalidChildLoader).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/flowSettings.test.ts

@@ -8,6 +8,10 @@
  */
 
 import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest';
+import React from 'react';
+import { createForm } from '@formily/core';
+import { createSchemaField, FormProvider } from '@formily/react';
+import { render, screen } from '@testing-library/react';
 import { FlowSettings } from '../flowSettings';
 import { DefaultSettingsIcon } from '../components/settings/wrappers/contextual/DefaultSettingsIcon';
 import { FlowModel } from '../models';
@@ -142,10 +146,10 @@ describe('FlowSettings', () => {
       expect(settingsItem?.sort).toBe(0);
     });
 
-    test('should set up observable properties', () => {
+    test('should set up observable properties', async () => {
       // Test that enabled property is reactive
       const initialEnabled = flowSettings.enabled;
-      flowSettings.enable();
+      await flowSettings.enable();
       expect(flowSettings.enabled).not.toBe(initialEnabled);
       expect(flowSettings.enabled).toBe(true);
     });
@@ -186,6 +190,43 @@ describe('FlowSettings', () => {
       flowSettings.registerComponents({});
       expect(Object.keys(flowSettings.components)).toHaveLength(0);
     });
+
+    test('should register component loaders and load component on render', async () => {
+      const loader = vi.fn(async () => ({
+        default: () => React.createElement('div', null, 'Lazy Flow Settings Component'),
+      }));
+
+      flowSettings.registerComponentLoaders({
+        DemoFlowSettingsLazyField: loader,
+      });
+
+      expect(loader).not.toHaveBeenCalled();
+
+      const SchemaField = createSchemaField();
+      const form = createForm();
+
+      render(
+        React.createElement(
+          FormProvider,
+          { form },
+          React.createElement(SchemaField, {
+            schema: {
+              type: 'object',
+              properties: {
+                demo: {
+                  type: 'void',
+                  'x-component': 'DemoFlowSettingsLazyField',
+                },
+              },
+            },
+            components: flowSettings.components,
+          }),
+        ),
+      );
+
+      expect(await screen.findByText('Lazy Flow Settings Component')).toBeInTheDocument();
+      expect(loader).toHaveBeenCalledTimes(1);
+    });
   });
 
   describe('Scope Registration', () => {
@@ -228,30 +269,68 @@ describe('FlowSettings', () => {
   });
 
   describe('Enable/Disable Functionality', () => {
-    test('should enable flow settings', () => {
+    test('should enable flow settings', async () => {
       expect(flowSettings.enabled).toBe(false);
 
-      flowSettings.enable();
+      await flowSettings.enable();
 
       expect(flowSettings.enabled).toBe(true);
     });
 
-    test('should disable flow settings', () => {
-      flowSettings.enable();
+    test('should preload model loaders before enabling flow settings', async () => {
+      const preloadSpy = vi.spyOn(engine, 'preloadModelLoaders').mockResolvedValue({
+        requested: [],
+        loaded: [],
+        failed: [],
+      });
+
+      await flowSettings.enable();
+
+      expect(preloadSpy).toHaveBeenCalledTimes(1);
       expect(flowSettings.enabled).toBe(true);
+    });
 
-      flowSettings.disable();
+    test('should preload model loaders before force enabling flow settings', async () => {
+      const preloadSpy = vi.spyOn(engine, 'preloadModelLoaders').mockResolvedValue({
+        requested: [],
+        loaded: [],
+        failed: [],
+      });
+
+      await flowSettings.forceEnable();
+
+      expect(preloadSpy).toHaveBeenCalledTimes(1);
+      expect(flowSettings.enabled).toBe(true);
+    });
+
+    test('should disable flow settings', async () => {
+      await flowSettings.enable();
+      expect(flowSettings.enabled).toBe(true);
+
+      await flowSettings.disable();
 
       expect(flowSettings.enabled).toBe(false);
     });
 
-    test('should handle multiple enable/disable calls', () => {
-      flowSettings.enable();
-      flowSettings.enable();
+    test('should handle multiple enable/disable calls', async () => {
+      await flowSettings.enable();
+      await flowSettings.enable();
       expect(flowSettings.enabled).toBe(true);
 
-      flowSettings.disable();
-      flowSettings.disable();
+      await flowSettings.disable();
+      await flowSettings.disable();
+      expect(flowSettings.enabled).toBe(false);
+    });
+
+    test('forceDisable should clear force-enabled state and disable flow settings', async () => {
+      await flowSettings.forceEnable();
+      expect(flowSettings.enabled).toBe(true);
+
+      await flowSettings.forceDisable();
+
+      expect(flowSettings.enabled).toBe(false);
+
+      await flowSettings.disable();
       expect(flowSettings.enabled).toBe(false);
     });
   });
@@ -512,7 +591,7 @@ describe('FlowSettings', () => {
   });
 
   describe('Complex Integration Scenarios', () => {
-    test('should maintain state consistency during multiple operations', () => {
+    test('should maintain state consistency during multiple operations', async () => {
       // Initialize with components and scopes
       const TestComponent = () => 'TestComponent';
       const testScope = () => 'testScope';
@@ -528,7 +607,7 @@ describe('FlowSettings', () => {
       });
 
       // Enable/disable
-      flowSettings.enable();
+      await flowSettings.enable();
       expect(flowSettings.enabled).toBe(true);
 
       // Verify all state is maintained
@@ -536,7 +615,7 @@ describe('FlowSettings', () => {
       expect(flowSettings.scopes.testScope).toBe(testScope);
       expect(flowSettings.getToolbarItems().find((item) => item.key === 'integration-test')).toBeDefined();
 
-      flowSettings.disable();
+      await flowSettings.disable();
       expect(flowSettings.enabled).toBe(false);
 
       // State should still be maintained after disable

package/src/__tests__/objectVariable.test.ts

@@ -26,6 +26,7 @@ function setupEngineWithCollections() {
     fields: [
       { name: 'id', type: 'integer', interface: 'number' },
       { name: 'name', type: 'string', interface: 'text' },
+      { name: 'rawUserPayload', type: 'json', filterable: true },
     ],
   });
   ds.addCollection({
@@ -41,6 +42,8 @@ function setupEngineWithCollections() {
     filterTargetKey: 'id',
     fields: [
       { name: 'title', type: 'string', interface: 'text' },
+      { name: 'internalName', type: 'string', interface: 'text' },
+      { name: 'rawPostPayload', type: 'json', filterable: true },
       { name: 'author', type: 'belongsTo', target: 'users', interface: 'm2o' },
       { name: 'tags', type: 'belongsToMany', target: 'tags', interface: 'm2m' },
     ],
@@ -91,6 +94,27 @@ describe('objectVariable utilities', () => {
     });
   });
 
+  it('createAssociationAwareObjectMetaFactory should hide fields without interface from object variable meta', async () => {
+    const { collection } = setupEngineWithCollections();
+    const obj = { title: 'hello', internalName: 'internal', rawPostPayload: { secret: true }, author: 1 };
+    const metaFactory = createAssociationAwareObjectMetaFactory(
+      () => collection,
+      'Current object',
+      () => obj,
+    );
+
+    const meta = await metaFactory();
+    const props = await (meta?.properties as any)?.();
+    const authorFields = await props?.author?.properties?.();
+
+    expect(props).toHaveProperty('title');
+    expect(props).toHaveProperty('internalName');
+    expect(props).toHaveProperty('author');
+    expect(props).not.toHaveProperty('rawPostPayload');
+    expect(authorFields).toHaveProperty('name');
+    expect(authorFields).not.toHaveProperty('rawUserPayload');
+  });
+
   it('integrates with FlowContext.resolveJsonTemplate to call variables:resolve with flattened contextParams', async () => {
     const { engine, collection } = setupEngineWithCollections();
     const obj = { author: 1 };

package/src/__tests__/provider.test.tsx

@@ -9,9 +9,10 @@
 
 import React from 'react';
 import { describe, expect, it } from 'vitest';
-import { renderHook } from '@testing-library/react';
+import { render, renderHook } from '@testing-library/react';
+import { App, ConfigProvider, theme } from 'antd';
 import { FlowEngine } from '../flowEngine';
-import { FlowEngineProvider, useFlowEngine } from '../provider';
+import { FlowEngineGlobalsContextProvider, FlowEngineProvider, useFlowEngine } from '../provider';
 
 describe('FlowEngineProvider/useFlowEngine', () => {
   it('returns engine within provider', () => {
@@ -20,4 +21,25 @@ describe('FlowEngineProvider/useFlowEngine', () => {
     const { result } = renderHook(() => useFlowEngine(), { wrapper });
     expect(result.current).toBe(engine);
   });
+
+  it('registers isDarkTheme within globals provider before first child render', () => {
+    const engine = new FlowEngine();
+    const reads: boolean[] = [];
+    const Reader = () => {
+      reads.push(engine.context.isDarkTheme);
+      return null;
+    };
+    const wrapper = ({ children }: any) => (
+      <ConfigProvider theme={{ algorithm: theme.darkAlgorithm }}>
+        <App>
+          <FlowEngineProvider engine={engine}>
+            <FlowEngineGlobalsContextProvider>{children}</FlowEngineGlobalsContextProvider>
+          </FlowEngineProvider>
+        </App>
+      </ConfigProvider>
+    );
+    render(<Reader />, { wrapper });
+    expect(reads[0]).toBe(true);
+    expect(engine.context.isDarkTheme).toBe(true);
+  });
 });

package/src/__tests__/renderHiddenInConfig.test.tsx

@@ -14,7 +14,7 @@ import { FlowEngine } from '../flowEngine';
 import { FlowModel, ModelRenderMode } from '../models/flowModel';
 
 describe('FlowModel.renderHiddenInConfig', () => {
-  it('renders via renderHiddenInConfig when hidden and config enabled (React element mode, mounted)', () => {
+  it('renders via renderHiddenInConfig when hidden and config enabled (React element mode, mounted)', async () => {
     class ElemModel extends FlowModel {
       render() {
         return <div data-testid="content">Content</div>;
@@ -28,14 +28,14 @@ describe('FlowModel.renderHiddenInConfig', () => {
     const model = new ElemModel({ uid: 'elem-1', flowEngine: engine });
 
     // runtime hidden => mounted result should be empty (no content/hidden)
-    engine.flowSettings.disable();
+    await engine.flowSettings.disable();
     model.setHidden(true);
     const { container, unmount, rerender } = render(model.render() as React.ReactElement);
     expect(screen.queryByTestId('content')).toBeNull();
     expect(screen.queryByTestId('hidden')).toBeNull();
 
     // config enabled + hidden => should show renderHiddenInConfig result
-    engine.flowSettings.enable();
+    await engine.flowSettings.enable();
     rerender(model.render() as React.ReactElement);
     expect(screen.getByTestId('hidden').textContent).toBe('HiddenViaAPI');
 
@@ -46,7 +46,7 @@ describe('FlowModel.renderHiddenInConfig', () => {
     unmount();
     cleanup();
   });
-  it('returns a render function when hidden and config enabled (RenderFunction mode)', () => {
+  it('returns a render function when hidden and config enabled (RenderFunction mode)', async () => {
     class FuncModel extends FlowModel {
       static override renderMode = ModelRenderMode.RenderFunction;
       render() {
@@ -63,13 +63,13 @@ describe('FlowModel.renderHiddenInConfig', () => {
     const model = engine.createModel({ use: 'FuncModel' }) as FuncModel;
 
     // runtime hidden => null
-    engine.flowSettings.disable();
+    await engine.flowSettings.disable();
     model.setHidden(true);
     const runtimeHidden = model.render();
     expect(runtimeHidden).toBeNull();
 
     // config enabled + hidden => renderHiddenInConfig (function)
-    engine.flowSettings.enable();
+    await engine.flowSettings.enable();
     const cfgHidden = model.render();
     expect(typeof cfgHidden).toBe('function');
     const cellNode = (cfgHidden as any)();

package/src/__tests__/runjsContext.test.ts

@@ -29,11 +29,16 @@ describe('flowRunJSContext registry and doc', () => {
       expect(RunJSContextRegistry['resolve']('v1' as any, '*')).toBeTruthy();
     });
 
+    it('should register v2 mapping', () => {
+      expect(RunJSContextRegistry['resolve']('v2' as any, '*')).toBeTruthy();
+    });
+
     it('should register all context types', () => {
       const contextTypes = [
         'JSBlockModel',
         'JSFieldModel',
         'JSItemModel',
+        'JSItemActionModel',
         'JSColumnModel',
         'FormJSFieldItemModel',
         'JSRecordActionModel',
@@ -44,12 +49,22 @@ describe('flowRunJSContext registry and doc', () => {
         const ctor = RunJSContextRegistry['resolve']('v1' as any, modelClass);
         expect(ctor).toBeTruthy();
       });
+
+      contextTypes.forEach((modelClass) => {
+        const ctor = RunJSContextRegistry['resolve']('v2' as any, modelClass);
+        expect(ctor).toBeTruthy();
+      });
     });
 
     it('should expose scene metadata for contexts', () => {
       expect(getRunJSScenesForModel('JSBlockModel', 'v1')).toEqual(['block']);
       expect(getRunJSScenesForModel('JSFieldModel', 'v1')).toEqual(['detail']);
+      expect(getRunJSScenesForModel('JSItemActionModel', 'v1')).toEqual(['table']);
+      expect(getRunJSScenesForModel('JSBlockModel', 'v2')).toEqual(['block']);
+      expect(getRunJSScenesForModel('JSFieldModel', 'v2')).toEqual(['detail']);
+      expect(getRunJSScenesForModel('JSItemActionModel', 'v2')).toEqual(['table']);
       expect(getRunJSScenesForModel('UnknownModel', 'v1')).toEqual([]);
+      expect(getRunJSScenesForModel('UnknownModel', 'v2')).toEqual([]);
     });
 
     it('should only execute once (idempotent)', async () => {
@@ -175,6 +190,7 @@ describe('flowRunJSContext registry and doc', () => {
       const ctx = new FlowContext();
       ctx.defineProperty('model', { value: { constructor: { name: 'JSColumnModel' } } });
       expect(getRunJSScenesForContext(ctx as any, { version: 'v1' })).toEqual(['table']);
+      expect(getRunJSScenesForContext(ctx as any, { version: 'v2' })).toEqual(['table']);
     });
 
     it('JSBlockModel context should have element property in doc', () => {

package/src/__tests__/runjsContextRuntime.test.ts

@@ -186,6 +186,7 @@ describe('RunJS Context Runtime Behavior', () => {
         'JSBlockModel',
         'JSFieldModel',
         'JSItemModel',
+        'JSItemActionModel',
         'JSColumnModel',
         'FormJSFieldItemModel',
         'JSRecordActionModel',
@@ -237,6 +238,7 @@ describe('RunJS Context Runtime Behavior', () => {
         'JSBlockModel',
         'JSFieldModel',
         'JSItemModel',
+        'JSItemActionModel',
         'JSColumnModel',
         'FormJSFieldItemModel',
         'JSRecordActionModel',

package/src/__tests__/runjsPreprocessDefault.test.ts

@@ -36,6 +36,29 @@ describe('ctx.runjs preprocessTemplates default', () => {
     expect(r.value).toBe('{{ctx.user.id}}');
   });
 
+  it('disables template preprocess by default for version v2', async () => {
+    const engine = new FlowEngine();
+    const ctx = engine.context as any;
+    ctx.defineProperty('user', { value: { id: 123 } });
+
+    const r = await ctx.runjs('return "{{ctx.user.id}}";', undefined, { version: 'v2' });
+    expect(r.success).toBe(true);
+    expect(r.value).toBe('{{ctx.user.id}}');
+  });
+
+  it('keeps explicit preprocessTemplates override higher priority than version', async () => {
+    const engine = new FlowEngine();
+    const ctx = engine.context as any;
+    ctx.defineProperty('user', { value: { id: 123 } });
+
+    const r = await ctx.runjs('return "{{ctx.user.id}}";', undefined, {
+      version: 'v2',
+      preprocessTemplates: true,
+    });
+    expect(r.success).toBe(true);
+    expect(r.value).toBe('123');
+  });
+
   it('does not double-preprocess already prepared code', async () => {
     const engine = new FlowEngine();
     const ctx = engine.context as any;

package/src/__tests__/runjsSnippets.test.ts

@@ -112,6 +112,27 @@ describe('RunJS Snippets', () => {
       expect(multiScene?.scenes).toEqual(expect.arrayContaining(['detail', 'table']));
       expect(multiScene?.groups).toEqual(expect.arrayContaining(['scene/detail', 'scene/table']));
     });
+
+    it('should expose new style snippets for matching contexts', async () => {
+      const tableSnippets = await listSnippetsForContext('JSColumnRunJSContext', 'v1', 'zh-CN');
+      const fieldSnippets = await listSnippetsForContext('FormJSFieldItemRunJSContext', 'v1', 'zh-CN');
+      const detailEventSnippets = await listSnippetsForContext('DetailsItemModel', 'v1', 'zh-CN');
+      const tableEventSnippets = await listSnippetsForContext('TableColumnModel', 'v1', 'zh-CN');
+
+      const tableStyle = tableSnippets.find((s) => s.ref === 'scene/table/set-cell-style');
+      expect(tableStyle?.name).toBe('表格字段样式设置');
+      expect(tableStyle?.body).toContain('ctx.model.props.onCell');
+      expect(tableStyle?.scenes).toEqual(['tableFieldEvent']);
+
+      const fieldStyle = fieldSnippets.find((s) => s.ref === 'scene/detail/set-field-style');
+      expect(fieldStyle?.name).toBe('设置表单项/详情项样式');
+      expect(fieldStyle?.body).toContain('ctx.model.props.style');
+      expect(fieldStyle?.scenes).toEqual(expect.arrayContaining(['detailFieldEvent', 'formFieldEvent']));
+      expect(fieldStyle?.groups).toEqual(expect.arrayContaining(['scene/detail', 'scene/form']));
+
+      expect(detailEventSnippets.some((s) => s.ref === 'scene/detail/set-field-style')).toBe(true);
+      expect(tableEventSnippets.some((s) => s.ref === 'scene/table/set-cell-style')).toBe(true);
+    });
   });
 
   describe('New snippets', () => {