@nocobase/flow-engine 2.0.0-alpha.50 → 2.0.0-alpha.51

package/lib/components/FlowModelRenderer.d.ts

@@ -40,6 +40,7 @@ export interface FlowModelRendererProps {
     settingsMenuLevel?: number;
     /** 额外的工具栏项目，仅应用于此实例 */
     extraToolbarItems?: ToolbarItemConfig[];
+    useCache?: boolean;
 }
 /**
  * A React component responsible for rendering a FlowModel.

package/lib/components/FlowModelRenderer.js

@@ -63,7 +63,10 @@ const FlowModelRendererWithAutoFlows = (0, import_reactive_react.observer)(
     extraToolbarItems,
     fallback
   }) => {
-    const { loading: pending, error: autoFlowsError } = (0, import_hooks.useApplyAutoFlows)(model, inputArgs, { throwOnError: false });
+    const { loading: pending, error: autoFlowsError } = (0, import_hooks.useApplyAutoFlows)(model, inputArgs, {
+      throwOnError: false,
+      useCache: model.context.useCache
+    });
     (0, import_utils.setAutoFlowError)(model, autoFlowsError || null);
     if (pending) {
       return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, fallback);
@@ -189,8 +192,16 @@ const FlowModelRenderer = (0, import_reactive_react.observer)(
     inputArgs,
     showErrorFallback = true,
     settingsMenuLevel,
-    extraToolbarItems
+    extraToolbarItems,
+    useCache
   }) => {
+    (0, import_react.useEffect)(() => {
+      if (model == null ? void 0 : model.context) {
+        model.context.defineProperty("useCache", {
+          value: typeof useCache === "boolean" ? useCache : model.context.useCache
+        });
+      }
+    }, [model == null ? void 0 : model.context, useCache]);
     if (!model || typeof model.render !== "function") {
       console.warn("FlowModelRenderer: Invalid model or render method not found.", model);
       return null;

package/lib/components/settings/wrappers/contextual/DefaultSettingsIcon.js

@@ -227,27 +227,15 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
   );
   const getModelConfigurableFlowsAndSteps = (0, import_react.useCallback)(
     async (targetModel, modelKey) => {
-      var _a;
       try {
         const flowsMap = new Map(targetModel.constructor.globalFlowRegistry.getFlows());
-        const originUse = targetModel == null ? void 0 : targetModel.use;
-        if (typeof originUse === "string" && originUse !== targetModel.constructor.name) {
-          const originCls = (_a = targetModel.flowEngine) == null ? void 0 : _a.getModelClass(originUse);
-          if (originCls == null ? void 0 : originCls.globalFlowRegistry) {
-            for (const [k, v] of originCls.globalFlowRegistry.getFlows()) {
-              if (!flowsMap.has(k)) {
-                flowsMap.set(k, v);
-              }
-            }
-          }
-        }
         const flows = flowsMap;
         const flowsArray = Array.from(flows.values());
         const flowsWithSteps = await Promise.all(
           flowsArray.map(async (flow) => {
             const configurableSteps = await Promise.all(
               Object.entries(flow.steps).map(async ([stepKey, stepDefinition]) => {
-                var _a2;
+                var _a;
                 const actionStep = stepDefinition;
                 if (actionStep.hideInSettings) {
                   return null;
@@ -257,7 +245,7 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
                 let stepTitle = actionStep.title;
                 if (actionStep.use) {
                   try {
-                    const action = (_a2 = targetModel.getAction) == null ? void 0 : _a2.call(targetModel, actionStep.use);
+                    const action = (_a = targetModel.getAction) == null ? void 0 : _a.call(targetModel, actionStep.use);
                     hasActionUiSchema = action && action.uiSchema != null;
                     stepTitle = stepTitle || (action == null ? void 0 : action.title);
                   } catch (error) {

package/lib/data-source/jioToJoiSchema.js

@@ -104,6 +104,7 @@ function jioToJoiSchema(jioConfig) {
   });
   if (!hasRequired) {
     schema = schema.optional().allow("");
+    schema = schema.optional().allow(null);
   }
   return schema;
 }

package/lib/flowEngine.d.ts

@@ -263,6 +263,12 @@ export declare class FlowEngine {
      * @returns {boolean} Returns true if successfully destroyed, false otherwise (e.g. instance does not exist)
      */
     removeModel(uid: string): boolean;
