@nocobase/client-v2 2.2.0-beta.7 → 2.2.0-beta.9

package/src/flow/actions/__tests__/dataScopeFilter.test.ts

@@ -64,6 +64,40 @@ describe('normalizeDataScopeFilter', () => {
     });
   });
 
+  it('prunes a missing URL search param variable', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.urlSearchParams.departmentId }}' }],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: undefined }],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toBeUndefined();
+  });
+
+  it('only prunes the missing URL search param condition from mixed filters', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        { path: 'departmentId', operator: '$eq', value: '{{ ctx.urlSearchParams.departmentId }}' },
+      ],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        { path: 'departmentId', operator: '$eq', value: undefined },
+      ],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ status: { $eq: 'active' } }],
+    });
+  });
+
   it('still prunes empty constant values', () => {
     const filter = {
       logic: '$and',
@@ -139,6 +173,34 @@ describe('normalizeDataScopeFilter', () => {
     expect(resource.removeFilterGroup).not.toHaveBeenCalled();
   });
 
+  it('dataScope handler removes data scope when a URL search param is missing', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+    };
+    const ctx = {
+      model: {
+        uid: 'field-1',
+        resource,
+      },
+      resolveJsonTemplate: vi.fn(async (template) => ({
+        ...template,
+        items: [{ ...template.items[0], value: undefined }],
+      })),
+    };
+    const params = {
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.urlSearchParams.departmentId }}' }],
+      },
+    };
+
+    await (dataScope as any).handler(ctx, params);
+
+    expect(resource.removeFilterGroup).toHaveBeenCalledWith('field-1');
+    expect(resource.addFilterGroup).not.toHaveBeenCalled();
+  });
+
   it('dataScope handler preserves current role as server-side variable', async () => {
     const engine = new FlowEngine();
     const resource = {

package/src/flow/actions/__tests__/openView.defineProps.route.test.tsx

@@ -9,8 +9,10 @@
 
 import React from 'react';
 import { describe, it, expect, vi } from 'vitest';
+import { RUNJS_OPEN_VIEW_ROUTE_STATE } from '@nocobase/flow-engine';
 import { openView } from '../openView';
 import { FlowPage } from '../../FlowPage';
+import { ROUTE_TRANSIENT_INPUT_ARGS_KEY } from '../../routeTransientInputArgs';
 
 describe('openView action - route mode defineProperties/defineMethods', () => {
   const createRouteManagedCtx = () => {
@@ -50,6 +52,27 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
     return { ctx, engine };
   };
 
+  const createFirstStageCtx = (inputArgs: Record<PropertyKey, unknown>) => {
+    const navigateTo = vi.fn();
+    const ctx: any = {
+      inputArgs,
+      engine: { context: { themeToken: { colorBgLayout: '#fff' } } },
+      model: {
+        uid: 'popup-uid',
+        context: {
+          inputArgs: {},
+          defineProperty: vi.fn(),
+        },
+        flowEngine: { context: { themeToken: { colorBgLayout: '#fff' } } },
+      },
+      view: {
+        navigation: { navigateTo },
+      },
+    };
+
+    return { ctx, navigateTo };
+  };
+
   it('injects defineProperties/defineMethods on onModelLoaded even when not present in current inputArgs', async () => {
     const { ctx } = createRouteManagedCtx();
 
@@ -149,4 +172,145 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
     const defineMethodCalls = pageModelContext.defineMethod.mock.calls.map((c: any[]) => c[0]);
     expect(defineMethodCalls).toContain('pong');
   });
+
+  it('passes formData through route navigation state', async () => {
+    const navigateTo = vi.fn();
+    const ctx: any = {
+      inputArgs: {
+        formData: {
+          start: '2026-06-24 08:00:00',
+          end: '2026-06-24 09:00:00',
+        },
+      },
+      engine: {
+        context: {},
+      },
+      model: {
+        uid: 'popup-uid',
+        context: {
+          defineProperty: vi.fn(),
+        },
+      },
+      view: {
+        navigation: {
+          navigateTo,
+        },
+      },
+      isNavigationEnabled: true,
+    };
+
+    await openView.handler(ctx, { navigation: true });
+
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+      },
+      {
+        state: {
+          [ROUTE_TRANSIENT_INPUT_ARGS_KEY]: {
+            'popup-uid': {
+              formData: {
+                start: '2026-06-24 08:00:00',
+                end: '2026-06-24 09:00:00',
+              },
+            },
+          },
+        },
+      },
+    );
+  });
+
+  it('adds route state to first-stage navigation only for RunJS ctx.openView calls', async () => {
+    const { ctx, navigateTo } = createFirstStageCtx({
+      mode: 'dialog',
+      size: 'large',
+      [RUNJS_OPEN_VIEW_ROUTE_STATE]: { mode: 'dialog', size: 'large' },
+    });
+
+    await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
+
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+        openViewRouteState: { mode: 'dialog', size: 'large' },
+      },
+      undefined,
+    );
+  });
+
+  it('normalizes first-stage RunJS route state mode on mobile layout', async () => {
+    const { ctx, navigateTo } = createFirstStageCtx({
+      isMobileLayout: true,
+      mode: 'dialog',
+      size: 'large',
+      [RUNJS_OPEN_VIEW_ROUTE_STATE]: { mode: 'dialog', size: 'large' },
+    });
+
+    await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
+
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+        openViewRouteState: { mode: 'embed', size: 'large' },
+      },
+      undefined,
+    );
+  });
+
+  it('uses route replay mode and size before persisted openView defaults', async () => {
+    const { ctx } = createRouteManagedCtx();
+    ctx.inputArgs.mode = 'dialog';
+    ctx.inputArgs.size = 'large';
+
+    await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
+
+    expect(ctx.viewer.open).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'dialog',
+        width: '80%',
+      }),
+    );
+  });
+
+  it('uses decoded openView route state during route replay', async () => {
+    const { ctx } = createRouteManagedCtx();
+    ctx.inputArgs.openViewRouteState = { mode: 'dialog', size: 'large' };
+
+    await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
+
+    expect(ctx.viewer.open).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'dialog',
+        width: '80%',
+      }),
+    );
+  });
+
+  it('keeps first-stage navigation unchanged for non-RunJS openView calls', async () => {
+    const { ctx, navigateTo } = createFirstStageCtx({
+      mode: 'dialog',
+      size: 'large',
+    });
+
+    await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
+
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+      },
+      undefined,
+    );
+  });
 });

