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

package/src/flow/__tests__/getKey.test.ts

@@ -58,4 +58,11 @@ describe('getKey', () => {
 
     expect(getKey(a)).not.toBe(getKey(b));
   });
+
+  it('distinguishes RunJS openView route state overrides', () => {
+    const a = createViewItem({ viewUid: 'v', openViewRouteState: { mode: 'drawer' } }, 0);
+    const b = createViewItem({ viewUid: 'v', openViewRouteState: { mode: 'dialog' } }, 0);
+
+    expect(getKey(a)).not.toBe(getKey(b));
+  });
 });

package/src/flow/__tests__/resolveViewParamsToViewList.test.ts

@@ -250,6 +250,40 @@ describe('resolveViewParamsToViewList', () => {
       expect(result[0].hidden.value).toBe(false); // default drawer type
       expect(result[1].hidden.value).toBe(false); // default drawer type
     });
+
+    it('should let RunJS openView route state override persisted mode for hidden calculation', () => {
+      const model2 = createMockModel('view2', 'drawer');
+      mockFlowEngine.getModel = vi.fn().mockReturnValue(model2);
+
+      const viewParams: ViewParam[] = [
+        { viewUid: 'view1' },
+        { viewUid: 'view2', openViewRouteState: { mode: 'embed' } },
+      ];
+
+      const result = resolveViewParamsToViewList(mockFlowEngine, viewParams, mockRouteModel);
+      updateViewListHidden(result);
+
+      expect(result[0].hidden.value).toBe(true);
+      expect(result[1].hidden.value).toBe(false);
+      expect(model2.getStepParams).not.toHaveBeenCalled();
+    });
+
+    it('should treat child views as embed in mobile hidden calculation', () => {
+      const model2 = createMockModel('view2', 'drawer');
+      mockFlowEngine.getModel = vi.fn().mockReturnValue(model2);
+
+      const viewParams: ViewParam[] = [
+        { viewUid: 'view1' },
+        { viewUid: 'view2', openViewRouteState: { mode: 'dialog' } },
+      ];
+
+      const result = resolveViewParamsToViewList(mockFlowEngine, viewParams, mockRouteModel);
+      updateViewListHidden(result, true);
+
+      expect(result[0].hidden.value).toBe(true);
+      expect(result[1].hidden.value).toBe(false);
+      expect(model2.getStepParams).not.toHaveBeenCalled();
+    });
   });
 
   describe('edge cases', () => {

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

@@ -0,0 +1,73 @@
+/**
+ * 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 {
+  FlowEngine,
+  FlowModel,
+  FlowRuntimeContext,
+  setupRuntimeContextSteps,
+  type Collection,
+} from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+import { afterSuccess, getAfterSuccessResponseRecord, getMetaTreeWithResponseRecord } from '../afterSuccess';
+
+describe('afterSuccess response record variable', () => {
+  it('reads the submit response record from the saveResource step', () => {
+    const record = { id: 1, title: 'Saved' };
+
+    expect(
+      getAfterSuccessResponseRecord({
+        steps: {
+          confirm: { params: {}, result: undefined },
+          saveResource: { params: {}, result: record },
+          afterSuccess: { params: {} },
+        },
+      }),
+    ).toBe(record);
+  });
+
+  it('injects responseRecord into the afterSuccess runtime context', async () => {
+    const record = { id: 1, title: 'Saved' };
+    const sourceCtx = {
+      steps: {
+        saveResource: { params: {}, result: record },
+      },
+      t: (value: string) => value,
+    };
+    const properties = await afterSuccess.defineProperties(sourceCtx as FlowRuntimeContext);
+
+    expect(properties.responseRecord.get()).toBe(record);
+  });
+
+  it('shows responseRecord in the variable picker for settings context', () => {
+    const engine = new FlowEngine();
+    class SubmitActionModel extends FlowModel {}
+    engine.registerModels({ SubmitActionModel });
+    const model = engine.createModel<SubmitActionModel>({ use: 'SubmitActionModel' });
+    const collection = {
+      name: 'users',
+      dataSourceKey: 'main',
+      getFilterByTK: (record: { id?: number }) => record.id,
+    } as unknown as Collection;
+    model.context.defineProperty('collection', { value: collection });
+    const flow = model.registerFlow({
+      key: 'submitSettings',
+      steps: {
+        saveResource: { title: 'Save record', handler: () => undefined },
+        afterSuccess: { use: 'afterSuccess' },
+      },
+    });
+    const ctx = new FlowRuntimeContext(model, 'submitSettings', 'settings');
+    setupRuntimeContextSteps(ctx, flow.steps, model, 'submitSettings');
+
+    const metaTree = getMetaTreeWithResponseRecord(ctx);
+
+    expect(metaTree.find((node) => node.name === 'responseRecord')?.title).toBe('Response record');
+  });
+});

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,92 @@ 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 = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+    };
+    const ctx = engine.context;
+    ctx.defineProperty('api', { value: { auth: { role: '__union__' } } });
+    ctx.defineProperty('user', {
+      value: {
+        roles: [{ name: 'admin' }, { name: 'member' }],
+      },
+    });
+    ctx.defineProperty('model', {
+      value: {
+        uid: 'table-1',
+        resource,
+      },
+    });
+    const params = {
+      filter: {
+        logic: '$and',
+        items: [{ path: 'roles.name', operator: '$includes', value: '{{ ctx.role }}' }],
+      },
+    };
+
+    await (dataScope as { handler: (ctx: typeof ctx, params: typeof params) => Promise<void> }).handler(ctx, params);
+
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('table-1', {
+      $and: [{ roles: { name: { $includes: '{{$nRole}}' } } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+
+  it('setTargetDataScope handler preserves current role as server-side variable', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+      hasData: vi.fn(() => false),
+      refresh: vi.fn(),
+    };
+    const ctx = createSetTargetDataScopeContext(resource, { resolvedValue: ['admin', 'member'] });
+    const params = {
+      targetBlockUid: 'target-1',
+      filter: {
+        logic: '$and',
+        items: [{ path: 'roles.name', operator: '$includes', value: '{{ctx.role}}' }],
+      },
+    };
+
+    await (setTargetDataScope as any).handler(ctx, params);
+
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('setTargetDataScope_action-1', {
+      $and: [{ roles: { name: { $includes: '{{$nRole}}' } } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+
   it('setTargetDataScope handler sends null for empty variable dependencies', async () => {
     const resource = {
       addFilterGroup: vi.fn(),