@nocobase/client-v2 2.1.0-alpha.22 → 2.1.0-alpha.24

package/src/flow/models/actions/UpdateRecordActionUtils.ts

@@ -0,0 +1,89 @@
+/**
+ * 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 { MultiRecordResource, SingleRecordResource, resolveRunJSObjectValues } from '@nocobase/flow-engine';
+import { dispatchEventDeep } from '../../utils';
+
+export async function refreshLinkageRulesAfterUpdate(ctx: any) {
+  const blockModel = ctx?.blockModel || ctx?.model?.context?.blockModel || ctx?.model;
+  const actionModel = ctx?.model;
+  const syncRecordAccessor = (model: any) => {
+    if (!model?.context?.defineProperty || typeof blockModel?.getCurrentRecord !== 'function') return;
+    model.context.defineProperty('record', {
+      get: () => blockModel.getCurrentRecord(),
+      cache: false,
+    });
+  };
+  syncRecordAccessor(ctx?.model);
+  if (ctx?.model?.forks && typeof ctx.model.forks.forEach === 'function') {
+    ctx.model.forks.forEach((fork: any) => syncRecordAccessor(fork));
+  }
+
+  if (typeof blockModel?.getCurrentRecord === 'function') {
+    const latestRecord = blockModel.getCurrentRecord();
+    if (typeof ctx?.defineProperty === 'function') {
+      ctx.defineProperty('record', {
+        get: () => blockModel.getCurrentRecord(),
+        cache: false,
+      });
+    } else {
+      ctx.record = latestRecord;
+    }
+  }
+
+  if (actionModel) {
+    await dispatchEventDeep(actionModel, 'paginationChange');
+  }
+  if (blockModel && blockModel !== actionModel) {
+    await dispatchEventDeep(blockModel, 'paginationChange');
+  }
+}
+
+export async function applyUpdateRecordAction(
+  ctx: any,
+  params: any,
+  options?: {
+    settingsFlowKey?: string;
+  },
+) {
+  const settingsFlowKey = options?.settingsFlowKey || 'assignSettings';
+
+  // 统一接入二次确认：如果启用则弹窗；未配置时默认不启用
+  const savedConfirm = ctx.model.getStepParams(settingsFlowKey, 'confirm');
+  const confirmParams = savedConfirm && typeof savedConfirm === 'object' ? savedConfirm : { enable: false };
+  await ctx.runAction('confirm', confirmParams);
+
+  let assignedValues: Record<string, any> = {};
+  try {
+    assignedValues = await resolveRunJSObjectValues(ctx, params?.assignedValues);
+  } catch (error) {
+    console.error('[UpdateRecordAction] RunJS execution failed', error);
+    ctx.message.error(ctx.t('RunJS execution failed'));
+    return;
+  }
+
+  if (!assignedValues || typeof assignedValues !== 'object' || !Object.keys(assignedValues).length) {
+    ctx.message.warning(ctx.t('No assigned fields configured'));
+    return;
+  }
+  const collection = ctx.collection?.name;
+  const filterByTk = ctx.collection?.getFilterByTK?.(ctx.record);
+  if (!collection || typeof filterByTk === 'undefined' || filterByTk === null) {
+    ctx.message.error(ctx.t('Record is required to perform this action'));
+    return;
+  }
+  if (ctx.resource instanceof SingleRecordResource) {
+    await ctx.resource.save(assignedValues, params.requestConfig);
+  } else if (ctx.resource instanceof MultiRecordResource) {
+    await ctx.resource.update(filterByTk, assignedValues, params.requestConfig);
+  }
+
+  await refreshLinkageRulesAfterUpdate(ctx);
+  ctx.message.success(ctx.t('Saved successfully'));
+}

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

@@ -0,0 +1,31 @@
+/**
+ * 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 { ActionSceneEnum, PopupActionModel } from '../base';
+
+export class ViewActionModel extends PopupActionModel {
+  static scene = ActionSceneEnum.record;
+
+  defaultProps: ButtonProps = {
+    type: 'link',
+    title: tExpr('View'),
+    icon: 'EyeOutlined',
+  };
+
+  getAclActionName() {
+    return 'view';
+  }
+}
+
+ViewActionModel.define({
+  label: tExpr('View'),
+  sort: 10,
+});

package/src/flow/models/actions/__tests__/AssignFormRefill.test.ts

@@ -0,0 +1,55 @@
+/**
+ * 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, it, expect } from 'vitest';
+import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
+import { UpdateRecordActionModel } from '../../..'; // 这样可以解决循环依赖问题
+
+/**
+ * 精简版 AssignFormModel（仅用于单测）：
+ * - 避免依赖复杂上下文；专注验证 beforeParamsSave 的聚合入参写入逻辑。
+ */
+class TestAssignFormModel extends FlowModel {
+  private _values: Record<string, any> = {};
+  setAssignedValues(v: Record<string, any>) {
+    this._values = v || {};
+  }
+  getAssignedValues(): Record<string, any> {
+    return this._values || {};
+  }
+}
+
+describe('AssignForm value refill and save (beforeParamsSave)', () => {
+  it('UpdateRecordActionModel: saves non-empty assignedValues from AssignForm', async () => {
+    const root = new FlowEngine();
+
+    // 仅 root 引擎：真实场景视图作用域引擎由弹窗创建，此处不需 link 模拟
+    root.registerModels({ UpdateRecordActionModel, AssignFormModel: TestAssignFormModel });
+
+    const action = root.createModel<UpdateRecordActionModel>({ use: 'UpdateRecordActionModel', uid: 'act-u' });
+
+    const form = root.createModel<TestAssignFormModel>({
+      use: 'AssignFormModel',
+      uid: 'form-u',
+      parentId: action.uid,
+      subKey: 'assignForm',
+    });
+    form.setAssignedValues({ nickname: 'Alice', score: 99 });
+    (action as any).assignFormUid = form.uid;
+
+    const flow = action.getFlow('assignSettings') as any;
+    const step = flow?.steps?.assignFieldValues;
+    expect(step?.beforeParamsSave).toBeTypeOf('function');
+
+    await step.beforeParamsSave({ engine: root, model: action });
+
+    const saved = action.getStepParams('assignSettings', 'assignFieldValues');
+    expect(saved?.assignedValues).toEqual({ nickname: 'Alice', score: 99 });
+  });
+});

