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

package/src/flow/internal/utils/__tests__/modelUtils.test.ts

@@ -0,0 +1,66 @@
+/**
+ * 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 } from 'vitest';
+import {
+  buildCustomFieldTargetPath,
+  findFormItemModelByFieldPath,
+  getFormItemFieldPathCandidates,
+} from '../modelUtils';
+
+describe('modelUtils', () => {
+  it('builds custom field target path candidates from formItemSettings', () => {
+    const model = {
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'formItemSettings' && stepKey === 'fieldSettings') {
+          return { name: 'custom_age' };
+        }
+        return undefined;
+      },
+    };
+
+    expect(getFormItemFieldPathCandidates(model)).toEqual([buildCustomFieldTargetPath('custom_age')]);
+  });
+
+  it('finds custom form item by custom target path token', () => {
+    const normalItem = {
+      uid: 'normal-1',
+      fieldPath: 'age',
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'age' };
+        }
+        return undefined;
+      },
+      subModels: { field: {} },
+    };
+    const customItem = {
+      uid: 'custom-1',
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'formItemSettings' && stepKey === 'fieldSettings') {
+          return { name: 'custom_age' };
+        }
+        return undefined;
+      },
+      subModels: { field: {} },
+    };
+    const root = {
+      subModels: {
+        grid: {
+          subModels: {
+            items: [normalItem, customItem],
+          },
+        },
+      },
+    };
+
+    const targetPath = buildCustomFieldTargetPath('custom_age');
+    expect(findFormItemModelByFieldPath(root, targetPath)).toBe(customItem as any);
+  });
+});

package/src/flow/internal/utils/__tests__/rebuildFieldSubModel.test.ts

@@ -0,0 +1,109 @@
+/**
+ * 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, test, vi, beforeEach } from 'vitest';
+import { FlowEngine } from '@nocobase/flow-engine';
+import { FlowModel } from '@nocobase/flow-engine';
+import { FieldModel } from '../../../models/base/FieldModel';
+import { rebuildFieldSubModel, getFieldBindingUse } from '../rebuildFieldSubModel';
+
+class DummyTargetFieldModel extends FieldModel {}
+class DummyColumnModel extends FlowModel {}
+
+class DummyParentModel extends FlowModel<{ subModels: { field?: FieldModel } }> {
+  getFieldSettingsInitParams() {
+    return { mock: true };
+  }
+}
+
+describe('rebuildFieldSubModel', () => {
+  let engine: FlowEngine;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    engine.registerModels({
+      FieldModel,
+      DummyTargetFieldModel,
+      DummyColumnModel,
+      DummyParentModel,
+    });
+  });
+
+  test('rebuilds field with same uid and updates binding use', async () => {
+    const staleClickHandler = () => null;
+    const parent = engine.createModel<DummyParentModel>({
+      use: DummyParentModel,
+      uid: 'parent-1',
+      subModels: {
+        field: {
+          use: FieldModel,
+          uid: 'field-1',
+          props: { foo: 'bar', onClick: staleClickHandler },
+          stepParams: {
+            fieldBinding: { use: 'FieldModel' },
+            fieldSettings: { init: { initKey: true } },
+          } as any,
+        },
+      },
+    });
+
+    const dispatchSpy = vi.spyOn(FieldModel.prototype, 'dispatchEvent');
+
+    await rebuildFieldSubModel({
+      parentModel: parent,
+      targetUse: 'DummyTargetFieldModel',
+      defaultProps: { added: 'yes' },
+      pattern: 'readPretty',
+    });
+
+    const rebuilt = parent.subModels.field as DummyTargetFieldModel;
+
+    expect(rebuilt).toBeInstanceOf(DummyTargetFieldModel);
+    expect(rebuilt.uid).toBe('field-1');
+    expect(getFieldBindingUse(rebuilt)).toBe('DummyTargetFieldModel');
+    expect(rebuilt.props).toMatchObject({ added: 'yes', pattern: 'readPretty' });
+    expect((rebuilt.props as any).onClick).toBeUndefined();
+
+    expect(dispatchSpy).toHaveBeenCalledWith('beforeRender', undefined, { useCache: false });
+    dispatchSpy.mockRestore();
+  });
+
+  test('preserves previous field subModels during rebuild', async () => {
+    const parent = engine.createModel<DummyParentModel>({
+      use: DummyParentModel,
+      uid: 'parent-2',
+      subModels: {
+        field: {
+          use: FieldModel,
+          uid: 'field-2',
+          stepParams: {
+            fieldBinding: { use: 'FieldModel' },
+            fieldSettings: { init: { initKey: true } },
+          } as any,
+          subModels: {
+            columns: [
+              { use: DummyColumnModel, uid: 'col-1', sortIndex: 0 },
+              { use: DummyColumnModel, uid: 'col-2', sortIndex: 1 },
+            ],
+          },
+        },
+      },
+    });
+
+    await rebuildFieldSubModel({
+      parentModel: parent,
+      targetUse: 'DummyTargetFieldModel',
+    });
+
+    const rebuilt = parent.subModels.field as DummyTargetFieldModel;
+    const cols = rebuilt.subModels?.['columns'] as any[];
+    expect(Array.isArray(cols)).toBe(true);
+    expect(cols.map((c) => c.uid)).toEqual(['col-1', 'col-2']);
+  });
+});

package/src/flow/internal/utils/__tests__/titleFieldQuickSync.test.ts

@@ -0,0 +1,93 @@
+/**
+ * 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 { isTitleUsableField, syncCollectionTitleField } from '../titleFieldQuickSync';
+
+describe('titleFieldQuickSync', () => {
+  it('filters title field candidates by interface metadata', () => {
+    const dm: any = {
+      collectionFieldInterfaceManager: {
+        getFieldInterface: vi.fn((name: string) => {
+          if (name === 'input') return { titleUsable: true };
+          if (name === 'formula') return { titleUsable: false };
+          return undefined;
+        }),
+      },
+    };
+
+    expect(isTitleUsableField(dm, { interface: 'input' } as any)).toBe(true);
+    expect(isTitleUsableField(dm, { interface: 'formula' } as any)).toBe(false);
+    expect(isTitleUsableField(dm, { interface: 'unknown' } as any)).toBe(false);
+    expect(isTitleUsableField(undefined, { interface: 'input' } as any)).toBe(false);
+  });
+
+  it('syncs title field to main data source collection', async () => {
+    const request = vi.fn().mockResolvedValue({});
+    const reload = vi.fn().mockResolvedValue({});
+    const setOption = vi.fn();
+
+    await syncCollectionTitleField({
+      api: { request },
+      dataSourceManager: { getDataSource: vi.fn(() => ({ reload })) } as any,
+      targetCollection: {
+        name: 'users',
+        dataSourceKey: 'main',
+        setOption,
+      },
+      titleField: 'nickname',
+    });
+
+    expect(request).toHaveBeenCalledWith({
+      url: 'collections:update',
+      method: 'post',
+      params: { filterByTk: 'users' },
+      data: { titleField: 'nickname' },
+    });
+    expect(setOption).toHaveBeenCalledWith('titleField', 'nickname');
+    expect(reload).toHaveBeenCalledTimes(1);
+  });
+
+  it('syncs title field to non-main data source collection', async () => {
+    const request = vi.fn().mockResolvedValue({});
+    const reload = vi.fn().mockResolvedValue({});
+
+    await syncCollectionTitleField({
+      api: { request },
+      dataSourceManager: { getDataSource: vi.fn(() => ({ reload })) } as any,
+      targetCollection: {
+        name: 'users',
+        dataSource: 'analytics',
+      },
+      titleField: 'name',
+    });
+
+    expect(request).toHaveBeenCalledWith({
+      url: 'dataSources/analytics/collections:update',
+      method: 'post',
+      params: { filterByTk: 'users' },
+      data: { titleField: 'name' },
+    });
+    expect(reload).toHaveBeenCalledTimes(1);
+  });
+
+  it('throws when target collection name is missing', async () => {
+    const request = vi.fn().mockResolvedValue({});
+
+    await expect(
+      syncCollectionTitleField({
+        api: { request },
+        targetCollection: { dataSourceKey: 'main' },
+        titleField: 'nickname',
+      }),
+    ).rejects.toThrow('Target collection name is required for syncing title field.');
+
+    expect(request).not.toHaveBeenCalled();
+  });
+});

package/src/flow/internal/utils/associationValueCoercion.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 function isToManyAssociation(collectionField: any): boolean {
+  if (!collectionField) return false;
+  const relationType = collectionField?.type;
+  return relationType === 'belongsToMany' || relationType === 'hasMany' || relationType === 'belongsToArray';
+}
+
+/**
+ * 若目标字段为“对一”关联且传入值为数组，则取第一个元素
+ * - 对多关联/非关联字段：不处理，原样返回
+ * - 传入空数组：返回 undefined
+ */
+export function coerceForToOneField(collectionField: any, value: any) {
+  const isAssociation = !!collectionField?.isAssociationField?.();
+  const toMany = isToManyAssociation(collectionField);
+  if (isAssociation && !toMany && Array.isArray(value)) {
+    return value.length ? value[0] : undefined;
+  }
+  return value;
+}

