@nocobase/client-v2 2.1.0-beta.29 → 2.1.0-beta.32

package/src/components/form/FileSizeInput.tsx

@@ -0,0 +1,105 @@
+/**
+ * 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 { css } from '@emotion/css';
+import { InputNumber, Select, Space } from 'antd';
+import React, { useCallback } from 'react';
+
+const DEFAULT_MIN = 1;
+const DEFAULT_MAX = Number.POSITIVE_INFINITY;
+const DEFAULT_VALUE = 1024 * 1024 * 20;
+
+const UNIT_OPTIONS = [
+  { value: 1, label: 'Byte' },
+  { value: 1024, label: 'KB' },
+  { value: 1024 * 1024, label: 'MB' },
+  { value: 1024 * 1024 * 1024, label: 'GB' },
+];
+
+// Mirrors v1's `.auto-width` rule registered globally on FormItem: shrink the
+// antd control to its content width while keeping a sensible minimum.
+const autoWidthClassName = css`
+  &.ant-input-number,
+  &.ant-select {
+    width: auto;
+    min-width: 6em;
+  }
+`;
+
+function getUnitOption(value: number, defaultUnit = 1024 * 1024) {
+  const size = value || defaultUnit;
+  for (let i = UNIT_OPTIONS.length - 1; i >= 0; i -= 1) {
+    const option = UNIT_OPTIONS[i];
+    if (size % option.value === 0) {
+      return option;
+    }
+  }
+  return UNIT_OPTIONS[0];
+}
+
+function clampSize(value: number, min: number, max: number) {
+  return Math.min(Math.max(min, value), max);
+}
+
+export interface FileSizeInputProps {
+  value?: number;
+  onChange?: (value?: number) => void;
+  disabled?: boolean;
+  /** Minimum byte size. Empty / below-min input snaps to this on blur. Defaults to 1. */
+  min?: number;
+  /** Maximum byte size. Defaults to `Number.POSITIVE_INFINITY`. */
+  max?: number;
+  /** Default byte size used to derive the initial unit shown when the field is empty. Defaults to 20 MB. */
+  defaultValue?: number;
+}
+
+/**
+ * Byte-valued size input paired with a unit selector (Byte / KB / MB / GB).
+ * The persisted value is always normalized to bytes; the displayed number is
+ * derived from the picked unit. Useful for fields like file-size limits or
+ * memory quotas where the natural input unit varies by magnitude.
+ */
+export function FileSizeInput(props: FileSizeInputProps) {
+  const min = props.min ?? DEFAULT_MIN;
+  const max = props.max ?? DEFAULT_MAX;
+  const defaultValue = props.defaultValue ?? DEFAULT_VALUE;
+  const unit = getUnitOption(props.value ?? defaultValue);
+  const value = props.value == null ? props.value : props.value / unit.value;
+
+  const handleBlur = useCallback(() => {
+    if (props.value == null || props.value < min) {
+      props.onChange?.(min);
+    }
+  }, [props, min]);
+
+  return (
+    <Space.Compact>
+      <InputNumber
+        value={value}
+        disabled={props.disabled}
+        defaultValue={defaultValue / getUnitOption(defaultValue).value}
+        step={1}
+        className={autoWidthClassName}
+        onBlur={handleBlur}
+        onChange={(nextValue) => {
+          props.onChange?.(nextValue == null ? undefined : clampSize(Number(nextValue) * unit.value, min, max));
+        }}
+      />
+      <Select
+        disabled={props.disabled}
+        options={UNIT_OPTIONS}
+        value={unit.value}
+        className={autoWidthClassName}
+        onChange={(nextUnit) => {
+          props.onChange?.(value == null ? undefined : clampSize(Number(value) * nextUnit, min, max));
+        }}
+      />
+    </Space.Compact>
+  );
+}

package/src/components/form/createFormRegistry.ts

