@oxyhq/services 6.10.3 → 6.10.5

package/src/ui/hooks/queries/usePaymentQueries.ts

@@ -0,0 +1,136 @@
+import { useQuery } from '@tanstack/react-query';
+import { authenticatedApiCall } from '@oxyhq/core';
+import { queryKeys } from './queryKeys';
+import { useOxy } from '../../context/OxyContext';
+import type {
+  Subscription,
+  Payment,
+  Wallet,
+  WalletTransactionsResponse,
+} from './paymentTypes';
+
+/**
+ * Payment / wallet / subscription query hooks.
+ *
+ * These replace the imperative `oxyServices.*` + `Promise.allSettled` +
+ * `useEffect` pattern used in app screens. Each hook:
+ *  - is gated on `isAuthenticated` (the underlying SDK methods read the
+ *    current user id off the access token and throw when unauthenticated),
+ *  - routes through `authenticatedApiCall` so a stale token is refreshed and
+ *    auth errors are handled consistently (matches `useUserDevices` /
+ *    `usePrivacySettings`),
+ *  - keeps its `queryFn` pure — no store writes, no side effects.
+ *
+ * The wrapped SDK methods (`@oxyhq/core` payment mixin) return `any`; the
+ * generic on `authenticatedApiCall<T>` pins the resolved value to the
+ * precise domain type so consumers get full typing.
+ */
+
+/**
+ * Get the current user's subscription.
+ *
+ * Wraps `oxyServices.getCurrentUserSubscription()`
+ * (`GET /subscription/:userId`). Returns the persisted subscription or the
+ * API's `{ plan: 'basic' }` fallback when the user has never subscribed.
+ */
+export const useUserSubscription = (options?: { enabled?: boolean }) => {
+  const { oxyServices, isAuthenticated, activeSessionId } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.payments.subscription(),
+    queryFn: async () => {
+      return authenticatedApiCall<Subscription>(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.getCurrentUserSubscription(),
+      );
+    },
+    enabled: (options?.enabled !== false) && isAuthenticated,
+    // Subscription state changes rarely; tolerate a longer fresh window.
+    staleTime: 5 * 60 * 1000, // 5 minutes
+    gcTime: 30 * 60 * 1000, // 30 minutes
+  });
+};
+
+/**
+ * Get the current user's payment / billing history.
+ *
+ * Wraps `oxyServices.getUserPayments()` (`GET /payments/user`), which
+ * returns the user's `deposit` and `purchase` transactions newest-first.
+ */
+export const useUserPayments = (options?: { enabled?: boolean }) => {
+  const { oxyServices, isAuthenticated, activeSessionId } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.payments.history(),
+    queryFn: async () => {
+      return authenticatedApiCall<Payment[]>(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.getUserPayments(),
+      );
+    },
+    enabled: (options?.enabled !== false) && isAuthenticated,
+    // Billing history is append-mostly; a short fresh window is fine.
+    staleTime: 2 * 60 * 1000, // 2 minutes
+    gcTime: 30 * 60 * 1000, // 30 minutes
+  });
+};
+
+/**
+ * Get the current user's FairCoin wallet balance.
+ *
+ * Wraps `oxyServices.getCurrentUserWallet()` (`GET /wallet/:userId`).
+ * Balance changes frequently, so the fresh window is intentionally short.
+ */
+export const useUserWallet = (options?: { enabled?: boolean }) => {
+  const { oxyServices, isAuthenticated, activeSessionId } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.payments.wallet(),
+    queryFn: async () => {
+      return authenticatedApiCall<Wallet>(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.getCurrentUserWallet(),
+      );
+    },
+    enabled: (options?.enabled !== false) && isAuthenticated,
+    staleTime: 60 * 1000, // 1 minute (balance moves often)
+    gcTime: 10 * 60 * 1000, // 10 minutes
+  });
+};
+
+/**
+ * Get the current user's wallet transaction history (paginated).
+ *
+ * Wraps `oxyServices.getCurrentUserWalletTransactions(options)`
+ * (`GET /wallet/transactions/:userId`). The API responds with a
+ * `{ data, pagination }` envelope, preserved here as
+ * `WalletTransactionsResponse`.
+ *
+ * @param params - Optional `limit` / `offset` pagination controls. These are
+ *   part of the query key, so distinct pages cache independently.
+ */
+export const useUserWalletTransactions = (
+  params?: { limit?: number; offset?: number },
+  options?: { enabled?: boolean },
+) => {
+  const { oxyServices, isAuthenticated, activeSessionId } = useOxy();
+  const limit = params?.limit;
+  const offset = params?.offset;
+
+  return useQuery({
+    queryKey: queryKeys.payments.walletTransactions(limit, offset),
+    queryFn: async () => {
+      return authenticatedApiCall<WalletTransactionsResponse>(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.getCurrentUserWalletTransactions({ limit, offset }),
+      );
+    },
+    enabled: (options?.enabled !== false) && isAuthenticated,
+    staleTime: 60 * 1000, // 1 minute (ledger updates frequently)
+    gcTime: 10 * 60 * 1000, // 10 minutes
+  });
+};

package/src/ui/hooks/queries/useServicesQueries.ts

@@ -1,6 +1,6 @@
 import { useQuery } from '@tanstack/react-query';
 import { authenticatedApiCall } from '@oxyhq/core';