package/src/flow/internal/utils/dateTimeUtils.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 { toGmt } from '@nocobase/utils/client';
+import dayjs from 'dayjs';
+
+export const handleDateChangeOnForm = (value, dateOnly, utc, picker, showTime, gmt) => {
+  // @ts-ignore
+  const currentTimeZone = dayjs.tz.guess();
+  const format = showTime ? 'YYYY-MM-DD HH:mm:ss' : 'YYYY-MM-DD';
+  if (!value) {
+    return value;
+  }
+  if (dateOnly) {
+    return dayjs(value).startOf(picker).format('YYYY-MM-DD');
+  }
+  if (utc) {
+    if (gmt) {
+      return toGmt(value);
+    }
+    if (picker !== 'date') {
+      return dayjs(value).startOf(picker).toISOString();
+    }
+    const formattedDate = dayjs(value).format(format);
+    // @ts-ignore
+    return dayjs(formattedDate).tz(currentTimeZone, true).toISOString();
+  }
+  if (showTime) {
+    return dayjs(value).format(format);
+  }
+  return dayjs(value).startOf(picker).format(format);
+};
+
+export const handleDateChangeOnFormWithTz = (value, picker, showTime) => {
+  // @ts-ignore
+  const currentTimeZone = dayjs.tz.guess();
+  const format = showTime ? 'YYYY-MM-DD HH:mm:ss' : 'YYYY-MM-DD';
+  if (!value) {
+    return value;
+  }
+  if (picker !== 'date') {
+    return dayjs(value).startOf(picker).toISOString();
+  }
+  const formattedDate = dayjs(value).format(format);
+  // @ts-ignore
+  return dayjs(formattedDate).tz(currentTimeZone, true).toISOString();
+};

