react-native-nitro-auth 0.1.0

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "react-native-nitro-auth",
+  "version": "0.1.0",
+  "description": "High-performance authentication library for React Native with Google Sign-In and Apple Sign-In support, powered by Nitro Modules (JSI)",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index.ts",
+  "browser": "src/index.web.ts",
+  "source": "src/index.ts",
+  "app": "app.plugin.js",
+  "files": [
+    "src",
+    "lib",
+    "cpp",
+    "android",
+    "ios",
+    "nitrogen",
+    "nitro.json",
+    "*.podspec",
+    "app.plugin.js",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!cpp/core/*Test.cpp",
+    "!cpp/build",
+    "!android/build",
+    "!android/.cxx",
+    "!scripts"
+  ],
+  "scripts": {
+    "prebuild": "npm run codegen",
+    "build": "bob build",
+    "clean": "rimraf lib nitrogen/generated",
+    "codegen": "nitrogen --logLevel=\"debug\"",
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "test:cpp": "node scripts/test-cpp.js",
+    "prepublishOnly": "npm run clean && npm run build",
+    "prepack": "node -e \"const fs=require('fs'); fs.copyFileSync('../../README.md','./README.md'); try{fs.copyFileSync('../../LICENSE','./LICENSE')}catch(e){}\"",
+    "postpack": "node -e \"const fs=require('fs'); ['./README.md','./LICENSE'].forEach(f=>fs.existsSync(f)&&fs.unlinkSync(f))\""
+  },
+  "keywords": [
+    "react-native",
+    "react-native-auth",
+    "authentication",
+    "google-sign-in",
+    "apple-sign-in",
+    "social-login",
+    "nitro",
+    "jsi",
+    "nitro-modules",
+    "expo",
+    "typescript",
+    "oauth",
+    "auth-provider",
+    "sign-in",
+    "login"
+  ],
+  "author": {
+    "name": "João Paulo C. Marra",
+    "url": "https://github.com/JoaoPauloCMarra"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/JoaoPauloCMarra/react-native-nitro-auth#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JoaoPauloCMarra/react-native-nitro-auth.git"
+  },
+  "bugs": {
+    "url": "https://github.com/JoaoPauloCMarra/react-native-nitro-auth/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "devDependencies": {
+    "@expo/config-plugins": "^54.0.4",
+    "@react-native/babel-preset": "^0.81.0",
+    "@testing-library/react": "^16.3.1",
+    "@testing-library/react-hooks": "^8.0.1",
+    "@testing-library/react-native": "^13.3.3",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
+    "react-native-nitro-modules": "^0.32.0",
+    "react-native-web": "^0.21.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": ">=0.75.0",
+    "react-native-nitro-modules": ">=0.32.0"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "commonjs",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      "typescript"
+    ]
+  }
+}

package/react-native-nitro-auth.podspec

@@ -0,0 +1,40 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-nitro-auth"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => "https://github.com/JoaoPauloCMarra/react-native-nitro-auth.git", :tag => "#{s.version}" }
+  
+  s.swift_version = "5.0"
+
+  s.source_files = [
+    "ios/**/*.{h,m,mm,swift}",
+    "cpp/**/*.{h,hpp,c,cpp}"
+  ]
+
+  s.pod_target_xcconfig = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "CLANG_CXX_LIBRARY" => "libc++",
+    "OTHER_LDFLAGS" => "-ObjC",
+    "DEFINES_MODULE" => "YES",
+    "HEADER_SEARCH_PATHS" => [
+      "\"$(PODS_TARGET_SRCROOT)/cpp\"",
+      "\"$(PODS_TARGET_SRCROOT)/nitrogen/generated/shared/c++\"",
+      "\"$(PODS_TARGET_SRCROOT)/nitrogen/generated/ios\""
+    ].join(" ")
+  }
+
+  s.dependency "React-Core"
+  s.dependency "GoogleSignIn"
+  
+  load 'nitrogen/generated/ios/NitroAuth+autolinking.rb'
+  add_nitrogen_files(s)
+end

package/src/Auth.nitro.ts

