@thoughtbot/react-native-social-auth 0.1.0

package/src/google/GoogleSignIn.ts

@@ -0,0 +1,131 @@
+import type {
+  GoogleAuthCredential,
+  GoogleSignInConfig,
+  GoogleUser,
+} from './types';
+import { GoogleSignInError, GoogleSignInErrorCode } from './errors';
+import NativeGoogleSignIn from './NativeGoogleSignIn';
+
+let _configured = false;
+
+function ensureConfigured(): void {
+  if (!_configured) {
+    throw new GoogleSignInError(
+      GoogleSignInErrorCode.NOT_CONFIGURED,
+      'GoogleSignIn.configure() must be called before using other methods.'
+    );
+  }
+}
+
+/**
+ * Initialize the native Google Sign-In SDK. Must be called once at app startup
+ * (or before any other method) — subsequent calls overwrite the prior config.
+ *
+ * @param config - See {@link GoogleSignInConfig}.
+ *
+ * @example
+ * ```ts
+ * GoogleSignIn.configure({
+ *   webClientId: 'WEB_CLIENT_ID.apps.googleusercontent.com',
+ *   iosClientId: 'IOS_CLIENT_ID.apps.googleusercontent.com',
+ * });
+ * ```
+ */
+function configure(config: GoogleSignInConfig): void {
+  NativeGoogleSignIn.configure(config);
+  _configured = true;
+}
+
+/**
+ * Trigger the Google sign-in flow.
+ *
+ * @remarks
+ * On both platforms, the SDK attempts silent restore of a previously authorized
+ * account first, then falls back to the interactive bottom sheet / system sheet
+ * if no authorized account is found.
+ *
+ * @returns A {@link GoogleAuthCredential} containing the ID token, optional
+ * access token, and user profile.
+ *
+ * @throws A {@link GoogleSignInError} with one of the
+ * {@link GoogleSignInErrorCode} values — most commonly `SIGN_IN_CANCELLED`
+ * when the user dismisses the sheet, or `NOT_CONFIGURED` when called before
+ * {@link configure}.
+ */
+async function signIn(): Promise<GoogleAuthCredential> {
+  ensureConfigured();
+  const result = await NativeGoogleSignIn.signIn();
+  return result as unknown as GoogleAuthCredential;
+}
+
+/**
+ * Clear the local credential state so the next {@link signIn} call requires
+ * fresh user interaction. The user remains signed into Google itself.
+ *
+ * @throws A {@link GoogleSignInError} with code `NOT_CONFIGURED` when called
+ * before {@link configure}.
+ */
+async function signOut(): Promise<void> {
+  ensureConfigured();
+  await NativeGoogleSignIn.signOut();
+}
+
+/**
+ * Return the in-memory authenticated user, or `null` if nobody has signed in
+ * since app launch.
+ *
+ * @returns The current {@link GoogleUser}, or `null`.
+ *
+ * @throws A {@link GoogleSignInError} with code `NOT_CONFIGURED` when called
+ * before {@link configure}.
+ */
+async function getCurrentUser(): Promise<GoogleUser | null> {
+  ensureConfigured();
+  const result = await NativeGoogleSignIn.getCurrentUser();
+  return result as unknown as GoogleUser | null;
+}
+
+/**
+ * Revoke the app's access to the user's Google account. The user will see a
+ * fresh consent screen on the next {@link signIn}.
+ *
+ * @throws A {@link GoogleSignInError} with code `NOT_CONFIGURED` when called
+ * before {@link configure}.
+ */
+async function revokeAccess(): Promise<void> {
+  ensureConfigured();
+  await NativeGoogleSignIn.revokeAccess();
+}
+
+/**
+ * Synchronous check for whether a user is currently signed in (in memory).
+ *
+ * @returns `true` when {@link getCurrentUser} would resolve to a non-null user.
+ *
+ * @throws A {@link GoogleSignInError} with code `NOT_CONFIGURED` when called
+ * before {@link configure}.
+ */
+function isSignedIn(): boolean {
+  ensureConfigured();
+  return NativeGoogleSignIn.isSignedIn();
+}
+
+/**
+ * The Google Sign-In runtime API. Call {@link GoogleSignIn.configure} once at
+ * app startup, then drive the flow with the other methods.
+ *
+ * @example
+ * ```ts
+ * GoogleSignIn.configure({ webClientId: '...' });
+ * const credential = await GoogleSignIn.signIn();
+ * console.log(credential.user.email);
+ * ```
+ */
+export const GoogleSignIn = {
+  configure,
+  signIn,
+  signOut,
+  getCurrentUser,
+  revokeAccess,
+  isSignedIn,
+} as const;

