@nocobase/client-v2 2.2.0-alpha.4 → 2.2.0-alpha.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.2.0-alpha.4",
+  "version": "2.2.0-alpha.5",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -27,11 +27,11 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/evaluators": "2.2.0-alpha.4",
-    "@nocobase/flow-engine": "2.2.0-alpha.4",
-    "@nocobase/sdk": "2.2.0-alpha.4",
-    "@nocobase/shared": "2.2.0-alpha.4",
-    "@nocobase/utils": "2.2.0-alpha.4",
+    "@nocobase/evaluators": "2.2.0-alpha.5",
+    "@nocobase/flow-engine": "2.2.0-alpha.5",
+    "@nocobase/sdk": "2.2.0-alpha.5",
+    "@nocobase/shared": "2.2.0-alpha.5",
+    "@nocobase/utils": "2.2.0-alpha.5",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -46,5 +46,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "81bf8733db4bccf08a6bc5e6d97f274bce349161"
+  "gitHead": "814ff497dd1233ca7218c9f7f2a016c2ead6516d"
 }

package/src/BaseApplication.tsx

@@ -30,6 +30,7 @@ import AntdAppProvider from './theme/AntdAppProvider';
 import { GlobalThemeProvider } from './theme';
 import { AIManager } from './ai';
 import { AppError, AppMaintaining, AppMaintainingDialog, AppNotFound, AppSpin, BlankComponent } from './components';
+import { EntryActionManager } from './entry-actions';
 import { SystemSettingsSource } from './flow/system-settings';
 import { LayoutManager } from './layout-manager/LayoutManager';
 import type { PluginClass, PluginManager, PluginType } from './PluginManager';
@@ -126,6 +127,7 @@ export abstract class BaseApplication<
   public pluginManager: TPluginManager;
   public pluginSettingsManager: TPluginSettingsManager;
   public layoutManager: LayoutManager<this>;
+  public entryActionManager = new EntryActionManager();
   public aiManager!: AIManager;
   public devDynamicImport?: DevDynamicImport;
   public requirejs!: RequireJS;

package/src/RouterManager.tsx

@@ -26,6 +26,7 @@ import type { BaseApplication } from './BaseApplication';
 import { BlankComponent, RouterContextCleaner } from './components';
 import { RouterBridge } from './components/RouterBridge';
 import { Router } from '@remix-run/router';
