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

package/src/flow/models/base/PageModel/__tests__/PageTabModel.test.ts

@@ -0,0 +1,225 @@
+/**
+ * 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';
+
+const { registerFlowMock } = vi.hoisted(() => ({
+  registerFlowMock: vi.fn(),
+}));
+
+vi.mock('@nocobase/flow-engine', async (importOriginal) => {
+  const actual = await importOriginal<any>();
+  return {
+    ...actual,
+    FlowModel: class {
+      props: any;
+      context: any;
+      stepParams: any;
+
+      constructor(options: any = {}) {
+        this.props = options.props || {};
+        this.context = options.context || {};
+        this.stepParams = options.stepParams || {};
+      }
+
+      serialize() {
+        return { flowRegistry: {} };
+      }
+
+      setProps(key: string, value: any) {
+        this.props[key] = value;
+      }
+
+      onInit() {}
+      static registerFlow(flow: any) {
+        registerFlowMock(flow);
+      }
+      static registerEvents() {}
+      static define() {}
+    },
+    tExpr: (str: string) => str,
+    FlowModelRenderer: () => null,
+    observable: {
+      ref: (value: any) => value,
+    },
+  };
+});
+
+vi.mock('ahooks', async (importOriginal) => {
+  const actual = await importOriginal<any>();
+  return {
+    ...actual,
+    useRequest: () => ({ data: null, loading: false }),
+  };
+});
+
+describe('PageTabModel', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+  });
+
+  it('should expose documentTitle field in Edit tab settings', async () => {
+    await import('../PageTabModel');
+    const flow = registerFlowMock.mock.calls.find((call) => call[0]?.key === 'pageTabSettings')?.[0];
+
+    expect(flow).toBeTruthy();
+    expect(flow.steps.tab.uiSchema.documentTitle).toMatchObject({
+      type: 'string',
+      title: 'Document title',
+      'x-decorator': 'FormItem',
+    });
+    expect(flow.steps.tab.uiSchema.documentTitle.description).toContain('browser tab title');
+  });
+
+  it('should place documentTitle right below tab name in Edit tab settings', async () => {
+    await import('../PageTabModel');
+    const flow = registerFlowMock.mock.calls.find((call) => call[0]?.key === 'pageTabSettings')?.[0];
+    const keys = Object.keys(flow.steps.tab.uiSchema);
+
+    expect(keys.indexOf('documentTitle')).toBe(keys.indexOf('title') + 1);
+  });
+
+  it('should trigger parent page title update in tab settings handler', async () => {
+    await import('../PageTabModel');
+    const flow = registerFlowMock.mock.calls.find((call) => call[0]?.key === 'pageTabSettings')?.[0];
+    const handler = flow.steps.tab.handler;
+
+    const setProps = vi.fn();
+    const updateDocumentTitle = vi.fn().mockResolvedValue(undefined);
+    const ctx = {
+      model: {
+        parentId: 'page-1',
+        setProps,
+      },
+      engine: {
+        getModel: vi.fn(() => ({ updateDocumentTitle })),
+      },
+    } as any;
+
+    await handler(ctx, { title: 'New tab', icon: 'TableOutlined', documentTitle: 'Tab doc title' });
+
+    expect(setProps).toHaveBeenCalledWith('title', 'New tab');
+    expect(setProps).toHaveBeenCalledWith('icon', 'TableOutlined');
+    expect(updateDocumentTitle).toHaveBeenCalledTimes(1);
+  });
+
+  it('should persist tab documentTitle to route options on save', async () => {
+    const { RootPageTabModel } = await import('../PageTabModel');
+    const request = vi.fn().mockResolvedValue({});
+    const model = new RootPageTabModel({
+      props: {
+        route: {
+          schemaUid: 'tab-1',
+        },
+      },
+      stepParams: {
+        pageTabSettings: {
+          tab: {
+            title: 'Tab title',
+            icon: 'TableOutlined',
+            documentTitle: 'Tab doc title',
+          },
+        },
+      },
+      context: {
+        api: { request },
+        t: (value: string) => value,
+      },
+    } as any);
+
+    await model.save();
+
+    const call = request.mock.calls[0][0];
+    expect(call.url).toBe('desktopRoutes:updateOrCreate');
+    expect(call.data.options.documentTitle).toBe('Tab doc title');
+  });
+
+  it('should sync persisted route id after save', async () => {
+    const { RootPageTabModel } = await import('../PageTabModel');
+    const request = vi.fn().mockResolvedValue({
+      data: {
+        data: {
+          id: 123,
+          schemaUid: 'tab-1',
+          sort: 9,
+        },
+      },
+    });
+    const model = new RootPageTabModel({
+      props: {
+        route: {
+          schemaUid: 'tab-1',
+        },
+      },
+      stepParams: {
+        pageTabSettings: {
+          tab: {
+            title: 'Tab title',
+          },
+        },
+      },
+      context: {
+        api: { request },
+        t: (value: string) => value,
+      },
+    } as any);
+
+    await model.save();
+
+    expect(model.props.route.id).toBe(123);
+    expect(model.props.route.sort).toBe(9);
+  });
+
+  it('should sync persisted route when updateOrCreate returns array', async () => {
+    const { RootPageTabModel } = await import('../PageTabModel');
+    const request = vi.fn().mockResolvedValue({
+      data: {
+        data: [
+          {
+            id: 456,
+            schemaUid: 'tab-1',
+            options: {
+              documentTitle: 'Server doc title',
+            },
+          },
+        ],
+      },
+    });
+    const model = new RootPageTabModel({
+      props: {
+        route: {
+          schemaUid: 'tab-1',
+          options: {
+            flowRegistry: {},
+          },
+        },
+      },
+      stepParams: {
+        pageTabSettings: {
+          tab: {
+            title: 'Tab title',
+          },
+        },
+      },
+      context: {
+        api: { request },
+        t: (value: string) => value,
+      },
+    } as any);
+
+    await model.save();
+
+    expect(model.props.route.id).toBe(456);
+    expect(model.props.route.options).toMatchObject({
+      flowRegistry: {},
+      documentTitle: 'Server doc title',
+    });
+  });
+});

package/src/flow/models/base/PageModel/__tests__/RootPageModel.test.ts

@@ -0,0 +1,242 @@
+/**
+ * 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 { RootPageModel } from '../RootPageModel';
+
+// Mock PageModel
+const mockPageModelSaveStepParams = vi.fn();
+vi.mock('../PageModel', () => ({
+  PageModel: class {
+    static registerFlow() {}
+
+    async saveStepParams() {
+      return mockPageModelSaveStepParams();
+    }
+  },
+}));
+
+describe('RootPageModel', () => {
+  let rootPageModel: RootPageModel;
+  let mockContext: any;
+  let mockApi: any;
+  let mockFlowEngine: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Mock API
+    mockApi = {
+      request: vi.fn().mockResolvedValue({ data: { success: true } }),
+    };
+
+    // Mock FlowEngine
+    mockFlowEngine = {
+      getModel: vi.fn(),
+      moveModel: vi.fn(),
+    };
+
+    // Mock context
+    mockContext = {
+      api: mockApi,
+    };
+
+    // Create RootPageModel instance
+    rootPageModel = new RootPageModel({});
+    (rootPageModel as any).context = mockContext;
+    (rootPageModel as any).flowEngine = mockFlowEngine;
+    (rootPageModel as any).props = {
+      routeId: 'route-123',
+    };
+    (rootPageModel as any).stepParams = {
+      pageSettings: {
+        general: {
+          enableTabs: true,
+        },
+      },
+    };
+  });
+
+  describe('saveStepParams', () => {
+    it('should call parent saveStepParams method', async () => {
+      await rootPageModel.saveStepParams();
+
+      expect(mockPageModelSaveStepParams).toHaveBeenCalledTimes(1);
+    });
+
+    it('should send API request to update route with enableTabs=true', async () => {
+      (rootPageModel as any).stepParams = {
+        pageSettings: {
+          general: {
+            enableTabs: true,
+          },
+        },
+      };
+
+      await rootPageModel.saveStepParams();
+
+      expect(mockApi.request).toHaveBeenCalledWith({
+        url: 'desktopRoutes:update?filter[id]=route-123',
+        method: 'post',
+        data: {
+          enableTabs: true,
+        },
+      });
+    });
+  });
+
+  describe('handleDragEnd', () => {
+    it('should call API request to move route and flowEngine.moveModel', async () => {
+      const mockActiveModel = {
+        uid: 'active-uid',
+        props: { route: { id: 'active-route-id' } },
+      };
+      const mockOverModel = {
+        uid: 'over-uid',
+        props: { route: { id: 'over-route-id' } },
+      };
+
+      const mockDragEndEvent = {
+        active: { id: 'active-model-id' },
+        over: { id: 'over-model-id' },
+      };
+
+      mockFlowEngine.getModel.mockReturnValueOnce(mockActiveModel).mockReturnValueOnce(mockOverModel);
+
+      await rootPageModel.handleDragEnd(mockDragEndEvent as any);
+
+      expect(mockFlowEngine.getModel).toHaveBeenCalledTimes(2);
+      expect(mockFlowEngine.getModel).toHaveBeenNthCalledWith(1, 'active-model-id');
+      expect(mockFlowEngine.getModel).toHaveBeenNthCalledWith(2, 'over-model-id');
+
+      expect(mockApi.request).toHaveBeenCalledWith({
+        url: 'desktopRoutes:move',
+        method: 'post',
+        params: {
+          sourceId: 'active-route-id',
+          targetId: 'over-route-id',
+          sortField: 'sort',
+        },
+      });
+
+      expect(mockFlowEngine.moveModel).toHaveBeenCalledWith('active-uid', 'over-uid', { persist: false });
+    });
+
+    it('should save new tab before moving when route id is missing', async () => {
+      const mockActiveModel = {
+        uid: 'active-uid',
+        props: { route: { schemaUid: 'active-schema-uid' } as { schemaUid: string; id?: string } },
+        save: vi.fn(async () => {
+          mockActiveModel.props.route.id = 'active-route-id';
+        }),
+      };
+      const mockOverModel = {
+        uid: 'over-uid',
+        props: { route: { id: 'over-route-id' } },
+        save: vi.fn(),
+      };
+
+      const mockDragEndEvent = {
+        active: { id: 'active-model-id' },
+        over: { id: 'over-model-id' },
+      };
+
+      mockFlowEngine.getModel.mockReturnValueOnce(mockActiveModel).mockReturnValueOnce(mockOverModel);
+
+      await rootPageModel.handleDragEnd(mockDragEndEvent as any);
+
+      expect(mockActiveModel.save).toHaveBeenCalledTimes(1);
+      expect(mockOverModel.save).not.toHaveBeenCalled();
+      expect(mockApi.request).toHaveBeenCalledWith({
+        url: 'desktopRoutes:move',
+        method: 'post',
+        params: {
+          sourceId: 'active-route-id',
+          targetId: 'over-route-id',
+          sortField: 'sort',
+        },
+      });
+      expect(mockFlowEngine.moveModel).toHaveBeenCalledWith('active-uid', 'over-uid', { persist: false });
+    });
+
+    it('should skip self-drop to avoid duplicate saves for the same new tab', async () => {
+      const mockModel = {
+        uid: 'same-uid',
+        props: { route: { schemaUid: 'same-schema-uid' } },
+        save: vi.fn(),
+      };
+
+      const mockDragEndEvent = {
+        active: { id: 'same-model-id' },
+        over: { id: 'same-model-id' },
+      };
+
+      mockFlowEngine.getModel.mockReturnValue(mockModel);
+
+      await rootPageModel.handleDragEnd(mockDragEndEvent as any);
+
+      expect(mockModel.save).not.toHaveBeenCalled();
+      expect(mockApi.request).not.toHaveBeenCalled();
+      expect(mockFlowEngine.moveModel).not.toHaveBeenCalled();
+    });
+
+    it('should handle case when activeModel is not found', async () => {
+      const mockDragEndEvent = {
+        active: { id: 'active-model-id' },
+        over: { id: 'over-model-id' },
+      };
+
+      mockFlowEngine.getModel
+        .mockReturnValueOnce(null)
+        .mockReturnValueOnce({ uid: 'over-uid', props: { route: { id: 'over-route-id' } } });
+      await rootPageModel.handleDragEnd(mockDragEndEvent as any);
+      expect(mockApi.request).not.toHaveBeenCalled();
+      expect(mockFlowEngine.moveModel).not.toHaveBeenCalled();
+    });
+
+    it('should handle case when overModel is not found', async () => {
+      const mockDragEndEvent = {
+        active: { id: 'active-model-id' },
+        over: { id: 'over-model-id' },
+      };
+
+      mockFlowEngine.getModel
+        .mockReturnValueOnce({ uid: 'active-uid', props: { route: { id: 'active-route-id' } } })
+        .mockReturnValueOnce(null);
+      // 实现选择静默返回而非抛错，这里只断言无副作用
+      await rootPageModel.handleDragEnd(mockDragEndEvent as any);
+      expect(mockApi.request).not.toHaveBeenCalled();
+      expect(mockFlowEngine.moveModel).not.toHaveBeenCalled();
+    });
+
+    it('should handle API request failure gracefully', async () => {
+      const mockActiveModel = {
+        uid: 'active-uid',
+        props: { route: { id: 'active-route-id' } },
+      };
+      const mockOverModel = {
+        uid: 'over-uid',
+        props: { route: { id: 'over-route-id' } },
+      };
+
+      const mockDragEndEvent = {
+        active: { id: 'active-model-id' },
+        over: { id: 'over-model-id' },
+      };
+
+      mockFlowEngine.getModel.mockReturnValueOnce(mockActiveModel).mockReturnValueOnce(mockOverModel);
+
+      mockApi.request.mockRejectedValueOnce(new Error('API Error'));
+
+      await expect(rootPageModel.handleDragEnd(mockDragEndEvent as any)).rejects.toThrow('API Error');
+
+      expect(mockFlowEngine.moveModel).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/flow/models/base/PageModel/closeGuard.ts

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ */
+
+type CloseGuardContext = {
+  inputArgs?: {
+    dirty?: {
+      hasDirtyForms?: boolean;
+      formModelUids?: string[];
+    };
+    controller?: {
+      prevent?: () => void;
+    };
+  };
+  modal: {
+    confirm: (options: {
+      title: string;
+      content: string;
+      okText: string;
+      cancelText: string;
+    }) => boolean | Promise<boolean>;
+  };
+  t: (value: string) => string;
+  exitAll: () => void;
+};
+
+export async function confirmUnsavedChangesHandler(ctx: CloseGuardContext) {
+  if (!ctx.inputArgs?.dirty?.hasDirtyForms) {
+    return;
+  }
+
+  const confirmed = await ctx.modal.confirm({
+    title: ctx.t('Unsaved changes'),
+    content: ctx.t("Are you sure you don't want to save?"),
+    okText: ctx.t('Confirm'),
+    cancelText: ctx.t('Cancel'),
+  });
+
+  if (!confirmed) {
+    ctx.inputArgs?.controller?.prevent?.();
+    ctx.exitAll();
+  }
+}