@@ -0,0 +1,50 @@
+import type { HybridObject } from "react-native-nitro-modules";
+
+export type AuthProvider = "google" | "apple";
+
+export type AuthErrorCode =
+  | "cancelled"
+  | "network_error"
+  | "configuration_error"
+  | "unsupported_provider"
+  | "unknown";
+
+export interface LoginOptions {
+  scopes?: string[];
+  loginHint?: string;
+}
+
+export interface AuthTokens {
+  accessToken?: string;
+  idToken?: string;
+  expirationTime?: number;
+}
+
+export interface AuthUser {
+  provider: AuthProvider;
+  email?: string;
+  name?: string;
+  photo?: string;
+  idToken?: string;
+  accessToken?: string;
+  scopes?: string[];
+  expirationTime?: number;
+}
+
+export interface Auth extends HybridObject<{ ios: "c++"; android: "c++" }> {
+  readonly currentUser: AuthUser | undefined;
+  readonly grantedScopes: string[];
+  readonly hasPlayServices: boolean;
+
+  login(provider: AuthProvider, options?: LoginOptions): Promise<void>;
+  requestScopes(scopes: string[]): Promise<void>;
+  revokeScopes(scopes: string[]): Promise<void>;
+  getAccessToken(): Promise<string | undefined>;
+  refreshToken(): Promise<AuthTokens>;
+
+  logout(): void;
+
+  onAuthStateChanged(
+    callback: (user: AuthUser | undefined) => void
+  ): () => void;
+}

package/src/Auth.web.ts