@@ -0,0 +1,60 @@
+/**
+ * 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.
+ */
+
+export interface FormRegistryEntry {
+  name: string;
+}
+
+export interface FormRegistry<T extends FormRegistryEntry> {
+  readonly namespace: string;
+  register(entry: T): void;
+  unregister(name: string): boolean;
+  get(name: string): T | undefined;
+  has(name: string): boolean;
+  list(): T[];
+}
+
+/**
+ * Create an isolated, namespaced registry of form-like entries.
+ *
+ * Each call returns a fresh registry instance backed by its own closure-scoped
+ * `Map`, so plugins do not share state across namespaces. Plugins that need an
+ * extension point for form-shaped registrations (e.g. storage configuration
+ * forms, data-source connection forms) can build their own typed registry on
+ * top of this primitive instead of re-implementing the same boilerplate.
+ *
+ * Re-registering the same `name` overwrites the previous entry and emits a
+ * console warning. This is intentional so HMR / hot reload works without
+ * throwing, while still surfacing unintended duplicates during development.
+ */
+export function createFormRegistry<T extends FormRegistryEntry>(namespace: string): FormRegistry<T> {
+  const entries = new Map<string, T>();
+
+  return {
+    namespace,
+    register(entry) {
+      if (entries.has(entry.name)) {
+        console.warn(`[${namespace}] entry "${entry.name}" already registered, overwriting.`);
+      }
+      entries.set(entry.name, entry);
+    },
+    unregister(name) {
+      return entries.delete(name);
+    },
+    get(name) {
+      return entries.get(name);
+    },
+    has(name) {
+      return entries.has(name);
+    },
+    list() {
+      return Array.from(entries.values());
+    },
+  };
+}

package/src/components/form/index.tsx

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+
+export * from './createFormRegistry';
+export * from './DrawerFormLayout';
+export * from './EnvVariableInput';
+export * from './FileSizeInput';
+export * from './JsonTextArea';

package/src/components/index.ts

@@ -9,6 +9,6 @@
 
 export * from './AppComponents';
 export * from './BlankComponent';
+export * from './form';
 export * from './Icon';
-export * from './form/JsonTextArea';
 export * from './RouterContextCleaner';

package/src/flow/__tests__/FlowRoute.test.tsx

@@ -10,7 +10,7 @@
 import React from 'react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { MemoryRouter, Route, Routes } from 'react-router-dom';
-import { render, waitFor } from '@testing-library/react';
+import { render, screen, waitFor } from '@testing-library/react';
 import { FlowEngine, FlowEngineProvider, type FlowModel } from '@nocobase/flow-engine';
 import FlowRoute from '../components/FlowRoute';
 
@@ -219,7 +219,7 @@ describe('FlowRoute', () => {
     });
   });
 