package/src/flow/actions/afterSuccess.tsx

@@ -7,13 +7,152 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { defineAction, tExpr } from '@nocobase/flow-engine';
+import {
+  FlowContext,
+  createRecordMetaFactory,
+  createRecordResolveOnServerWithLocal,
+  defineAction,
+  tExpr,
+  useFlowSettingsContext,
+  type Collection,
+  type FlowRuntimeContext,
+  type MetaTreeNode,
+  type PropertyMetaFactory,
+} from '@nocobase/flow-engine';
 import { isURL } from '@nocobase/utils/client';
-import { TextAreaWithContextSelector } from '../components/TextAreaWithContextSelector';
+import React, { useMemo } from 'react';
+import {
+  TextAreaWithContextSelector,
+  type TextAreaWithContextSelectorProps,
+} from '../components/TextAreaWithContextSelector';
+
+type ResponseRecordPlainStepContext = {
+  steps?: FlowRuntimeContext['steps'];
+};
+
+type ResponseRecordFlowDefinitionContext = {
+  flowKey?: string;
+  model?: {
+    getFlow?: (flowKey: string) => { steps?: Record<string, unknown> } | undefined;
+  };
+};
+
+type ResponseRecordContext = FlowContext &
+  ResponseRecordPlainStepContext & {
+    blockModel?: { collection?: Collection };
+    collection?: Collection;
+    model?: FlowRuntimeContext['model'] & { collection?: Collection };
+  };
+
+function getResponseRecordSteps(ctx: FlowContext | ResponseRecordPlainStepContext): FlowRuntimeContext['steps'] {
+  return 'steps' in ctx ? ctx.steps || {} : {};
+}
+
+export function getAfterSuccessResponseRecord(ctx: FlowContext | ResponseRecordPlainStepContext) {
+  const steps = getResponseRecordSteps(ctx);
+  const preferredStepKeys = ['saveResource', 'submit', 'request', 'apply', 'save'];
+
+  for (const stepKey of preferredStepKeys) {
+    if (Object.prototype.hasOwnProperty.call(steps, stepKey) && steps[stepKey]?.result != null) {
+      return steps[stepKey].result;
+    }
+  }
+
+  const results = Object.entries(steps)
+    .filter(([stepKey, step]) => stepKey !== 'afterSuccess' && step?.result != null)
+    .map(([, step]) => step.result);
+  return results[results.length - 1];
+}
+
+function getResponseRecordMeta(ctx: ResponseRecordContext): PropertyMetaFactory | undefined {
+  if (!hasResponseRecordSource(ctx)) {
+    return;
+  }
+  const collectionAccessor = getResponseRecordCollectionAccessor(ctx);
+  if (!collectionAccessor()) {
+    return;
+  }
+  return createRecordMetaFactory(collectionAccessor, ctx.t('Response record'), () => {
+    const collection = collectionAccessor();
+    const record = getAfterSuccessResponseRecord(ctx);
+    if (!collection || !record) {
+      return;
+    }
+    try {
+      const filterByTk = collection.getFilterByTK(record);
+      if (filterByTk == null) {
+        return;
+      }
+      return {
+        collection: collection.name,
+        dataSourceKey: collection.dataSourceKey || 'main',
+        filterByTk,
+      };
+    } catch (error) {
+      return;
+    }
+  });
+}
+
+function hasResponseRecordSource(ctx: FlowContext | ResponseRecordPlainStepContext) {
+  if (Object.prototype.hasOwnProperty.call(getResponseRecordSteps(ctx), 'saveResource')) {
+    return true;
+  }
+
+  const { model, flowKey } = ctx as ResponseRecordFlowDefinitionContext;
+  if (!model || typeof model.getFlow !== 'function' || !flowKey) {
+    return false;
+  }
+
+  return Object.prototype.hasOwnProperty.call(model.getFlow(flowKey)?.steps || {}, 'saveResource');
+}
+
+function getResponseRecordCollectionAccessor(ctx: ResponseRecordContext) {
+  return () => ctx.blockModel?.collection || ctx.collection || ctx.model?.collection || null;
+}
+
+export function getMetaTreeWithResponseRecord(ctx: FlowRuntimeContext): MetaTreeNode[] {
+  const responseRecordMeta = getResponseRecordMeta(ctx);
+  if (!responseRecordMeta) {
+    return ctx.getPropertyMetaTree?.() || [];
+  }
+
+  const scoped = new FlowContext();
+  scoped.addDelegate(ctx);
+  scoped.defineProperty('responseRecord', {
+    get: () => getAfterSuccessResponseRecord(ctx),
+    cache: false,
+    resolveOnServer: createRecordResolveOnServerWithLocal(getResponseRecordCollectionAccessor(ctx), () =>
+      getAfterSuccessResponseRecord(ctx),
+    ),
+    meta: responseRecordMeta,
+  });
+  return scoped.getPropertyMetaTree();
+}
+
+function AfterSuccessRedirectTextArea(props: TextAreaWithContextSelectorProps) {
+  const flowCtx = useFlowSettingsContext();
+  const metaTree = useMemo(() => () => getMetaTreeWithResponseRecord(flowCtx), [flowCtx]);
+
+  return <TextAreaWithContextSelector {...props} metaTree={metaTree} />;
+}
 
 export const afterSuccess = defineAction({
   name: 'afterSuccess',
   title: tExpr('After successful submission'),
+  defineProperties(ctx) {
+    const responseRecordMeta = getResponseRecordMeta(ctx);
+    return {
+      responseRecord: {
+        get: () => getAfterSuccessResponseRecord(ctx),
+        cache: false,
+        resolveOnServer: createRecordResolveOnServerWithLocal(getResponseRecordCollectionAccessor(ctx), () =>
+          getAfterSuccessResponseRecord(ctx),
+        ),
+        ...(responseRecordMeta ? { meta: responseRecordMeta } : {}),
+      },
+    };
+  },
   uiSchema: {
     successMessage: {
       type: 'string',
@@ -46,7 +185,7 @@ export const afterSuccess = defineAction({
       type: 'string',
       title: tExpr('Link'),
       'x-decorator': 'FormItem',
-      'x-component': TextAreaWithContextSelector,
+      'x-component': AfterSuccessRedirectTextArea,
       'x-reactions': {
         dependencies: ['actionAfterSuccess'],
         fulfill: {

package/src/flow/actions/dataScopeFilter.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { isVariableExpression, pruneFilter } from '@nocobase/flow-engine';
+import { extractPropertyPath, isVariableExpression, pruneFilter } from '@nocobase/flow-engine';
 import { transformFilter } from '@nocobase/utils/client';
 import _ from 'lodash';
 
@@ -45,6 +45,14 @@ function restorePreservedNull(value: any): any {
   return value;
 }
 
+function isUrlSearchParamsExpression(value: any) {
+  if (!isVariableExpression(value)) {
+    return false;
+  }
+
+  return extractPropertyPath(value)?.[0] === 'urlSearchParams';
+}
+
 function markEmptyVariableValues(rawNode: any, resolvedNode: any) {
   if (!rawNode || !resolvedNode || typeof rawNode !== 'object' || typeof resolvedNode !== 'object') {
     return;
@@ -57,6 +65,7 @@ function markEmptyVariableValues(rawNode: any, resolvedNode: any) {
     }
     if (
       isVariableExpression(rawNode.value) &&
+      !isUrlSearchParamsExpression(rawNode.value) &&
       (resolvedNode.value === undefined || resolvedNode.value === null || resolvedNode.value === '')
     ) {
       resolvedNode.value = PRESERVE_NULL;

package/src/flow/actions/dateTimeFormat.tsx

@@ -28,11 +28,11 @@ const isTableColumnFieldSubModel = (model) => {
 
 const syncTableColumnDateTimeFormatProps = (ctx, props) => {
   const model = ctx.model;
-  if (!isTableColumnFieldSubModel(model) || !model?.parent?.collectionField?.isAssociationField?.()) {
+  if (!isTableColumnFieldSubModel(model)) {
     return;
   }
 
-  model.parent.setProps(props);
+  model.parent?.setProps?.(props);
 };
 
 export const dateTimeFormat = defineAction({

package/src/flow/actions/index.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-export * from './afterSuccess';
+export { afterSuccess } from './afterSuccess';
 export * from './confirm';
 export * from './dataScope';
 export * from './openView';

package/src/flow/actions/openView.tsx

@@ -7,11 +7,20 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { defineAction, tExpr, FlowModelContext, FlowModel, FlowExitAllException } from '@nocobase/flow-engine';
+import {
+  defineAction,
+  tExpr,
+  FlowModelContext,
+  FlowModel,
+  FlowExitAllException,
+  createOpenViewRouteState,
+  RUNJS_OPEN_VIEW_ROUTE_STATE,
+} from '@nocobase/flow-engine';
 import React from 'react';
 import { FlowPage } from '../FlowPage';
 import { PageModel, RootPageModel } from '../models';
 import _ from 'lodash';
+import { ROUTE_TRANSIENT_INPUT_ARGS_KEY } from '../routeTransientInputArgs';
 
 type DirtyAwareFlowModel = FlowModel & {
   getUserModifiedFields?: () => Set<string> | undefined;
@@ -23,6 +32,15 @@ type BeforeCloseDirtyState = {
   formModelUids: string[];
 };
 
+const pickRouteTransientInputArgs = (inputArgs: Record<string, unknown>) => {
+  return _.pickBy(
+    {
+      formData: inputArgs.formData,
+    },
+    (value) => typeof value !== 'undefined',
+  );
+};
+
 function collectDirtyFormModelUids(model?: FlowModel | null, ignoredDirtyFormModelUids: string[] = []): string[] {
   if (!model) {
     return [];
@@ -291,8 +309,32 @@ export const openView = defineAction({
         ? (inputArgs as any).associationName
         : (params as any)?.associationName;
     const mergedTabUid = typeof inputArgs.tabUid !== 'undefined' ? inputArgs.tabUid : params.tabUid;
-    // 移动端中只需要显示子页面
-    const openMode = ctx.inputArgs?.isMobileLayout ? 'embed' : ctx.inputArgs?.mode || params.mode || 'drawer';
+    const hasRunJSOpenViewRouteState = Object.prototype.hasOwnProperty.call(inputArgs, RUNJS_OPEN_VIEW_ROUTE_STATE);
+    const runJSOpenViewRouteStateInput = (inputArgs as Record<PropertyKey, unknown>)[RUNJS_OPEN_VIEW_ROUTE_STATE];
+    const runJSOpenViewRouteState = hasRunJSOpenViewRouteState
+      ? createOpenViewRouteState(
+          runJSOpenViewRouteStateInput && typeof runJSOpenViewRouteStateInput === 'object'
+            ? (runJSOpenViewRouteStateInput as { mode?: unknown; size?: unknown })
+            : {
+                mode: inputArgs.mode,
+                size: inputArgs.size,
+              },
+        )
+      : undefined;
+    const replayOpenViewRouteStateInput = (inputArgs as { openViewRouteState?: unknown }).openViewRouteState;
+    const replayOpenViewRouteState =
+      replayOpenViewRouteStateInput && typeof replayOpenViewRouteStateInput === 'object'
+        ? createOpenViewRouteState(replayOpenViewRouteStateInput as { mode?: unknown; size?: unknown })
+        : undefined;
+    const runtimeOpenViewRouteState = runJSOpenViewRouteState || replayOpenViewRouteState;
+    // 移动端中只需要显示子页面。本次 dispatch 参数优先于持久化默认值。
+    const openMode = ctx.inputArgs?.isMobileLayout
+      ? 'embed'
+      : runtimeOpenViewRouteState?.mode || ctx.inputArgs?.mode || params.mode || 'drawer';
+    const effectiveRunJSOpenViewRouteState =
+      runJSOpenViewRouteState && ctx.inputArgs?.isMobileLayout
+        ? createOpenViewRouteState({ ...runJSOpenViewRouteState, mode: openMode })
+        : runJSOpenViewRouteState;
     let navigation = typeof inputArgs.navigation !== 'undefined' ? inputArgs.navigation : params.navigation;
 
     // 传递了上下文就必须禁用路由，否则下次路由打开会缺少上下文
@@ -313,6 +355,7 @@ export const openView = defineAction({
           sourceId: mergedSourceId,
           tabUid: mergedTabUid,
           viewUid: ctx.model.context?.inputArgs?.viewUid || ctx.model.uid,
+          ...(effectiveRunJSOpenViewRouteState ? { openViewRouteState: effectiveRunJSOpenViewRouteState } : {}),
         } as Record<string, unknown>;
         const pendingView = {
           type: pendingType,
@@ -328,8 +371,19 @@ export const openView = defineAction({
           filterByTk: mergedFilterByTk,
           sourceId: mergedSourceId,
           tabUid: mergedTabUid,
+          ...(effectiveRunJSOpenViewRouteState ? { openViewRouteState: effectiveRunJSOpenViewRouteState } : {}),
         };
-        ctx.view.navigation.navigateTo(nextView);
+        const transientInputArgs = pickRouteTransientInputArgs(inputArgs);
+        const navigationOptions = Object.keys(transientInputArgs).length
+          ? {
+              state: {
+                [ROUTE_TRANSIENT_INPUT_ARGS_KEY]: {
+                  [nextView.viewUid]: transientInputArgs,
+                },
+              },
+            }
+          : undefined;
+        ctx.view.navigation.navigateTo(nextView, navigationOptions);
         return;
       }
     }
@@ -373,7 +427,7 @@ export const openView = defineAction({
 
     const pageModelClass =
       ctx.inputArgs.pageModelClass || params.pageModelClass || ctx.layout?.childPageModelClass || 'ChildPageModel';
-    const size = ctx.inputArgs.size || params.size || 'medium';
+    const size = runtimeOpenViewRouteState?.size || ctx.inputArgs.size || params.size || 'medium';
     let pageModelUid: string | null = null;
     let pageModelRef: FlowModel | null = null;