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

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

@@ -0,0 +1,58 @@
+/**
+ * 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 { createMockClient, PluginFlowEngine } from '@nocobase/client-v2';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { detectedDeviceType } = vi.hoisted(() => ({
+  detectedDeviceType: { value: 'mobile' },
+}));
+
+vi.mock('react-device-detect', () => ({
+  get deviceType() {
+    return detectedDeviceType.value;
+  },
+}));
+
+describe('PluginFlowEngine', () => {
+  beforeEach(() => {
+    detectedDeviceType.value = 'mobile';
+  });
+
+  it('should register the current device type before shared flow components', async () => {
+    const app = createMockClient({
+      router: {
+        type: 'memory',
+        initialEntries: ['/'],
+      },
+    });
+    const plugin = new PluginFlowEngine({}, app);
+    const addComponents = app.addComponents.bind(app);
+    const deviceTypesBeforeComponentRegistration: string[] = [];
+    vi.spyOn(app, 'addComponents').mockImplementation((components) => {
+      deviceTypesBeforeComponentRegistration.push(app.flowEngine.context.deviceType);
+      return addComponents(components);
+    });
+
+    await plugin.load();
+
+    expect(app.flowEngine.context.deviceType).toBe('mobile');
+    expect(deviceTypesBeforeComponentRegistration).toEqual(['mobile']);
+  });
+
+  it('should normalize the browser device type to computer', async () => {
+    detectedDeviceType.value = 'browser';
+    const app = createMockClient();
+    const plugin = new PluginFlowEngine({}, app);
+
+    await plugin.load();
+
+    expect(app.flowEngine.context.deviceType).toBe('computer');
+  });
+});

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__/actionLinkageRules.forkProps.test.ts

@@ -0,0 +1,115 @@
+/**
+ * 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 } from '@nocobase/flow-engine';
+import { describe, expect, it, vi } from 'vitest';
+import { ActionModel as ConfiguredActionModel } from '../../models/base/ActionModel';
+import { ActionModel } from '../../models/base/ActionModelCore';
+import { actionLinkageRules, linkageSetActionProps } from '../linkageRules';
+
+class TestActionModel extends ActionModel {}
+
+describe('action linkage rules on action forks', () => {
+  it('does not snapshot unrelated master props when disabling an action', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ TestActionModel });
+    const master = engine.createModel<TestActionModel>({
+      use: 'TestActionModel',
+      props: { title: 'Edit' },
+    });
+    const fork = master.createFork({ className: 'row-action' });
+
+    const ctx = {
+      flowKey: 'buttonSettings',
+      model: fork,
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      t: (value: string) => value,
+      resolveJsonTemplate: vi.fn(async (value: unknown) => value),
+      getAction: (name: string) => {
+        if (name !== 'linkageSetActionProps') return undefined;
+        return {
+          handler: async (_ctx: unknown, params: { setProps: Function }) => {
+            params.setProps(fork, { disabled: true });
+          },
+        };
+      },
+    } as never;
+
+    await actionLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'disable-edit',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [{ name: 'linkageSetActionProps', params: { value: 'disabled' } }],
+        },
+      ],
+    });
+
+    expect(fork.localProps.title).toBeUndefined();
+    expect(fork.__originalProps.title).toBeUndefined();
+    expect(fork.localProps.disabled).toBe(true);
+
+    master.setProps('title', 'Updated');
+    await actionLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'disable-edit',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [{ name: 'linkageSetActionProps', params: { value: 'disabled' } }],
+        },
+      ],
+    });
+
+    expect(fork.getProps().title).toBe('Updated');
+    expect(fork.serialize().props.title).toBe('Updated');
+
+    const refreshedFork = master.createFork({ className: 'row-action' });
+    expect(refreshedFork.getProps().title).toBe('Updated');
+  });
+
+  it('updates a disabled row action title through the real beforeRender flow', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ ConfiguredActionModel });
+    engine.registerActions({ actionLinkageRules, linkageSetActionProps });
+    const master = engine.createModel<ConfiguredActionModel>({
+      use: 'ConfiguredActionModel',
+      props: { title: 'Edit' },
+      stepParams: {
+        buttonSettings: {
+          general: { title: 'Edit' },
+          linkageRules: {
+            value: [
+              {
+                key: 'disable-edit',
+                enable: true,
+                condition: { logic: '$and', items: [] },
+                actions: [{ name: 'linkageSetActionProps', params: { value: 'disabled' } }],
+              },
+            ],
+          },
+        },
+      },
+    });
+    const fork = master.createFork({ className: 'row-action' });
+
+    await fork.dispatchEvent('beforeRender', undefined, { useCache: false });
+    expect(fork.getProps()).toMatchObject({ title: 'Edit', disabled: true });
+
+    master.setStepParams('buttonSettings', 'general', { title: 'Updated' });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(fork.getProps()).toMatchObject({ title: 'Updated', disabled: true });
+  });
+});

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(),