@nocobase/flow-engine 2.3.0-beta.10 → 2.3.0-beta.11

package/lib/data-source/jioToJoiSchema.js

@@ -94,7 +94,15 @@ function jioToJoiSchema(jioConfig) {
     if (name === "required") hasRequired = true;
     if (typeof schema[name] === "function") {
       try {
-        schema = schema[name](...getArgs(name, args));
+        if (jioConfig.type === "number" && name === "precision") {
+          const precisionSchema = import_joi.default.number().precision(getArgs(name, args)[0]).strict();
+          schema = schema.custom((value, helpers) => {
+            const { error } = precisionSchema.validate(value);
+            return error ? helpers.error("number.precision", error.details[0].context) : value;
+          });
+        } else {
+          schema = schema[name](...getArgs(name, args));
+        }
       } catch (err) {
         console.warn(`\u8C03\u7528 Joi \u65B9\u6CD5 ${name} \u5931\u8D25:`, err);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.3.0-beta.10",
+  "version": "2.3.0-beta.11",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,8 +8,8 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "2.3.0-beta.10",
-    "@nocobase/shared": "2.3.0-beta.10",
+    "@nocobase/sdk": "2.3.0-beta.11",
+    "@nocobase/shared": "2.3.0-beta.11",
     "ahooks": "^3.7.2",
     "axios": "^1.7.0",
     "dayjs": "^1.11.9",
@@ -37,5 +37,5 @@
   ],
   "author": "NocoBase Team",
   "license": "Apache-2.0",
-  "gitHead": "7aa3dce6cf3201752882f7012c72997898015d89"
+  "gitHead": "e81c2c69d55f13e4d237c420a51ebad1e9dae515"
 }

package/src/data-source/__tests__/index.test.ts

@@ -114,6 +114,34 @@ describe('DataSource & Collection APIs', () => {
     await expect(rules[0].validator({}, '123')).rejects.toBe('单行文本 长度必须为 18 个字符');
   });
 
+  it('enforces collection field precision in component validation rules', async () => {
+    const { m, engine } = makeManager();
+    const translate = vi.spyOn(engine, 'translate').mockImplementation((key) => key);
+    const ds = new DataSource({ key: 'main' });
+    m.addDataSource(ds);
+    ds.addCollection({
+      name: 'employees',
+      fields: [
+        {
+          name: 'years',
+          type: 'double',
+          interface: 'number',
+          title: 'Years',
+          validation: { type: 'number', rules: [{ name: 'precision', args: { limit: 2 } }] },
+        },
+      ],
+    });
+    const rules = ds.getCollection('employees').getField('years').getComponentProps().rules;
+
+    await expect(rules[0].validator({}, 39.2234)).rejects.toContain('2 decimal places');
+    expect(translate).toHaveBeenCalledWith(
+      'number.precision',
+      expect.objectContaining({ ns: 'data-source-main', label: 'Years', limit: 2 }),
+    );
+    await expect(rules[0].validator({}, 39.22)).resolves.toBeUndefined();
+    translate.mockRestore();
+  });
+
   it('ensureLoaded, reload and data source events work for main loader', async () => {
     const { m, engine } = makeManager();
     const loadedListener = vi.fn();

package/src/data-source/__tests__/jioToJoiSchema.test.ts

@@ -49,6 +49,57 @@ describe('jioToJoiSchema', () => {
     expect(s2.validate('zz').error).toBeTruthy();
   });
 
+  describe('number precision', () => {
+    const schema = jioToJoiSchema({ type: 'number', rules: [{ name: 'precision', args: { limit: 2 } }] });
+
+    it.each([39.2234, -39.2234, 0.001, 1e-7])('rejects %s without rounding', (value) => {
+      const result = schema.validate(value);
+      expect(result.error?.details[0]).toMatchObject({ type: 'number.precision', context: { limit: 2 } });
+      expect(result.value).toBe(value);
+    });
+
+    it.each([39.22, -39.22, 39.2, 39, 0, 0.01, '', null, undefined])('accepts %s', (value) => {
+      expect(schema.validate(value).error).toBeUndefined();
+    });
+
+    it('supports zero precision', () => {
+      const integerSchema = jioToJoiSchema({ type: 'number', rules: [{ name: 'precision', args: { limit: 0 } }] });
+      expect(integerSchema.validate(39).error).toBeUndefined();
+      expect(integerSchema.validate(39.2).error?.details[0].type).toBe('number.precision');
+    });
+
+    it('validates numeric strings without rounding them', () => {
+      expect(schema.validate('39.22')).toEqual({ value: 39.22 });
+      expect(schema.validate('39.2200')).toEqual({ value: 39.22 });
+      expect(schema.validate('39.2234').error?.details[0].type).toBe('number.precision');
+      expect(schema.validate('1e-7').error?.details[0].type).toBe('number.precision');
+      expect(schema.validate('not a number').error?.details[0].type).toBe('number.base');
+    });
+
+    it('preserves required and min/max validation', () => {
+      const requiredSchema = jioToJoiSchema({
+        type: 'number',
+        rules: [
+          { name: 'precision', args: { limit: 2 } },
+          { name: 'min', args: { limit: 1 } },
+          { name: 'max', args: { limit: 10 } },
+          { name: 'required' },
+        ],
+      });
+      expect(requiredSchema.validate(undefined).error?.details[0].type).toBe('any.required');
+      expect(requiredSchema.validate('').error).toBeDefined();
+      expect(requiredSchema.validate(null).error).toBeDefined();
+      expect(requiredSchema.validate(0.99).error?.details[0].type).toBe('number.min');
+      expect(requiredSchema.validate(10.01).error?.details[0].type).toBe('number.max');
+      expect(requiredSchema.validate(1.23).error).toBeUndefined();
+    });
+
+    it('preserves numeric string conversion when precision is not configured', () => {
+      const numberSchema = jioToJoiSchema({ type: 'number', rules: [{ name: 'min', args: { limit: 1 } }] });
+      expect(numberSchema.validate('39.2234')).toEqual({ value: 39.2234 });
+    });
+  });
+
   it('optional when no required and allows empty string', () => {
     const schema = jioToJoiSchema({ type: 'string' });
     expect(schema.validate('').error).toBeUndefined();

package/src/data-source/jioToJoiSchema.ts

@@ -85,7 +85,16 @@ export function jioToJoiSchema<T extends JioType>(jioConfig: {
     if (name === 'required') hasRequired = true;
     if (typeof schema[name] === 'function') {
       try {
-        schema = schema[name](...getArgs(name, args));
+        if (jioConfig.type === 'number' && name === 'precision') {
+          // Validate precision without rounding, while preserving the outer schema's numeric string conversion.
+          const precisionSchema = Joi.number().precision(getArgs(name, args)[0]).strict();
+          schema = schema.custom((value: number, helpers: Joi.CustomHelpers) => {
+            const { error } = precisionSchema.validate(value);
+            return error ? helpers.error('number.precision', error.details[0].context) : value;
+          });
+        } else {
+          schema = schema[name](...getArgs(name, args));
+        }
       } catch (err) {
         console.warn(`调用 Joi 方法 ${name} 失败:`, err);
       }