@@ -0,0 +1,310 @@
+import type { Auth, AuthUser, AuthProvider, LoginOptions } from "./Auth.nitro";
+
+const CACHE_KEY = "nitro_auth_user";
+const SCOPES_KEY = "nitro_auth_scopes";
+const DEFAULT_SCOPES = ["openid", "email", "profile"];
+
+const getConfig = () => {
+  try {
+    const Constants = require("expo-constants").default;
+    return Constants.expoConfig?.extra || {};
+  } catch {
+    return {};
+  }
+};
+
+class AuthWeb implements Auth {
+  private _currentUser: AuthUser | undefined;
+  private _grantedScopes: string[] = [];
+  private _listeners: ((user: AuthUser | undefined) => void)[] = [];
+
+  constructor() {
+    const cached = localStorage.getItem(CACHE_KEY);
+    if (cached) {
+      try {
+        this._currentUser = JSON.parse(cached);
+      } catch {
+        localStorage.removeItem(CACHE_KEY);
+      }
+    }
+    const scopes = localStorage.getItem(SCOPES_KEY);
+    if (scopes) {
+      try {
+        this._grantedScopes = JSON.parse(scopes);
+      } catch {
+        localStorage.removeItem(SCOPES_KEY);
+      }
+    }
+  }
+
+  get currentUser(): AuthUser | undefined {
+    return this._currentUser;
+  }
+
+  get grantedScopes(): string[] {
+    return this._grantedScopes;
+  }
+
+  get hasPlayServices(): boolean {
+    return true;
+  }
+
+  onAuthStateChanged(
+    callback: (user: AuthUser | undefined) => void
+  ): () => void {
+    this._listeners.push(callback);
+    callback(this._currentUser);
+    return () => {
+      this._listeners = this._listeners.filter((l) => l !== callback);
+    };
+  }
+
+  private notify() {
+    this._listeners.forEach((l) => l(this._currentUser));
+  }
+
+  async login(provider: AuthProvider, options?: LoginOptions): Promise<void> {
+    const scopes = options?.scopes ?? DEFAULT_SCOPES;
+    const loginHint = options?.loginHint;
+    try {
+      if (provider === "google") {
+        return await this.loginGoogle(scopes, loginHint);
+      }
+      return await this.loginApple();
+    } catch (e: unknown) {
+      throw this.mapError(e);
+    }
+  }
+
+  async requestScopes(scopes: string[]): Promise<void> {
+    if (!this._currentUser) {
+      throw new Error("No user logged in");
+    }
+    if (this._currentUser.provider !== "google") {
+      throw new Error("Scope management only supported for Google");
+    }
+    const newScopes = [...new Set([...this._grantedScopes, ...scopes])];
+    return this.loginGoogle(newScopes).catch((e) => {
+      throw this.mapError(e);
+    });
+  }
+
+  async revokeScopes(scopes: string[]): Promise<void> {
+    this._grantedScopes = this._grantedScopes.filter(
+      (s) => !scopes.includes(s)
+    );
+    localStorage.setItem(SCOPES_KEY, JSON.stringify(this._grantedScopes));
+    if (this._currentUser) {
+      this._currentUser.scopes = this._grantedScopes;
+      this.updateUser(this._currentUser);
+    }
+  }
+
+  async getAccessToken(): Promise<string | undefined> {
+    if (this._currentUser?.expirationTime) {
+      const now = Date.now();
+      if (now + 300000 > this._currentUser.expirationTime) {
+        await this.refreshToken();
+      }
+    }
+    return this._currentUser?.accessToken;
+  }
+
+  async refreshToken(): Promise<{ accessToken?: string; idToken?: string }> {
+    if (!this._currentUser) {
+      throw new Error("No user logged in");
+    }
+    if (this._currentUser.provider !== "google") {
+      throw new Error("Token refresh only supported for Google");
+    }
+    await this.loginGoogle(
+      this._grantedScopes.length > 0 ? this._grantedScopes : DEFAULT_SCOPES
+    );
+    return {
+      accessToken: this._currentUser.accessToken,
+      idToken: this._currentUser.idToken,
+    };
+  }
+
+  private mapError(error: unknown): Error {
+    const msg = (error as any)?.message?.toLowerCase() ?? "";
+    if (msg.includes("cancel") || msg.includes("popup_closed")) {
+      return new Error("cancelled");
+    }
+    if (msg.includes("network")) {
+      return new Error("network_error");
+    }
+    if (msg.includes("client id") || msg.includes("config")) {
+      return new Error("configuration_error");
+    }
+    return error as Error;
+  }
+
+  private async loginGoogle(
+    scopes: string[],
+    loginHint?: string
+  ): Promise<void> {
+    const config = getConfig();
+    const clientId = config.googleWebClientId;
+
+    if (!clientId) {
+      throw new Error(
+        "Google Web Client ID not configured. Add 'GOOGLE_WEB_CLIENT_ID' to your .env file."
+      );
+    }
+
+    return new Promise((resolve, reject) => {
+      const redirectUri = window.location.origin;
+      const authUrl = new URL("https://accounts.google.com/o/oauth2/v2/auth");
+      authUrl.searchParams.set("client_id", clientId);
+      authUrl.searchParams.set("redirect_uri", redirectUri);
+      authUrl.searchParams.set("response_type", "id_token token");
+      authUrl.searchParams.set("scope", scopes.join(" "));
+      authUrl.searchParams.set("nonce", Math.random().toString(36).slice(2));
+      if (loginHint) {
+        authUrl.searchParams.set("login_hint", loginHint);
+      }
+
+      const width = 500;
+      const height = 600;
+      const left = window.screenX + (window.outerWidth - width) / 2;
+      const top = window.screenY + (window.outerHeight - height) / 2;
+
+      const popup = window.open(
+        authUrl.toString(),
+        "google-auth",
+        `width=${width},height=${height},left=${left},top=${top}`
+      );
+
+      if (!popup) {
+        reject(new Error("Popup blocked. Please allow popups for this site."));
+        return;
+      }
+
+      const checkInterval = setInterval(() => {
+        try {
+          if (popup.closed) {
+            clearInterval(checkInterval);
+            reject(new Error("cancelled"));
+            return;
+          }
+
+          const url = popup.location.href;
+          if (url.startsWith(redirectUri)) {
+            clearInterval(checkInterval);
+            popup.close();
+
+            const hash = new URL(url).hash.slice(1);
+            const params = new URLSearchParams(hash);
+            const idToken = params.get("id_token");
+            const accessToken = params.get("access_token");
+            const expiresIn = params.get("expires_in");
+
+            if (idToken) {
+              this._grantedScopes = scopes;
+              localStorage.setItem(SCOPES_KEY, JSON.stringify(scopes));
+
+              const user: AuthUser = {
+                provider: "google",
+                idToken,
+                accessToken: accessToken ?? undefined,
+                scopes,
+                expirationTime: expiresIn
+                  ? Date.now() + parseInt(expiresIn) * 1000
+                  : undefined,
+                ...this.decodeGoogleJwt(idToken),
+              };
+              this.updateUser(user);
+              resolve();
+            } else {
+              reject(new Error("No id_token in response"));
+            }
+          }
+        } catch {}
+      }, 100);
+    });
+  }
+
+  private decodeGoogleJwt(token: string): Partial<AuthUser> {
+    try {
+      const payload = token.split(".")[1];
+      const decoded = JSON.parse(atob(payload));
+      return {
+        email: decoded.email,
+        name: decoded.name,
+        photo: decoded.picture,
+      };
+    } catch {
+      return {};
+    }
+  }
+
+  private async loginApple(): Promise<void> {
+    const config = getConfig();
+    const clientId = config.appleWebClientId;
+
+    if (!clientId) {
+      throw new Error(
+        "Apple Web Client ID not configured. Add 'APPLE_WEB_CLIENT_ID' to your .env file."
+      );
+    }
+
+    return new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.src =
+        "https://appleid.cdn-apple.com/appleauth/static/jsapi/appleid/1/en_US/appleid.auth.js";
+      script.async = true;
+      script.onload = () => {
+        if (!window.AppleID) {
+          reject(new Error("Apple SDK not loaded"));
+          return;
+        }
+        window.AppleID.auth.init({
+          clientId,
+          scope: "name email",
+          redirectURI: window.location.origin,
+          usePopup: true,
+        });
+        window.AppleID.auth
+          .signIn()
+          .then((response: any) => {
+            const user: AuthUser = {
+              provider: "apple",
+              idToken: response.authorization.id_token,
+              email: response.user?.email,
+              name: response.user?.name
+                ? `${response.user.name.firstName} ${response.user.name.lastName}`.trim()
+                : undefined,
+            };
+            this.updateUser(user);
+            resolve();
+          })
+          .catch((e: any) => reject(this.mapError(e)));
+      };
+      script.onerror = () => reject(new Error("Failed to load Apple SDK"));
+      document.head.appendChild(script);
+    });
+  }
+
+  logout(): void {
+    this._currentUser = undefined;
+    this._grantedScopes = [];
+    localStorage.removeItem(CACHE_KEY);
+    localStorage.removeItem(SCOPES_KEY);
+    this.notify();
+  }
+
+  private updateUser(user: AuthUser) {
+    this._currentUser = user;
+    localStorage.setItem(CACHE_KEY, JSON.stringify(user));
+    this.notify();
+  }
+
+  name = "Auth";
+  dispose() {}
+  equals(other: any) {
+    return other === this;
+  }
+}
+
+export const AuthModule = new AuthWeb();

