react-native-nitro-auth 0.5.4 → 0.5.6

package/src/service.web.ts

@@ -1,8 +1,14 @@
+import type {
+  Auth,
+  AuthProvider,
+  AuthTokens,
+  LoginOptions,
+  AuthUser,
+} from "./Auth.nitro";
 import { AuthModule } from "./Auth.web";
+import { AuthError } from "./utils/auth-error";
 
-export const AuthService = {
-  ...AuthModule,
-
+export const AuthService: Auth = {
   get name() {
     return AuthModule.name;
   },
@@ -19,16 +25,79 @@ export const AuthService = {
     return AuthModule.hasPlayServices;
   },
 
-  login: AuthModule.login.bind(AuthModule),
-  logout: AuthModule.logout.bind(AuthModule),
-  requestScopes: AuthModule.requestScopes.bind(AuthModule),
-  revokeScopes: AuthModule.revokeScopes.bind(AuthModule),
-  getAccessToken: AuthModule.getAccessToken.bind(AuthModule),
-  refreshToken: AuthModule.refreshToken.bind(AuthModule),
-  silentRestore: AuthModule.silentRestore.bind(AuthModule),
-  onAuthStateChanged: AuthModule.onAuthStateChanged.bind(AuthModule),
-  onTokensRefreshed: AuthModule.onTokensRefreshed.bind(AuthModule),
-  setLoggingEnabled: AuthModule.setLoggingEnabled.bind(AuthModule),
-  dispose: AuthModule.dispose.bind(AuthModule),
-  equals: AuthModule.equals.bind(AuthModule),
+  async login(provider: AuthProvider, options?: LoginOptions) {
+    try {
+      await AuthModule.login(provider, options);
+      return;
+    } catch (e) {
+      throw AuthError.from(e);
+    }
+  },
+
+  async requestScopes(scopes: string[]) {
+    try {
+      await AuthModule.requestScopes(scopes);
+      return;
+    } catch (e) {
+      throw AuthError.from(e);
+    }
+  },
+
+  async revokeScopes(scopes: string[]) {
+    try {
+      await AuthModule.revokeScopes(scopes);
+      return;
+    } catch (e) {
+      throw AuthError.from(e);
+    }
+  },
+
+  async getAccessToken() {
+    try {
+      return await AuthModule.getAccessToken();
+    } catch (e) {
+      throw AuthError.from(e);
+    }
+  },
+
+  async refreshToken() {
+    try {
+      return await AuthModule.refreshToken();
+    } catch (e) {
+      throw AuthError.from(e);
+    }
+  },
+
+  logout() {
+    AuthModule.logout();
+  },
+
+  async silentRestore() {
+    try {
+      await AuthModule.silentRestore();
+      return;
+    } catch (e) {
+      throw AuthError.from(e);
+    }
+  },
+
+  onAuthStateChanged(callback: (user: AuthUser | undefined) => void) {
+    return AuthModule.onAuthStateChanged(callback);
+  },
+
+  onTokensRefreshed(callback: (tokens: AuthTokens) => void) {
+    return AuthModule.onTokensRefreshed(callback);
+  },
+
+  setLoggingEnabled(enabled: boolean) {
+    AuthModule.setLoggingEnabled(enabled);
+  },
+
+  dispose() {
+    AuthModule.dispose();
+  },
+
+  equals(other: Parameters<Auth["equals"]>[0]): boolean {
+    return AuthModule.equals(other);
+  },
 };

package/src/ui/social-button.tsx

@@ -7,8 +7,9 @@ import {
   View,
   ActivityIndicator,
 } from "react-native";
-import { NitroModules } from "react-native-nitro-modules";
-import type { Auth, AuthProvider, AuthUser } from "../Auth.nitro";
+import { AuthService } from "../service";
+import { logger } from "../utils/logger";
+import type { AuthProvider, AuthUser } from "../Auth.nitro";
 
 export type SocialButtonVariant = "primary" | "outline" | "white" | "black";
 
@@ -56,8 +57,7 @@ const getTextColor = (variant: SocialButtonVariant): string =>
   variant === "white" || variant === "outline" ? "#000000" : "#FFFFFF";
 
 async function performLogin(provider: AuthProvider): Promise<void> {
-  const auth = NitroModules.createHybridObject<Auth>("Auth");
-  await auth.login(provider);
+  await AuthService.login(provider);
 }
 
 export const SocialButton = ({
@@ -83,12 +83,16 @@ export const SocialButton = ({
     setLoading(true);
     try {
       await performLogin(provider);
-      const user = NitroModules.createHybridObject<Auth>("Auth").currentUser;
+      const user = AuthService.currentUser;
       if (user) {
         onSuccess?.(user);
       }
     } catch (error) {
-      onError?.(error);
+      if (onError) {
+        onError(error);
+      } else if (__DEV__) {
+        logger.error("SocialButton unhandled error:", error);
+      }
     } finally {
       setLoading(false);
     }
@@ -126,19 +130,21 @@ export const SocialButton = ({
           <>
             {provider === "google" && variant !== "primary" && (
               <View style={styles.iconPlaceholder}>
-                <Text style={{ fontSize: 18 }}>G</Text>
+                <Text style={styles.iconText}>G</Text>
               </View>
             )}
             {provider === "apple" && variant !== "primary" && (
               <View style={styles.iconPlaceholder}>
-                <Text style={{ fontSize: 18, color: getTextColor(variant) }}>
+                <Text
+                  style={[styles.iconText, { color: getTextColor(variant) }]}
+                >
                   
                 </Text>
               </View>
             )}
             {provider === "microsoft" && variant !== "primary" && (
               <View style={styles.iconPlaceholder}>
-                <Text style={{ fontSize: 16 }}>⊞</Text>
+                <Text style={styles.microsoftIconText}>⊞</Text>
               </View>
             )}
             <Text
@@ -179,4 +185,10 @@ const styles = StyleSheet.create({
     fontSize: 16,
     fontWeight: "600",
   },
+  iconText: {
+    fontSize: 18,
+  },
+  microsoftIconText: {
+    fontSize: 16,
+  },
 });

package/src/ui/social-button.web.tsx

@@ -8,6 +8,7 @@ import {
   ActivityIndicator,
 } from "react-native";
 import { AuthModule } from "../Auth.web";
+import { logger } from "../utils/logger";
 import type { AuthProvider, AuthUser } from "../Auth.nitro";
 
 export type SocialButtonVariant = "primary" | "outline" | "white" | "black";
@@ -87,7 +88,11 @@ export const SocialButton = ({
         onSuccess?.(user);
       }
     } catch (error) {
-      onError?.(error);
+      if (onError) {
+        onError(error);
+      } else if (process.env.NODE_ENV !== "production") {
+        logger.error("SocialButton unhandled error:", error);
+      }
     } finally {
       setLoading(false);
     }
@@ -125,19 +130,21 @@ export const SocialButton = ({
           <>
             {provider === "google" && variant !== "primary" && (
               <View style={styles.iconPlaceholder}>
-                <Text style={{ fontSize: 18 }}>G</Text>
+                <Text style={styles.iconText}>G</Text>
               </View>
             )}
             {provider === "apple" && variant !== "primary" && (
               <View style={styles.iconPlaceholder}>
-                <Text style={{ fontSize: 18, color: getTextColor(variant) }}>
+                <Text
+                  style={[styles.iconText, { color: getTextColor(variant) }]}
+                >
                   
                 </Text>
               </View>
             )}
             {provider === "microsoft" && variant !== "primary" && (
               <View style={styles.iconPlaceholder}>
-                <Text style={{ fontSize: 16 }}>⊞</Text>
+                <Text style={styles.microsoftIconText}>⊞</Text>
               </View>
             )}
             <Text
@@ -178,4 +185,10 @@ const styles = StyleSheet.create({
     fontSize: 16,
     fontWeight: "600",
   },
+  iconText: {
+    fontSize: 18,
+  },
+  microsoftIconText: {
+    fontSize: 16,
+  },
 });

package/src/use-auth.ts

@@ -6,38 +6,25 @@ import type {
   AuthTokens,
 } from "./Auth.nitro";
 import { AuthService } from "./service";
+import { AuthError } from "./utils/auth-error";
 
 type AuthState = {
   user: AuthUser | undefined;
   scopes: string[];
   loading: boolean;
-  error: Error | undefined;
+  error: AuthError | undefined;
 };
 
 const areScopesEqual = (left: string[], right: string[]): boolean => {
-  if (left.length !== right.length) {
-    return false;
+  if (left.length !== right.length) return false;
+  const sortedLeft = [...left].sort();
+  const sortedRight = [...right].sort();
+  for (let i = 0; i < sortedLeft.length; i += 1) {
+    if (sortedLeft[i] !== sortedRight[i]) return false;
   }
-
-  for (let index = 0; index < left.length; index += 1) {
-    if (left[index] !== right[index]) {
-      return false;
-    }
-  }
-
   return true;
 };
 
-class AuthHookError extends Error {
-  public readonly underlyingError?: string;
-
-  constructor(message: string, underlyingError?: string) {
-    super(message);
-    this.name = "AuthHookError";
-    this.underlyingError = underlyingError;
-  }
-}
-
 export type UseAuthReturn = AuthState & {
   hasPlayServices: boolean;
   login: (provider: AuthProvider, options?: LoginOptions) => Promise<void>;
@@ -58,7 +45,7 @@ export function useAuth(): UseAuthReturn {
   });
 
   const syncStateFromService = useCallback(
-    (nextLoading: boolean, nextError: Error | undefined) => {
+    (nextLoading: boolean, nextError: AuthError | undefined) => {
       const nextUser = AuthService.currentUser;
       const nextScopes = AuthService.grantedScopes;
       setState((prev) => {
@@ -70,7 +57,6 @@ export function useAuth(): UseAuthReturn {
         ) {
           return prev;
         }
-
         return {
           user: nextUser,
           scopes: nextScopes,
@@ -89,12 +75,8 @@ export function useAuth(): UseAuthReturn {
         await AuthService.login(provider, options);
         syncStateFromService(false, undefined);
       } catch (e) {
-        const error = e instanceof Error ? e : new Error(String(e));
-        setState((prev) => ({
-          ...prev,
-          loading: false,
-          error,
-        }));
+        const error = AuthError.from(e);
+        setState((prev) => ({ ...prev, loading: false, error }));
         throw error;
       }
     },
@@ -103,12 +85,7 @@ export function useAuth(): UseAuthReturn {
 
   const logout = useCallback(() => {
     AuthService.logout();
-    setState({
-      user: undefined,
-      scopes: [],
-      loading: false,
-      error: undefined,
-    });
+    setState({ user: undefined, scopes: [], loading: false, error: undefined });
   }, []);
 
   const requestScopes = useCallback(
@@ -118,12 +95,8 @@ export function useAuth(): UseAuthReturn {
         await AuthService.requestScopes(newScopes);
         syncStateFromService(false, undefined);
       } catch (e) {
-        const error = e instanceof Error ? e : new Error(String(e));
-        setState((prev) => ({
-          ...prev,
-          loading: false,
-          error,
-        }));
+        const error = AuthError.from(e);
+        setState((prev) => ({ ...prev, loading: false, error }));
         throw error;
       }
     },
@@ -137,12 +110,8 @@ export function useAuth(): UseAuthReturn {
         await AuthService.revokeScopes(scopesToRevoke);
         syncStateFromService(false, undefined);
       } catch (e) {
-        const error = e instanceof Error ? e : new Error(String(e));
-        setState((prev) => ({
-          ...prev,
-          loading: false,
-          error,
-        }));
+        const error = AuthError.from(e);
+        setState((prev) => ({ ...prev, loading: false, error }));
         throw error;
       }
     },
@@ -158,17 +127,9 @@ export function useAuth(): UseAuthReturn {
       syncStateFromService(false, undefined);
       return tokens;
     } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      const authError = new AuthHookError(
-        msg,
-        AuthService.currentUser?.underlyingError,
-      );
-      setState((prev) => ({
-        ...prev,
-        loading: false,
-        error: authError,
-      }));
-      throw authError;
+      const error = AuthError.from(e);
+      setState((prev) => ({ ...prev, loading: false, error }));
+      throw error;
     }
   }, [syncStateFromService]);
 
@@ -178,18 +139,14 @@ export function useAuth(): UseAuthReturn {
       await AuthService.silentRestore();
       syncStateFromService(false, undefined);
     } catch (e) {
-      const error = e instanceof Error ? e : new Error(String(e));
-      setState((prev) => ({
-        ...prev,
-        loading: false,
-        error,
-      }));
+      const error = AuthError.from(e);
+      setState((prev) => ({ ...prev, loading: false, error }));
       throw error;
     }
   }, [syncStateFromService]);
 
   useEffect(() => {
-    const unsubscribe = AuthService.onAuthStateChanged((currentUser) => {
+    const unsubscribeAuth = AuthService.onAuthStateChanged((currentUser) => {
       const nextScopes = AuthService.grantedScopes;
       setState((prev) => {
         if (
@@ -199,7 +156,6 @@ export function useAuth(): UseAuthReturn {
         ) {
           return prev;
         }
-
         return {
           ...prev,
           user: currentUser,
@@ -208,8 +164,14 @@ export function useAuth(): UseAuthReturn {
         };
       });
     });
-    return unsubscribe;
-  }, []);
+    const unsubscribeTokens = AuthService.onTokensRefreshed?.(() => {
+      syncStateFromService(false, undefined);
+    });
+    return () => {
+      unsubscribeAuth();
+      unsubscribeTokens?.();
+    };
+  }, [syncStateFromService]);
 
   return useMemo(
     () => ({

package/src/utils/auth-error.ts

@@ -0,0 +1,49 @@
+import type { AuthErrorCode } from "../Auth.nitro";
+
+const AUTH_ERROR_CODES: ReadonlySet<string> = new Set<AuthErrorCode>([
+  "cancelled",
+  "timeout",
+  "popup_blocked",
+  "network_error",
+  "configuration_error",
+  "unsupported_provider",
+  "invalid_state",
+  "invalid_nonce",
+  "token_error",
+  "no_id_token",
+  "parse_error",
+  "refresh_failed",
+  "unknown",
+]);
+
+export function isAuthErrorCode(value: string): value is AuthErrorCode {
+  return AUTH_ERROR_CODES.has(value);
+}
+
+export function toAuthErrorCode(raw: string): AuthErrorCode {
+  return isAuthErrorCode(raw) ? raw : "unknown";
+}
+
+/**
+ * Typed error thrown by all AuthService operations.
+ *
+ * - `code` — always a valid `AuthErrorCode`, safe to switch on
+ * - `underlyingMessage` — the raw platform message when it differs from `code`
+ */
+export class AuthError extends Error {
+  readonly code: AuthErrorCode;
+  readonly underlyingMessage: string | undefined;
+
+  constructor(raw: unknown) {
+    const message = raw instanceof Error ? raw.message : String(raw);
+    const code = toAuthErrorCode(message);
+    super(code);
+    this.name = "AuthError";
+    this.code = code;
+    this.underlyingMessage = code !== message ? message : undefined;
+  }
+
+  static from(e: unknown): AuthError {
+    return e instanceof AuthError ? e : new AuthError(e);
+  }
+}

package/src/utils/logger.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 let enabled = false;
 
 export const logger = {