package/src/google/GoogleSignInButton.tsx

@@ -0,0 +1,224 @@
+import {
+  Pressable,
+  View,
+  Text,
+  StyleSheet,
+  type StyleProp,
+  type ViewStyle,
+} from 'react-native';
+import { GoogleLogo } from './GoogleLogo';
+
+// Layout dimensions
+const BUTTON_HEIGHT = 40;
+const ICON_BUTTON_SIZE = 40;
+const BORDER_RADIUS_ROUNDED = 20;
+const BORDER_RADIUS_SQUARE = 4;
+const GOOGLE_LOGO_SIZE = 20;
+
+// Spacing
+const LOGO_MARGIN_START = 12;
+const LOGO_MARGIN_END = 10;
+
+// Typography
+const LABEL_FONT_SIZE = 14;
+const LABEL_LINE_HEIGHT = 20;
+const LABEL_FONT_WEIGHT = '500';
+
+// Effects
+const DISABLED_OPACITY = 0.38;
+const BORDER_WIDTH_THEMED = 1;
+const BORDER_WIDTH_NEUTRAL = 0;
+
+/**
+ * One of the three button themes defined by Google's branding guidelines.
+ *
+ * - `light` — white background, dark text, gray border
+ * - `dark` — near-black background, light text, gray border
+ * - `neutral` — light gray background, dark text, no border
+ */
+export type GoogleSignInButtonTheme = 'light' | 'dark' | 'neutral';
+
+/**
+ * Button corner radius:
+ *
+ * - `rounded` — pill shape (`borderRadius: 20`)
+ * - `square` — slightly rounded rectangle (`borderRadius: 4`)
+ */
+export type GoogleSignInButtonShape = 'rounded' | 'square';
+
+/**
+ * The call-to-action label. Only these three strings are permitted by Google.
+ *
+ * - `signin` — "Sign in with Google"
+ * - `signup` — "Sign up with Google"
+ * - `continue` — "Continue with Google"
+ */
+export type GoogleSignInButtonText = 'signin' | 'signup' | 'continue';
+
+/**
+ * Button size:
+ *
+ * - `standard` — full button with logo + text
+ * - `icon` — 40×40 logo-only button for compact layouts
+ */
+export type GoogleSignInButtonSize = 'standard' | 'icon';
+
+/** Props for {@link GoogleSignInButton}. */
+export interface GoogleSignInButtonProps {
+  /** {@inheritDoc GoogleSignInButtonTheme} @defaultValue `'light'` */
+  theme?: GoogleSignInButtonTheme;
+  /** {@inheritDoc GoogleSignInButtonShape} @defaultValue `'rounded'` */
+  shape?: GoogleSignInButtonShape;
+  /** {@inheritDoc GoogleSignInButtonText} @defaultValue `'signin'` */
+  text?: GoogleSignInButtonText;
+  /** {@inheritDoc GoogleSignInButtonSize} @defaultValue `'standard'` */
+  size?: GoogleSignInButtonSize;
+  /** Tap handler. Typically wired to {@link GoogleSignIn.signIn}. */
+  onPress?: () => void;
+  /**
+   * When `true`, renders at 0.38 opacity and disables taps.
+   * @defaultValue false
+   */
+  disabled?: boolean;
+  /** Additional container styles (margin, alignment, etc.). */
+  style?: StyleProp<ViewStyle>;
+  /** Testing identifier. */
+  testID?: string;
+}
+
+const BUTTON_LABELS: Record<GoogleSignInButtonText, string> = {
+  signin: 'Sign in with Google',
+  signup: 'Sign up with Google',
+  continue: 'Continue with Google',
+};
+
+const THEME_STYLES: Record<
+  GoogleSignInButtonTheme,
+  {
+    backgroundColor: string;
+    borderColor: string;
+    borderWidth: number;
+    textColor: string;
+  }
+> = {
+  light: {
+    backgroundColor: '#FFFFFF',
+    borderColor: '#747775',
+    borderWidth: BORDER_WIDTH_THEMED,
+    textColor: '#1F1F1F',
+  },
+  dark: {
+    backgroundColor: '#131314',
+    borderColor: '#8E918F',
+    borderWidth: BORDER_WIDTH_THEMED,
+    textColor: '#E3E3E3',
+  },
+  neutral: {
+    backgroundColor: '#F2F2F2',
+    borderColor: 'transparent',
+    borderWidth: BORDER_WIDTH_NEUTRAL,
+    textColor: '#1F1F1F',
+  },
+};
+
+/**
+ * A pre-built button conforming to Google's official branding guidelines.
+ *
+ * @remarks
+ * The Google "G" is rendered via `react-native-svg` so the button stays crisp
+ * at any density without bundled raster assets. Colors, typography, padding,
+ * and the permitted CTA strings all follow the official spec — do not
+ * restyle the logo or override theme colors, or Google may reject your app
+ * during brand review.
+ *
+ * @example
+ * ```tsx
+ * <GoogleSignInButton
+ *   theme="dark"
+ *   text="continue"
+ *   onPress={() => GoogleSignIn.signIn()}
+ * />
+ * ```
+ */
+export function GoogleSignInButton({
+  theme = 'light',
+  shape = 'rounded',
+  text = 'signin',
+  size = 'standard',
+  onPress,
+  disabled = false,
+  style,
+  testID,
+}: GoogleSignInButtonProps) {
+  const themeStyle = THEME_STYLES[theme];
+  const isIcon = size === 'icon';
+  const borderRadius =
+    shape === 'rounded' ? BORDER_RADIUS_ROUNDED : BORDER_RADIUS_SQUARE;
+  const label = BUTTON_LABELS[text];
+
+  return (
+    <Pressable
+      style={[
+        styles.button,
+        {
+          backgroundColor: themeStyle.backgroundColor,
+          borderColor: themeStyle.borderColor,
+          borderWidth: themeStyle.borderWidth,
+          borderRadius,
+        },
+        isIcon && styles.iconButton,
+        disabled && styles.disabled,
+        style,
+      ]}
+      onPress={onPress}
+      disabled={disabled}
+      accessibilityRole="button"
+      accessibilityLabel={label}
+      testID={testID}
+    >
+      <View style={isIcon ? styles.iconLogoContainer : styles.logoContainer}>
+        <GoogleLogo size={GOOGLE_LOGO_SIZE} />
+      </View>
+      {!isIcon && (
+        <Text
+          style={[styles.label, { color: themeStyle.textColor }]}
+          numberOfLines={1}
+        >
+          {label}
+        </Text>
+      )}
+    </Pressable>
+  );
+}
+
+const styles = StyleSheet.create({
+  button: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    height: BUTTON_HEIGHT,
+    alignSelf: 'flex-start',
+  },
+  iconButton: {
+    width: ICON_BUTTON_SIZE,
+    justifyContent: 'center',
+  },
+  logoContainer: {
+    marginStart: LOGO_MARGIN_START,
+    marginEnd: LOGO_MARGIN_END,
+  },
+  iconLogoContainer: {
+    alignItems: 'center',
+    justifyContent: 'center',
+    flex: 1,
+  },
+  label: {
+    fontFamily: 'Roboto-Medium',
+    fontSize: LABEL_FONT_SIZE,
+    lineHeight: LABEL_LINE_HEIGHT,
+    fontWeight: LABEL_FONT_WEIGHT,
+    marginEnd: LOGO_MARGIN_END,
+  },
+  disabled: {
+    opacity: DISABLED_OPACITY,
+  },
+});