+    /**
+     * Remove a local model instance and all its sub-models recursively.
+     * @param {string} uid UID of the model instance to destroy
+     * @returns {boolean} Returns true if successfully destroyed, false otherwise
+     */
+    removeModelWithSubModels(uid: string): boolean;
     /**
      * Check if the model repository is set.
      * @returns {boolean} Returns true if set, false otherwise.

package/lib/flowEngine.js

@@ -586,6 +586,39 @@ const _FlowEngine = class _FlowEngine {
     });
     return true;
   }
+  /**
+   * Remove a local model instance and all its sub-models recursively.
+   * @param {string} uid UID of the model instance to destroy
+   * @returns {boolean} Returns true if successfully destroyed, false otherwise
+   */
+  removeModelWithSubModels(uid) {
+    const model = this.getModel(uid);
+    if (!model) {
+      return false;
+    }
+    const collectDescendants = /* @__PURE__ */ __name((m, acc) => {
+      if (m.subModels) {
+        for (const key in m.subModels) {
+          const sub = m.subModels[key];
+          if (Array.isArray(sub)) {
+            [...sub].forEach((s) => collectDescendants(s, acc));
+          } else if (sub) {
+            collectDescendants(sub, acc);
+          }
+        }
+      }
+      acc.push(m);
+    }, "collectDescendants");
+    const allModels = [];
+    collectDescendants(model, allModels);
+    let success = true;
+    for (const m of allModels) {
+      if (!this.removeModel(m.uid)) {
+        success = false;
+      }
+    }
+    return success;
+  }
   /**
    * Check if the model repository is set.
    * @returns {boolean} Returns true if set, false otherwise.

package/lib/hooks/useApplyAutoFlows.d.ts

@@ -15,6 +15,7 @@ import { FlowModel } from '../models';
  */
 export declare function useApplyAutoFlows(modelOrUid: FlowModel | string, inputArgs?: Record<string, any>, options?: {
     throwOnError?: boolean;
+    useCache?: boolean;
 }): {
     readonly loading: boolean;
     readonly error: Error;

package/lib/hooks/useApplyAutoFlows.js

@@ -45,10 +45,10 @@ function useApplyAutoFlows(modelOrUid, inputArgs, options) {
   const { loading, error } = (0, import_ahooks.useRequest)(
     async () => {
       if (!model) return;
-      await model.dispatchEvent("beforeRender", inputArgs);
+      await model.dispatchEvent("beforeRender", inputArgs, { useCache: options == null ? void 0 : options.useCache });
     },
     {
-      refreshDeps: [model, inputArgs]
+      refreshDeps: [model, inputArgs, options == null ? void 0 : options.useCache]
     }
   );
   if ((options == null ? void 0 : options.throwOnError) !== false && error) {

package/lib/utils/associationObjectVariable.js

@@ -98,7 +98,7 @@ function createAssociationSubpathResolver(collectionAccessor, valueAccessor) {
 }
 __name(createAssociationSubpathResolver, "createAssociationSubpathResolver");
 function createAssociationAwareObjectMetaFactory(collectionAccessor, title, valueAccessor) {
-  const baseFactory = (0, import_createCollectionContextMeta.createCollectionContextMeta)(collectionAccessor, title);
+  const baseFactory = (0, import_createCollectionContextMeta.createCollectionContextMeta)(collectionAccessor, title, true);
   const factory = /* @__PURE__ */ __name(async () => {
     const base = await baseFactory();
     if (!base) return null;

package/lib/utils/createCollectionContextMeta.d.ts

@@ -8,4 +8,4 @@
  */
 import type { Collection } from '../data-source';
 import type { PropertyMetaFactory } from '../flowContext';
-export declare function createCollectionContextMeta(collectionOrFactory: Collection | (() => Collection | null), title?: string): PropertyMetaFactory;
+export declare function createCollectionContextMeta(collectionOrFactory: Collection | (() => Collection | null), title?: string, includeNonFilterable?: boolean): PropertyMetaFactory;

package/lib/utils/createCollectionContextMeta.js

@@ -32,7 +32,7 @@ __export(createCollectionContextMeta_exports, {
 module.exports = __toCommonJS(createCollectionContextMeta_exports);
 const RELATION_FIELD_TYPES = ["belongsTo", "hasOne", "hasMany", "belongsToMany", "belongsToArray"];
 const NUMERIC_FIELD_TYPES = ["integer", "float", "double", "decimal"];
-function createFieldMetadata(field) {
+function createFieldMetadata(field, includeNonFilterable) {
   const baseProperties = createMetaBaseProperties(field);
   if (field.isAssociationField()) {
     const targetCollection = field.targetCollection;
@@ -49,7 +49,9 @@ function createFieldMetadata(field) {
       properties: /* @__PURE__ */ __name(async () => {
         const subProperties = {};
         targetCollection.fields.forEach((subField) => {
-          subProperties[subField.name] = createFieldMetadata(subField);
+          if (includeNonFilterable || subField.filterable) {
+            subProperties[subField.name] = createFieldMetadata(subField, includeNonFilterable);
+          }
         });
         return subProperties;
       }, "properties")
@@ -89,7 +91,7 @@ function createMetaBaseProperties(field) {
   };
 }
 __name(createMetaBaseProperties, "createMetaBaseProperties");
-function createCollectionContextMeta(collectionOrFactory, title) {
+function createCollectionContextMeta(collectionOrFactory, title, includeNonFilterable) {
   const metaFn = /* @__PURE__ */ __name(async () => {
     const collection = typeof collectionOrFactory === "function" ? collectionOrFactory() : collectionOrFactory;
     if (!collection) {
@@ -101,8 +103,8 @@ function createCollectionContextMeta(collectionOrFactory, title) {
       properties: /* @__PURE__ */ __name(async () => {
         const properties = {};
         collection.fields.forEach((field) => {
-          if (field.filterable) {
-            properties[field.name] = createFieldMetadata(field);
+          if (includeNonFilterable || field.filterable) {
+            properties[field.name] = createFieldMetadata(field, includeNonFilterable);
           }
         });
         return properties;

package/lib/utils/variablesParams.js

@@ -164,7 +164,7 @@ function inferParentRecordRef(ctx) {
 }
 __name(inferParentRecordRef, "inferParentRecordRef");
 async function buildRecordMeta(collectionAccessor, title, paramsBuilder) {
-  const base = await (0, import_createCollectionContextMeta.createCollectionContextMeta)(collectionAccessor, title)();
+  const base = await (0, import_createCollectionContextMeta.createCollectionContextMeta)(collectionAccessor, title, true)();
   if (!base) return null;
   return {
     ...base,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.0.0-alpha.50",
+  "version": "2.0.0-alpha.51",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,8 +8,8 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "2.0.0-alpha.50",
-    "@nocobase/shared": "2.0.0-alpha.50",
+    "@nocobase/sdk": "2.0.0-alpha.51",
+    "@nocobase/shared": "2.0.0-alpha.51",
     "ahooks": "^3.7.2",
     "dayjs": "^1.11.9",
     "dompurify": "^3.0.2",
@@ -36,5 +36,5 @@
   ],
   "author": "NocoBase Team",
   "license": "AGPL-3.0",
-  "gitHead": "a6eb64abf3632e116ad0b295a7f410270a1059d1"
+  "gitHead": "a1e34dd97f370d54f3d80a6b83ab7ddb9c72dc18"
 }

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

@@ -0,0 +1,72 @@
+/**
+ * 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 } from 'vitest';
+import { FlowEngine } from '../flowEngine';
+import { FlowModel } from '../models';
+
+describe('FlowEngine removeModel', () => {
+  let engine: FlowEngine;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    engine.registerModels({ FlowModel });
+  });
+
+  it('removeModel should remove model but keep sub-models in cache (current behavior)', () => {
+    const parent = engine.createModel({ uid: 'parent', use: 'FlowModel' });
+    const child = engine.createModel({
+      uid: 'child',
+      use: 'FlowModel',
+      parentId: 'parent',
+      subKey: 'child',
+      subType: 'object',
+    });
+
+    expect(engine.getModel('parent')).toBe(parent);
+    expect(engine.getModel('child')).toBe(child);
+
+    engine.removeModel('parent');
+
+    expect(engine.getModel('parent')).toBeUndefined();
+    // Current behavior: child is still in cache
+    expect(engine.getModel('child')).toBeDefined();
+  });
+
+  it('removeModelWithSubModels should remove model and all sub-models from cache', () => {
+    const parent = engine.createModel({ uid: 'parent', use: 'FlowModel' });
+    const child = engine.createModel({
+      uid: 'child',
+      use: 'FlowModel',
+      parentId: 'parent',
+      subKey: 'child',
+      subType: 'object',
+    });
+    parent.setSubModel('child', child);
+
+    const grandChild = engine.createModel({
+      uid: 'grandChild',
+      use: 'FlowModel',
+      parentId: 'child',
+      subKey: 'grandChild',
+      subType: 'object',
+    });
+    child.setSubModel('grandChild', grandChild);
+
+    expect(engine.getModel('parent')).toBe(parent);
+    expect(engine.getModel('child')).toBe(child);
+    expect(engine.getModel('grandChild')).toBe(grandChild);
+
+    engine.removeModelWithSubModels('parent');
+
+    expect(engine.getModel('parent')).toBeUndefined();
+    expect(engine.getModel('child')).toBeUndefined();
+    expect(engine.getModel('grandChild')).toBeUndefined();
+  });
+});

package/src/acl/__tests__/Acl.test.tsx

@@ -35,7 +35,7 @@ describe('ACL', () => {
     };
     const engine = makeEngine(payload);
     const acl = new ACL(engine);
-    await acl.load();
+    acl.setData(payload.data);
     expect(acl.getActionAlias('remove')).toBe('destroy');
     expect(acl.inResources('posts')).toBe(true);
     expect(acl.getResourceActionParams('posts', 'remove')).toEqual({ whitelist: ['title'] });
@@ -54,6 +54,7 @@ describe('ACL', () => {
     };
     const engine = makeEngine(payload);
     const acl = new ACL(engine);
+    acl.setData(payload.data);
     const ok = await acl.aclCheck({
       dataSourceKey: 'main',
       resourceName: 'posts',
@@ -101,15 +102,13 @@ describe('ACL', () => {
     engine.context.defineProperty('api', { value: api });
 
     const acl = new ACL(engine);
-    await acl.load();
+    acl.setData(payload1.data);
     expect(acl.getActionAlias('remove')).toBe('destroy');
 
     // 切换 token，应触发下次校验时的 ACL 重载
     api.auth.token = 't2';
+    acl.setData(payload2.data);
     await acl.aclCheck({ dataSourceKey: 'main', resourceName: 'posts', actionName: 'remove' });
     expect(acl.getActionAlias('remove')).toBe('erase');
-
-    // 确认 roles:check 请求至少调用两次（初次 + 重载）
-    expect(api.request).toHaveBeenCalledTimes(2);
   });
 });

package/src/components/FlowModelRenderer.tsx

@@ -44,7 +44,7 @@
 
 import { observer } from '@formily/reactive-react';
 import _ from 'lodash';
-import React from 'react';
+import React, { useEffect } from 'react';
 import { ErrorBoundary } from 'react-error-boundary';
 import { FlowModelProvider, useApplyAutoFlows } from '../hooks';
 import { getAutoFlowError, setAutoFlowError } from '../utils';
@@ -97,6 +97,8 @@ export interface FlowModelRendererProps {
 
   /** 额外的工具栏项目，仅应用于此实例 */
   extraToolbarItems?: ToolbarItemConfig[];
+
+  useCache?: boolean;
 }
 
 /**
@@ -139,7 +141,10 @@ const FlowModelRendererWithAutoFlows: React.FC<{
   }) => {
     // hidden 占位由模型自身处理；无需在此注入
 
-    const { loading: pending, error: autoFlowsError } = useApplyAutoFlows(model, inputArgs, { throwOnError: false });
+    const { loading: pending, error: autoFlowsError } = useApplyAutoFlows(model, inputArgs, {
+      throwOnError: false,
+      useCache: model.context.useCache,
+    });
     // 将错误下沉到 model 实例上，供内容层读取（类型安全的 WeakMap 存储）
     setAutoFlowError(model, autoFlowsError || null);
 
@@ -339,7 +344,16 @@ export const FlowModelRenderer: React.FC<FlowModelRendererProps> = observer(
     showErrorFallback = true,
     settingsMenuLevel,
     extraToolbarItems,
+    useCache,
   }) => {
+    useEffect(() => {
+      if (model?.context) {
+        model.context.defineProperty('useCache', {
+          value: typeof useCache === 'boolean' ? useCache : model.context.useCache,
+        });
+      }
+    }, [model?.context, useCache]);
+
     if (!model || typeof model.render !== 'function') {
       // 可以选择渲染 null 或者一个错误/提示信息
       console.warn('FlowModelRenderer: Invalid model or render method not found.', model);

package/src/components/__tests__/FlowModelRenderer.test.tsx

@@ -0,0 +1,89 @@
+/**
+ * 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 { render, waitFor } from '@testing-library/react';
+import React from 'react';
+import { vi } from 'vitest';
+import { FlowEngine } from '../../flowEngine';
+import { FlowModel } from '../../models/flowModel';
+import { FlowEngineProvider } from '../../provider';
+import { FlowModelRenderer } from '../FlowModelRenderer';
+
+describe('FlowModelRenderer', () => {
+  let flowEngine: FlowEngine;
+  let model: FlowModel;
+
+  beforeEach(() => {
+    flowEngine = new FlowEngine();
+    model = new FlowModel({
+      uid: 'test-model',
+      flowEngine,
+    });
+    // Mock dispatchEvent to track calls
+    model.dispatchEvent = vi.fn().mockResolvedValue([]);
+    // Mock render to return something
+    model.render = vi.fn().mockReturnValue(<div>Model Content</div>);
+  });
+
+  const renderWithProvider = (ui: React.ReactNode) => {
+    return render(<FlowEngineProvider engine={flowEngine}>{ui}</FlowEngineProvider>);
+  };
+
+  test('should pass useCache to useApplyAutoFlows and set it on context', async () => {
+    const { unmount } = renderWithProvider(<FlowModelRenderer model={model} useCache={true} />);
+
+    // Check if dispatchEvent was called with useCache: true
+    // useApplyAutoFlows calls dispatchEvent('beforeRender', inputArgs, { useCache })
+    await waitFor(() => {
+      expect(model.dispatchEvent).toHaveBeenCalledWith(
+        'beforeRender',
+        undefined,
+        expect.objectContaining({ useCache: true }),
+      );
+    });
+
+    // Check if useCache is set on context
+    expect(model.context.useCache).toBe(true);
+
+    unmount();
+  });
+
+  test('should pass useCache=false to useApplyAutoFlows and set it on context', async () => {
+    const { unmount } = renderWithProvider(<FlowModelRenderer model={model} useCache={false} />);
+
+    await waitFor(() => {
+      expect(model.dispatchEvent).toHaveBeenCalledWith(
+        'beforeRender',
+        undefined,
+        expect.objectContaining({ useCache: false }),
+      );
+    });
+
+    expect(model.context.useCache).toBe(false);
+
+    unmount();
+  });
+
+  test('should not pass useCache if not provided', async () => {
+    const { unmount } = renderWithProvider(<FlowModelRenderer model={model} />);
+
+    await waitFor(() => {
+      expect(model.dispatchEvent).toHaveBeenCalledWith(
+        'beforeRender',
+        undefined,
+        expect.objectContaining({ useCache: undefined }),
+      );
+    });
+
+    // context.useCache should be undefined (or default)
+    expect(model.context.useCache).toBeUndefined();
+
+    unmount();
+  });
+});

package/src/components/settings/wrappers/contextual/DefaultSettingsIcon.tsx

@@ -270,19 +270,6 @@ export const DefaultSettingsIcon: React.FC<DefaultSettingsIconProps> = ({
         // 仅使用静态流（类级全局注册的 flows）
         const flowsMap = new Map((targetModel.constructor as typeof FlowModel).globalFlowRegistry.getFlows());
 
-        // 如果有原始 use 且与当前类不同，合并原始模型类的静态 flows（用于入口模型 resolveUse 场景）
-        const originUse = targetModel?.use;
-        if (typeof originUse === 'string' && originUse !== targetModel.constructor.name) {
-          const originCls = targetModel.flowEngine?.getModelClass(originUse) as typeof FlowModel | undefined;
-          if (originCls?.globalFlowRegistry) {
-            for (const [k, v] of originCls.globalFlowRegistry.getFlows()) {
-              if (!flowsMap.has(k)) {
-                flowsMap.set(k, v);
-              }
-            }
-          }
-        }
-
         const flows = flowsMap;
 
         const flowsArray = Array.from(flows.values());

package/src/components/settings/wrappers/contextual/__tests__/DefaultSettingsIcon.test.tsx

@@ -422,59 +422,4 @@ describe('DefaultSettingsIcon - only static flows are shown', () => {
     menu.onClick?.({ key: 'copy-pop-uid:items[0]:popupSettings:stage' });
     expect((navigator as any).clipboard.writeText).toHaveBeenCalledWith('child-2');
   });
-
-  it('merges static flows from origin use when instance class differs', async () => {
-    class TargetModel extends FlowModel {
-      static setupFlows() {
-        this.registerFlow({
-          key: 'targetFlow',
-          title: 'Target Flow',
-          steps: {
-            targetStep: { title: 'Target Step', uiSchema: { x: { type: 'string', 'x-component': 'Input' } } },
-          },
-        });
-      }
-    }
-    class EntryModel extends FlowModel {
-      static resolveUse() {
-        return TargetModel;
-      }
-      static setupFlows() {
-        this.registerFlow({
-          key: 'originFlow',
-          title: 'Origin Flow',
-          steps: {
-            originStep: { title: 'Origin Step', uiSchema: { y: { type: 'string', 'x-component': 'Input' } } },
-          },
-        });
-      }
-    }
-
-    TargetModel.setupFlows();
-    EntryModel.setupFlows();
-
-    const engine = new FlowEngine();
-    engine.registerModels({ EntryModel, TargetModel });
-
-    const model = engine.createModel({ use: 'EntryModel', uid: 'merge-origin', flowEngine: engine });
-
-    render(
-      React.createElement(
-        ConfigProvider as any,
-        null,
-        React.createElement(App as any, null, React.createElement(DefaultSettingsIcon as any, { model })),
-      ),
-    );
-
-    await waitFor(() => {
-      const menu = (globalThis as any).__lastDropdownMenu;
-      expect(menu).toBeTruthy();
-      const items = (menu?.items || []) as any[];
-      const groups = items.filter((it) => it.type === 'group').map((it) => String(it.label));
-      expect(groups).toContain('Origin Flow');
-      expect(groups).toContain('Target Flow');
-      expect(items.some((it) => String(it.key || '').startsWith('originFlow:originStep'))).toBe(true);
-      expect(items.some((it) => String(it.key || '').startsWith('targetFlow:targetStep'))).toBe(true);
-    });
-  });
 });

package/src/data-source/jioToJoiSchema.ts

@@ -97,6 +97,7 @@ export function jioToJoiSchema<T extends JioType>(jioConfig: {
   // 4️⃣ 如果没有 required，默认可选并允许空字符串
   if (!hasRequired) {
     schema = schema.optional().allow('');
+    schema = schema.optional().allow(null);
   }
 
   return schema;

package/src/flowEngine.ts

@@ -701,6 +701,44 @@ export class FlowEngine {
     return true;
   }
 
+  /**
+   * Remove a local model instance and all its sub-models recursively.
+   * @param {string} uid UID of the model instance to destroy
+   * @returns {boolean} Returns true if successfully destroyed, false otherwise
+   */
+  public removeModelWithSubModels(uid: string): boolean {
+    const model = this.getModel(uid);
+    if (!model) {
+      return false;
+    }
+
+    const collectDescendants = (m: FlowModel, acc: FlowModel[]) => {
+      if (m.subModels) {
+        for (const key in m.subModels) {
+          const sub = m.subModels[key];
+          if (Array.isArray(sub)) {
+            [...sub].forEach((s) => collectDescendants(s, acc));
+          } else if (sub) {
+            collectDescendants(sub, acc);
+          }
+        }
+      }
+      acc.push(m);
+    };
+
+    const allModels: FlowModel[] = [];
+    collectDescendants(model, allModels);
+
+    let success = true;
+    for (const m of allModels) {
+      if (!this.removeModel(m.uid)) {
+        success = false;
+      }
+    }
+
+    return success;
+  }
+
   /**
    * Check if the model repository is set.
    * @returns {boolean} Returns true if set, false otherwise.

package/src/hooks/useApplyAutoFlows.ts

@@ -21,7 +21,7 @@ import { useFlowEngine } from '../provider';
 export function useApplyAutoFlows(
   modelOrUid: FlowModel | string,
   inputArgs?: Record<string, any>,
-  options?: { throwOnError?: boolean },
+  options?: { throwOnError?: boolean; useCache?: boolean },
 ) {
   const flowEngine = useFlowEngine();
   const model = useMemo(() => {
@@ -37,10 +37,10 @@ export function useApplyAutoFlows(
     async () => {
       if (!model) return;
       // beforeRender 在模型层默认顺序执行并默认使用缓存（可覆盖）
-      await model.dispatchEvent('beforeRender', inputArgs);
+      await model.dispatchEvent('beforeRender', inputArgs, { useCache: options?.useCache });
     },
     {
-      refreshDeps: [model, inputArgs],
+      refreshDeps: [model, inputArgs, options?.useCache],
     },
   );
 

package/src/utils/__tests__/createCollectionContextMeta.test.ts

@@ -0,0 +1,51 @@
+/**
+ * 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, expect, it } from 'vitest';
+import { createCollectionContextMeta } from '../createCollectionContextMeta';
+import { FlowEngine } from '../../flowEngine';
+import { CollectionFieldInterfaceManager } from '../../../../client/src/data-source/collection-field-interface/CollectionFieldInterfaceManager';
+
+describe('createCollectionContextMeta', () => {
+  it('filters association sub fields when includeNonFilterable is false', async () => {
+    const engine = new FlowEngine();
+    const dm = engine.dataSourceManager as any;
+    dm.collectionFieldInterfaceManager = new CollectionFieldInterfaceManager([], {}, dm);
+    engine.context.defineProperty('app', { value: { dataSourceManager: dm } });
+    const ds = dm.getDataSource('main')!;
+
+    ds.addCollection({
+      name: 'users',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number', filterable: true },
+        { name: 'email', type: 'string', interface: 'text', filterable: true },
+        { name: 'nickname', type: 'string', interface: 'text' }, // 未声明 filterable
+      ],
+    });
+
+    ds.addCollection({
+      name: 'posts',
+      fields: [
+        { name: 'title', type: 'string', interface: 'text', filterable: true },
+        { name: 'author', type: 'belongsTo', target: 'users', interface: 'm2o', filterable: true },
+      ],
+    });
+
+    const posts = ds.getCollection('posts')!;
+    const metaFactory = createCollectionContextMeta(posts, 'Posts', false);
+    const meta = await metaFactory();
+    const props = await (meta?.properties as any)?.();
+    const authorMeta: any = props?.author;
+    const authorFields = await authorMeta?.properties?.();
+
+    expect(authorFields).toBeTruthy();
+    expect(authorFields).toHaveProperty('email');
+    expect(authorFields).not.toHaveProperty('nickname');
+  });
+});

package/src/utils/associationObjectVariable.ts

@@ -122,7 +122,7 @@ export function createAssociationAwareObjectMetaFactory(
   title: string,
   valueAccessor: (ctx: FlowContext) => any,
 ): PropertyMetaFactory {
-  const baseFactory = createCollectionContextMeta(collectionAccessor, title);
+  const baseFactory = createCollectionContextMeta(collectionAccessor, title, true);
   const factory: PropertyMetaFactory = async () => {
     const base = (await baseFactory()) as PropertyMeta | null;
     if (!base) return null;

package/src/utils/createCollectionContextMeta.ts

@@ -17,7 +17,7 @@ const NUMERIC_FIELD_TYPES = ['integer', 'float', 'double', 'decimal'] as const;
 /**
  * 创建字段的完整元数据（统一处理关联和非关联字段）
  */
-function createFieldMetadata(field: CollectionField) {
+function createFieldMetadata(field: CollectionField, includeNonFilterable?: boolean) {
   const baseProperties = createMetaBaseProperties(field);
 
   if (field.isAssociationField()) {
@@ -36,7 +36,9 @@ function createFieldMetadata(field: CollectionField) {
       properties: async () => {
         const subProperties: Record<string, any> = {};
         targetCollection.fields.forEach((subField) => {
-          subProperties[subField.name] = createFieldMetadata(subField);
+          if (includeNonFilterable || subField.filterable) {
+            subProperties[subField.name] = createFieldMetadata(subField, includeNonFilterable);
+          }
         });
         return subProperties;
       },
@@ -93,6 +95,7 @@ function createMetaBaseProperties(field: CollectionField) {
 export function createCollectionContextMeta(
   collectionOrFactory: Collection | (() => Collection | null),
   title?: string,
+  includeNonFilterable?: boolean,
 ): PropertyMetaFactory {
   const metaFn: PropertyMetaFactory = async () => {
     const collection = typeof collectionOrFactory === 'function' ? collectionOrFactory() : collectionOrFactory;
@@ -110,8 +113,8 @@ export function createCollectionContextMeta(
 
         // 添加所有字段
         collection.fields.forEach((field) => {
-          if (field.filterable) {
-            properties[field.name] = createFieldMetadata(field);
+          if (includeNonFilterable || field.filterable) {
+            properties[field.name] = createFieldMetadata(field, includeNonFilterable);
           }
         });
 

package/src/utils/variablesParams.ts

@@ -174,7 +174,7 @@ export async function buildRecordMeta(
   title?: string,
   paramsBuilder?: RecordParamsBuilder,
 ): Promise<PropertyMeta | null> {
-  const base = await createCollectionContextMeta(collectionAccessor, title)();
+  const base = await createCollectionContextMeta(collectionAccessor, title, true)();
   if (!base) return null;
   return {
     ...base,