@nocobase/client-v2 2.2.0-alpha.1 → 2.2.0-alpha.11

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/__tests__/subFormFieldLinkageRules.inputArgs.test.ts

@@ -13,7 +13,7 @@ import { subFormFieldLinkageRules } from '../linkageRules';
 import { SubFormFieldModel, SubFormListFieldModel } from '../../models/fields/AssociationFieldModel/SubFormFieldModel';
 
 describe('subFormFieldLinkageRules action', () => {
-  it('passes inputArgs to fork runtime context', async () => {
+  it('passes inputArgs to fork runtime context when grid forks are stored in a Set', async () => {
     const linkageAssignHandler = vi.fn();
     const engine = new FlowEngine();
     const forkModel = new FlowModel({ uid: 'fork-model', flowEngine: engine }) as any;
@@ -38,7 +38,7 @@ describe('subFormFieldLinkageRules action', () => {
         hidden: false,
         subModels: {
           grid: {
-            forks: [forkModel],
+            forks: new Set([forkModel]),
           },
         },
       },

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/customVariable.tsx

@@ -12,7 +12,6 @@ import {
   defineAction,
   isRunJSValue,
   normalizeRunJSValue,
-  runjsWithSafeGlobals,
   tExpr,
   type RunJSValue,
   useFlowContext,
@@ -43,7 +42,7 @@ export const customVariable = defineAction({
       if (variable.type === 'runjs') {
         const getFunction = async () => {
           const { code, version } = normalizeRunJSValue(variable.runjs);
-          return runjsWithSafeGlobals(ctx, code, { version });
+          return ctx.runjs(code, undefined, { version });
         };
         const metaFunction = () => ({
           title: variable.title,

package/src/flow/actions/dataScopeFilter.ts

@@ -7,11 +7,17 @@
  * 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';
 
 const PRESERVE_NULL = { __nocobaseDataScopeNull__: true };
+const SERVER_CURRENT_ROLE_VARIABLE = '{{$nRole}}';
+const CURRENT_ROLE_EXPRESSION_RE = /^\s*\{\{\s*ctx\.role\s*\}\}\s*$/;
+
+function isCurrentRoleExpression(value: unknown) {
+  return typeof value === 'string' && CURRENT_ROLE_EXPRESSION_RE.test(value);
+}
 
 function isPreserveNull(value: any) {
   return (
@@ -39,14 +45,27 @@ 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;
   }
 
   if ('path' in rawNode && 'operator' in rawNode) {
+    if (isCurrentRoleExpression(rawNode.value)) {
+      resolvedNode.value = SERVER_CURRENT_ROLE_VARIABLE;
+      return;
+    }
     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

@@ -11,13 +11,36 @@ import { css } from '@emotion/css';
 import { defineAction, tExpr } from '@nocobase/flow-engine';
 import { getPickerFormat } from '@nocobase/utils/client';
 import { DateFormatCom, ExpiresRadio } from '../components';
+import {
+  getDateTimeFormatCollectionField,
+  isDateOnlyCollectionField,
+  isTimeCollectionField,
+  resolveDateTimeDisplayProps,
+} from '../utils/dateTimeDisplayProps';
+
+const isTableColumnFieldSubModel = (model) => {
+  const parent = model?.parent;
+  return (
+    parent?.subModels?.field === model &&
+    (parent?.use === 'TableColumnModel' || parent?.constructor?.name === 'TableColumnModel')
+  );
+};
+
+const syncTableColumnDateTimeFormatProps = (ctx, props) => {
+  const model = ctx.model;
+  if (!isTableColumnFieldSubModel(model)) {
+    return;
+  }
+
+  model.parent?.setProps?.(props);
+};
 
 export const dateTimeFormat = defineAction({
   title: tExpr('Date display format'),
   name: 'dateDisplayFormat',
   uiSchema: (ctx) => {
-    const { collectionField } = ctx.model.context as any;
-    const isTimeField = collectionField.type === 'time' || collectionField.interface === 'time';
+    const collectionField = getDateTimeFormatCollectionField({ model: ctx.model });
+    const isTimeField = isTimeCollectionField(collectionField);
     const timeFormatField = {
       type: 'string',
       title: '{{t("Time format")}}',
@@ -43,7 +66,7 @@ export const dateTimeFormat = defineAction({
         (field) => {
           if (!isTimeField) {
             const { showTime, picker } = field.form.values || {};
-            field.hidden = !showTime || picker !== 'date';
+            field.hidden = isDateOnlyCollectionField(collectionField) || !showTime || picker !== 'date';
           }
         },
       ],
@@ -146,10 +169,11 @@ export const dateTimeFormat = defineAction({
             },
           },
           (field) => {
-            const { collectionField } = ctx.model.context as any;
+            const collectionField = getDateTimeFormatCollectionField({ model: ctx.model });
             const { picker } = field.form.values || {};
-            field.hidden = collectionField.type === 'dateOnly' || picker !== 'date';
-            if (picker !== 'date') {
+            const isDateOnlyField = isDateOnlyCollectionField(collectionField);
+            field.hidden = isDateOnlyField || picker !== 'date';
+            if (isDateOnlyField || picker !== 'date') {
               field.value = false;
             }
           },
@@ -159,34 +183,24 @@ export const dateTimeFormat = defineAction({
     };
   },
   defaultParams: (ctx: any) => {
-    const { showTime, dateFormat, format, timeFormat, picker }: any = {
-      ...ctx.model.context.collectionField.getComponentProps(),
-      ...ctx.model.props,
-    };
-    const collectionField = ctx.model.context.collectionField;
-    const isTimeField = collectionField.type === 'time' || collectionField.interface === 'time';
+    const { showTime, dateFormat, timeFormat, picker } = resolveDateTimeDisplayProps({
+      model: ctx.model,
+      withDefaults: true,
+    });
     return {
       picker: picker || 'date',
       dateFormat: dateFormat || 'YYYY-MM-DD',
-      timeFormat: timeFormat || (isTimeField ? format : undefined) || 'HH:mm:ss',
+      timeFormat: timeFormat || 'HH:mm:ss',
       showTime,
     };
   },
+  async beforeParamsSave(ctx: any, params) {
+    const props = resolveDateTimeDisplayProps({ model: ctx.model, params });
+    ctx.model.setProps(props);
+    syncTableColumnDateTimeFormatProps(ctx, props);
+    await ctx.model.save?.();
+  },
   handler(ctx: any, params) {
-    const { collectionField } = ctx.model.context as any;
-    const isTimeField = collectionField.type === 'time' || collectionField.interface === 'time';
-    if (isTimeField) {
-      const timeFormat = params?.timeFormat || params?.format || 'HH:mm:ss';
-      ctx.model.setProps({
-        ...params,
-        timeFormat,
-        format: timeFormat,
-      });
-    } else {
-      ctx.model.setProps({
-        ...params,
-        format: params?.showTime ? `${params.dateFormat} ${params.timeFormat}` : params.dateFormat,
-      });
-    }
+    ctx.model.setProps(resolveDateTimeDisplayProps({ model: ctx.model, params }));
   },
 });

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';
@@ -43,10 +43,12 @@ export {
   linkageSetDetailsFieldProps,
   actionLinkageRules,
   menuLinkageRules,
+  tabLinkageRules,
   blockLinkageRules,
   linkageSetBlockProps,
   linkageSetActionProps,
   linkageSetMenuItemProps,
+  linkageSetTabProps,
   linkageSetFieldProps,
   subFormLinkageSetFieldProps,
   linkageAssignField,