@nocobase/client-v2 2.1.32 → 2.1.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.32",
+  "version": "2.1.34",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -27,11 +27,11 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/evaluators": "2.1.32",
-    "@nocobase/flow-engine": "2.1.32",
-    "@nocobase/sdk": "2.1.32",
-    "@nocobase/shared": "2.1.32",
-    "@nocobase/utils": "2.1.32",
+    "@nocobase/evaluators": "2.1.34",
+    "@nocobase/flow-engine": "2.1.34",
+    "@nocobase/sdk": "2.1.34",
+    "@nocobase/shared": "2.1.34",
+    "@nocobase/utils": "2.1.34",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -48,5 +48,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "737a1324f650d7bc66594203b68eb0180553a551"
+  "gitHead": "6d4dfdfbde69698ed1c2ed54108a8f6736e56e10"
 }

package/src/flow/models/base/CollectionBlockModel.tsx

@@ -82,6 +82,15 @@ export class CollectionBlockModel<T = DefaultStructure> extends DataBlockModel<T
     const engine = this.context.engine as FlowEngine;
     const currentVersion = this.getDirtyTrackingVersion(engine, dataSourceKey, resource, params);
 
+    if (resource instanceof MultiRecordResource && this.getDataLoadingMode() === 'manual' && !this.hasActiveFilters()) {
+      resource.setData([]);
+      resource.setMeta({ count: 0, hasNext: false });
+      resource.setPage(1);
+      resource.loading = false;
+      this.lastSeenDirtyVersion = currentVersion;
+      return;
+    }
+
     if (forceRefresh) {
       if (this.dirtyRefreshing) return;
       this.dirtyRefreshing = true;

package/src/flow/models/base/__tests__/CollectionBlockModel.initialBeforeRenderRefresh.test.ts

@@ -128,4 +128,64 @@ describe('CollectionBlockModel initial beforeRender refresh', () => {
     expect(resource.getData()).toEqual([]);
     expect(resource.getMeta('count')).toBe(0);
   });
+
+  it('skips forced active refresh in manual mode when filters are empty', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh');
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true });
+    resource.setPage(2);
+    resource.loading = true;
+
+    model.onActive(true);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(refreshSpy).not.toHaveBeenCalled();
+    expect(resource.getData()).toEqual([]);
+    expect(resource.getMeta('count')).toBe(0);
+    expect(resource.getMeta('hasNext')).toBe(false);
+    expect(resource.getMeta('page')).toBe(1);
+    expect(resource.getRequestParameter('page')).toBe(1);
+    expect(resource.loading).toBe(false);
+  });
+
+  it('keeps forced active refresh in manual mode when filters are active', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh').mockResolvedValue();
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true, page: 2 });
+    model.setFilterActive('filter-form-item', true);
+
+    model.onActive(true);
+    await Promise.resolve();
+
+    expect(refreshSpy).toHaveBeenCalledTimes(1);
+    expect(resource.getData()).toEqual([{ id: 2, name: 'Stale' }]);
+    expect(resource.getMeta('count')).toBe(1);
+  });
+
+  it('skips forced active refresh in manual mode when only resource filters are active', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh');
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true });
+    resource.setPage(2);
+    resource.loading = true;
+    resource.addFilterGroup('data-scope', { status: { $eq: 'active' } });
+
+    model.onActive(true);
+    await Promise.resolve();
+
+    expect(refreshSpy).not.toHaveBeenCalled();
+    expect(resource.getData()).toEqual([]);
+    expect(resource.getMeta('count')).toBe(0);
+    expect(resource.getMeta('hasNext')).toBe(false);
+    expect(resource.getMeta('page')).toBe(1);
+    expect(resource.getRequestParameter('page')).toBe(1);
+    expect(resource.loading).toBe(false);
+  });
 });

package/src/flow/models/fields/JsonFieldModel.tsx

@@ -13,6 +13,22 @@ import JSON5 from 'json5';
 import React, { useState, useEffect, useRef } from 'react';
 import { FieldModel } from '../base/FieldModel';
 
