@nocobase/client-v2 2.1.0-alpha.3 → 2.1.0-alpha.31

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

@@ -0,0 +1,110 @@
+/**
+ * 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.
+ */
+
+/**
+ * 通用的字段子模型重建工具：
+ * - 保留原有 uid
+ * - 直接重建为目标字段类，保持与 defineChildren 初始创建逻辑一致
+ * - 支持同步父项模式（pattern）
+ * - 同一字段模型类型下保留已有字段设置；切换到其他字段模型类型时丢弃不兼容设置
+ * - 重建后触发 beforeRender（useCache: false）
+ */
+import { FieldModel } from '../../models/base/FieldModel';
+import { FlowEngine, FlowModel, StepParams } from '@nocobase/flow-engine';
+
+type FieldBindingParams = {
+  fieldBinding?: { use?: string };
+  fieldSettings?: { init?: unknown };
+};
+
+type FieldStepParams = Record<string, unknown> & FieldBindingParams;
+
+type FieldParentModel = FlowModel & {
+  subModels: FlowModel['subModels'] & {
+    field?: FieldModel;
+  };
+  getFieldSettingsInitParams?: () => unknown;
+};
+
+type RebuildOptions = {
+  parentModel: FieldParentModel;
+  targetUse: string;
+  defaultProps?: Record<string, unknown>;
+  pattern?: string;
+  fieldSettingsInit?: unknown;
+};
+
+function normalizeModelUse(value: unknown): string | undefined {
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (typeof value === 'function' && value.name) {
+    return value.name;
+  }
+  return undefined;
+}
+
+export function getFieldBindingUse(fieldModel?: FieldModel): string | undefined {
+  const bindingUse = (fieldModel?.stepParams as FieldStepParams | undefined)?.fieldBinding?.use;
+  return typeof bindingUse === 'string' ? bindingUse : undefined;
+}
+
+export async function rebuildFieldSubModel({
+  parentModel,
+  targetUse,
+  defaultProps,
+  pattern,
+  fieldSettingsInit,
+}: RebuildOptions) {
+  const fieldModel = parentModel.subModels['field'];
+  const fieldUid = fieldModel?.uid;
+  const prevSubModels = fieldModel?.serialize?.()?.subModels;
+  // RecordPickerFieldModel 的子model提前创建会报错
+  for (const key in prevSubModels) {
+    const subModel = prevSubModels[key];
+    if (subModel.delegateToParent === false) {
+      delete prevSubModels[key];
+    }
+  }
+  const currentUse = normalizeModelUse(getFieldBindingUse(fieldModel) || fieldModel?.use);
+  const shouldPreserveStepParams = currentUse === targetUse;
+  const prevStepParams: FieldStepParams = shouldPreserveStepParams
+    ? (fieldModel?.stepParams as FieldStepParams) || {}
+    : {};
+  const nextFieldSettingsInit = fieldSettingsInit ?? parentModel.getFieldSettingsInitParams?.();
+  const { fieldBinding: _fieldBinding, ...restStepParams } = prevStepParams;
+
+  const nextStepParams: FieldStepParams = {
+    ...restStepParams,
+    fieldSettings: {
+      ...(restStepParams.fieldSettings || {}),
+      init: nextFieldSettingsInit,
+    },
+  };
+
+  const engine: FlowEngine = parentModel.flowEngine;
+
+  if (fieldUid) {
+    fieldModel?.invalidateFlowCache('beforeRender', true);
+    engine.removeModelWithSubModels(fieldUid);
+  }
+
+  const subModel = parentModel.setSubModel('field', {
+    uid: fieldUid,
+    use: targetUse,
+    props: { ...(defaultProps || {}), ...(pattern ? { pattern } : {}) },
+    stepParams: nextStepParams as StepParams,
+    // Preserve existing subModels (e.g. SubTable columns) so switching field component back and forth
+    // does not require a full page refresh to restore the UI.
+    subModels: prevSubModels,
+  });
+
+  await subModel.dispatchEvent('beforeRender', undefined, { useCache: false });
+  await parentModel.save();
+}

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