+import { getV2EffectiveBasePath } from './authRedirect';
 
 export interface BrowserRouterOptions extends Omit<BrowserRouterProps, 'children'> {
   type?: 'browser';
@@ -55,6 +56,87 @@ export interface RouteType extends Omit<RouteObject, 'children' | 'Component'> {
 export type RenderComponentType = (Component: ComponentTypeAndString, props?: any) => React.ReactNode;
 export type RouterComponentType = React.FC<{ BaseLayout?: ComponentType }>;
 
+const DEFAULT_ADMIN_ROUTE_PATH = '/admin';
+
+type AdminRouteNavigationTarget = {
+  currentPathname?: string;
+  targetPathname: unknown;
+  basePath?: string;
+  adminRoutePath?: string;
+  replace?: boolean;
+};
+
+function trimPathSearchAndHash(pathname: string) {
+  return pathname.split(/[?#]/)[0];
+}
+
+function splitPathSearchAndHash(pathname: string) {
+  const match = pathname.match(/^([^?#]*)(.*)$/);
+  return {
+    pathname: match?.[1] || '',
+    suffix: match?.[2] || '',
+  };
+}
+
+function normalizeRootPath(pathname?: string) {
+  const trimmed = trimPathSearchAndHash(pathname || '').trim();
+  if (!trimmed || trimmed === '/') {
+    return '/';
+  }
+  return `/${trimmed.replace(/^\/+|\/+$/g, '')}`;
+}
+
+function isRootRelativePath(pathname: string) {
+  return pathname.startsWith('/') && !pathname.startsWith('//') && !pathname.startsWith('/\\');
+}
+
+function removeBasePath(pathname: string, basePath?: string) {
+  const normalizedPathname = normalizeRootPath(pathname);
+  const normalizedBasePath = normalizeRootPath(basePath);
+
+  if (normalizedBasePath === '/') {
+    return normalizedPathname;
+  }
+  if (normalizedPathname === normalizedBasePath) {
+    return '/';
+  }
+  if (normalizedPathname.startsWith(`${normalizedBasePath}/`)) {
+    return normalizeRootPath(normalizedPathname.slice(normalizedBasePath.length));
+  }
+  return normalizedPathname;
+}
+
+function removeAppSegment(pathname: string) {
+  return normalizeRootPath(pathname).replace(/^\/(?:apps|_app)\/[^/]+(?=\/|$)/, '') || '/';
+}
+
+function normalizePortalRoutePath(pathname: string, basePath?: string) {
+  return removeAppSegment(removeBasePath(pathname, basePath));
+}
+
+function isSameOrChildPath(pathname: string, basePath: string) {
+  const normalizedPathname = normalizeRootPath(pathname);
+  const normalizedBasePath = normalizeRootPath(basePath);
+  return normalizedPathname === normalizedBasePath || normalizedPathname.startsWith(`${normalizedBasePath}/`);
+}
+
+export function shouldOpenAdminRouteInNewWindow(options: AdminRouteNavigationTarget) {
+  if (options.replace || typeof options.targetPathname !== 'string') {
+    return false;
+  }
+
+  const targetPathname = options.targetPathname.trim();
+  if (!isRootRelativePath(targetPathname)) {
+    return false;
+  }
+
+  const adminRoutePath = normalizeRootPath(options.adminRoutePath || DEFAULT_ADMIN_ROUTE_PATH);
+  const currentRoutePath = normalizePortalRoutePath(options.currentPathname || '/', options.basePath);
+  const targetRoutePath = normalizePortalRoutePath(targetPathname, options.basePath);
+
+  return !isSameOrChildPath(currentRoutePath, adminRoutePath) && isSameOrChildPath(targetRoutePath, adminRoutePath);
+}
+
 function removeBasename(pathname: string, basename?: string) {
   if (!basename || basename === '/') {
     return pathname;
@@ -72,6 +154,7 @@ function removeBasename(pathname: string, basename?: string) {
 export class RouterManager<TApp extends BaseApplication<any> = BaseApplication<any>> {
   protected routes: Record<string, RouteType> = {};
   protected options: RouterOptions;
+  private routerNavigate?: Router['navigate'];
   public app: TApp;
   public router!: Router;
   get basename() {
@@ -81,7 +164,7 @@ export class RouterManager<TApp extends BaseApplication<any> = BaseApplication<a
     return this.router.state;
   }
   get navigate() {
-    return this.router.navigate;
+    return this.navigateWithPortalPolicy;
   }
 
   constructor(options: RouterOptions = {}, app: TApp) {
@@ -90,6 +173,62 @@ export class RouterManager<TApp extends BaseApplication<any> = BaseApplication<a
     this.routes = options.routes || {};
   }
 
+  private navigateWithPortalPolicy: Router['navigate'] = ((to, opts) => {
+    if (this.shouldOpenAdminRouteInNewWindow(to, opts)) {
+      window.open(this.getAdminRouteNavigationHref(to as string), '_blank', 'noopener,noreferrer');
+      return Promise.resolve();
+    }
+
+    const navigate = this.routerNavigate || this.router.navigate.bind(this.router);
+    return navigate(to, opts);
+  }) as Router['navigate'];
+
+  private shouldOpenAdminRouteInNewWindow(
+    to: Parameters<Router['navigate']>[0],
+    opts?: Parameters<Router['navigate']>[1],
+  ) {
+    if (this.options.type && this.options.type !== 'browser') {
+      return false;
+    }
+
+    return shouldOpenAdminRouteInNewWindow({
+      currentPathname:
+        typeof window !== 'undefined' ? window.location.pathname : this.router?.state?.location?.pathname,
+      targetPathname: to,
+      basePath: this.getRuntimeBasePath(),
+      adminRoutePath: this.getAdminRoutePath(),
+      replace: opts?.replace,
+    });
+  }
+
+  private getRuntimeBasePath() {
+    return getV2EffectiveBasePath(this.app);
+  }
+
+  private getAdminRoutePath() {
+    try {
+      return this.app.layoutManager?.getLayout?.('admin')?.routePath || DEFAULT_ADMIN_ROUTE_PATH;
+    } catch {
+      return DEFAULT_ADMIN_ROUTE_PATH;
+    }
+  }
+
+  private getAdminRouteNavigationHref(pathname: string) {
+    const { pathname: rawPathname, suffix } = splitPathSearchAndHash(pathname.trim());
+    const normalizedPathname = normalizeRootPath(rawPathname);
+    const runtimeBasePath = this.getRuntimeBasePath();
+    const normalizedBasePath = normalizeRootPath(runtimeBasePath);
+
+    if (
+      normalizedBasePath !== '/' &&
+      (normalizedPathname === normalizedBasePath || normalizedPathname.startsWith(`${normalizedBasePath}/`))
+    ) {
+      return `${normalizedPathname}${suffix}`;
+    }
+
+    return `${this.app.getHref(normalizePortalRoutePath(normalizedPathname, runtimeBasePath))}${suffix}`;
+  }
+
   protected resolveLoadedComponent(moduleOrComponent: ComponentLoaderResult): ComponentTypeAndString | undefined {
     if (!moduleOrComponent) {
       return undefined;
@@ -257,6 +396,8 @@ export class RouterManager<TApp extends BaseApplication<any> = BaseApplication<a
       ],
       opts,
     );
+    this.routerNavigate = this.router.navigate.bind(this.router) as Router['navigate'];
+    this.router.navigate = this.navigateWithPortalPolicy;
 
     const RenderRouter: RouterComponentType = ({ BaseLayout = BlankComponent }) => {
       return (

package/src/__tests__/RouterManager.test.ts

@@ -0,0 +1,125 @@
+/**
+ * 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 { BaseApplication } from '../BaseApplication';
+import { RouterManager, shouldOpenAdminRouteInNewWindow } from '../RouterManager';
+
+describe('RouterManager', () => {
+  describe('shouldOpenAdminRouteInNewWindow', () => {
+    it('opens admin route in a new window from a non-admin portal', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: '/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(true);
+    });
+
+    it('supports target pathname with the v2 base path', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/nocobase/v/test',
+          targetPathname: '/nocobase/v/admin/settings',
+          basePath: '/nocobase/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(true);
+    });
+
+    it('supports custom portal routes in sub-apps', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/apps/a_9xlild35jir/crm-amd/ekeisumx1zu',
+          targetPathname: '/v/apps/a_9xlild35jir/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(true);
+    });
+
+    it('keeps admin route navigation in the current window when already in sub-app admin', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/apps/a_9xlild35jir/admin',
+          targetPathname: '/v/apps/a_9xlild35jir/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+
+    it('keeps admin route navigation in the current window when already in admin', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/admin',
+          targetPathname: '/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+
+    it('keeps non-admin portal navigation in the current window', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: '/test/page',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+
+    it('does not intercept replace navigation or relative paths', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: '/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+          replace: true,
+        }),
+      ).toBe(false);
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: 'admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+  });
+
+  it('opens admin route in a new window through the underlying router navigate from a sub-app portal', async () => {
+    const app = {
+      name: 'a_9xlild35jir',
+      getPublicPath: () => '/v/',
+      getHref: (pathname: string) => `/v/apps/a_9xlild35jir/${pathname.replace(/^\/+/, '')}`,
+      layoutManager: {
+        getLayout: () => ({ routePath: '/admin' }),
+      },
+      renderComponent: () => null,
+    } as unknown as BaseApplication<unknown>;
+    const manager = new RouterManager({ type: 'browser' }, app);
+    const open = vi.spyOn(window, 'open').mockImplementation(() => null);
+
+    window.history.pushState({}, '', '/v/apps/a_9xlild35jir/crm-amd/ekeisumx1zu');
+    manager.getRouterComponent();
+    await manager.router.navigate('/admin/settings/version-control/list');
+
+    expect(open).toHaveBeenCalledWith(
+      '/v/apps/a_9xlild35jir/admin/settings/version-control/list',
+      '_blank',
+      'noopener,noreferrer',
+    );
+  });
+});

package/src/entry-actions/EntryActionManager.ts

@@ -0,0 +1,76 @@
+/**
+ * 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 {
+  define,
+  observable,
+  type FlowModelContext,
+  type SubModelItem,
+  type SubModelItemsType,
+} from '@nocobase/flow-engine';
+
+export type EntryActionScope = 'action-panel' | 'app-switcher' | string;
+
+export type EntryActionProvider = (ctx: FlowModelContext) => SubModelItem[] | Promise<SubModelItem[]>;
+
+type ProviderRecord = {
+  name: string;
+  scope: EntryActionScope;
+  provider: EntryActionProvider;
+  sort: number;
+};
+
+export class EntryActionManager {
+  private readonly providers = new Map<string, ProviderRecord>();
+  revision = 0;
+
+  constructor() {
+    define(this, {
+      revision: observable.ref,
+    });
+  }
+
+  register(name: string, options: { scope: EntryActionScope; provider: EntryActionProvider; sort?: number }) {
+    this.providers.set(name, {
+      name,
+      scope: options.scope,
+      provider: options.provider,
+      sort: options.sort ?? 0,
+    });
+    this.invalidate();
+  }
+
+  unregister(name: string) {
+    this.providers.delete(name);
+    this.invalidate();
+  }
+
+  invalidate() {
+    this.revision += 1;
+  }
+
+  getItems(scope: EntryActionScope): SubModelItemsType {
+    return async (ctx) => {
+      const providers = [...this.providers.values()]
+        .filter((item) => item.scope === scope)
+        .sort((a, b) => a.sort - b.sort);
+      const groups = await Promise.all(
+        providers.map(async (item) => {
+          try {
+            return await item.provider(ctx);
+          } catch (error) {
+            console.error(`[NocoBase] Failed to load entry action provider "${item.name}".`, error);
+            return [];
+          }
+        }),
+      );
+      return groups.flat();
+    };
+  }
+}

package/src/entry-actions/index.ts

@@ -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 * from './EntryActionManager';

package/src/flow/FlowPage.tsx

@@ -14,7 +14,7 @@ import {
   useFlowModelById,
   useFlowViewContext,
 } from '@nocobase/flow-engine';
-import type { FlowModel, FlowModelRendererProps, ModelConstructor } from '@nocobase/flow-engine';
+import type { FlowEngineContext, FlowModel, FlowModelRendererProps, ModelConstructor } from '@nocobase/flow-engine';
 import { useRequest } from 'ahooks';
 import React from 'react';
 import FlowRoute from './components/FlowRoute';
@@ -57,10 +57,36 @@ type FlowPageProps = {
   showFlowSettings?: FlowModelRendererProps['showFlowSettings'];
 };
 
+type FlowPageViewContext = FlowEngineContext & {
+  view?: {
+    inputArgs?: {
+      isMobileLayout?: unknown;
+    };
+  };
+};
+
+const bindViewLayoutState = (model: FlowModel, ctx?: FlowPageViewContext | null) => {
+  const hasViewMobileLayout = typeof ctx?.view?.inputArgs?.isMobileLayout === 'boolean';
+  const hasContextMobileLayout = typeof ctx?.isMobileLayout === 'boolean';
+  if (!hasViewMobileLayout && !hasContextMobileLayout) {
+    return;
+  }
+
+  model.context.defineProperty('isMobileLayout', {
+    get: () => {
+      if (typeof ctx?.isMobileLayout === 'boolean') {
+        return ctx.isMobileLayout;
+      }
+      return !!ctx?.view?.inputArgs?.isMobileLayout;
+    },
+    cache: false,
+  });
+};
+
 export const FlowPage = React.memo((props: FlowPageProps & Record<string, unknown>) => {
   const { pageModelClass = 'ChildPageModel', parentId, onModelLoaded, defaultTabTitle, ...rest } = props;
   const flowEngine = useFlowEngine();
-  const ctx = useFlowViewContext();
+  const ctx = useFlowViewContext<FlowPageViewContext>();
   const { loading, data, error } = useRequest(
     async () => {
       const ModelClass = await flowEngine.getModelClassAsync(pageModelClass);
@@ -105,6 +131,7 @@ export const FlowPage = React.memo((props: FlowPageProps & Record<string, unknow
       const data = await flowEngine.loadOrCreateModel(options, { skipSave: !flowEngine.context.flowSettingsEnabled });
       if (data?.uid && onModelLoaded) {
         data.context.addDelegate(ctx);
+        bindViewLayoutState(data, ctx);
         data.removeParentDelegate();
         onModelLoaded(data.uid, data);
       }