@djangocfg/api 2.1.606 → 2.1.608

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@djangocfg/api",
-  "version": "2.1.606",
+  "version": "2.1.608",
   "description": "Auto-generated TypeScript API client with React hooks, SWR integration, and Zod validation for Django REST Framework backends",
   "keywords": [
     "django",
@@ -91,7 +91,7 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@djangocfg/typescript-config": "^2.1.606",
+    "@djangocfg/typescript-config": "^2.1.608",
     "@testing-library/react": "^16.3.2",
     "@types/node": "^25.9.5",
     "@types/react": "19.2.15",

package/src/auth/__tests__/useOAuthLogin.test.tsx

@@ -340,9 +340,24 @@ describe('useOAuthProviders', () => {
     const { useOAuthProviders } = await import('../hooks/useOAuthProviders');
     const { result } = renderHook(() => useOAuthProviders(), { wrapper });
 
-    await waitFor(() => expect(result.current.isReady).toBe(true));
+    // Not ready while the retries run: the form holds the room of the buttons.
+    await waitFor(() => expect(sdk.cfgAccountsOauthProvidersRetrieve).toHaveBeenCalledTimes(2), { timeout: 3000 });
+    expect(result.current.isReady).toBe(false);
+    await waitFor(() => expect(result.current.isReady).toBe(true), { timeout: 6000 });
+    expect(sdk.cfgAccountsOauthProvidersRetrieve).toHaveBeenCalledTimes(3);
     expect(result.current.providers).toEqual([]);
-  });
+  }, 10000);
+
+  it('shows the buttons when the first request fails and a retry succeeds (flaky mobile network)', async () => {
+    sdk.cfgAccountsOauthProvidersRetrieve
+      .mockRejectedValueOnce(new Error('502'))
+      .mockResolvedValue({ data: { providers: [{ id: 'google', name: 'Google', icon: 'google' }] } });
+    const { useOAuthProviders } = await import('../hooks/useOAuthProviders');
+    const { result } = renderHook(() => useOAuthProviders(), { wrapper });
+
+    await waitFor(() => expect(result.current.providers.map((p) => p.id)).toEqual(['google']), { timeout: 4000 });
+    expect(result.current.isReady).toBe(true);
+  }, 8000);
 
   it('persists the fetched list under the registry key', async () => {
     sdk.cfgAccountsOauthProvidersRetrieve.mockResolvedValue({

package/src/auth/context/AuthContext.tsx

@@ -52,8 +52,8 @@ import type {
 import type { OtpRequestRequest } from '../../_api/generated/_cfg_accounts/types.gen';
 
 // The ONLY place route conventions are declared. '/auth' is the sign-in page
-// convention; the framework has no opinion about where an app's "home" is, so
-// the callback default is the site root. Apps override via AuthConfig.routes;
+// convention and '/private' is the default landing page after sign-in
+// (`defaultCallback`). Apps override via AuthConfig.routes;
 // everything downstream reads the RESOLVED values from `useAuth().routes`.
 const defaultRoutes = {
   auth: '/auth',

package/src/auth/hooks/useOAuthProviders.ts

@@ -1,6 +1,6 @@
 'use client';
 
-import { useMemo, useSyncExternalStore } from 'react';
+import { useMemo, useState, useSyncExternalStore } from 'react';
 
 import { useCfgAccountsOauthProvidersRetrieve } from '../../_api/generated/_cfg_accounts/hooks/useCfgAccountsOauthProvidersRetrieve';
 import { CFG_KEYS, cfgStorage } from '../../_api/generated/helpers/keys';
@@ -17,6 +17,11 @@ export interface UseOAuthProvidersReturn {
 const EMPTY: OAuthProviderInfo[] = [];
 const CACHE_KEY = CFG_KEYS.oauthProviders.key;
 
+/** A failed request is tried again this many times before the list is given up as empty. */
+export const OAUTH_PROVIDERS_MAX_RETRIES = 2;
+/** Base wait before a retry; grows linearly (1s, then 2s), so a flaky mobile network has ~3s to recover. */
+export const OAUTH_PROVIDERS_RETRY_MS = 1000;
+
 const isInfo = (value: unknown): value is OAuthProviderInfo =>
   typeof value === 'object' && value !== null && typeof (value as { id?: unknown }).id === 'string';
 
@@ -46,22 +51,35 @@ const serverSnapshot = () => undefined;
  *
  * Fetched once per page session and kept in `sessionStorage`, so a reload or
  * "Try again" after a failed callback shows the buttons at once; the server
- * answer always wins. A failure yields the cached list, else `[]`, with
- * `isReady: true`: the email form never waits on, or breaks because of, this
- * list. Ids this client has no adapter for (a newer backend) are dropped.
+ * answer always wins. A failed request is retried twice (a dropped mobile
+ * connection or a gateway 502 must not hide the buttons for the whole visit);
+ * only when the retries fail too does the hook yield the cached list, else
+ * `[]`, with `isReady: true`: the email form never waits on, or breaks
+ * because of, this list. Ids this client has no adapter for (a newer backend) are dropped.
  */
 export const useOAuthProviders = (): UseOAuthProvidersReturn => {
   // Server and first client render see `undefined`, so hydration matches.
   const cached = useSyncExternalStore(subscribe, readCached, serverSnapshot);
 
-  const { data, error, isLoading } = useCfgAccountsOauthProvidersRetrieve(undefined, {
+  const [failed, setFailed] = useState(false);
+
+  const { data } = useCfgAccountsOauthProvidersRetrieve(undefined, {
     revalidateOnFocus: false,
     revalidateOnReconnect: false,
     revalidateOnMount: true,
-    shouldRetryOnError: false,
+    shouldRetryOnError: true,
+    onErrorRetry: (_error, _key, _config, revalidate, opts) => {
+      // `opts.retryCount` is 1 for the first failure.
+      if (opts.retryCount > OAUTH_PROVIDERS_MAX_RETRIES) {
+        setFailed(true);
+        return;
+      }
+      setTimeout(() => void revalidate(opts), OAUTH_PROVIDERS_RETRY_MS * opts.retryCount);
+    },
     dedupingInterval: 60 * 60 * 1000,
     fallbackData: cached && { providers: cached },
     onSuccess: (response) => {
+      setFailed(false);
       cfgStorage.writeJSON(CACHE_KEY, response.providers);
     },
   });
@@ -71,6 +89,7 @@ export const useOAuthProviders = (): UseOAuthProvidersReturn => {
     [data],
   );
 
-  // SWR keeps `isLoading` on while it revalidates fallback data; a cached list is already usable.
-  return { providers, isReady: !isLoading || Boolean(error) || cached !== undefined };
+  // Ready on an answer, on a cached list (usable at once), or when the retries gave up.
+  // Not `isLoading`: it is off in the wait between a failure and its retry.
+  return { providers, isReady: data !== undefined || failed || cached !== undefined };
 };