子账号登录微信授权

apps/h5-partner/src/contexts/PartnerSessionContext.tsx

@@ -1,17 +1,39 @@
-import { createContext, useCallback, useContext, useEffect, useState, type ReactNode } from 'react';
-import { toAppPath } from '@dukang/weixin-sdk';
-import { clearAuth, isLoggedIn, request } from '../lib/api';
-
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+  type ReactNode,
+} from 'react';
+import { stripOAuthParamsFromLocation, toAppPath } from '@dukang/weixin-sdk';
+import { isWxAuthorizeEnabled } from '@dukang/shared-types';
+import {
+  clearAuth,
+  ensureSession,
+  request,
+  saveAuth,
+  type PartnerSessionPayload,
+  type PartnerSessionProfile,
+} from '../lib/api';
 import type { PartnerMe, PartnerStaffRole } from '@dukang/shared-types';
+import { fetchClientConfig, processPartnerWechatOAuthCallback } from '../lib/wechat-auth';
+import { isWechatEnv } from '../lib/weixin';
 
 export type PartnerAccount = PartnerMe & {
   staffRole?: PartnerStaffRole;
 };
 
 type PartnerSessionValue = {
+  ready: boolean;
+  authenticated: boolean;
   account: PartnerAccount | null;
-  loading: boolean;
+  /** @deprecated 使用 authenticated */
   loggedIn: boolean;
+  /** @deprecated 使用 ready */
+  loading: boolean;
+  applySession: (session: PartnerSessionPayload) => void;
   refresh: () => Promise<PartnerAccount | null>;
   logout: () => void;
 };
@@ -19,46 +41,111 @@ type PartnerSessionValue = {
 const PartnerSessionContext = createContext<PartnerSessionValue | null>(null);
 
 export function PartnerSessionProvider({ children }: { children: ReactNode }) {
+  const [ready, setReady] = useState(false);
+  const [authenticated, setAuthenticated] = useState(false);
   const [account, setAccount] = useState<PartnerAccount | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [loggedIn, setLoggedIn] = useState(() => isLoggedIn());
+
+  const applySession = useCallback((session: PartnerSessionPayload) => {
+    saveAuth(session);
+    setAuthenticated(true);
+    if (session.partner) {
+      setAccount({
+        id: session.partner.id,
+        name: session.partner.name,
+        phone: session.partner.phone,
+        companyName: session.partner.companyName,
+        isPrimary: session.partner.isPrimary,
+      });
+    }
+  }, []);
 
   const refresh = useCallback(async (): Promise<PartnerAccount | null> => {
-    if (!isLoggedIn()) {
-      setAccount(null);
-      setLoggedIn(false);
-      setLoading(false);
-      return null;
-    }
-    setLoggedIn(true);
-    setLoading(true);
     try {
-      const data = await request<PartnerAccount>('PARTNER_H5', '/partner/me', { silent: true });
-      setAccount(data);
-      return data;
+      const result = await ensureSession();
+      setAuthenticated(result.authenticated);
+      if (!result.authenticated || !result.partner) {
+        setAccount(null);
+        return null;
+      }
+      const me = await request<PartnerAccount>('PARTNER_H5', '/partner/me', { silent: true });
+      setAccount(me);
+      return me;
     } catch {
       setAccount(null);
+      setAuthenticated(false);
       return null;
-    } finally {
-      setLoading(false);
     }
   }, []);
 
   const logout = useCallback(() => {
     clearAuth();
     setAccount(null);
-    setLoggedIn(false);
+    setAuthenticated(false);
     window.location.href = toAppPath('/login');
   }, []);
 
   useEffect(() => {
-    void refresh();
-  }, [refresh]);
+    let cancelled = false;
+    (async () => {
+      try {
+        const params = new URLSearchParams(window.location.search);
+        if (isWechatEnv() && params.get('code')) {
+          try {
+            const config = await fetchClientConfig();
+            if (isWxAuthorizeEnabled(config)) {
+              const session = await processPartnerWechatOAuthCallback();
+              if (session && !cancelled) {
+                applySession(session);
+                const me = await request<PartnerAccount>('PARTNER_H5', '/partner/me', { silent: true }).catch(() => null);
+                if (me && !cancelled) setAccount(me);
+              }
+              stripOAuthParamsFromLocation();
+            }
+          } catch {
+            stripOAuthParamsFromLocation();
+          }
+        }
+
+        const result = await ensureSession();
+        if (cancelled) return;
+        setAuthenticated(result.authenticated);
+        if (result.authenticated) {
+          const me = await request<PartnerAccount>('PARTNER_H5', '/partner/me', { silent: true }).catch(() => null);
+          if (!cancelled) setAccount(me);
+        } else {
+          setAccount(null);
+        }
+      } catch {
+        if (!cancelled) {
+          clearAuth({ keepProfile: true });
+          setAuthenticated(false);
+          setAccount(null);
+        }
+      } finally {
+        if (!cancelled) setReady(true);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [applySession]);
+
+  const value = useMemo(
+    () => ({
+      ready,
+      authenticated,
+      account,
+      loggedIn: authenticated,
+      loading: !ready,
+      applySession,
+      refresh,
+      logout,
+    }),
+    [ready, authenticated, account, applySession, refresh, logout],
+  );
 
   return (
-    <PartnerSessionContext.Provider
-      value={{ account, loading, loggedIn, refresh, logout }}
-    >
+    <PartnerSessionContext.Provider value={value}>
       {children}
     </PartnerSessionContext.Provider>
   );
@@ -69,3 +156,5 @@ export function usePartnerSession(): PartnerSessionValue {
   if (!ctx) throw new Error('usePartnerSession 必须在 PartnerSessionProvider 内使用');
   return ctx;
 }
+
+export type { PartnerSessionProfile };