package/src/global.d.ts

@@ -0,0 +1,38 @@
+declare global {
+  interface Window {
+    google?: {
+      accounts: {
+        id: {
+          initialize: (config: {
+            client_id: string;
+            callback: (response: { credential: string }) => void;
+          }) => void;
+          prompt: () => void;
+        };
+      };
+    };
+    AppleID?: {
+      auth: {
+        init: (config: {
+          clientId: string;
+          scope: string;
+          redirectURI: string;
+          usePopup: boolean;
+        }) => void;
+        signIn: () => Promise<{
+          authorization: { id_token: string };
+          user?: {
+            email?: string;
+            name?: {
+              firstName?: string;
+              lastName?: string;
+            };
+          };
+        }>;
+      };
+    };
+  }
+}
+
+export {};
+

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./Auth.nitro";
+export * from "./ui/social-button";
+export * from "./use-auth";
+export { AuthService } from "./service";

package/src/index.web.ts

@@ -0,0 +1,4 @@
+export * from "./Auth.nitro";
+export * from "./ui/social-button.web";
+export * from "./use-auth";
+export { AuthService } from "./service.web";

package/src/service.ts

@@ -0,0 +1,4 @@
+import { NitroModules } from "react-native-nitro-modules";
+import type { Auth } from "./Auth.nitro";
+
+export const AuthService = NitroModules.createHybridObject<Auth>("Auth");