-import type { ClientSession } from '@oxyhq/core';
+import type { AccountStorageUsageResponse, ClientSession } from '@oxyhq/core';
 import { queryKeys } from './queryKeys';
 import { useOxy } from '../../context/OxyContext';
 import { fetchSessionsWithFallback, mapSessionsToClient } from '../../utils/sessionHelpers';
@@ -124,3 +124,28 @@ export const useSecurityInfo = (options?: { enabled?: boolean }) => {
   });
 };
 
+/**
+ * Get account storage usage (server-aggregated usage across assets, mail,
+ * recordings, etc.). Wraps `oxyServices.getAccountStorageUsage()` in a
+ * TanStack query so consumers get caching, background refetch, and a
+ * consistent `isLoading` / `refetch` surface instead of hand-rolled
+ * `useEffect` fetches.
+ */
+export const useAccountStorageUsage = (options?: { enabled?: boolean }) => {
+  const { oxyServices, isAuthenticated, activeSessionId } = useOxy();
+
+  return useQuery<AccountStorageUsageResponse>({
+    queryKey: queryKeys.storage.usage(),
+    queryFn: async () => {
+      return authenticatedApiCall(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.getAccountStorageUsage()
+      );
+    },
+    enabled: (options?.enabled !== false) && isAuthenticated,
+    staleTime: 5 * 60 * 1000,
+    gcTime: 30 * 60 * 1000,
+  });
+};
+

package/src/ui/hooks/queryClient.ts

@@ -50,6 +50,7 @@ const PERSISTED_QUERY_PREFIXES: ReadonlyArray<string> = [
   'sessions',
   'devices',
   'privacy',
+  'payments',
 ];
 
 /**

package/src/ui/hooks/useWebSSO.ts

@@ -38,36 +38,6 @@ interface UseWebSSOResult {
   isFedCMSupported: boolean;
 }
 
-/**
- * Module-level guard tracking which (origin + API) signatures have already
- * had a silent SSO attempt this page load.
- *
- * A per-component `useRef` guard resets whenever the provider remounts (route
- * churn, StrictMode double-invoke, error-boundary recovery), which previously
- * allowed silent SSO to re-fire and — combined with a routing redirect loop —
- * produced an accelerating `navigator.credentials.get` retry storm. Keying the
- * guard on a stable signature instead of the component instance makes silent
- * SSO fire EXACTLY ONCE per page load regardless of how many times the
- * provider mounts. The set is intentionally never cleared: a fresh page load
- * (the only thing that can change the answer) starts a fresh module scope.
- */
-const silentSSOAttempted = new Set<string>();
-
-/**
- * Build a stable signature for the silent-SSO run-once guard. Two providers
- * pointed at the same API from the same origin share one attempt.
- */
-function ssoSignature(oxyServices: OxyServices): string {
-  const origin = typeof window !== 'undefined' ? window.location.origin : 'no-origin';
-  let baseURL = '';
-  try {
-    baseURL = oxyServices.getBaseURL?.() ?? '';
-  } catch {
-    baseURL = '';
-  }
-  return `${origin}|${baseURL}`;
-}
-
 /**
  * Check if we're running in a web browser environment (not React Native)
  */
@@ -195,12 +165,12 @@ export function useWebSSO({
 
   // Auto-check SSO on mount (web only, FedCM only, not on auth domain).
   //
-  // Run-once is enforced by TWO guards:
-  //   1. `hasCheckedRef` — cheap per-instance fast-path so effect re-runs
-  //      (from changing deps) within one mount never re-fire.
-  //   2. `silentSSOAttempted` — module-level, survives remounts/StrictMode so
-  //      silent SSO fires exactly once per page load even if the provider
-  //      unmounts and remounts.
+  // `hasCheckedRef` is a cheap per-instance fast-path so effect re-runs (from
+  // changing deps) within one mount never re-fire. The page-load run-once
+  // guarantee — silent SSO invoking `navigator.credentials.get` AT MOST ONCE
+  // per page load across remounts / StrictMode / multiple consumers — lives in
+  // `@oxyhq/core`'s `silentSignInWithFedCM`, which memoizes the first silent
+  // attempt's result for this origin + API. The hook therefore calls it freely.
   useEffect(() => {
     if (!enabled || !isWebBrowser() || hasCheckedRef.current || isIdentityProvider(authWebUrl)) {
       if (isIdentityProvider(authWebUrl)) {
@@ -209,23 +179,14 @@ export function useWebSSO({
       return;
     }
 
-    const signature = ssoSignature(oxyServices);
-    if (silentSSOAttempted.has(signature)) {
-      // Already attempted this page load (e.g. before a remount) — do not
-      // re-fire. Mark the local fast-path too so subsequent re-renders skip.
-      hasCheckedRef.current = true;
-      return;
-    }
-
     hasCheckedRef.current = true;
-    silentSSOAttempted.add(signature);
 
     if (fedCMSupported) {
       checkSSO();
     } else {
       onSSOUnavailable?.();
     }
-  }, [enabled, checkSSO, fedCMSupported, onSSOUnavailable, oxyServices, authWebUrl]);
+  }, [enabled, checkSSO, fedCMSupported, onSSOUnavailable, authWebUrl]);
 
   return {
     checkSSO,