@nocobase/client-v2 2.2.0-beta.1 → 2.2.0-beta.3

package/src/flow/utils/formValueDeps.ts

@@ -0,0 +1,170 @@
+/**
+ * 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 { FlowContext } from '@nocobase/flow-engine';
+import { namePathToPathKey, parsePathString, pathKeyToNamePath } from '../models/blocks/form/value-runtime/path';
+
+export type NamePath = Array<string | number>;
+
+export type FieldIndexEntry = {
+  name: string;
+  index: number;
+};
+
+export function isSameNamePath(a: NamePath, b: NamePath) {
+  return a.length === b.length && a.every((seg, index) => seg === b[index]);
+}
+
+export function isNamePathPrefix(prefix: NamePath, path: NamePath) {
+  if (prefix.length > path.length) return false;
+  return prefix.every((seg, index) => seg === path[index]);
+}
+
+export function dedupeNamePaths(paths: NamePath[]) {
+  const byKey = new Map<string, NamePath>();
+  for (const path of paths) {
+    if (!path?.length) continue;
+    byKey.set(namePathToPathKey(path), path);
+  }
+  return Array.from(byKey.values());
+}
+
+export function minimizeNamePaths(paths: NamePath[]) {
+  const deduped = dedupeNamePaths(paths);
+  return deduped.filter((path, index) => {
+    return !deduped.some((other, otherIndex) => otherIndex !== index && isNamePathPrefix(path, other));
+  });
+}
+
+export function parseFieldIndexEntries(fieldIndex: unknown): FieldIndexEntry[] {
+  const arr = Array.isArray(fieldIndex) ? fieldIndex : [];
+  const entries: FieldIndexEntry[] = [];
+  for (const item of arr) {
+    if (typeof item !== 'string') continue;
+    const [name, indexStr] = item.split(':');
+    const index = Number(indexStr);
+    if (!name || Number.isNaN(index)) continue;
+    entries.push({ name, index });
+  }
+  return entries;
+}
+
+export function getFieldIndexEntriesFromContext(ctx: FlowContext | { model?: unknown; fieldIndex?: unknown }) {
+  const model = ctx?.model as { context?: { fieldIndex?: unknown } } | undefined;
+  return parseFieldIndexEntries(model?.context?.fieldIndex ?? (ctx as { fieldIndex?: unknown })?.fieldIndex);
+}
+
+export function buildItemRowPath(entries: FieldIndexEntry[], parentDepth: number): NamePath | null {
+  const targetIndex = entries.length - 1 - parentDepth;
+  if (targetIndex < 0) return null;
+
+  const out: NamePath = [];
+  for (let index = 0; index <= targetIndex; index++) {
+    out.push(entries[index].name, entries[index].index);
+  }
+  return out;
+}
+
+export function buildItemListRootPath(entries: FieldIndexEntry[], parentDepth: number): NamePath | null {
+  const rowPath = buildItemRowPath(entries, parentDepth);
+  if (!rowPath?.length) return null;
+  return rowPath.slice(0, -1);
+}
+
+export function parseDependencyPath(subPath: string): NamePath {
+  return parsePathString(subPath).filter((seg) => typeof seg !== 'object') as NamePath;
+}
+
+export function parsePathKey(pathKey: string): NamePath {
+  return pathKeyToNamePath(pathKey) as NamePath;
+}
+
+export function getChangedPathsFromPayload(
+  payload: unknown,
+  options: { includeArrayChangedValues?: boolean } = {},
+): NamePath[] {
+  const payloadObj = payload as
+    | {
+        changedPaths?: unknown;
+        changedValues?: unknown;
+      }
+    | undefined;
+  const rawChangedPaths = Array.isArray(payloadObj?.changedPaths) ? payloadObj.changedPaths : [];
+  const out: NamePath[] = [];
+
+  for (const path of rawChangedPaths) {
+    if (Array.isArray(path)) {
+      if (path.length === 1 && typeof path[0] === 'string') {
+        const namePath = pathKeyToNamePath(path[0]);
+        if (namePath.length) out.push(namePath as NamePath);
+        continue;
+      }
+      const segs = path.filter((seg) => typeof seg === 'string' || typeof seg === 'number') as NamePath;
+      if (segs.length) out.push(segs);
+      continue;
+    }
+    if (typeof path === 'string' && path) {
+      out.push(pathKeyToNamePath(path) as NamePath);
+    }
+  }
+
+  if (out.length) {
+    return out;
+  }
+
+  const changedValues = payloadObj?.changedValues;
+  const canReadChangedValues =
+    changedValues &&
+    typeof changedValues === 'object' &&
+    (options.includeArrayChangedValues || !Array.isArray(changedValues));
+  if (canReadChangedValues) {
+    for (const key of Object.keys(changedValues)) {
+      const namePath = pathKeyToNamePath(key);
+      if (namePath.length) out.push(namePath as NamePath);
+    }
+  }
+
+  return out;
+}
+
+export function isFormValueChangeSource(model: unknown) {
+  const candidate = model as
+    | {
+        emitter?: { on?: unknown; off?: unknown };
+        formValueRuntime?: unknown;
+        context?: { form?: unknown; setFormValues?: unknown };
+      }
+    | undefined;
+  if (!candidate || typeof candidate !== 'object') return false;
+  if (!candidate.emitter || typeof candidate.emitter.on !== 'function' || typeof candidate.emitter.off !== 'function') {
+    return false;
+  }
+  return (
+    !!candidate.formValueRuntime || !!candidate.context?.form || typeof candidate.context?.setFormValues === 'function'
+  );
+}
+
+export function findFormValueChangeSource(ctx: FlowContext): unknown | null {
+  const candidates: unknown[] = [];
+  const push = (model: unknown) => {
+    if (model && !candidates.includes(model)) candidates.push(model);
+  };
+
+  const model = ctx.model as { context?: { blockModel?: unknown }; parent?: unknown } | undefined;
+  push(model?.context?.blockModel);
+  push(ctx.model);
+
+  let cursor = model?.parent as { parent?: unknown } | undefined;
+  while (cursor) {
+    push(cursor);
+    cursor = cursor?.parent as { parent?: unknown } | undefined;
+  }
+
+  return candidates.find(isFormValueChangeSource) || null;
+}

package/src/nocobase-buildin-plugin/index.tsx

@@ -28,6 +28,13 @@ export type CurrentUserState = {
   loading: boolean;
 };
 
+type CurrentUserAuthStatus = 'unknown' | 'authenticated' | 'unauthenticated' | 'redirecting';
+
+type CurrentUserInternalState = CurrentUserState & {
+  authStatus: CurrentUserAuthStatus;
+  error?: Error | null;
+};
+
 export type CurrentRoleOption = {
   name: string;
   title: string;
@@ -151,7 +158,7 @@ const DataSourceBootstrapProvider: FC = ({ children }) => {
       }
     };
 
-    void run();
+    run();
 
     return () => {
       mounted = false;
@@ -173,21 +180,33 @@ const CurrentUserProvider: FC = ({ children }) => {
   const app = useApp<Application>();
   const location = useLocation();
   const navigate = useNavigate();
-  const [state, setState] = useState<CurrentUserState>({ loading: true });
+  const [state, setState] = useState<CurrentUserInternalState>({ loading: true, authStatus: 'unknown' });
   const locationRef = useRef(location);
   locationRef.current = location;
   const authCheckRouteState = getCurrentUserAuthCheckRouteState(app, location.pathname);
+  const shouldBlockAuthRequiredRoute = authCheckRouteState === 'required' && state.authStatus !== 'authenticated';
+  const contextValue = useMemo<CurrentUserState>(
+    () => ({
+      data: state.data,
+      loading: state.loading,
+    }),
+    [state.data, state.loading],
+  );
 
   useEffect(() => {
     let mounted = true;
 
     if (authCheckRouteState !== 'required') {
       // 认证页等免鉴权路由不应再执行 `/auth:check`，否则未登录时会重复鉴权并触发重定向抖动。
-      setState({ loading: false });
+      setState({ loading: false, authStatus: 'unauthenticated', error: null });
       return;
     }
 
-    setState((previous) => (previous.loading ? previous : { ...previous, loading: true }));
+    setState((previous) =>
+      previous.authStatus === 'authenticated'
+        ? previous
+        : { data: previous.data, loading: true, authStatus: 'unknown', error: null },
+    );
 
     const run = async () => {
       try {
@@ -204,11 +223,12 @@ const CurrentUserProvider: FC = ({ children }) => {
         const user = res?.data?.data;
         // 服务端通过 `{ code: 302, redirect }` 通知客户端先去某个中间页(例如 2FA 验证页)。这类响应没有 user.id,但也不能视为未登录——否则会和处理 302 的全局响应拦截器 (例如 plugin-two-factor-authentication 注册的那一个)竞态,而 `window.location.replace` 会覆盖更早发出的 `window.location.href`,把用户错误地弹回登录页。让响应拦截器接管跳转。
         if (user?.code === 302) {
-          setState({ loading: false });
+          setState({ loading: false, authStatus: 'redirecting', error: null });
           return;
         }
         if (user?.id == null) {
           // 用 react-router navigate (虚拟跳转)而不是 location.replace, 这样如果有其他响应拦截器已经发起了 window.location.href 整页跳转(例如 2FA 插件接收到服务端 302 重定向), 真实跳转可以胜出 navigate, 不会被这里的 signin 重定向覆盖。
+          setState({ loading: true, authStatus: 'unauthenticated', error: null });
           navigate(`/signin?redirect=${encodeURIComponent(getCurrentV2RedirectPath(app, locationRef.current))}`, {
             replace: true,
           });
@@ -230,21 +250,28 @@ const CurrentUserProvider: FC = ({ children }) => {
         setState({
           data: res?.data,
           loading: false,
+          authStatus: 'authenticated',
+          error: null,
         });
-      } catch (error: any) {
+      } catch (error: unknown) {
         if (!mounted) {
           return;
         }
 
-        const isAuthError = error?.response?.status === 401 || error?.status === 401;
+        const errorLike = error as { response?: { status?: number }; status?: number };
+        const isAuthError = errorLike?.response?.status === 401 || errorLike?.status === 401;
         if (isAuthError) {
+          setState({ loading: true, authStatus: 'unauthenticated', error: null });
           navigate(`/signin?redirect=${encodeURIComponent(getCurrentV2RedirectPath(app, locationRef.current))}`, {
             replace: true,
           });
           return;
         }
-        setState({ loading: false });
-        throw error;
+        setState({
+          loading: false,
+          authStatus: 'unknown',
+          error: error instanceof Error ? error : new Error(String(error)),
+        });
       }
     };
 
@@ -255,11 +282,15 @@ const CurrentUserProvider: FC = ({ children }) => {
     };
   }, [app, authCheckRouteState, navigate]);
 
-  if (state.loading) {
+  if (state.error) {
+    throw state.error;
+  }
+
+  if (state.loading || shouldBlockAuthRequiredRoute) {
     return app.renderComponent('AppSpin');
   }
 
-  return <CurrentUserContext.Provider value={state}>{children}</CurrentUserContext.Provider>;
+  return <CurrentUserContext.Provider value={contextValue}>{children}</CurrentUserContext.Provider>;
 };
 
 const RootRedirect: FC = () => {
@@ -289,8 +320,9 @@ export class NocoBaseBuildInPlugin extends Plugin<any, Application> {
     this.addComponents();
     this.addRoutes();
 
-    this.app.use(DataSourceBootstrapProvider);
+    // Auth-required routes must finish auth check or redirect before data source metadata requests can start.
     this.app.use(CurrentUserProvider);
+    this.app.use(DataSourceBootstrapProvider);
     this.app.flowEngine.registerModels({
       AdminLayoutModel,
       AdminLayoutMenuItemModel,

package/src/settings-center/AdminSettingsLayout.tsx

@@ -239,11 +239,12 @@ export const InternalAdminSettingsLayout = () => {
       <Layout.Content
         style={{
           background: token.colorBgLayout,
+          flex: 1,
           display: 'flex',
           flexDirection: 'column',
           minWidth: 0,
-          overflowY: 'auto',
-          overflowX: 'hidden',
+          minHeight: 0,
+          overflow: 'hidden',
         }}
       >
         <PageHeader
@@ -273,6 +274,10 @@ export const InternalAdminSettingsLayout = () => {
         />
         <div
           style={{
+            flex: 1,
+            minHeight: 0,
+            boxSizing: 'border-box',
+            overflow: 'auto',
             padding: token.paddingLG,
           }}
         >