-  it('should replace to legacy page when current route is page', async () => {
+  it('should show 404 when current route is a legacy page in v2 runtime', async () => {
     const originalLocation = window.location;
     const replace = vi.fn();
     Object.defineProperty(window, 'location', {
@@ -271,9 +271,8 @@ describe('FlowRoute', () => {
         </FlowEngineProvider>,
       );
 
-      await waitFor(() => {
-        expect(replace).toHaveBeenCalledWith('/admin/test-page/tabs/tab-1?from=direct#dialog');
-      });
+      expect(await screen.findByText('404')).toBeInTheDocument();
+      expect(replace).not.toHaveBeenCalled();
       expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalled();
       expect(adminLayoutModel.updateRoutePage).not.toHaveBeenCalled();
     } finally {

package/src/flow/actions/__tests__/actionLinkageRules.race.repro.test.ts

@@ -0,0 +1,199 @@
+/**
+ * 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 { actionLinkageRules } from '../linkageRules';
+
+function createActionModel() {
+  const model: any = {
+    uid: 'edit-action',
+    hidden: false,
+    props: {
+      title: 'Edit',
+    },
+    context: {},
+    setProps: vi.fn((keyOrProps: string | Record<string, any>, value?: any) => {
+      if (typeof keyOrProps === 'string') {
+        model.props[keyOrProps] = value;
+        return;
+      }
+      model.props = {
+        ...model.props,
+        ...keyOrProps,
+      };
+    }),
+  };
+
+  return model;
+}
+
+function createLinkageParams(actions: any[] = []) {
+  return {
+    value: actions.length
+      ? [
+          {
+            key: 'hide-edit',
+            title: 'hide edit',
+            enable: true,
+            condition: {
+              logic: '$and',
+              items: [],
+            },
+            actions,
+          },
+        ]
+      : [],
+  };
+}
+
+function createRuntime(model: any, options: { pauseHiddenAction?: boolean } = {}) {
+  const { pauseHiddenAction = true } = options;
+  let releaseHiddenAction: () => void = () => {};
+  let hiddenActionCount = 0;
+  const hiddenActionWaiters: Array<{ count: number; resolve: () => void }> = [];
+  const waitForHiddenActionCount = (count: number) => {
+    if (hiddenActionCount >= count) {
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      hiddenActionWaiters.push({ count, resolve });
+    });
+  };
+  const hiddenActionReachedPromise = waitForHiddenActionCount(1);
+  const releaseHiddenActionPromise = new Promise<void>((resolve) => {
+    releaseHiddenAction = resolve;
+  });
+  const notifyHiddenActionReached = () => {
+    hiddenActionCount += 1;
+    for (let i = hiddenActionWaiters.length - 1; i >= 0; i--) {
+      const waiter = hiddenActionWaiters[i];
+      if (hiddenActionCount < waiter.count) continue;
+      hiddenActionWaiters.splice(i, 1);
+      waiter.resolve();
+    }
+  };
+
+  const ctx: any = {
+    flowKey: 'buttonSettings',
+    model,
+    app: {
+      jsonLogic: {
+        apply: vi.fn(() => true),
+      },
+    },
+    t: (s: string) => s,
+    resolveJsonTemplate: vi.fn(async (value: any) => value),
+    getAction: (name: string) => {
+      if (name !== 'linkageSetActionProps') return undefined;
+
+      return {
+        handler: async (_ctx: any, params: any) => {
+          params.setProps(model, {
+            hiddenModel: params.value === 'hidden',
+            disabled: false,
+            hiddenText: false,
+          });
+          notifyHiddenActionReached();
+          if (pauseHiddenAction) {
+            await releaseHiddenActionPromise;
+          }
+        },
+      };
+    },
+  };
+
+  return {
+    ctx,
+    hiddenActionReachedPromise,
+    waitForHiddenActionCount,
+    releaseHiddenAction,
+  };
+}
+
+describe('actionLinkageRules props patch isolation', () => {
+  async function runReproOnce() {
+    const model = createActionModel();
+    const { ctx, hiddenActionReachedPromise, releaseHiddenAction } = createRuntime(model);
+
+    const hideRun = actionLinkageRules.handler(
+      ctx,
+      createLinkageParams([
+        {
+          name: 'linkageSetActionProps',
+          params: {
+            value: 'hidden',
+          },
+        },
+      ]),
+    );
+
+    await hiddenActionReachedPromise;
+    expect(model.hidden).toBe(false);
+
+    await actionLinkageRules.handler(ctx, createLinkageParams());
+    expect(model.hidden).toBe(false);
+
+    releaseHiddenAction();
+    await hideRun;
+
+    expect(model.hidden).toBe(true);
+  }
+
+  it('keeps a concurrent empty run from clearing another run props patch', async () => {
+    for (let i = 0; i < 50; i++) {
+      await runReproOnce();
+    }
+  });
+
+  it('still restores original props when a later completed run has no matched actions', async () => {
+    const model = createActionModel();
+    const { ctx } = createRuntime(model, { pauseHiddenAction: false });
+
+    await actionLinkageRules.handler(
+      ctx,
+      createLinkageParams([
+        {
+          name: 'linkageSetActionProps',
+          params: {
+            value: 'hidden',
+          },
+        },
+      ]),
+    );
+    expect(model.hidden).toBe(true);
+
+    await actionLinkageRules.handler(ctx, createLinkageParams());
+    expect(model.hidden).toBe(false);
+  });
+
+  it('keeps concurrent matched runs from clearing each other props patch', async () => {
+    const model = createActionModel();
+    const { ctx, waitForHiddenActionCount, releaseHiddenAction } = createRuntime(model);
+    const params = createLinkageParams([
+      {
+        name: 'linkageSetActionProps',
+        params: {
+          value: 'hidden',
+        },
+      },
+    ]);
+
+    const firstRun = actionLinkageRules.handler(ctx, params);
+    await waitForHiddenActionCount(1);
+
+    const secondRun = actionLinkageRules.handler(ctx, params);
+    await waitForHiddenActionCount(2);
+
+    releaseHiddenAction();
+    await firstRun;
+    await secondRun;
+
+    expect(model.hidden).toBe(true);
+  });
+});

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

@@ -8,10 +8,31 @@
  */
 
 import { describe, expect, it, vi } from 'vitest';
+import { FlowEngine, MultiRecordResource } from '@nocobase/flow-engine';
 import { dataScope } from '../dataScope';
 import { normalizeDataScopeFilter } from '../dataScopeFilter';
 import { setTargetDataScope } from '../setTargetDataScope';
 
+function createSetTargetDataScopeContext(resource: any, options: { selected?: boolean; resolvedValue?: any } = {}) {
+  const targetModel = { resource };
+  const inputArgs = options.selected === undefined ? undefined : { selected: options.selected };
+
+  return {
+    ...(inputArgs ? { inputArgs } : {}),
+    model: {
+      uid: 'action-1',
+      scheduleModelOperation: vi.fn((_uid, callback) => callback(targetModel)),
+    },
+    resolveJsonTemplate: vi.fn(async (template) => ({
+      ...template,
+      filter: {
+        ...template.filter,
+        items: [{ ...template.filter.items[0], value: options.resolvedValue }],
+      },
+    })),
+  };
+}
+
 describe('normalizeDataScopeFilter', () => {
   it('keeps null when a right-side variable resolves to empty', () => {
     const rawFilter = {
@@ -125,34 +146,92 @@ describe('normalizeDataScopeFilter', () => {
       hasData: vi.fn(() => false),
       refresh: vi.fn(),
     };
-    const targetModel = { resource };
-    const ctx = {
-      model: {
-        uid: 'action-1',
-        scheduleModelOperation: vi.fn((_uid, callback) => callback(targetModel)),
+    const ctx = createSetTargetDataScopeContext(resource);
+    const params = {
+      targetBlockUid: 'target-1',
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
       },
-      resolveJsonTemplate: vi.fn(async (template) => ({
-        ...template,
-        filter: {
-          ...template.filter,
-          items: [{ ...template.filter.items[0], value: undefined }],
-        },
-      })),
     };
+
+    await (setTargetDataScope as any).handler(ctx, params);
+
+    expect(ctx.model.scheduleModelOperation).toHaveBeenCalledWith('target-1', expect.any(Function));
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('setTargetDataScope_action-1', {
+      $and: [{ departmentId: { $eq: null } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+
+  it('setTargetDataScope handler removes clicked-row data scope when row click deselects', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+      hasData: vi.fn(() => true),
+      refresh: vi.fn(),
+    };
+    const ctx = createSetTargetDataScopeContext(resource, { selected: false, resolvedValue: null });
     const params = {
       targetBlockUid: 'target-1',
       filter: {
         logic: '$and',
-        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+        items: [{ path: 'id', operator: '$eq', value: '{{ ctx.clickedRowRecord.id }}' }],
       },
     };
 
     await (setTargetDataScope as any).handler(ctx, params);
 
     expect(ctx.model.scheduleModelOperation).toHaveBeenCalledWith('target-1', expect.any(Function));
+    expect(resource.removeFilterGroup).toHaveBeenCalledWith('setTargetDataScope_action-1');
+    expect(resource.addFilterGroup).not.toHaveBeenCalled();
+    expect(resource.refresh).toHaveBeenCalledTimes(1);
+  });
+
+  it('setTargetDataScope handler keeps null clicked-row field values while row is selected', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+      hasData: vi.fn(() => false),
+      refresh: vi.fn(),
+    };
+    const ctx = createSetTargetDataScopeContext(resource, { selected: true, resolvedValue: null });
+    const params = {
+      targetBlockUid: 'target-1',
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.clickedRowRecord.departmentId }}' }],
+      },
+    };
+
+    await (setTargetDataScope as any).handler(ctx, params);
+
     expect(resource.addFilterGroup).toHaveBeenCalledWith('setTargetDataScope_action-1', {
       $and: [{ departmentId: { $eq: null } }],
     });
     expect(resource.removeFilterGroup).not.toHaveBeenCalled();
   });
+
+  it('setTargetDataScope handler refreshes empty loaded target while preserving its own data scope', async () => {
+    const engine = new FlowEngine();
+    const resource = engine.createResource(MultiRecordResource);
+    resource.addFilterGroup('target-table', { status: { $eq: 'active' } });
+    resource.addFilterGroup('setTargetDataScope_action-1', { id: { $eq: 1 } });
+    resource.setData([]);
+    resource.setMeta({ count: 0, hasNext: false });
+    const refresh = vi.spyOn(resource, 'refresh').mockResolvedValue(undefined);
+    const ctx = createSetTargetDataScopeContext(resource, { selected: false, resolvedValue: null });
+    const params = {
+      targetBlockUid: 'target-1',
+      filter: {
+        logic: '$and',
+        items: [{ path: 'id', operator: '$eq', value: '{{ ctx.clickedRowRecord.id }}' }],
+      },
+    };
+
+    await (setTargetDataScope as any).handler(ctx, params);
+
+    expect(resource.getRequestParameter('filter')).toBe(JSON.stringify({ $and: [{ status: { $eq: 'active' } }] }));
+    expect(refresh).toHaveBeenCalledTimes(1);
+  });
 });

package/src/flow/actions/__tests__/linkageRules.formValueDrivenRefresh.test.ts

@@ -26,7 +26,12 @@ function createRule(overrides: any = {}) {
 
 function createRuntime(
   params: any,
-  options: { fieldIndex?: string[]; fieldIndexRef?: { current: string[] }; actionHandler?: any; engineEmitter?: any } = {},
+  options: {
+    fieldIndex?: string[];
+    fieldIndexRef?: { current: string[] };
+    actionHandler?: any;
+    engineEmitter?: any;
+  } = {},
 ) {
   const formEmitter = new EventEmitter();
   const formBlock: any = {

package/src/flow/actions/__tests__/linkageRules.menu.test.ts

@@ -0,0 +1,90 @@
+/**
+ * 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 { ActionScene } from '@nocobase/flow-engine';
+import { describe, expect, it, vi } from 'vitest';
+
+import * as registeredActions from '../index';
+import { linkageRunjs, linkageSetMenuItemProps, menuLinkageRules } from '../linkageRules';
+
+describe('menu linkage rules', () => {
+  it('should register menu linkage actions from the actions entry', () => {
+    expect(registeredActions.menuLinkageRules).toBe(menuLinkageRules);
+    expect(registeredActions.linkageSetMenuItemProps).toBe(linkageSetMenuItemProps);
+  });
+
+  it('should expose menu state and runjs actions in ui schema', () => {
+    const schema = menuLinkageRules.uiSchema?.({
+      getActions: () =>
+        new Map([
+          ['linkageSetMenuItemProps', linkageSetMenuItemProps],
+          ['linkageRunjs', linkageRunjs],
+          [
+            'actionOnly',
+            {
+              name: 'actionOnly',
+              scene: ActionScene.ACTION_LINKAGE_RULES,
+            },
+          ],
+        ]),
+    } as any) as any;
+
+    expect(schema?.value?.['x-component-props']?.supportedActions).toEqual(['linkageSetMenuItemProps', 'linkageRunjs']);
+  });
+
+  it('should set menu model hidden through common linkage handler', async () => {
+    const setProps = vi.fn(function (this: any, props: any) {
+      this.props = {
+        ...this.props,
+        ...props,
+      };
+    });
+    const setHidden = vi.fn(function (this: any, value: boolean) {
+      this.hidden = value;
+    });
+    const model: any = {
+      uid: 'menu-item-1',
+      props: {},
+      hidden: false,
+      __allModels: [],
+      setProps,
+      setHidden,
+    };
+    const ctx: any = {
+      app: { jsonLogic: { apply: () => true } },
+      model,
+      t: (text: string) => text,
+      getAction: (name: string) => (name === 'linkageSetMenuItemProps' ? linkageSetMenuItemProps : undefined),
+      resolveJsonTemplate: vi.fn(async (value: any) => value),
+    };
+
+    await menuLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'r1',
+          title: 'Hide menu item',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [
+            {
+              key: 'a1',
+              name: 'linkageSetMenuItemProps',
+              params: {
+                value: 'hidden',
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(setHidden).toHaveBeenCalledWith(true);
+    expect(model.hidden).toBe(true);
+  });
+});