package/src/flow/models/actions/__tests__/JSItemActionModel.test.tsx

@@ -0,0 +1,85 @@
+/**
+ * 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 React from 'react';
+import { render, screen, waitFor } from '@nocobase/test/client';
+import { App, ConfigProvider } from 'antd';
+import { describe, expect, it } from 'vitest';
+import { FlowEngine, FlowEngineProvider, FlowModelRenderer } from '@nocobase/flow-engine';
+import { JSItemActionModel } from '../JSItemActionModel';
+
+describe('JSItemActionModel', () => {
+  it('renders collection-level custom content', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ JSItemActionModel });
+
+    const model = engine.createModel<JSItemActionModel>({
+      use: 'JSItemActionModel',
+      uid: 'js-collection-item',
+      stepParams: {
+        jsSettings: {
+          runJs: {
+            version: 'v2',
+            code: `ctx.render(<span data-testid="collection-js-item">collection item</span>);`,
+          },
+        },
+      },
+    });
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>
+            <FlowModelRenderer model={model} />
+          </App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('collection-js-item')).toHaveTextContent('collection item');
+    });
+  });
+
+  it('renders record-level custom content with current row context', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ JSItemActionModel });
+
+    const model = engine.createModel<JSItemActionModel>({
+      use: 'JSItemActionModel',
+      uid: 'js-record-item',
+      stepParams: {
+        jsSettings: {
+          runJs: {
+            version: 'v2',
+            code: `ctx.render(<span data-testid="record-js-item">{ctx.record?.name}</span>);`,
+          },
+        },
+      },
+    });
+    model.context.defineProperty('record', {
+      get: () => ({ id: 1, name: 'row item' }),
+      cache: false,
+    });
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>
+            <FlowModelRenderer model={model} />
+          </App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('record-js-item')).toHaveTextContent('row item');
+    });
+  });
+});

package/src/flow/models/actions/__tests__/LinkActionModel.test.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.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import { joinUrlSearch } from '../joinUrlSearch';
+import { handleLinkNavigation, shouldDestroyViewAfterLinkNavigation } from '../LinkActionUtils';
+
+describe('handleLinkNavigation', () => {
+  it('should navigate relative link without closing popup view implicitly', () => {
+    const navigate = vi.fn();
+
+    handleLinkNavigation({
+      link: '/target-page',
+      openInNewWindow: false,
+      router: { navigate },
+      isExternalLink: false,
+    });
+
+    expect(navigate).toHaveBeenCalledWith('/target-page', { replace: true });
+  });
+
+  it('should use location href for external link', () => {
+    const navigate = vi.fn();
+    const setLocationHref = vi.fn();
+
+    handleLinkNavigation({
+      link: 'https://www.nocobase.com/docs',
+      openInNewWindow: false,
+      router: { navigate },
+      isExternalLink: true,
+      setLocationHref,
+    });
+
+    expect(setLocationHref).toHaveBeenCalledWith('https://www.nocobase.com/docs');
+    expect(navigate).not.toHaveBeenCalled();
+  });
+
+  it('should open link in new window when openInNewWindow is true', () => {
+    const navigate = vi.fn();
+    const setLocationHref = vi.fn();
+    const openWindow = vi.fn();
+
+    handleLinkNavigation({
+      link: '/target-page',
+      openInNewWindow: true,
+      router: { navigate },
+      isExternalLink: false,
+      setLocationHref,
+      openWindow,
+    });
+
+    expect(openWindow).toHaveBeenCalledWith(`${window.location.origin}/target-page`, '_blank');
+    expect(navigate).not.toHaveBeenCalled();
+    expect(setLocationHref).not.toHaveBeenCalled();
+  });
+});
+
+describe('joinUrlSearch', () => {
+  it('should append params into hash route', () => {
+    const result = joinUrlSearch('https://example.com/pcEmpAppCenter/#/usermassage', [{ name: 'exp', value: 'm' }]);
+
+    expect(result).toBe('https://example.com/pcEmpAppCenter/#/usermassage?exp=m');
+  });
+
+  it('should append params into hash route with existing hash query', () => {
+    const result = joinUrlSearch('https://example.com/pcEmpAppCenter/#/usermassage?a=1', [{ name: 'exp', value: 'm' }]);
+
+    expect(result).toBe('https://example.com/pcEmpAppCenter/#/usermassage?a=1&exp=m');
+  });
+
+  it('should append params before normal anchor hash', () => {
+    const result = joinUrlSearch('https://example.com/page#section', [{ name: 'exp', value: 'm' }]);
+
+    expect(result).toBe('https://example.com/page?exp=m#section');
+  });
+
+  it('should keep existing search params before normal anchor hash', () => {
+    const result = joinUrlSearch('https://example.com/page?a=1#section', [{ name: 'exp', value: 'm' }]);
+
+    expect(result).toBe('https://example.com/page?a=1&exp=m#section');
+  });
+});
+
+describe('shouldDestroyViewAfterLinkNavigation', () => {
+  it('should not destroy embed view for internal same-window link', () => {
+    expect(
+      shouldDestroyViewAfterLinkNavigation({
+        openInNewWindow: false,
+        isExternalLink: false,
+        viewType: 'embed',
+      }),
+    ).toBe(false);
+  });
+
+  it('should destroy popup view for internal same-window link', () => {
+    expect(
+      shouldDestroyViewAfterLinkNavigation({
+        openInNewWindow: false,
+        isExternalLink: false,
+        viewType: 'drawer',
+      }),
+    ).toBe(true);
+  });
+});

package/src/flow/models/actions/__tests__/UpdateRecordActionModel.test.ts

@@ -0,0 +1,72 @@
+/**
+ * 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 { beforeEach, describe, expect, it, vi } from 'vitest';
+import { MultiRecordResource } from '@nocobase/flow-engine';
+import { applyUpdateRecordAction } from '../UpdateRecordActionUtils';
+import { dispatchEventDeep } from '../../../utils';
+
+vi.mock('../../../utils', () => ({
+  dispatchEventDeep: vi.fn(),
+}));
+
+describe('UpdateRecordActionModel apply action', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('dispatches paginationChange for action and block after successful update', async () => {
+    const resource: any = Object.create(MultiRecordResource.prototype);
+    resource.update = vi.fn(async () => ({}));
+    resource.refresh = vi.fn(async () => {});
+
+    const blockModel: any = { uid: 'details-block' };
+    const ctx: any = {
+      model: {
+        getStepParams: vi.fn(() => undefined),
+        context: {
+          blockModel,
+        },
+      },
+      blockModel,
+      runAction: vi.fn(async () => {}),
+      collection: {
+        name: 'users',
+        getFilterByTK: vi.fn(() => 1),
+      },
+      record: {
+        id: 1,
+      },
+      resource,
+      message: {
+        success: vi.fn(),
+        warning: vi.fn(),
+        error: vi.fn(),
+      },
+      t: (value: string) => value,
+    };
+
+    await applyUpdateRecordAction(ctx, {
+      assignedValues: {
+        marital_status: '已婚',
+      },
+    });
+
+    expect(resource.update).toHaveBeenCalledWith(1, { marital_status: '已婚' }, undefined);
+    expect(resource.refresh).not.toHaveBeenCalled();
+
+    const paginationCalls = (dispatchEventDeep as any).mock.calls.filter(
+      ([, eventName]: [any, string]) => eventName === 'paginationChange',
+    );
+    expect(paginationCalls.length).toBeGreaterThan(0);
+    expect(paginationCalls.some(([model]: [any]) => model === ctx.model)).toBe(true);
+    expect(paginationCalls.some(([model]: [any]) => model === blockModel)).toBe(true);
+    expect(ctx.message.success).toHaveBeenCalledWith('Saved successfully');
+  });
+});

package/src/flow/models/actions/index.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 * from './AddNewActionModel';
+export * from './BulkDeleteActionModel';
+export * from './DeleteActionModel';
+export * from './EditActionModel';
+export * from './FilterActionModel';
+export * from './JSActionModel';
+export * from './JSCollectionActionModel';
+export * from './JSItemActionModel';
+export * from './JSRecordActionModel';
+export * from './PopupCollectionActionModel';
+export * from './RefreshActionModel';
+export * from './UpdateRecordActionModel';
+export * from './ViewActionModel';
+export * from './LinkActionModel';
+export * from './ExpandCollapseActionModel';
+export * from './AddChildActionModel';
+//

package/src/flow/models/actions/joinUrlSearch.ts

@@ -0,0 +1,42 @@
+/**
+ * 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.
+ */
+
+function mergeQueryString(url: string, params: { name: string; value: any }[]): string {
+  const questionIndex = url.indexOf('?');
+  const path = questionIndex >= 0 ? url.slice(0, questionIndex) : url;
+  const search = questionIndex >= 0 ? url.slice(questionIndex + 1) : '';
+  const searchParams = new URLSearchParams(search);
+
+  for (const { name, value } of params) {
+    searchParams.set(name, String(value));
+  }
+
+  const nextSearch = searchParams.toString();
+  return nextSearch ? `${path}?${nextSearch}` : path;
+}
+
+export function joinUrlSearch(url: string, params: { name: string; value: any }[] = []): string {
+  if (!params?.length) return url;
+
+  const filtered = params.filter((p) => p.name && p.value !== undefined && p.value !== null && p.value !== '');
+  if (!filtered.length) return url;
+
+  const hashIndex = url.indexOf('#');
+  const hasHash = hashIndex >= 0;
+  const path = hasHash ? url.slice(0, hashIndex) : url;
+  const hash = hasHash ? url.slice(hashIndex + 1) : '';
+  const isHashRoute = hash.startsWith('/') || hash.startsWith('!/');
+
+  if (hasHash && isHashRoute) {
+    return `${path}#${mergeQueryString(hash, filtered)}`;
+  }
+
+  const nextPath = mergeQueryString(path, filtered);
+  return hasHash ? `${nextPath}#${hash}` : nextPath;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * 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 { ActionGroupModel, CollectionActionGroupModel, RecordActionGroupModel } from './ActionGroupModelCore';

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

@@ -0,0 +1,117 @@
+/**
+ * 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 {
+  buildSubModelItem,
+  buildSubModelItems,
+  FlowModel,
+  FlowModelContext,
+  ModelConstructor,
+} from '@nocobase/flow-engine';
+import _ from 'lodash';
+import { ActionModel, ActionSceneEnum, ActionSceneType } from './ActionModelCore';
+import { areCapabilitiesSupported, getActionCapabilityNamesFromModelClass } from '../../utils/actionCapability';
+
+export class ActionGroupModel extends FlowModel {
+  static baseClass?: string | ModelConstructor;
+  static scene: ActionSceneType;
+  private static _models: Map<string, typeof ActionModel>;
+
+  static getAllParentClasses(): any[] {
+    const parentClasses = [];
+    let currentClass: any = this;
+
+    while (currentClass && currentClass !== Object) {
+      currentClass = Object.getPrototypeOf(currentClass);
+      if (currentClass?.currentModels) {
+        parentClasses.push(currentClass);
+      }
+    }
+
+    return parentClasses;
+  }
+
+  static get currentModels() {
+    if (!Object.prototype.hasOwnProperty.call(this, '_models') || !this._models) {
+      this._models = new Map();
+    }
+    return this._models;
+  }
+
+  static get models() {
+    const allModels = new Map();
+
+    for (const parentClass of this.getAllParentClasses()) {
+      for (const [name, M] of parentClass.currentModels) {
+        allModels.set(name, M);
+      }
+    }
+
+    for (const [name, M] of this.currentModels) {
+      allModels.set(name, M);
+    }
+
+    return allModels;
+  }
+
+  static registerActionModels(models: Record<string, any>) {
+    for (const [name, M] of Object.entries(models)) {
+      Object.defineProperty(M, 'name', { value: name });
+      this.currentModels.set(name, M);
+    }
+  }
+
+  static isActionModelVisible(ModelClass: typeof ActionModel, ctx: FlowModelContext) {
+    const collection = ctx.collection || ctx.blockModel?.collection;
+    const capabilityNames = getActionCapabilityNamesFromModelClass(ModelClass);
+    return areCapabilitiesSupported(collection, capabilityNames);
+  }
+
+  static async defineChildren(ctx: FlowModelContext) {
+    const children = this.baseClass ? await buildSubModelItems(this.baseClass)(ctx) : [];
+    const extra = [];
+
+    const items = children.filter((item) => {
+      const M = ctx.engine.getModelClass(item.useModel) as typeof ActionModel;
+      if (!this.isActionModelVisible(M, ctx)) {
+        return false;
+      }
+      if (!this.scene) {
+        return true;
+      }
+      return M._isScene(this.scene);
+    });
+
+    for (const [_, M] of this.models) {
+      if (!this.isActionModelVisible(M, ctx)) {
+        continue;
+      }
+      const r = items.find((item) => item.useModel === M.name);
+      if (r) {
+        continue;
+      }
+      const item = await buildSubModelItem(M, ctx);
+      if (item) {
+        extra.push(item);
+      }
+    }
+
+    return _.sortBy([...items, ...extra], 'sort');
+  }
+}
+
+export class CollectionActionGroupModel extends ActionGroupModel {
+  static baseClass = ActionModel;
+  static scene = ActionSceneEnum.collection;
+}
+
+export class RecordActionGroupModel extends ActionGroupModel {
+  static baseClass = ActionModel;
+  static scene = ActionSceneEnum.record;
+}