package/src/flow/internal/utils/enumOptionsUtils.ts

@@ -0,0 +1,66 @@
+/**
+ * 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 { CollectionField, FlowModel } from '@nocobase/flow-engine';
+
+export type UiSchemaEnumItem = string | number | boolean | { label?: any; value?: any; color?: string; icon?: any };
+
+type Option = { label: any; value: any } & Record<string, any>;
+
+// Internal utility: normalize uiSchema.enum into antd-friendly options
+function normalizeUiSchemaEnumToOptions(uiEnum: UiSchemaEnumItem[] = []): Option[] {
+  if (!Array.isArray(uiEnum)) return [];
+  return uiEnum.map((item: UiSchemaEnumItem) => {
+    if (item && typeof item === 'object' && !Array.isArray(item)) {
+      const anyItem = item as any;
+      const hasLabel = typeof anyItem.label !== 'undefined';
+      const hasValue = typeof anyItem.value !== 'undefined';
+      const label = hasLabel ? anyItem.label : String(anyItem.value ?? '');
+      const value = hasValue ? anyItem.value : label;
+      const opt: any = { label, value };
+      if (anyItem.color) opt.color = anyItem.color;
+      if (anyItem.icon) opt.icon = anyItem.icon;
+      return opt;
+    }
+    // Primitive values: keep original value; stringify label
+    return { label: String(item), value: item };
+  });
+}
+
+// Map option labels through t() (supports {{t('key')}} template and plain strings)
+export function translateOptions(options: Option[] = [], t: (s: string) => string): Option[] {
+  if (!Array.isArray(options)) return [] as Option[];
+  return options.map((opt) => (typeof opt?.label === 'string' ? { ...opt, label: t(opt.label) } : opt));
+}
+
+// Build options from uiSchema.enum with translated labels
+export function enumToOptions(uiEnum: UiSchemaEnumItem[] | undefined, t: (s: string) => string): Option[] | undefined {
+  if (!uiEnum || !Array.isArray(uiEnum) || uiEnum.length === 0) return undefined;
+  const normalized = normalizeUiSchemaEnumToOptions(uiEnum);
+  return translateOptions(normalized, t);
+}
+
+// Populate model.props.options from uiSchema.enum if missing; returns whether options were injected
+export function ensureOptionsFromUiSchemaEnumIfAbsent(model: FlowModel, collectionField: CollectionField): boolean {
+  const iface = collectionField?.interface;
+  const isLocalEnumInterface = ['radioGroup', 'checkboxGroup', 'select', 'multipleSelect'].includes(iface);
+  if (!isLocalEnumInterface) return false;
+
+  const hasOptions = Array.isArray(model.props?.options) && model.props?.options?.length > 0;
+  if (hasOptions) return false;
+
+  const uiEnum = collectionField.uiSchema?.enum as UiSchemaEnumItem[] | undefined;
+  if (!Array.isArray(uiEnum) || uiEnum.length === 0) return false;
+
+  const normalized = normalizeUiSchemaEnumToOptions(uiEnum);
+  if (!normalized.length) return false;
+
+  model.setProps({ options: normalized });
+  return true;
+}

package/src/flow/internal/utils/modelUtils.ts

@@ -0,0 +1,158 @@
+/**
+ * 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 type { FlowModel } from '@nocobase/flow-engine';
+import { FormItemModel } from '../../models';
+
+export interface CollectionLike {
+  getField?: (name: string) => unknown;
+  getFields?: () => unknown[];
+  dataSourceKey?: string;
+  name?: string;
+}
+
+export const CUSTOM_FIELD_TARGET_PATH_PREFIX = '__custom__';
+
+export function buildCustomFieldTargetPath(customFieldName: string): string {
+  return `${CUSTOM_FIELD_TARGET_PATH_PREFIX}:${customFieldName}`;
+}
+
+export function isToManyAssociationField(field: unknown): boolean {
+  if (!field || typeof field !== 'object') return false;
+  const f = field as { isAssociationField?: () => boolean; type?: unknown; interface?: unknown };
+  if (!f.isAssociationField?.()) return false;
+  const relType = f.type;
+  const relInterface = f.interface;
+  return (
+    relType === 'belongsToMany' ||
+    relType === 'hasMany' ||
+    relType === 'belongsToArray' ||
+    relInterface === 'm2m' ||
+    relInterface === 'o2m' ||
+    relInterface === 'mbm'
+  );
+}
+
+type ModelWithMaybeCollection = {
+  collection?: CollectionLike;
+  context?: { collection?: CollectionLike } | null;
+};
+
+export function getCollectionFromModel(model: unknown): CollectionLike | undefined {
+  if (!model || typeof model !== 'object') return undefined;
+  const m = model as ModelWithMaybeCollection;
+  return m.collection || m.context?.collection || undefined;
+}
+
+function normalizePath(val: unknown): string {
+  return typeof val === 'string' ? val.trim() : '';
+}
+
+export function getFormItemFieldPathCandidates(model: unknown): string[] {
+  if (!model || typeof model !== 'object') return [];
+  const record = model as Record<string, unknown>;
+
+  const init =
+    typeof record.getStepParams === 'function'
+      ? (record.getStepParams as (flowKey: string, stepKey: string) => unknown)('fieldSettings', 'init')
+      : undefined;
+  const initObj = init && typeof init === 'object' ? (init as Record<string, unknown>) : undefined;
+  const customSettings =
+    typeof record.getStepParams === 'function'
+      ? (record.getStepParams as (flowKey: string, stepKey: string) => unknown)('formItemSettings', 'fieldSettings')
+      : undefined;
+  const customSettingsObj =
+    customSettings && typeof customSettings === 'object' ? (customSettings as Record<string, unknown>) : undefined;
+
+  const rawFieldPath = (initObj?.fieldPath as unknown) ?? record.fieldPath;
+  const rawAssocPath = (initObj?.associationPathName as unknown) ?? record.associationPathName;
+  const rawCustomFieldName = customSettingsObj?.name;
+
+  const fieldPath = normalizePath(rawFieldPath);
+  const assocPath = normalizePath(rawAssocPath);
+  const customFieldName = normalizePath(rawCustomFieldName);
+
+  const paths = new Set<string>();
+  if (fieldPath) {
+    paths.add(fieldPath);
+  }
+  if (assocPath) {
+    if (!fieldPath) {
+      paths.add(assocPath);
+    } else if (fieldPath.startsWith(`${assocPath}.`)) {
+      paths.add(fieldPath);
+    } else {
+      paths.add(`${assocPath}.${fieldPath}`);
+    }
+  }
+  if (customFieldName) {
+    paths.add(buildCustomFieldTargetPath(customFieldName));
+  }
+
+  return Array.from(paths);
+}
+
+export function getFormItemPreferredFieldPath(model: unknown): string | undefined {
+  const candidates = getFormItemFieldPathCandidates(model);
+  return candidates[0];
+}
+
+function getSubModelItems(model: unknown): unknown[] {
+  if (!model || typeof model !== 'object') return [];
+  const record = model as Record<string, unknown>;
+  const subModels = record.subModels;
+  if (!subModels || typeof subModels !== 'object') return [];
+
+  // Support both:
+  // - FormBlockModel-like: root.subModels.grid.subModels.items
+  // - FormGridModel-like:  root.subModels.items
+  const directItems = (subModels as Record<string, unknown>).items;
+  if (Array.isArray(directItems)) return directItems;
+
+  const grid = (subModels as Record<string, unknown>).grid;
+  if (!grid || typeof grid !== 'object') return [];
+
+  const gridSubModels = (grid as Record<string, unknown>).subModels;
+  if (!gridSubModels || typeof gridSubModels !== 'object') return [];
+
+  const items = (gridSubModels as Record<string, unknown>).items;
+  return Array.isArray(items) ? items : [];
+}
+
+function getChildFormItems(formItemModel: unknown): unknown[] {
+  if (!formItemModel || typeof formItemModel !== 'object') return [];
+  const record = formItemModel as Record<string, unknown>;
+  const subModels = record.subModels;
+  if (!subModels || typeof subModels !== 'object') return [];
+  const fieldModel = (subModels as Record<string, unknown>).field;
+  return getSubModelItems(fieldModel);
+}
+
+/**
+ * Find a configured FormItemModel by its `fieldSettings.init.fieldPath` (or `fieldPath`) in the current form grid,
+ * including nested subform items. Also supports combined path matching when a model stores
+ * `associationPathName + fieldPath` separately (e.g. wrapper field children builders).
+ */
+export function findFormItemModelByFieldPath(root: unknown, targetPath: string): FormItemModel | null {
+  const normalizedTargetPath = normalizePath(targetPath);
+  if (!normalizedTargetPath) return null;
+
+  const walk = (items: unknown[]): FormItemModel | null => {
+    if (!Array.isArray(items)) return null;
+    for (const it of items) {
+      const candidates = getFormItemFieldPathCandidates(it);
+      if (candidates.some((p) => p === normalizedTargetPath)) return it as FormItemModel;
+      const hit = walk(getChildFormItems(it));
+      if (hit) return hit;
+    }
+    return null;
+  };
+
+  return walk(getSubModelItems(root));
+}

package/src/flow/internal/utils/operatorSchemaHelper.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { DateFilterDynamicComponent } from '../../models/blocks/filter-form/fields/date-time/components/DateFilterDynamicComponent';
+
+/**
+ * 根据操作符的 schema 定位组件及其 props。
+ */
+export function resolveOperatorComponent(app: any, operator: string, operators?: Array<any>) {
+  if (!operators || !Array.isArray(operators)) return null;
+  const op = operators.find((item) => item?.value === operator);
+  const schema = op?.schema;
+  const xComp = schema?.['x-component'];
+  if (!xComp) return null;
+  let Comp;
+  if (xComp === 'DateFilterDynamicComponent') {
+    Comp = DateFilterDynamicComponent;
+  } else {
+    Comp = app?.getComponent?.(xComp as any);
+  }
+  if (!Comp) return null;
+  const props = (schema?.['x-component-props'] as Record<string, any>) || {};
+  return { Comp, props };
+}