@nocobase/client-v2 2.1.26 → 2.1.28

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

@@ -59,6 +59,51 @@ vi.mock('ahooks', async (importOriginal) => {
   };
 });
 
+type RootPageTabModelClass = typeof import('../PageTabModel').RootPageTabModel;
+
+type TestRoute = {
+  schemaUid?: string;
+  options?: Record<string, unknown>;
+} & Record<string, unknown>;
+
+type RootPageTabModelTestOptions = {
+  props?: {
+    route?: TestRoute;
+  };
+  stepParams?: {
+    pageTabSettings?: {
+      tab?: {
+        title?: string;
+        icon?: string;
+        documentTitle?: string;
+      };
+    };
+  };
+  context: {
+    api: {
+      request: ReturnType<typeof vi.fn>;
+    };
+    routeRepository?: {
+      getRouteBySchemaUid?: (schemaUid: string) => TestRoute | undefined;
+      refreshAccessible?: () => Promise<unknown>;
+    };
+    refreshDesktopRoutes?: () => Promise<unknown>;
+    logger?: {
+      warn?: (context: { err: unknown }, message: string) => void;
+    };
+    t: (value: string) => string;
+  };
+};
+
+type RootPageTabModelTestConstructor = new (
+  options: RootPageTabModelTestOptions,
+) => InstanceType<RootPageTabModelClass>;
+
+function createRootPageTabModel(Model: RootPageTabModelClass, options: RootPageTabModelTestOptions) {
+  const TestModel = Model as unknown as RootPageTabModelTestConstructor;
+  return new TestModel(options);
+}
+
 describe('PageTabModel', () => {
   beforeEach(() => {
     vi.resetModules();
@@ -113,7 +158,7 @@ describe('PageTabModel', () => {
   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({
+    const model = createRootPageTabModel(RootPageTabModel, {
       props: {
         route: {
           schemaUid: 'tab-1',
@@ -132,7 +177,7 @@ describe('PageTabModel', () => {
         api: { request },
         t: (value: string) => value,
       },
-    } as any);
+    });
 
     await model.save();
 
@@ -141,6 +186,413 @@ describe('PageTabModel', () => {
     expect(call.data.options.documentTitle).toBe('Tab doc title');
   });
 
+  it('should update a persisted tab route by id with only editable fields and latest options', async () => {
+    const { RootPageTabModel } = await import('../PageTabModel');
+    const request = vi.fn().mockResolvedValue({});
+    const model = createRootPageTabModel(RootPageTabModel, {
+      props: {
+        route: {
+          id: 123,
+          parentId: 456,
+          schemaUid: 'tab-1',
+          type: 'tabs',
+          sort: 1,
+          hidden: true,
+          tabSchemaName: 'tab-name-1',
+          hideInMenu: false,
+          enableTabs: false,
+          roles: [{ name: 'admin', title: 'Admin' }],
+          createdAt: '2026-07-16T00:00:00.000Z',
+          updatedAt: '2026-07-16T01:00:00.000Z',
+          options: {
+            badge: {
+              showZero: false,
+            },
+            pluginState: 'stale',
+            removedPluginState: 'stale-only',
+            flowRegistry: { stale: true },
+            documentTitle: 'Stale document title',
+          },
+        },
+      },
+      stepParams: {
+        pageTabSettings: {
+          tab: {
+            title: 'Renamed tab',
+            icon: 'TableOutlined',
+            documentTitle: 'Current document title',
+          },
+        },
+      },
+      context: {
+        api: { request },
+        routeRepository: {
+          getRouteBySchemaUid: vi.fn(() => ({
+            schemaUid: 'tab-1',
+            options: {
+              badge: {
+                showZero: true,
+              },
+              pluginState: 'fresh',
+              flowRegistry: { fresh: true },
+              documentTitle: 'Fresh document title',
+            },
+          })),
+        },
+        t: (value: string) => value,
+      },
+    });
+
+    await model.save();
+
+    const call = request.mock.calls[0][0];
+    expect(call).toEqual({
+      method: 'post',
+      url: 'desktopRoutes:update?filter[id]=123',
+      data: {
+        schemaUid: 'tab-1',
+        title: 'Renamed tab',
+        icon: 'TableOutlined',
+        options: {
+          badge: {
+            showZero: true,
+          },
+          pluginState: 'fresh',
+          flowRegistry: {},
+          documentTitle: 'Current document title',
+        },
+      },
+    });
+    expect(Object.keys(call.data).sort()).toEqual(['icon', 'options', 'schemaUid', 'title']);
+  });
+
+  it('should fall back to model route options when the current route is unavailable', async () => {
+    const { RootPageTabModel } = await import('../PageTabModel');
+    const request = vi.fn().mockResolvedValue({});
+    const model = createRootPageTabModel(RootPageTabModel, {
+      props: {
+        route: {
+          id: 123,
+          parentId: 456,
+          schemaUid: 'tab-1',
+          type: 'tabs',
+          sort: 1,
+          hidden: true,
+          options: {
+            badge: {
+              showZero: true,
+            },
+          },
+        },
+      },
+      stepParams: {
+        pageTabSettings: {
+          tab: {
+            title: 'Renamed tab',
+          },
+        },
+      },
+      context: {
+        api: { request },
+        routeRepository: {
+          getRouteBySchemaUid: vi.fn(() => undefined),
+        },
+        t: (value: string) => value,
+      },
+    });
+
+    await model.save();
+
+    const call = request.mock.calls[0][0];
+    expect(call).toEqual({
+      method: 'post',
+      url: 'desktopRoutes:update?filter[id]=123',
+      data: {
+        schemaUid: 'tab-1',
+        title: 'Renamed tab',
+        icon: undefined,
+        options: {
+          badge: {
+            showZero: true,
+          },
+          flowRegistry: {},
+          documentTitle: undefined,
+        },
+      },
+    });
+  });
+
+  it('should await a route refresh after the request before a subsequent persisted tab save', async () => {
+    const { RootPageTabModel } = await import('../PageTabModel');
+    const events: string[] = [];
+    let resolveFirstRefresh: () => void = () => {};
+    const firstRefreshDone = new Promise<void>((resolve) => {
+      resolveFirstRefresh = resolve;
+    });
+    let currentRoute = {
+      schemaUid: 'tab-1',
+      options: {
+        pluginState: 'before-save',
+      },
+    };
+    let requestCall = 0;
+    const request = vi.fn(async () => {
+      requestCall += 1;
+      events.push(`request:${requestCall}`);
+      if (requestCall === 1) {
+        return {
+          data: {
+            data: [
+              {
+                id: 123,
+                schemaUid: 'tab-1',
+                options: {
+                  pluginState: 'after-save',
+                  serverHookState: true,
+                },
+              },
+            ],
+          },
+        };
+      }
+      return {};
+    });
+    let refreshCall = 0;
+    const refreshAccessible = vi.fn(async () => {
+      refreshCall += 1;
+      events.push(`refresh:${refreshCall}:start`);
+      if (refreshCall === 1) {
+        await firstRefreshDone;
+        currentRoute = {
+          schemaUid: 'tab-1',
+          options: {
+            pluginState: 'after-save',
+            serverHookState: true,
+          },
+        };
+      }
+      events.push(`refresh:${refreshCall}:end`);
+    });
+    const model = createRootPageTabModel(RootPageTabModel, {
+      props: {
+        route: {
+          id: 123,
+          schemaUid: 'tab-1',
+        },
+      },
+      stepParams: {
+        pageTabSettings: {
+          tab: {
+            title: 'Renamed tab',
+          },
+        },
+      },
+      context: {
+        api: { request },
+        routeRepository: {
+          getRouteBySchemaUid: vi.fn(() => currentRoute),
+          refreshAccessible,
+        },
+        t: (value: string) => value,
+      },
+    });
+
+    let firstSaveResolved = false;
+    const firstSave = model.save().then(() => {
+      firstSaveResolved = true;
+      events.push('save:1:end');
+    });
+
+    await vi.waitFor(() => expect(refreshAccessible).toHaveBeenCalledTimes(1));
+    expect(events.slice(0, 2)).toEqual(['request:1', 'refresh:1:start']);
+    await Promise.resolve();
+    expect(firstSaveResolved).toBe(false);
+
+    resolveFirstRefresh();
+    await firstSave;
+    expect(events.indexOf('request:1')).toBeLessThan(events.indexOf('refresh:1:start'));
+    expect(events.indexOf('refresh:1:end')).toBeLessThan(events.indexOf('save:1:end'));
+
+    await model.save();
+
+    expect(refreshAccessible).toHaveBeenCalledTimes(2);
+    expect(request.mock.calls[1][0].data.options).toMatchObject({
+      pluginState: 'after-save',
+      serverHookState: true,
+    });
+  });
+
+  it('should serialize route refreshes when new tabs are saved concurrently', async () => {
+    const { RootPageTabModel } = await import('../PageTabModel');
+    let releaseFirstRefresh: () => void = () => {};
+    const firstRefreshDone = new Promise<void>((resolve) => {
+      releaseFirstRefresh = resolve;
+    });
+    let refreshCall = 0;
+    let activeRefreshes = 0;
+    let maxActiveRefreshes = 0;
+    const refreshAccessible = vi.fn(async () => {
+      refreshCall += 1;
+      activeRefreshes += 1;
+      maxActiveRefreshes = Math.max(maxActiveRefreshes, activeRefreshes);
+      if (refreshCall === 1) {
+        await firstRefreshDone;
+      }
+      activeRefreshes -= 1;
+    });
+    const request = vi
+      .fn()
+      .mockResolvedValueOnce({
+        data: {
+          data: {
+            id: 101,
+            schemaUid: 'tab-1',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          data: {
+            id: 102,
+            schemaUid: 'tab-2',
+          },
+        },
+      });
+    const routeRepository = {
+      refreshAccessible,
+    };
+    const createModel = (schemaUid: string, title: string) =>
+      createRootPageTabModel(RootPageTabModel, {
+        props: {
+          route: {
+            parentId: 999,
+            schemaUid,
+            tabSchemaName: `${schemaUid}-name`,
+            type: 'tabs',
+          },
+        },
+        stepParams: {
+          pageTabSettings: {
+            tab: {
+              title,
+            },
+          },
+        },
+        context: {
+          api: { request },
+          routeRepository,
+          t: (value: string) => value,
+        },
+      });
+
+    const saves = Promise.all([createModel('tab-1', 'Tab 1').save(), createModel('tab-2', 'Tab 2').save()]);
+
+    await vi.waitFor(() => expect(request).toHaveBeenCalledTimes(2));
+    await vi.waitFor(() => expect(refreshAccessible).toHaveBeenCalled());
+    await Promise.resolve();
+    await Promise.resolve();
+    const refreshCallsBeforeRelease = refreshAccessible.mock.calls.length;
+
+    releaseFirstRefresh();
+    await saves;
+
+    expect(refreshCallsBeforeRelease).toBe(1);
+    expect(refreshAccessible).toHaveBeenCalledTimes(2);
+    expect(maxActiveRefreshes).toBe(1);
+  });
+
+  it('should keep a successful route save when refreshing the route cache fails', async () => {
+    const { RootPageTabModel } = await import('../PageTabModel');
+    const refreshError = new Error('refresh failed');
+    const request = vi
+      .fn()
+      .mockResolvedValueOnce({
+        data: {
+          data: {
+            id: 123,
+            schemaUid: 'tab-1',
+          },
+        },
+      })
+      .mockResolvedValueOnce({});
+    const refreshAccessible = vi.fn().mockRejectedValueOnce(refreshError).mockResolvedValueOnce([]);
+    const warn = vi.fn();
+    const model = createRootPageTabModel(RootPageTabModel, {
+      props: {
+        route: {
+          parentId: 999,
+          schemaUid: 'tab-1',
+          tabSchemaName: 'tab-name-1',
+          type: 'tabs',
+        },
+      },
+      stepParams: {
+        pageTabSettings: {
+          tab: {
+            title: 'Tab title',
+          },
+        },
+      },
+      context: {
+        api: { request },
+        routeRepository: {
+          refreshAccessible,
+        },
+        logger: { warn },
+        t: (value: string) => value,
+      },
+    });
+
+    await expect(model.save()).resolves.toBeUndefined();
+
+    expect(model.props.route.id).toBe(123);
+    expect(warn).toHaveBeenCalledWith(
+      { err: refreshError },
+      '[client-v2] Failed to refresh desktop routes after saving a page tab',
+    );
+
+    await expect(model.save()).resolves.toBeUndefined();
+    expect(refreshAccessible).toHaveBeenCalledTimes(2);
+  });
+
+  it('should still reject when writing the tab route fails', async () => {
+    const { RootPageTabModel } = await import('../PageTabModel');
+    const writeError = new Error('write failed');
+    const request = vi.fn().mockRejectedValue(writeError);
+    const refreshAccessible = vi.fn().mockResolvedValue([]);
+    const warn = vi.fn();
+    const model = createRootPageTabModel(RootPageTabModel, {
+      props: {
+        route: {
+          parentId: 999,
+          schemaUid: 'tab-1',
+          tabSchemaName: 'tab-name-1',
+          type: 'tabs',
+        },
+      },
+      stepParams: {
+        pageTabSettings: {
+          tab: {
+            title: 'Tab title',
+          },
+        },
+      },
+      context: {
+        api: { request },
+        routeRepository: {
+          refreshAccessible,
+        },
+        logger: { warn },
+        t: (value: string) => value,
+      },
+    });
+
+    await expect(model.save()).rejects.toBe(writeError);
+    expect(refreshAccessible).not.toHaveBeenCalled();
+    expect(warn).not.toHaveBeenCalled();
+    expect(model.props.route.id).toBeUndefined();
+  });
+
   it('should sync persisted route id after save', async () => {
     const { RootPageTabModel } = await import('../PageTabModel');
     const request = vi.fn().mockResolvedValue({
@@ -152,16 +604,24 @@ describe('PageTabModel', () => {
         },
       },
     });
-    const model = new RootPageTabModel({
+    const model = createRootPageTabModel(RootPageTabModel, {
       props: {
         route: {
+          parentId: 999,
           schemaUid: 'tab-1',
+          tabSchemaName: 'tab-name-1',
+          type: 'tabs',
+          params: [],
+          hideInMenu: false,
+          enableTabs: false,
         },
       },
       stepParams: {
         pageTabSettings: {
           tab: {
             title: 'Tab title',
+            icon: 'TableOutlined',
+            documentTitle: 'Tab document title',
           },
         },
       },
@@ -169,10 +629,33 @@ describe('PageTabModel', () => {
         api: { request },
         t: (value: string) => value,
       },
-    } as any);
+    });
 
     await model.save();
 
+    const call = request.mock.calls[0][0];
+    expect(call).toEqual({
+      method: 'post',
+      url: 'desktopRoutes:updateOrCreate',
+      params: {
+        filterKeys: ['schemaUid'],
+      },
+      data: {
+        parentId: 999,
+        schemaUid: 'tab-1',
+        tabSchemaName: 'tab-name-1',
+        type: 'tabs',
+        params: [],
+        hideInMenu: false,
+        enableTabs: false,
+        title: 'Tab title',
+        icon: 'TableOutlined',
+        options: {
+          flowRegistry: {},
+          documentTitle: 'Tab document title',
+        },
+      },
+    });
     expect(model.props.route.id).toBe(123);
     expect(model.props.route.sort).toBe(9);
   });
@@ -192,7 +675,7 @@ describe('PageTabModel', () => {
         ],
       },
     });
-    const model = new RootPageTabModel({
+    const model = createRootPageTabModel(RootPageTabModel, {
       props: {
         route: {
           schemaUid: 'tab-1',
@@ -212,7 +695,7 @@ describe('PageTabModel', () => {
         api: { request },
         t: (value: string) => value,
       },
-    } as any);
+    });
 
     await model.save();
 

package/src/flow/models/base/__tests__/CollectionBlockModel.addAppends.test.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { FlowEngine, FlowModelContext, MultiRecordResource } from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+import { CollectionBlockModel } from '../CollectionBlockModel';
+
+class AddAppendsCollectionBlockModel extends CollectionBlockModel {
+  createResource(ctx: FlowModelContext) {
+    return ctx.createResource(MultiRecordResource);
+  }
+}
+
+describe('CollectionBlockModel addAppends', () => {
+  it('does not throw for a nested field path when the collection is unavailable', () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ AddAppendsCollectionBlockModel });
+
+    const model = engine.createModel<AddAppendsCollectionBlockModel>({
+      uid: 'missing-collection-add-appends-block',
+      use: 'AddAppendsCollectionBlockModel',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'missing_collection',
+          },
+        },
+      },
+    });
+
+    expect(model.collection).toBeUndefined();
+    expect(() => model.addAppends('createdBy.departments')).not.toThrow();
+  });
+});

package/src/locale/languageCodes.ts

@@ -54,6 +54,7 @@ export const languageCodes: Record<string, LocaleOptions> = {
   'ml-IN': { label: 'മലയാളം' },
   'mn-MN': { label: 'Монгол хэл' },
   'ms-MY': { label: 'بهاس ملايو' },
+  'my-MM': { label: 'မြန်မာဘာသာ' },
   'nb-NO': { label: 'Norsk bokmål' },
   'ne-NP': { label: 'नेपाली' },
   'nl-BE': { label: 'Vlaams' },