package/src/google/NativeGoogleSignIn.ts

@@ -0,0 +1,12 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+  configure(config: Object): void;
+  signIn(): Promise<Object>;
+  signOut(): Promise<void>;
+  getCurrentUser(): Promise<Object | null>;
+  revokeAccess(): Promise<void>;
+  isSignedIn(): boolean;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('GoogleSignIn');

package/src/google/errors.ts

@@ -0,0 +1,72 @@
+/**
+ * Discriminator for {@link GoogleSignInError.code}. Identical on Android and
+ * iOS so error-handling code is platform-agnostic.
+ */
+export enum GoogleSignInErrorCode {
+  /** The user dismissed the sign-in sheet. Don't surface an error. */
+  SIGN_IN_CANCELLED = 'SIGN_IN_CANCELLED',
+  /** A generic native failure; inspect `message` and `nativeErrorCode` for details. */
+  SIGN_IN_FAILED = 'SIGN_IN_FAILED',
+  /** No Google accounts are available on the device. */
+  NO_CREDENTIALS = 'NO_CREDENTIALS',
+  /** Google Play Services is missing or out of date (Android only). */
+  PLAY_SERVICES_NOT_AVAILABLE = 'PLAY_SERVICES_NOT_AVAILABLE',
+  /** The device could not reach Google's auth servers. */
+  NETWORK_ERROR = 'NETWORK_ERROR',
+  /** A method was called before {@link GoogleSignIn.configure}. */
+  NOT_CONFIGURED = 'NOT_CONFIGURED',
+}
+
+/**
+ * Typed error thrown / rejected by every {@link GoogleSignIn} method.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await GoogleSignIn.signIn();
+ * } catch (error) {
+ *   if (isGoogleSignInError(error) && error.code === GoogleSignInErrorCode.SIGN_IN_CANCELLED) {
+ *     return;
+ *   }
+ *   throw error;
+ * }
+ * ```
+ */
+export class GoogleSignInError extends Error {
+  /** The platform-agnostic error code. */
+  readonly code: GoogleSignInErrorCode;
+  /**
+   * The underlying native error code (e.g. Android `28444`, iOS
+   * `kGIDSignInErrorCode...`). Useful for telemetry; do not branch on it from
+   * application code — branch on {@link code} instead.
+   */
+  readonly nativeErrorCode: string | undefined;
+
+  /**
+   * @param code - A {@link GoogleSignInErrorCode} value.
+   * @param message - Human-readable description, suitable for logs.
+   * @param nativeErrorCode - Optional native-side code for diagnostics.
+   */
+  constructor(
+    code: GoogleSignInErrorCode,
+    message: string,
+    nativeErrorCode?: string
+  ) {
+    super(message);
+    this.name = 'GoogleSignInError';
+    this.code = code;
+    this.nativeErrorCode = nativeErrorCode;
+  }
+}
+
+/**
+ * Type guard that narrows `unknown` to {@link GoogleSignInError}.
+ *
+ * @param error - Any caught value.
+ * @returns `true` when `error` is a {@link GoogleSignInError} instance.
+ */
+export function isGoogleSignInError(
+  error: unknown
+): error is GoogleSignInError {
+  return error instanceof GoogleSignInError;
+}

