@nocobase/flow-engine 2.1.0-beta.26 → 2.1.0-beta.29

package/src/components/variables/index.ts

@@ -8,6 +8,8 @@
  */
 
 export { VariableInput } from './VariableInput';
+export { VariableHybridInput } from './VariableHybridInput';
+export type { VariableHybridInputProps, VariableHybridInputConverters } from './VariableHybridInput';
 export { SlateVariableEditor } from './SlateVariableEditor';
 export { VariableTag } from './VariableTag';
 export { InlineVariableTag } from './InlineVariableTag';

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

@@ -7,8 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { describe, expect, it } from 'vitest';
-import { DataSource, DataSourceManager, isFieldInterfaceMatch } from '../index';
+import { describe, expect, it, vi } from 'vitest';
+import { DataSource, DataSourceManager, getCollectionFieldInterface, isFieldInterfaceMatch } from '../index';
 import { FlowEngine } from '../../flowEngine';
 
 describe('Collection/Field helpers', () => {
@@ -55,4 +55,43 @@ describe('Collection/Field helpers', () => {
     const field = posts.getFieldByPath('category.name');
     expect(field?.name).toBe('name');
   });
+
+  it('resolves collection field interfaces from the first available manager', () => {
+    const first = { collectionFieldInterfaceManager: { getFieldInterface: vi.fn((name) => ({ name })) } };
+    const second = { collectionFieldInterfaceManager: { getFieldInterface: vi.fn((name) => ({ name })) } };
+
+    expect(getCollectionFieldInterface('input', {}, first, second)).toEqual({ name: 'input' });
+    expect(first.collectionFieldInterfaceManager.getFieldInterface).toHaveBeenCalledWith('input');
+    expect(second.collectionFieldInterfaceManager.getFieldInterface).not.toHaveBeenCalled();
+    expect(getCollectionFieldInterface(undefined, first)).toBeUndefined();
+    expect(getCollectionFieldInterface('input', {})).toBeUndefined();
+  });
+
+  it('uses collection field interface resolver from getInterfaceOptions', () => {
+    const { ds, m } = setup();
+    const ctx = m.flowEngine.context;
+    const getOwnerFieldInterface = vi.fn((name: string) => ({ name, source: 'owner' }));
+    const getLegacyFieldInterface = vi.fn((name: string) => ({ name, source: 'legacy' }));
+
+    ctx.defineProperty('app', {
+      value: {
+        dataSourceManager: {
+          collectionFieldInterfaceManager: {
+            getFieldInterface: getLegacyFieldInterface,
+          },
+        },
+      },
+    });
+    ds.addCollection({
+      name: 'posts',
+      fields: [{ name: 'title', type: 'string', interface: 'input' }],
+    });
+
+    const field = ds.getCollection('posts')!.getField('title')!;
+    expect(field.getInterfaceOptions()).toEqual({ name: 'input', source: 'legacy' });
+
+    m.setCollectionFieldInterfaceManager({ getFieldInterface: getOwnerFieldInterface });
+    expect(field.getInterfaceOptions()).toEqual({ name: 'input', source: 'owner' });
+    expect(getLegacyFieldInterface).toHaveBeenCalledTimes(1);
+  });
 });

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

@@ -80,6 +80,40 @@ describe('DataSource & Collection APIs', () => {
     ).toThrow(/circular/);
   });
 