package/src/flow/models/base/PageModel/index.tsx

@@ -0,0 +1,16 @@
+/**
+ * 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 './ChildPageModel';
+export * from './MainPageModel';
+export * from './PageModel';
+export * from './PageTabModel';
+export * from './RootPageModel';
+export * from './SubPageModel';
+//

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

@@ -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.
+ */
+
+import { tExpr } from '@nocobase/flow-engine';
+import { ButtonProps } from 'antd';
+import { openViewFlow } from '../../flows/openViewFlow';
+import { ActionModel } from './ActionModel';
+
+export class PopupActionModel extends ActionModel {
+  defaultProps: ButtonProps = {
+    title: tExpr('Popup'),
+    icon: 'ExportOutlined',
+  };
+}
+
+PopupActionModel.define({
+  label: tExpr('Popup'),
+});
+
+PopupActionModel.registerFlow(openViewFlow);

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

@@ -0,0 +1,23 @@
+/**
+ * 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 { buildSubModelItems, DefaultStructure } from '@nocobase/flow-engine';
+import { ActionModel, ActionSceneEnum } from './ActionModel';
+
+export class RecordActionModel<T extends DefaultStructure = DefaultStructure> extends ActionModel<T> {}
+
+RecordActionModel.define({
+  children: async (ctx) => {
+    const children = await buildSubModelItems(ActionModel)(ctx);
+    return children.filter((item) => {
+      const M = ctx.engine.getModelClass(item.useModel) as typeof ActionModel;
+      return M._isScene(ActionSceneEnum.record);
+    });
+  },
+});

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

@@ -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.
+ */
+
+import { DefaultStructure, FlowModel } from '@nocobase/flow-engine';
+
+export class RouteModel<T = DefaultStructure> extends FlowModel<T> {}
+
+RouteModel.registerFlow({
+  key: 'popupSettings',
+  on: 'click',
+  steps: {
+    openView: {
+      use: 'openView',
+      defaultParams(ctx) {
+        return {
+          mode: 'embed',
+          preventClose: true,
+          pageModelClass: 'RootPageModel',
+        };
+      },
+    },
+  },
+});