+const jsonValidationRuleMarker = '__jsonSyntaxValidation';
+
+interface JsonValidationRule {
+  [jsonValidationRuleMarker]: true;
+  type: 'any';
+  validator?: (_rule: unknown, value: unknown) => Promise<void>;
+}
+
+function isRuleObject(rule: unknown): rule is Record<string, unknown> {
+  return typeof rule === 'object' && rule !== null;
+}
+
+function isJsonValidationRule(rule: unknown): rule is JsonValidationRule {
+  return isRuleObject(rule) && rule[jsonValidationRuleMarker] === true;
+}
+
 const jsonCss = css`
   font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;
   font-size: 14px;
@@ -40,7 +56,7 @@ export const JsonInput = observer((props: any) => {
     }
 
     internalChange.current = false;
-  }, [value]);
+  }, [_JSON, space, value]);
 
   // 用户输入时
   const handleChange = (ev) => {
@@ -91,23 +107,30 @@ JsonFieldModel.registerFlow({
   key: 'jsonInitSetting',
   steps: {
     initValidation: {
-      handler(ctx, params) {
-        const rules = ctx.model.parent.props.rules || [];
+      handler(ctx) {
+        const currentRules = Array.isArray(ctx.model.parent.props.rules) ? ctx.model.parent.props.rules : [];
+        const rules = currentRules.filter((rule: unknown) => {
+          return (!isRuleObject(rule) || Object.keys(rule).length > 0) && !isJsonValidationRule(rule);
+        });
         // 添加 JSON 语法校验规则
         rules.push({
-          validator: (_, value) => {
+          // validator 函数序列化后会被丢弃；保留 any 类型可避免持久化规则退化为默认字符串校验。
+          type: 'any',
+          [jsonValidationRuleMarker]: true,
+          validator: (_rule: unknown, value: unknown) => {
             // 允许空
             if (value === null || value === undefined || value === '') return Promise.resolve();
             // 如果已经是对象/数组，直接通过
             if (typeof value === 'object') return Promise.resolve();
             try {
-              JSON.parse(value);
+              JSON.parse(String(value));
               return Promise.resolve();
-            } catch (err) {
-              return Promise.reject(ctx.t('Invalid JSON format') + ': ' + err.message);
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              return Promise.reject(ctx.t('Invalid JSON format') + ': ' + message);
             }
           },
-        });
+        } satisfies JsonValidationRule);
         ctx.model.parent.setProps({
           rules,
         });

package/src/flow/models/fields/__tests__/JsonFieldModel.test.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 } from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+import { JsonFieldModel } from '../JsonFieldModel';
+
+interface ValidationRule {
+  required?: boolean;
+  type?: string;
+  validator?: (_rule: unknown, value: unknown) => Promise<void>;
+}
+
+function createModels(rules: ValidationRule[]) {
+  const engine = new FlowEngine();
+  engine.registerModels({ JsonFieldModel });
+  const parent = engine.createModel<FlowModel<{ subModels: { field: JsonFieldModel } }>>({
+    use: FlowModel,
+    uid: 'json-form-item',
+    props: { rules },
+    subModels: {
+      field: {
+        use: JsonFieldModel,
+        uid: 'json-field',
+      },
+    },
+  });
+
+  return { field: parent.subModels.field, parent };
+}
+
+function initializeJsonValidation(field: JsonFieldModel) {
+  const step = field.getFlow('jsonInitSetting')?.steps.initValidation;
+  if (!step) {
+    throw new Error('JSON validation step is not registered');
+  }
+  step.handler(field.context, {});
+}
+
+describe('JsonFieldModel validation', () => {
+  it('replaces legacy empty rules with one serializable JSON validation rule', async () => {
+    const { field, parent } = createModels([{}, { required: true }]);
+
+    initializeJsonValidation(field);
+
+    const rules = parent.props.rules as ValidationRule[];
+    expect(rules).toHaveLength(2);
+    expect(rules[0]).toEqual({ required: true });
+    expect(rules[1]).toMatchObject({ type: 'any' });
+    expect(rules[1].validator).toBeTypeOf('function');
+    if (!rules[1].validator) {
+      throw new Error('JSON validator is missing');
+    }
+    await expect(rules[1].validator({}, { name: 'NocoBase' })).resolves.toBeUndefined();
+    await expect(rules[1].validator({}, '{"name":')).rejects.toContain('Invalid JSON format');
+
+    const persistedRules = JSON.parse(JSON.stringify(parent.serialize())).props.rules as ValidationRule[];
+    expect(persistedRules).toHaveLength(2);
+    expect(persistedRules[1]).toMatchObject({ type: 'any' });
+    expect(persistedRules[1].validator).toBeUndefined();
+  });
+
+  it('re-registers the runtime validator without duplicating its persisted placeholder', () => {
+    const { field, parent } = createModels([{}]);
+    initializeJsonValidation(field);
+    const persistedRules = JSON.parse(JSON.stringify(parent.serialize())).props.rules as ValidationRule[];
+    parent.setProps({ rules: persistedRules });
+
+    initializeJsonValidation(field);
+
+    const rules = parent.props.rules as ValidationRule[];
+    expect(rules).toHaveLength(1);
+    expect(rules[0]).toMatchObject({ type: 'any' });
+    expect(rules[0].validator).toBeTypeOf('function');
+  });
+});