+  it('translates validation messages from data-source-main in component rules', async () => {
+    const { m, engine } = makeManager();
+    engine.context.i18n = {
+      t: (key: string, options?: Record<string, any>) => {
+        if (key === 'string.length' && options?.ns === 'data-source-main') {
+          return `${options.label} 长度必须为 ${options.limit} 个字符`;
+        }
+        return key;
+      },
+    } as any;
+
+    const ds = new DataSource({ key: 'main' });
+    m.addDataSource(ds);
+    ds.addCollection({
+      name: 'posts',
+      fields: [
+        {
+          name: 'title',
+          type: 'string',
+          interface: 'text',
+          title: '单行文本',
+          validation: {
+            type: 'string',
+            rules: [{ name: 'length', args: { limit: 18 } }],
+          },
+        },
+      ],
+    });
+
+    const rules = ds.getCollection('posts')!.getField('title')!.getComponentProps().rules;
+
+    await expect(rules[0].validator({}, '123')).rejects.toBe('单行文本 长度必须为 18 个字符');
+  });
+
   it('ensureLoaded, reload and data source events work for main loader', async () => {
     const { m, engine } = makeManager();
     const loadedListener = vi.fn();

package/src/data-source/index.ts

@@ -295,6 +295,29 @@ export class DataSourceManager {
   }
 }
 
+export type CollectionFieldInterfaceDataSourceManager = Pick<DataSourceManager, 'collectionFieldInterfaceManager'>;
+
+export function getCollectionFieldInterface(
+  interfaceName: string | undefined,
+  ...dataSourceManagers: Array<CollectionFieldInterfaceDataSourceManager | null | undefined>
+) {
+  if (!interfaceName) {
+    return undefined;
+  }
+
+  // TODO: Once legacy client is removed and all runtimes share the client-v2 flow-engine
+  // DataSourceManager, callers should only pass the flow-engine context DataSourceManager.
+  for (const dataSourceManager of dataSourceManagers) {
+    const collectionFieldInterfaceManager = dataSourceManager?.collectionFieldInterfaceManager;
+    const getFieldInterface = collectionFieldInterfaceManager?.getFieldInterface;
+    if (typeof getFieldInterface === 'function') {
+      return getFieldInterface.call(collectionFieldInterfaceManager, interfaceName);
+    }
+  }
+
+  return undefined;
+}
+
 export class DataSource {
   dataSourceManager: DataSourceManager;
   collectionManager: CollectionManager;
@@ -1112,7 +1135,21 @@ export class CollectionField {
           });
 
           if (error) {
-            const message = error.details.map((d: any) => d.message.replace(/"value"/g, `"${label}"`)).join(', ');
+            const message = error.details
+              .map((d: any) => {
+                const translated = this.flowEngine.translate(d.type, {
+                  ...d.context,
+                  ns: 'data-source-main',
+                  label,
+                });
+
+                if (translated && translated !== d.type) {
+                  return translated;
+                }
+
+                return d.message.replace(/"value"/g, `"${label}"`);
+              })
+              .join(', ');
             return Promise.reject(message);
           }
 
@@ -1135,8 +1172,13 @@ export class CollectionField {
   }
 
   getInterfaceOptions() {
-    const app = this.flowEngine.context.app;
-    return app.dataSourceManager.collectionFieldInterfaceManager.getFieldInterface(this.interface);
+    const ctx = this.flowEngine.context;
+    return getCollectionFieldInterface(
+      this.interface,
+      this.collection?.dataSource?.dataSourceManager,
+      ctx.dataSourceManager,
+      ctx.app?.dataSourceManager,
+    );
   }
 
   getFilterOperators() {

package/src/views/ViewNavigation.ts

@@ -26,6 +26,10 @@ function encodeFilterByTk(val: SharedViewParam['filterByTk']): string {
   return encodeURIComponent(String(val));
 }
 
+function hasUsableSourceId(sourceId: unknown): sourceId is string | number {
+  return sourceId !== undefined && sourceId !== null && String(sourceId) !== '';
+}
+
 /**
  * 将 ViewParam 数组转换为 pathname
  *
@@ -65,8 +69,8 @@ export function generatePathnameFromViewParams(viewParams: ViewParams[]): string
         segments.push('filterbytk', encoded);
       }
     }
-    if (viewParam.sourceId) {
-      segments.push('sourceid', viewParam.sourceId);
+    if (hasUsableSourceId(viewParam.sourceId)) {
+      segments.push('sourceid', String(viewParam.sourceId));
     }
   });