@nocobase/client-v2 2.1.0-alpha.21 → 2.1.0-alpha.23

package/src/flow/actions/__tests__/openView.subModelKey.test.tsx

@@ -0,0 +1,95 @@
+/**
+ * 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 React from 'react';
+import { describe, it, expect, vi } from 'vitest';
+import { openView } from '../openView';
+import { FlowPage } from '../../FlowPage';
+
+describe('openView action - subModelKey behavior', () => {
+  const createCtx = () => {
+    const engine = {
+      loadOrCreateModel: vi.fn(),
+      getModel: vi.fn(),
+      context: { themeToken: { colorBgLayout: '#fff' } },
+    } as any;
+
+    const ctx: any = {
+      inputArgs: {},
+      engine,
+      model: {
+        uid: 'parent-model-uid',
+        flowEngine: { context: { themeToken: { colorBgLayout: '#fff' } } },
+      },
+      layoutContentElement: {},
+      view: {},
+      viewer: {
+        open: vi.fn(async (_opts: any) => undefined),
+      },
+    };
+
+    return { ctx, engine };
+  };
+
+  it('creates container under ctx.model when subModelKey is provided and uses it as parentId', async () => {
+    const { ctx, engine } = createCtx();
+
+    engine.loadOrCreateModel.mockResolvedValueOnce({ uid: 'container-uid' });
+
+    let capturedElement: any;
+    (ctx.viewer.open as any).mockImplementation(async (opts) => {
+      // call content to get the React element
+      const currentView = { close: vi.fn(), update: vi.fn() };
+      capturedElement = opts.content(currentView);
+      return undefined;
+    });
+
+    await openView.handler(ctx, { subModelKey: 'myContainer', navigation: false });
+
+    // ensure container created with expected options
+    expect(engine.loadOrCreateModel).toHaveBeenCalledTimes(1);
+    expect(engine.loadOrCreateModel).toHaveBeenCalledWith(
+      {
+        async: true,
+        parentId: 'parent-model-uid',
+        subKey: 'myContainer',
+        subType: 'object',
+        use: 'FlowModel',
+      },
+      { skipSave: true },
+    );
+
+    // ensure FlowPage receives container uid as parentId
+    expect(capturedElement?.type).toBe(FlowPage);
+    expect(capturedElement?.props?.parentId).toBe('container-uid');
+    // still passes ChildPageModel by default so downstream will create tabs
+    expect(capturedElement?.props?.pageModelClass).toBe('ChildPageModel');
+  });
+
+  it('uses ctx.model.uid as parentId when subModelKey is not provided', async () => {
+    const { ctx, engine } = createCtx();
+
+    let capturedElement: any;
+    (ctx.viewer.open as any).mockImplementation(async (opts) => {
+      const currentView = { close: vi.fn(), update: vi.fn() };
+      capturedElement = opts.content(currentView);
+      return undefined;
+    });
+
+    await openView.handler(ctx, { navigation: false });
+
+    // container should not be created
+    expect(engine.loadOrCreateModel).not.toHaveBeenCalled();
+
+    // FlowPage should receive parent model uid
+    expect(capturedElement?.type).toBe(FlowPage);
+    expect(capturedElement?.props?.parentId).toBe('parent-model-uid');
+    expect(capturedElement?.props?.pageModelClass).toBe('ChildPageModel');
+  });
+});

package/src/flow/actions/__tests__/setTargetDataScope.leftMetaTree.test.tsx

@@ -0,0 +1,225 @@
+/**
+ * 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 React from 'react';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { FlowEngine, FlowModel, FlowSettingsContextProvider } from '@nocobase/flow-engine';
+import { setTargetDataScope } from '../setTargetDataScope';
+import { createMockFlowApp, TestCollectionFieldInterface } from '../../__tests__/helpers/mockFlowApp';
+
+// Mock VariableInput used inside VariableFilterItem and left field selector
+vi.mock('@nocobase/flow-engine', async () => {
+  const actual = await vi.importActual<any>('@nocobase/flow-engine');
+  const MockVariableInput = ({ onChange }: any) => (
+    <button
+      type="button"
+      data-testid="variable-input"
+      onClick={() =>
+        onChange?.(
+          (globalThis as any).__TEST_PATH__ || 'title',
+          (globalThis as any).__TEST_META__ || {
+            interface: 'input',
+            uiSchema: { 'x-component': 'Input', 'x-component-props': { placeholder: 'Enter value' } },
+            paths: ['collection', (globalThis as any).__TEST_PATH__ || 'title'],
+          },
+        )
+      }
+    >
+      mock-variable-input
+    </button>
+  );
+  return { ...actual, VariableInput: MockVariableInput };
+});
+
+function createEngineWithCollections() {
+  const engine = new FlowEngine();
+  const app = createMockFlowApp();
+  const ds = engine.dataSourceManager.getDataSource('main');
+  ds.addCollection({
+    name: 'posts',
+    fields: [
+      { name: 'title', type: 'string', interface: 'input', uiSchema: { 'x-component': 'Input' } },
+      { name: 'published', type: 'boolean', interface: 'switch', uiSchema: { 'x-component': 'Switch' } },
+    ],
+  });
+  return { engine, app } as const;
+}
+
+function registerFieldInterface(app: ReturnType<typeof createMockFlowApp>) {
+  class InputInterface extends TestCollectionFieldInterface {
+    name = 'input';
+    group = 'basic';
+    filterable = {
+      operators: [
+        { value: '$eq', label: 'Equals' },
+        { value: '$null', label: 'Is null', noValue: true },
+      ],
+    };
+  }
+  app.addFieldInterfaces([InputInterface]);
+}
+
+describe('setTargetDataScope with leftMetaTree', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+    (globalThis as any).__TEST_PATH__ = undefined;
+    (globalThis as any).__TEST_META__ = undefined;
+  });
+
+  function renderAction(ctxModel: FlowModel, targetUid: string, value: any) {
+    const Comp: any = (setTargetDataScope as any).uiSchema.filter['x-component'];
+    return render(
+      <FlowSettingsContextProvider value={ctxModel.context}>
+        <Comp value={value} uid={targetUid} />
+      </FlowSettingsContextProvider>,
+    );
+  }
+
+  it('shows warning when target model not found', async () => {
+    const { engine, app } = createEngineWithCollections();
+    const ctxModel = engine.createModel<FlowModel>({ uid: 'ctx-1', use: FlowModel });
+    ctxModel.context.defineProperty('app', { value: app });
+    ctxModel.context.defineProperty('themeToken', { value: { colorError: '#f00' } });
+    const value = { logic: '$and', items: [{ path: '', operator: '', value: '' }] };
+    renderAction(ctxModel, 'non-exist', value);
+    expect(screen.getByText(/Cannot find the model instance with UID/i)).toBeTruthy();
+  });
+
+  it('renders FilterGroup when target model exists', async () => {
+    const { engine, app } = createEngineWithCollections();
+    registerFieldInterface(app);
+    const ctxModel = engine.createModel<FlowModel>({ uid: 'ctx-2', use: FlowModel });
+    ctxModel.context.defineProperty('app', { value: app });
+    const target = engine.createModel<FlowModel>({ uid: 'target-1', use: FlowModel });
+    // inject collection getter on target
+    const ds = engine.dataSourceManager.getDataSource('main');
+    target.context.defineProperty('collection', { get: () => ds.getCollection('posts') });
+    target.context.defineProperty('app', { value: app });
+    const value = { logic: '$and', items: [{ path: '', operator: '', value: '' }] };
+    renderAction(ctxModel, target.uid, value);
+    expect(await screen.findAllByTestId('variable-input')).toBeTruthy();
+  });
+
+  it('left selection updates path (no collection prefix)', async () => {
+    const { engine, app } = createEngineWithCollections();
+    registerFieldInterface(app);
+    const ctxModel = engine.createModel<FlowModel>({ uid: 'ctx-3', use: FlowModel });
+    ctxModel.context.defineProperty('app', { value: app });
+    const target = engine.createModel<FlowModel>({ uid: 'target-2', use: FlowModel });
+    const ds = engine.dataSourceManager.getDataSource('main');
+    target.context.defineProperty('collection', { get: () => ds.getCollection('posts') });
+    target.context.defineProperty('app', { value: app });
+    const value = { logic: '$and', items: [{ path: '', operator: '', value: '' }] };
+    renderAction(ctxModel, target.uid, value);
+    fireEvent.click(screen.getAllByTestId('variable-input')[0]);
+    expect(value.items[0].path).toBe('title');
+  });
+
+  it('rightAsVariable shows RHS then hides for noValue operator', async () => {
+    const { engine, app } = createEngineWithCollections();
+    registerFieldInterface(app);
+    const ctxModel = engine.createModel<FlowModel>({ uid: 'ctx-4', use: FlowModel });
+    ctxModel.context.defineProperty('app', { value: app });
+    const target = engine.createModel<FlowModel>({ uid: 'target-3', use: FlowModel });
+    const ds = engine.dataSourceManager.getDataSource('main');
+    target.context.defineProperty('collection', { get: () => ds.getCollection('posts') });
+    target.context.defineProperty('app', { value: app });
+    const value = { logic: '$and', items: [{ path: '', operator: '', value: '' }] };
+    renderAction(ctxModel, target.uid, value);
+    fireEvent.click(screen.getAllByTestId('variable-input')[0]);
+    expect(screen.getAllByTestId('variable-input').length).toBeGreaterThanOrEqual(2);
+    value.items[0].operator = '$null';
+    renderAction(ctxModel, target.uid, value);
+    expect(screen.getAllByTestId('variable-input').length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('RHS constant mapping sets empty string', async () => {
+    const { engine, app } = createEngineWithCollections();
+    registerFieldInterface(app);
+    const ctxModel = engine.createModel<FlowModel>({ uid: 'ctx-5', use: FlowModel });
+    ctxModel.context.defineProperty('app', { value: app });
+    const target = engine.createModel<FlowModel>({ uid: 'target-4', use: FlowModel });
+    const ds = engine.dataSourceManager.getDataSource('main');
+    target.context.defineProperty('collection', { get: () => ds.getCollection('posts') });
+    target.context.defineProperty('app', { value: app });
+    const value = { logic: '$and', items: [{ path: '', operator: '$eq', value: 'x' }] };
+    renderAction(ctxModel, target.uid, value);
+    fireEvent.click(screen.getAllByTestId('variable-input')[0]);
+    (globalThis as any).__TEST_META__ = { paths: ['constant'] };
+    fireEvent.click(screen.getAllByTestId('variable-input')[1]);
+    expect(screen.getAllByTestId('variable-input').length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('RHS null mapping sets null', async () => {
+    const { engine, app } = createEngineWithCollections();
+    registerFieldInterface(app);
+    const ctxModel = engine.createModel<FlowModel>({ uid: 'ctx-6', use: FlowModel });
+    ctxModel.context.defineProperty('app', { value: app });
+    const target = engine.createModel<FlowModel>({ uid: 'target-5', use: FlowModel });
+    const ds = engine.dataSourceManager.getDataSource('main');
+    target.context.defineProperty('collection', { get: () => ds.getCollection('posts') });
+    target.context.defineProperty('app', { value: app });
+    const value = { logic: '$and', items: [{ path: '', operator: '$eq', value: 'x' }] };
+    renderAction(ctxModel, target.uid, value);
+    fireEvent.click(screen.getAllByTestId('variable-input')[0]);
+    (globalThis as any).__TEST_META__ = { paths: ['null'] };
+    fireEvent.click(screen.getAllByTestId('variable-input')[1]);
+    expect(screen.getAllByTestId('variable-input').length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('root meta tree does not contain collection globally', async () => {
+    const { engine, app } = createEngineWithCollections();
+    const ctxModel = new FlowModel({ uid: 'ctx-7', flowEngine: engine });
+    ctxModel.context.defineProperty('app', { value: app });
+    const root = ctxModel.context.getPropertyMetaTree();
+    const nodes = Array.isArray(root) ? root : await (root as any)();
+    expect(nodes.map((n) => n.name)).not.toContain('collection');
+  });
+
+  it('child operator via x-filter-operators preferred', async () => {
+    const { engine, app } = createEngineWithCollections();
+    registerFieldInterface(app);
+    const ctxModel = engine.createModel<FlowModel>({ uid: 'ctx-8', use: FlowModel });
+    ctxModel.context.defineProperty('app', { value: app });
+    const target = engine.createModel<FlowModel>({ uid: 'target-6', use: FlowModel });
+    const ds = engine.dataSourceManager.getDataSource('main');
+    target.context.defineProperty('collection', { get: () => ds.getCollection('posts') });
+    target.context.defineProperty('app', { value: app });
+    (globalThis as any).__TEST_PATH__ = 'containsText';
+    (globalThis as any).__TEST_META__ = {
+      interface: 'input',
+      uiSchema: { 'x-component': 'Input', 'x-filter-operators': [{ value: '$includes', label: 'contains' }] },
+      paths: ['collection', 'containsText'],
+    };
+    const value = { logic: '$and', items: [{ path: '', operator: '', value: '' }] };
+    renderAction(ctxModel, target.uid, value);
+    fireEvent.click(screen.getAllByTestId('variable-input')[0]);
+    value.items[0].operator = '$includes';
+    renderAction(ctxModel, target.uid, value);
+    expect(value.items[0].operator).toBe('$includes');
+  });
+
+  it('works across re-renders with same target', async () => {
+    const { engine, app } = createEngineWithCollections();
+    registerFieldInterface(app);
+    const ctxModel = engine.createModel<FlowModel>({ uid: 'ctx-9', use: FlowModel });
+    ctxModel.context.defineProperty('app', { value: app });
+    const target = engine.createModel<FlowModel>({ uid: 'target-7', use: FlowModel });
+    const ds = engine.dataSourceManager.getDataSource('main');
+    target.context.defineProperty('collection', { get: () => ds.getCollection('posts') });
+    target.context.defineProperty('app', { value: app });
+    const value = { logic: '$and', items: [{ path: '', operator: '$eq', value: '' }] };
+    const view = renderAction(ctxModel, target.uid, value);
+    fireEvent.click(screen.getAllByTestId('variable-input')[0]);
+    expect(value.items[0].path).toBe('title');
+    renderAction(ctxModel, target.uid, value);
+    expect(value.items[0].path).toBe('title');
+  });
+});

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

@@ -0,0 +1,79 @@
+/**
+ * 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, vi } from 'vitest';
+import { showMessage } from '../showMessage';
+import { showNotification } from '../showNotification';
+
+describe('showMessage action', () => {
+  it('renders custom close control when duration is 0', async () => {
+    const open = vi.fn();
+    const ctx: any = { message: { open, destroy: vi.fn() } };
+
+    await showMessage.handler(ctx, {
+      value: { type: 'info', content: 'hello', duration: 0 },
+    });
+
+    const options = open.mock.calls[0][0];
+    expect(open).toHaveBeenCalledWith(
+      expect.objectContaining({
+        duration: 0,
+        content: expect.any(Object),
+      }),
+    );
+    expect(options.content.props.children[1].props['aria-label']).toBe('close message');
+  });
+
+  it('normalizes decimal duration to integer', async () => {
+    const open = vi.fn();
+    const ctx: any = { message: { open } };
+
+    await showMessage.handler(ctx, {
+      value: { type: 'success', content: 'ok', duration: 2.9 },
+    });
+
+    expect(open).toHaveBeenCalledWith(
+      expect.objectContaining({
+        duration: 2,
+      }),
+    );
+  });
+});
+
+describe('showNotification action', () => {
+  it('normalizes decimal duration to integer', async () => {
+    const open = vi.fn();
+    const ctx: any = { notification: { open } };
+
+    await showNotification.handler(ctx, {
+      value: { type: 'info', title: 'title', description: 'desc', duration: 4.9, placement: 'topRight' },
+    });
+
+    expect(open).toHaveBeenCalledWith(
+      expect.objectContaining({
+        duration: 4,
+      }),
+    );
+  });
+
+  it('keeps duration as 0 when no auto close', async () => {
+    const open = vi.fn();
+    const ctx: any = { notification: { open } };
+
+    await showNotification.handler(ctx, {
+      value: { type: 'warning', title: 'title', description: 'desc', duration: 0, placement: 'topRight' },
+    });
+
+    expect(open).toHaveBeenCalledWith(
+      expect.objectContaining({
+        duration: 0,
+      }),
+    );
+  });
+});

package/src/flow/actions/__tests__/subFormFieldLinkageRules.inputArgs.test.ts

@@ -0,0 +1,173 @@
+/**
+ * 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, vi } from 'vitest';
+import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
+import { subFormFieldLinkageRules } from '../linkageRules';
+import { SubFormFieldModel, SubFormListFieldModel } from '../../models/fields/AssociationFieldModel/SubFormFieldModel';
+
+describe('subFormFieldLinkageRules action', () => {
+  it('passes inputArgs to fork runtime context', async () => {
+    const linkageAssignHandler = vi.fn();
+    const engine = new FlowEngine();
+    const forkModel = new FlowModel({ uid: 'fork-model', flowEngine: engine }) as any;
+    forkModel.hidden = false;
+    forkModel.getAction = vi.fn((name: string) => {
+      if (name === 'linkageAssignField') {
+        return {
+          handler: linkageAssignHandler,
+        };
+      }
+    });
+    forkModel.context.defineProperty('app', {
+      value: {
+        jsonLogic: {
+          apply: () => true,
+        },
+      },
+    });
+
+    const ctx: any = {
+      model: {
+        hidden: false,
+        subModels: {
+          grid: {
+            forks: [forkModel],
+          },
+        },
+      },
+      flowKey: 'eventSettings',
+      inputArgs: {
+        source: 'user',
+        changedPaths: [['users', 0, 'name']],
+      },
+    };
+
+    await subFormFieldLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'rule-1',
+          title: 'rule-1',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [
+            {
+              name: 'linkageAssignField',
+              params: {
+                value: [
+                  {
+                    key: 'r1',
+                    enable: true,
+                    targetPath: 'foo',
+                    mode: 'assign',
+                    value: 'bar',
+                    condition: { logic: '$and', items: [] },
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(linkageAssignHandler).toHaveBeenCalledTimes(1);
+    const actionCtx = linkageAssignHandler.mock.calls[0][0];
+    expect(actionCtx.inputArgs).toEqual({
+      source: 'user',
+      changedPaths: [['users', 0, 'name']],
+    });
+  });
+
+  it('passes linkageScopeDepth to fork runtime context', async () => {
+    const linkageAssignHandler = vi.fn();
+    const engine = new FlowEngine();
+    const forkModel = new FlowModel({ uid: 'fork-model-depth', flowEngine: engine }) as any;
+    forkModel.hidden = false;
+    forkModel.getAction = vi.fn((name: string) => {
+      if (name === 'linkageAssignField') {
+        return {
+          handler: linkageAssignHandler,
+        };
+      }
+    });
+    forkModel.context.defineProperty('app', {
+      value: {
+        jsonLogic: {
+          apply: () => true,
+        },
+      },
+    });
+
+    const nestedSubFormModel = {
+      parent: {
+        parent: {
+          parent: null,
+        },
+      },
+    };
+    Object.setPrototypeOf(nestedSubFormModel.parent.parent, SubFormListFieldModel.prototype);
+    Object.setPrototypeOf(nestedSubFormModel.parent, SubFormFieldModel.prototype);
+
+    const ctx: any = {
+      model: {
+        ...nestedSubFormModel,
+        hidden: false,
+        subModels: {
+          grid: {
+            forks: [forkModel],
+          },
+        },
+      },
+      flowKey: 'eventSettings',
+      inputArgs: {
+        source: 'user',
+        txId: 'tx-1',
+        changedPaths: [['users', 0, 'name']],
+      },
+    };
+
+    await subFormFieldLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'rule-1',
+          title: 'rule-1',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [
+            {
+              name: 'linkageAssignField',
+              params: {
+                value: [
+                  {
+                    key: 'r1',
+                    enable: true,
+                    targetPath: 'foo',
+                    mode: 'assign',
+                    value: 'bar',
+                    condition: { logic: '$and', items: [] },
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(linkageAssignHandler).toHaveBeenCalledTimes(1);
+    const actionCtx = linkageAssignHandler.mock.calls[0][0];
+    expect(actionCtx.linkageScopeDepth).toBe(2);
+    expect(actionCtx.inputArgs).toEqual({
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['users', 0, 'name']],
+    });
+  });
+});

package/src/flow/actions/aclCheck.tsx

@@ -0,0 +1,46 @@
+/**
+ * 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 { defineAction } from '@nocobase/flow-engine';
+
+const getRecordPkValue = (value: any) => {
+  if (!value) return undefined;
+
+  // 如果是对象，取第一个 value
+  if (typeof value === 'object') {
+    return Object.values(value)[0];
+  }
+
+  // 原始值（number / string）
+  return value;
+};
+
+export const aclCheck = defineAction({
+  name: 'aclCheck',
+  async handler(ctx, params) {
+    const result = await ctx.aclCheck({
+      dataSourceKey: ctx.dataSource?.key,
+      resourceName: ctx.collectionField?.collectionName || ctx.resourceName,
+      actionName: ctx.actionName,
+      fields: ctx?.collectionField && [ctx.collectionField.name],
+      allowedActions: ctx.collectionField ? null : ctx.resource?.getMeta('allowedActions'),
+      recordPkValue: getRecordPkValue(ctx?.record && ctx.collection?.getFilterByTK?.(ctx?.record)),
+    });
+    if (!ctx.actionName) {
+      return;
+    }
+    if (!result) {
+      ctx.model.hidden = true;
+      ctx.model.forbidden = {
+        actionName: ctx.actionName,
+      };
+      ctx.exitAll();
+    }
+  },
+});