package/src/google/index.ts

@@ -0,0 +1,19 @@
+export { GoogleSignIn } from './GoogleSignIn';
+export {
+  GoogleSignInError,
+  GoogleSignInErrorCode,
+  isGoogleSignInError,
+} from './errors';
+export { GoogleSignInButton } from './GoogleSignInButton';
+export type {
+  GoogleSignInButtonProps,
+  GoogleSignInButtonTheme,
+  GoogleSignInButtonShape,
+  GoogleSignInButtonText,
+  GoogleSignInButtonSize,
+} from './GoogleSignInButton';
+export type {
+  GoogleSignInConfig,
+  GoogleUser,
+  GoogleAuthCredential,
+} from './types';

package/src/google/types.ts

@@ -0,0 +1,100 @@
+/**
+ * Configuration accepted by {@link GoogleSignIn.configure}.
+ *
+ * @remarks
+ * `webClientId` is required on every platform — it sets the audience (`aud`)
+ * of the issued ID token so a single backend verification path works across
+ * iOS, Android, and web.
+ */
+export interface GoogleSignInConfig {
+  /**
+   * The OAuth 2.0 **Web application** client ID from Google Cloud Console.
+   * Used as the `serverClientID` on iOS and the `serverClientId` on Android,
+   * which becomes the `aud` claim of the issued ID token.
+   */
+  webClientId: string;
+
+  /**
+   * The OAuth 2.0 **iOS application** client ID. Required when running on iOS;
+   * ignored on Android.
+   */
+  iosClientId?: string;
+
+  /**
+   * When `true`, request a server auth code in addition to the ID token so a
+   * backend can exchange it for refresh tokens. Not yet exposed end-to-end.
+   *
+   * @defaultValue false
+   */
+  offlineAccess?: boolean;
+
+  /**
+   * Additional OAuth scopes to request beyond the default `openid email profile`.
+   */
+  scopes?: string[];
+
+  /**
+   * Restrict sign-in to accounts on a specific Google Workspace domain (e.g.
+   * `"example.com"`).
+   */
+  hostedDomain?: string;
+
+  /**
+   * When `true`, returning users sign in silently with the most recently used
+   * account without showing the bottom sheet.
+   *
+   * @defaultValue false
+   */
+  autoSelect?: boolean;
+
+  /**
+   * A unique value bound into the ID token. Recommended when verifying tokens
+   * server-side to prevent replay attacks.
+   *
+   * @remarks
+   * Honored on Android. On iOS the GoogleSignIn 7.x public API does not expose
+   * a nonce parameter; nonce verification must be enforced server-side instead.
+   */
+  nonce?: string;
+}
+
+/**
+ * The authenticated Google account's profile, returned by
+ * {@link GoogleSignIn.signIn} and {@link GoogleSignIn.getCurrentUser}.
+ */
+export interface GoogleUser {
+  /** The user's stable Google account ID (`sub` claim in the ID token). */
+  id: string;
+  /** The user's primary email address. */
+  email: string;
+  /** The user's full display name, if provided. */
+  displayName: string | null;
+  /** The user's given (first) name, if provided. */
+  givenName: string | null;
+  /** The user's family (last) name, if provided. */
+  familyName: string | null;
+  /** A URL to the user's profile photo (200×200), if provided. */
+  photoUrl: string | null;
+}
+
+/**
+ * The result of a successful {@link GoogleSignIn.signIn} call.
+ *
+ * @remarks
+ * Pass `idToken` to your backend and verify it with Google's public keys. The
+ * `aud` claim will equal the {@link GoogleSignInConfig.webClientId} you passed
+ * to {@link GoogleSignIn.configure}.
+ */
+export interface GoogleAuthCredential {
+  /** The Google-issued ID token. JWT format; verify on your backend. */
+  idToken: string;
+  /** OAuth access token for calling Google APIs; `null` when not requested. */
+  accessToken: string | null;
+  /**
+   * One-time code your backend can exchange for refresh tokens. `null` unless
+   * {@link GoogleSignInConfig.offlineAccess} was set.
+   */
+  serverAuthCode: string | null;
+  /** The authenticated user's profile. */
+  user: GoogleUser;
+}

package/src/index.tsx

@@ -0,0 +1,18 @@
+export {
+  GoogleSignIn,
+  GoogleSignInButton,
+  GoogleSignInError,
+  GoogleSignInErrorCode,
+  isGoogleSignInError,
+} from './google';
+
+export type {
+  GoogleSignInButtonProps,
+  GoogleSignInButtonTheme,
+  GoogleSignInButtonShape,
+  GoogleSignInButtonText,
+  GoogleSignInButtonSize,
+  GoogleSignInConfig,
+  GoogleUser,
+  GoogleAuthCredential,
+} from './google';