package/src/service.web.ts

@@ -0,0 +1 @@
+export { AuthModule as AuthService } from "./Auth.web";

package/src/ui/social-button.tsx

@@ -0,0 +1,129 @@
+import React, { useState } from "react";
+import {
+  Pressable,
+  Text,
+  StyleSheet,
+  View,
+  ViewStyle,
+  TextStyle,
+  ActivityIndicator,
+} from "react-native";
+import { NitroModules } from "react-native-nitro-modules";
+import type { Auth, AuthProvider, AuthUser } from "../Auth.nitro";
+
+interface SocialButtonProps {
+  provider: AuthProvider;
+  variant?: "primary" | "outline" | "white" | "black";
+  borderRadius?: number;
+  style?: ViewStyle;
+  textStyle?: TextStyle;
+  disabled?: boolean;
+  onSuccess?: (user: AuthUser) => void;
+  onError?: (error: unknown) => void;
+  onPress?: () => void;
+}
+
+async function performLogin(provider: AuthProvider): Promise<AuthUser | null> {
+  const auth = NitroModules.createHybridObject<Auth>("Auth");
+  await auth.login(provider);
+  return auth.currentUser ?? null;
+}
+
+export const SocialButton: React.FC<SocialButtonProps> = ({
+  provider,
+  variant = "primary",
+  borderRadius = 8,
+  style,
+  textStyle,
+  disabled,
+  onSuccess,
+  onError,
+  onPress,
+}) => {
+  const [loading, setLoading] = useState(false);
+
+  const handleLogin = () => {
+    if (loading || disabled) return;
+    if (onPress) {
+      onPress();
+      return;
+    }
+    setLoading(true);
+    performLogin(provider)
+      .then((user) => {
+        setLoading(false);
+        if (user) onSuccess?.(user);
+      })
+      .catch((e) => {
+        setLoading(false);
+        onError?.(e);
+      });
+  };
+
+  const isGoogle = provider === "google";
+  const isDisabled = loading || disabled;
+
+  const getBackgroundColor = () => {
+    if (isDisabled) return "#CCCCCC";
+    if (variant === "black") return "#000000";
+    if (variant === "white") return "#FFFFFF";
+    if (variant === "outline") return "transparent";
+    return isGoogle ? "#4285F4" : "#000000";
+  };
+
+  const getTextColor = () => {
+    if (variant === "white" || variant === "outline") return "#000000";
+    return "#FFFFFF";
+  };
+
+  const getBorderColor = () => {
+    if (variant === "outline") return "#DDDDDD";
+    return "transparent";
+  };
+
+  return (
+    <Pressable
+      style={[
+        styles.button,
+        {
+          backgroundColor: getBackgroundColor(),
+          borderRadius,
+          borderColor: getBorderColor(),
+          borderWidth: variant === "outline" ? 1 : 0,
+        },
+        style,
+      ]}
+      onPress={handleLogin}
+      disabled={isDisabled}
+    >
+      <View style={styles.content}>
+        {loading ? (
+          <ActivityIndicator size="small" color={getTextColor()} />
+        ) : (
+          <Text style={[styles.text, { color: getTextColor() }, textStyle]}>
+            Sign in with {provider.charAt(0).toUpperCase() + provider.slice(1)}
+          </Text>
+        )}
+      </View>
+    </Pressable>
+  );
+};
+
+const styles = StyleSheet.create({
+  button: {
+    paddingVertical: 12,
+    paddingHorizontal: 16,
+    minHeight: 48,
+    justifyContent: "center",
+    alignItems: "center",
+    width: "100%",
+  },
+  content: {
+    flexDirection: "row",
+    alignItems: "center",
+  },
+  text: {
+    fontSize: 16,
+    fontWeight: "600",
+  },
+});