@@ -0,0 +1,40 @@
+/**
+ * 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 const SAVE_STEP_PARAMS_WITH_SUB_MODELS_FLAG = '__saveStepParamsWithSubModels' as const;
+
+export function markSaveStepParamsWithSubModels(model: unknown) {
+  if (!model || (typeof model !== 'object' && typeof model !== 'function')) {
+    throw new Error('[saveStepParamsWithSubModels] model is not an object');
+  }
+  (model as any)[SAVE_STEP_PARAMS_WITH_SUB_MODELS_FLAG] = true;
+}
+
+export async function saveStepParamsWithSubModelsIfNeeded<T>(model: unknown, fallback: () => Promise<T>): Promise<T> {
+  if (!model || (typeof model !== 'object' && typeof model !== 'function')) {
+    throw new Error('[saveStepParamsWithSubModels] model is not an object');
+  }
+  const record = model as any;
+
+  const shouldSaveSubModels = record[SAVE_STEP_PARAMS_WITH_SUB_MODELS_FLAG] === true;
+  if (!shouldSaveSubModels) {
+    return await fallback();
+  }
+
+  if (typeof record.save !== 'function') {
+    throw new Error('[saveStepParamsWithSubModels] model.save is not a function');
+  }
+
+  try {
+    // full save (including subModels) to persist migrated field-level settings cleanup
+    return await record.save();
+  } finally {
+    delete record[SAVE_STEP_PARAMS_WITH_SUB_MODELS_FLAG];
+  }
+}

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

@@ -0,0 +1,95 @@
+/**
+ * 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 { DataSourceManager, getCollectionFieldInterface } from '@nocobase/flow-engine';
+import type { CollectionFieldOptions } from '../../../flow-compat';
+import { DEFAULT_DATA_SOURCE_KEY } from '../../../flow-compat';
+
+type CollectionLike = {
+  name?: unknown;
+  dataSource?: unknown;
+  dataSourceKey?: unknown;
+  setOption?: (key: string, value: any) => any;
+};
+
+type ApiClientLike = {
+  request?: (options: {
+    url: string;
+    method?: string;
+    params?: Record<string, any>;
+    data?: Record<string, any>;
+  }) => Promise<any>;
+};
+
+export function isTitleUsableField(
+  dm: DataSourceManager | undefined,
+  field: CollectionFieldOptions | undefined,
+): boolean {
+  const ifaceName = typeof field?.interface === 'string' ? field.interface : undefined;
+  if (!dm || !ifaceName) return false;
+  return !!getCollectionFieldInterface(ifaceName, dm)?.titleUsable;
+}
+
+function resolveDataSourceKey(targetCollection: CollectionLike | null | undefined): string {
+  const raw = targetCollection?.dataSourceKey ?? targetCollection?.dataSource;
+  if (typeof raw === 'string' && raw) return raw;
+  return DEFAULT_DATA_SOURCE_KEY;
+}
+
+function resolveCollectionName(targetCollection: CollectionLike | null | undefined): string {
+  const name = targetCollection?.name;
+  if (typeof name === 'string' && name) return name;
+  throw new Error('Target collection name is required for syncing title field.');
+}
+
+function resolveUpdateUrl(dataSourceKey: string): string {
+  if (!dataSourceKey || dataSourceKey === DEFAULT_DATA_SOURCE_KEY) {
+    return 'collections:update';
+  }
+  return `dataSources/${dataSourceKey}/collections:update`;
+}
+
+export async function syncCollectionTitleField(options: {
+  api: ApiClientLike;
+  dataSourceManager?: DataSourceManager;
+  targetCollection: CollectionLike | null | undefined;
+  titleField: string;
+}) {
+  const { api, dataSourceManager, targetCollection, titleField } = options;
+
+  if (typeof api?.request !== 'function') {
+    throw new Error('API client is unavailable.');
+  }
+  if (typeof titleField !== 'string' || !titleField) {
+    throw new Error('Title field is required.');
+  }
+
+  const collectionName = resolveCollectionName(targetCollection);
+  const dataSourceKey = resolveDataSourceKey(targetCollection);
+
+  await api.request({
+    url: resolveUpdateUrl(dataSourceKey),
+    method: 'post',
+    params: { filterByTk: collectionName },
+    data: { titleField },
+  });
+
+  targetCollection?.setOption?.('titleField', titleField);
+
+  const dataSource = dataSourceManager?.getDataSource?.(dataSourceKey);
+  if (dataSource && typeof dataSource.reload === 'function') {
+    await dataSource.reload();
+  }
+
+  return {
+    dataSourceKey,
+    collectionName,
+    titleField,
+  };
+}

package/src/flow/models/actions/AddChildActionModel.tsx

@@ -0,0 +1,69 @@
+/**
+ * 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 { tExpr } from '@nocobase/flow-engine';
+import type { ButtonProps } from 'antd/es/button';
+import { RecordActionGroupModel, PopupActionModel } from '../base';
+
+export class AddChildActionModel extends PopupActionModel {
+  static capabilityActionName = null;
+
+  defaultProps: ButtonProps = {
+    type: 'link',
+    title: tExpr('Add child'),
+    icon: 'PlusOutlined',
+  };
+
+  getAclActionName() {
+    return 'create';
+  }
+  onInit(options: any): void {
+    super.onInit(options);
+    this.context.defineProperty('association', {
+      get: () => {
+        return this.context.blockModel.dataSource.getAssociation(`${this.context.blockModel.collection.name}.children`);
+      },
+    });
+  }
+}
+
+AddChildActionModel.registerFlow({
+  key: 'addChildSettingsInit',
+  steps: {
+    addChildInit: {
+      async handler(ctx, params) {
+        ctx.model.onClick = (e) => {
+          ctx.model.dispatchEvent(
+            'click',
+            {
+              event: e,
+              ...ctx.inputArgs,
+              sourceId: ctx.record.id,
+              filterByTk: null,
+            },
+            {
+              debounce: true,
+            },
+          );
+        };
+      },
+    },
+  },
+});
+
+AddChildActionModel.define({
+  label: tExpr('Add child'),
+  hide(ctx) {
+    return ctx.collection?.template !== 'tree' || ctx.blockModel.props.treeTable === false;
+  },
+});
+
+RecordActionGroupModel.registerActionModels({
+  AddChildActionModel,
+});

package/src/flow/models/actions/AddNewActionModel.tsx

@@ -0,0 +1,32 @@
+/**
+ * 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 { tExpr } from '@nocobase/flow-engine';
+import { ButtonProps } from 'antd';
+import { ActionSceneEnum, PopupActionModel } from '../base';
+
+export class AddNewActionModel extends PopupActionModel {
+  static scene = ActionSceneEnum.collection;
+
+  defaultPopupTitle = tExpr('Add new');
+  defaultProps: ButtonProps = {
+    type: 'primary',
+    title: tExpr('Add new'),
+    icon: 'PlusOutlined',
+  };
+
+  getAclActionName() {
+    return 'create';
+  }
+}
+
+AddNewActionModel.define({
+  label: tExpr('Add new'),
+  sort: 10,
+});

package/src/flow/models/actions/AssociateActionModel.tsx

@@ -0,0 +1,196 @@
+/**
+ * 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 { FlowModel, FlowModelRenderer, tExpr, useFlowViewContext } from '@nocobase/flow-engine';
+import { useRequest } from 'ahooks';
+import { Button } from 'antd';
+import type { ButtonProps } from 'antd';
+import React from 'react';
+import { SkeletonFallback } from '../../components/SkeletonFallback';
+import { ActionModel, ActionSceneEnum } from '../base';
+import {
+  applyAssociateAction,
+  getAssociationTargetResourceSettings,
+  isAssociationBlockContext,
+} from './AssociationActionUtils';
+
+function AssociateSelectorGridRenderer({ options }: { options: any }) {
+  const ctx = useFlowViewContext();
+  const { data, loading } = useRequest(
+    async () => {
+      return await ctx.engine.loadOrCreateModel(options, {
+        delegateToParent: false,
+        delegate: ctx,
+        skipSave: !ctx.flowSettingsEnabled,
+      });
+    },
+    {
+      refreshDeps: [ctx, options],
+    },
+  );
+
+  if (loading || !data?.uid) {
+    return <SkeletonFallback style={{ margin: 16 }} />;
+  }
+  return <FlowModelRenderer model={data as FlowModel} fallback={<SkeletonFallback style={{ margin: 16 }} />} />;
+}
+
+function AssociateSelectorContent({ model }: { model: AssociateActionModel }) {
+  const ctx = useFlowViewContext();
+  const { Header, Footer, type } = ctx.view;
+  return (
+    <div>
+      <Header
+        title={
+          type === 'dialog' ? (
+            <div
+              style={{
+                padding: `${ctx.themeToken.paddingLG}px ${ctx.themeToken.paddingLG}px 0`,
+                marginBottom: -ctx.themeToken.marginSM,
+                backgroundColor: 'var(--colorBgLayout)',
+              }}
+            >
+              {ctx.t('Select record')}
+            </div>
+          ) : (
+            ctx.t('Select record')
+          )
+        }
+      />
+      <AssociateSelectorGridRenderer
+        options={{
+          parentId: ctx.view.inputArgs.parentId,
+          subKey: 'associate-selector-grid',
+          async: true,
+          delegateToParent: false,
+          subType: 'object',
+          use: 'BlockGridModel',
+        }}
+      />
+      <Footer>
+        {type === 'dialog' ? (
+          <div style={{ padding: `0 ${ctx.themeToken.paddingLG}px ${ctx.themeToken.paddingLG}px` }}>
+            <Button
+              type="primary"
+              onClick={async () => {
+                await model.associateSelectedRows();
+                ctx.view.close();
+              }}
+            >
+              {ctx.t('Submit')}
+            </Button>
+          </div>
+        ) : (
+          <Button
+            type="primary"
+            onClick={async () => {
+              await model.associateSelectedRows();
+              ctx.view.close();
+            }}
+          >
+            {ctx.t('Submit')}
+          </Button>
+        )}
+      </Footer>
+    </div>
+  );
+}
+
+export class AssociateActionModel extends ActionModel {
+  static scene = ActionSceneEnum.collection;
+  static capabilityActionName = 'update';
+
+  defaultPopupTitle = tExpr('Select record');
+  selectedRows: any[] = [];
+
+  defaultProps: ButtonProps = {
+    title: tExpr('Associate'),
+    icon: 'LinkOutlined',
+  };
+
+  getAclActionName() {
+    return 'update';
+  }
+
+  async associateSelectedRows() {
+    await applyAssociateAction(this.context, this.selectedRows);
+    this.selectedRows = [];
+  }
+}
+
+AssociateActionModel.define({
+  label: tExpr('Associate'),
+  sort: 15,
+  hide(ctx) {
+    return !isAssociationBlockContext(ctx);
+  },
+});
+
+AssociateActionModel.registerFlow({
+  key: 'associateSettings',
+  title: tExpr('Associate settings'),
+  on: 'click',
+  steps: {
+    openSelector: {
+      async handler(ctx, params) {
+        const blockModel = ctx.blockModel;
+        const targetResourceSettings = getAssociationTargetResourceSettings(ctx);
+        const openMode = ctx.inputArgs?.isMobileLayout ? 'embed' : ctx.inputArgs?.mode || params?.mode || 'drawer';
+        const size = ctx.inputArgs?.size || params?.size || 'medium';
+        const sizeToWidthMap: Record<string, Record<string, string | undefined>> = {
+          drawer: {
+            small: '30%',
+            medium: '50%',
+            large: '70%',
+          },
+          dialog: {
+            small: '40%',
+            medium: '50%',
+            large: '80%',
+          },
+          embed: {},
+        };
+
+        ctx.model.selectedRows = [];
+        await ctx.viewer.open({
+          type: openMode,
+          width: sizeToWidthMap[openMode][size],
+          inheritContext: false,
+          target: ctx.layoutContentElement,
+          inputArgs: {
+            parentId: ctx.model.uid,
+            scene: 'select',
+            dataSourceKey: targetResourceSettings.dataSourceKey,
+            collectionName: targetResourceSettings.collectionName,
+            rowSelectionProps: {
+              type: 'checkbox',
+              defaultSelectedRows: () => blockModel?.resource?.getData?.() || [],
+              renderCell: undefined,
+              selectedRowKeys: undefined,
+              onChange: (_, selectedRows) => {
+                ctx.model.selectedRows = selectedRows || [];
+              },
+            },
+          },
+          content: () => <AssociateSelectorContent model={ctx.model as AssociateActionModel} />,
+          styles: {
+            content: {
+              padding: 0,
+              backgroundColor: ctx.model.flowEngine.context.themeToken.colorBgLayout,
+              ...(openMode === 'embed' ? { position: 'absolute', top: 0, left: 0, right: 0, bottom: 0 } : {}),
+            },
+            body: {
+              padding: 0,
+            },
+          },
+        });
+      },
+    },
+  },
+});

package/src/flow/models/actions/AssociationActionUtils.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 type { FlowModelContext } from '@nocobase/flow-engine';
+
+export const getAssociationBlockResourceSettings = (ctx: FlowModelContext | any) => {
+  const blockModel = ctx?.blockModel || ctx?.model?.context?.blockModel;
+  return (
+    blockModel?.getResourceSettingsInitParams?.() ||
+    blockModel?.getStepParams?.('resourceSettings', 'init') ||
+    ctx?.model?.getStepParams?.('resourceSettings', 'init')
+  );
+};
+
+export const isAssociationBlockContext = (ctx: FlowModelContext | any) => {
+  return !!getAssociationBlockResourceSettings(ctx)?.associationName;
+};
+
+export const getAssociationTargetResourceSettings = (ctx: FlowModelContext | any) => {
+  const resourceSettings = getAssociationBlockResourceSettings(ctx);
+  const association = ctx?.blockModel?.association || ctx?.model?.context?.blockModel?.association;
+  const targetCollection = association?.targetCollection;
+
+  return {
+    dataSourceKey: targetCollection?.dataSourceKey || resourceSettings?.dataSourceKey,
+    collectionName: targetCollection?.name || association?.target || resourceSettings?.collectionName,
+  };
+};
+
+const callAssociationResourceAction = async (resource: any, action: 'add' | 'remove', values: any[]) => {
+  if (typeof resource?.[action] === 'function') {
+    return await resource[action]({ values });
+  }
+
+  return await resource?.runAction?.(action, {
+    data: values,
+  });
+};
+
+export const applyDisassociateAction = async (ctx: FlowModelContext | any) => {
+  const resource = ctx?.blockModel?.resource || ctx?.resource;
+  const collection = ctx?.blockModel?.collection || ctx?.collection;
+
+  if (!isAssociationBlockContext(ctx)) {
+    ctx.message?.error?.(ctx.t('No association block selected'));
+    return;
+  }
+  if (!resource) {
+    ctx.message?.error?.(ctx.t('No resource selected for disassociation'));
+    return;
+  }
+  if (!ctx.record) {
+    ctx.message?.error?.(ctx.t('No record selected for disassociation'));
+    return;
+  }
+
+  const filterByTk = collection?.getFilterByTK?.(ctx.record);
+  await callAssociationResourceAction(resource, 'remove', [filterByTk]);
+  await resource.refresh?.();
+  ctx.message?.success?.(ctx.t('Record disassociated successfully'));
+};
+
+export const applyAssociateAction = async (ctx: FlowModelContext | any, selectedRows: any[]) => {
+  const resource = ctx?.blockModel?.resource || ctx?.resource;
+  const collection = ctx?.blockModel?.collection || ctx?.collection;
+
+  if (!isAssociationBlockContext(ctx)) {
+    ctx.message?.error?.(ctx.t('No association block selected'));
+    return;
+  }
+  if (!resource) {
+    ctx.message?.error?.(ctx.t('No resource selected for association'));
+    return;
+  }
+  if (!selectedRows?.length) {
+    ctx.message?.warning?.(ctx.t('Please select at least one record'));
+    return;
+  }
+
+  const values = selectedRows.map((row) => collection?.getFilterByTK?.(row) ?? row).filter((value) => value != null);
+  await callAssociationResourceAction(resource, 'add', values);
+  await resource.refresh?.();
+  ctx.message?.success?.(ctx.t('Record associated successfully'));
+};

package/src/flow/models/actions/BulkDeleteActionModel.tsx

@@ -0,0 +1,61 @@
+/**
+ * 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 { tExpr, MultiRecordResource } from '@nocobase/flow-engine';
+import { ButtonProps } from 'antd';
+import { ActionModel, ActionSceneEnum } from '../base';
+
+export class BulkDeleteActionModel extends ActionModel {
+  static scene = ActionSceneEnum.collection;
+  static capabilityActionName = 'destroyMany';
+
+  defaultProps: ButtonProps = {
+    title: tExpr('Delete'),
+    icon: 'DeleteOutlined',
+  };
+
+  getAclActionName() {
+    return 'destroy';
+  }
+}
+
+BulkDeleteActionModel.define({
+  label: tExpr('Delete'),
+});
+
+BulkDeleteActionModel.registerFlow({
+  key: 'deleteSettings',
+  title: tExpr('Delete settings'),
+  on: 'click',
+  steps: {
+    confirm: {
+      use: 'confirm',
+      defaultParams: {
+        enable: true,
+        title: tExpr('Delete record'),
+        content: tExpr('Are you sure you want to delete it?'),
+      },
+    },
+    delete: {
+      async handler(ctx, params) {
+        if (!ctx.blockModel?.resource) {
+          ctx.message.error(ctx.t('No resource selected for deletion'));
+          return;
+        }
+        const resource = ctx.blockModel.resource as MultiRecordResource;
+        if (resource.getSelectedRows().length === 0) {
+          ctx.message.warning(ctx.t('Please select at least one record to delete'));
+          return;
+        }
+        await resource.destroy(ctx.blockModel.collection.getFilterByTK(resource.getSelectedRows()));
+        ctx.message.success(ctx.t('Selected records deleted successfully'));
+      },
+    },
+  },
+});