@pricava/react-native-google-credential 0.1.0

package/android/src/main/java/com/pricava/googlecredential/ReactGoogleCredentialOptions.kt

@@ -0,0 +1,45 @@
+package com.pricava.googlecredential
+
+import com.facebook.react.bridge.ReadableMap
+
+internal data class ReactGoogleCredentialOptions(
+  val webClientId: String,
+  val iosClientId: String? = null,
+  val nonce: String? = null,
+  val androidFlow: String = "sign-in-button",
+  val androidAccountFilter: String = "authorized-first",
+  val androidAutoSelect: Boolean = true,
+  val webAutoSelect: Boolean = true,
+  val webUseFedCm: Boolean = true
+) {
+  companion object {
+    fun fromMap(options: ReadableMap): ReactGoogleCredentialOptions {
+      return ReactGoogleCredentialOptions(
+        webClientId = options.getString("webClientId") ?: "",
+        iosClientId = options.optionalString("iosClientId"),
+        nonce = options.optionalString("nonce"),
+        androidFlow = options.optionalString("androidFlow") ?: "sign-in-button",
+        androidAccountFilter = options.optionalString("androidAccountFilter") ?: "authorized-first",
+        androidAutoSelect = options.optionalBoolean("androidAutoSelect") ?: true,
+        webAutoSelect = options.optionalBoolean("webAutoSelect") ?: true,
+        webUseFedCm = options.optionalBoolean("webUseFedCm") ?: true
+      )
+    }
+  }
+}
+
+private fun ReadableMap.optionalString(key: String): String? {
+  if (!hasKey(key) || isNull(key)) {
+    return null
+  }
+
+  return getString(key)?.takeIf { it.isNotBlank() }
+}
+
+private fun ReadableMap.optionalBoolean(key: String): Boolean? {
+  if (!hasKey(key) || isNull(key)) {
+    return null
+  }
+
+  return getBoolean(key)
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require("./plugin/withGoogleCredentialIos");

package/index.ts

@@ -0,0 +1,2 @@
+export * from "./src";
+export { default } from "./src";

package/ios/PricavaGoogleCredential.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <PricavaGoogleCredentialSpec/PricavaGoogleCredentialSpec.h>
+
+@interface PricavaGoogleCredential : NativePricavaGoogleCredentialSpecBase <NativePricavaGoogleCredentialSpec>
+@end
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface PricavaGoogleCredential : NSObject <RCTBridgeModule>
+@end
+#endif

package/ios/PricavaGoogleCredential.mm

@@ -0,0 +1,194 @@
+#import "PricavaGoogleCredential.h"
+
+#import <GoogleSignIn/GoogleSignIn.h>
+#import <React/RCTUtils.h>
+
+#include <memory>
+
+static NSString *PricavaGoogleCredentialTrimmedString(NSString *value)
+{
+  if (![value isKindOfClass:NSString.class]) {
+    return nil;
+  }
+
+  NSString *trimmedValue = [value stringByTrimmingCharactersInSet:NSCharacterSet.whitespaceAndNewlineCharacterSet];
+  return trimmedValue.length > 0 ? trimmedValue : nil;
+}
+
+static NSString *PricavaGoogleCredentialBundledClientId(void)
+{
+  NSString *infoPlistClientId = PricavaGoogleCredentialTrimmedString(
+      [NSBundle.mainBundle objectForInfoDictionaryKey:@"GIDClientID"]);
+
+  if (infoPlistClientId != nil) {
+    return infoPlistClientId;
+  }
+
+  NSString *path = [NSBundle.mainBundle pathForResource:@"GoogleService-Info" ofType:@"plist"];
+  NSDictionary *plist = path != nil ? [NSDictionary dictionaryWithContentsOfFile:path] : nil;
+
+  return PricavaGoogleCredentialTrimmedString(plist[@"CLIENT_ID"]);
+}
+
+static NSDictionary *PricavaGoogleCredentialResult(GIDGoogleUser *user, NSString *idToken)
+{
+  GIDProfileData *profile = user.profile;
+  NSString *imageUrl = profile.hasImage ? [profile imageURLWithDimension:120].absoluteString : nil;
+
+  return @{
+    @"idToken": idToken,
+    @"displayName": profile.name ?: NSNull.null,
+    @"email": profile.email ?: NSNull.null,
+    @"familyName": profile.familyName ?: NSNull.null,
+    @"givenName": profile.givenName ?: NSNull.null,
+    @"id": user.userID ?: profile.email ?: NSNull.null,
+    @"phoneNumber": NSNull.null,
+    @"profilePictureUri": imageUrl ?: NSNull.null
+  };
+}
+
+@implementation PricavaGoogleCredential
+
+RCT_EXPORT_MODULE(PricavaGoogleCredential)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)isAvailableAsync:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject
+{
+  resolve(@YES);
+}
+
+- (void)signInAsync:(JS::NativePricavaGoogleCredential::GoogleCredentialOptionsSpec &)options
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject
+{
+  NSString *webClientId = PricavaGoogleCredentialTrimmedString(options.webClientId());
+  NSString *iosClientId = PricavaGoogleCredentialTrimmedString(options.iosClientId())
+      ?: PricavaGoogleCredentialBundledClientId();
+  NSString *nonce = PricavaGoogleCredentialTrimmedString(options.nonce());
+
+  [self signInWithWebClientId:webClientId
+                  iosClientId:iosClientId
+                        nonce:nonce
+                      resolve:resolve
+                       reject:reject];
+}
+
+- (void)clearCredentialStateAsync:(RCTPromiseResolveBlock)resolve
+                           reject:(RCTPromiseRejectBlock)reject
+{
+  [GIDSignIn.sharedInstance signOut];
+  resolve(nil);
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativePricavaGoogleCredentialSpecJSI>(params);
+}
+#else
+RCT_EXPORT_METHOD(isAvailableAsync:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+  resolve(@YES);
+}
+
+RCT_EXPORT_METHOD(signInAsync:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+  NSString *webClientId = PricavaGoogleCredentialTrimmedString(options[@"webClientId"]);
+  NSString *iosClientId = PricavaGoogleCredentialTrimmedString(options[@"iosClientId"])
+      ?: PricavaGoogleCredentialBundledClientId();
+  NSString *nonce = PricavaGoogleCredentialTrimmedString(options[@"nonce"]);
+
+  [self signInWithWebClientId:webClientId
+                  iosClientId:iosClientId
+                        nonce:nonce
+                      resolve:resolve
+                       reject:reject];
+}
+
+RCT_EXPORT_METHOD(clearCredentialStateAsync:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+  [GIDSignIn.sharedInstance signOut];
+  resolve(nil);
+}
+#endif
+
+- (void)signInWithWebClientId:(NSString *)webClientId
+                  iosClientId:(NSString *)iosClientId
+                        nonce:(NSString *)nonce
+                      resolve:(RCTPromiseResolveBlock)resolve
+                       reject:(RCTPromiseRejectBlock)reject
+{
+  if (webClientId == nil) {
+    reject(@"ERR_GOOGLE_CREDENTIAL_MISSING_CLIENT_ID", @"Missing Google webClientId.", nil);
+    return;
+  }
+
+  if (iosClientId == nil) {
+    reject(
+        @"ERR_GOOGLE_CREDENTIAL_MISSING_CLIENT_ID",
+        @"Missing Google iosClientId. Pass it in options or bundle GoogleService-Info.plist.",
+        nil);
+    return;
+  }
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    UIViewController *presentingViewController = RCTPresentedViewController();
+
+    if (presentingViewController == nil) {
+      reject(
+          @"ERR_GOOGLE_CREDENTIAL_MISSING_VIEW_CONTROLLER",
+          @"No presenting view controller found for Google sign-in.",
+          nil);
+      return;
+    }
+
+    GIDSignIn.sharedInstance.configuration =
+        [[GIDConfiguration alloc] initWithClientID:iosClientId serverClientID:webClientId];
+
+    [GIDSignIn.sharedInstance signInWithPresentingViewController:presentingViewController
+                                                           hint:nil
+                                               additionalScopes:nil
+                                                          nonce:nonce
+                                                     completion:^(GIDSignInResult *_Nullable signInResult,
+                                                                  NSError *_Nullable error) {
+      if (error != nil) {
+        reject(@"ERR_GOOGLE_CREDENTIAL_REQUEST", error.localizedDescription, error);
+        return;
+      }
+
+      GIDGoogleUser *user = signInResult.user;
+
+      if (user == nil) {
+        reject(
+            @"ERR_GOOGLE_CREDENTIAL_REQUEST",
+            @"Google sign-in did not return a user.",
+            nil);
+        return;
+      }
+
+      NSString *idToken = user.idToken.tokenString;
+
+      if (idToken.length == 0) {
+        reject(
+            @"ERR_GOOGLE_CREDENTIAL_REQUEST",
+            @"Google sign-in did not return an ID token.",
+            nil);
+        return;
+      }
+
+      resolve(PricavaGoogleCredentialResult(user, idToken));
+    }];
+  });
+}
+
+@end

package/ios/PricavaGoogleCredential.podspec

@@ -0,0 +1,24 @@
+Pod::Spec.new do |s|
+  s.name           = "PricavaGoogleCredential"
+  s.version        = "1.0.0"
+  s.summary        = "React Native Google credential sign-in."
+  s.description    = "React Native TurboModule support for Android Credential Manager, GoogleSignIn on iOS, and Google Identity Services on web."
+  s.author         = "Pricava"
+  s.homepage       = "https://pricava.com"
+  s.license        = "UNLICENSED"
+  s.platforms      = { :ios => "15.1" }
+  s.source         = { :path => "." }
+  s.source_files   = "*.{h,m,mm}"
+  s.pod_target_xcconfig = {
+    "DEFINES_MODULE" => "YES",
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20"
+  }
+
+  s.dependency "GoogleSignIn", "~> 9.0"
+
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-Core"
+  end
+end

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@pricava/react-native-google-credential",
+  "version": "0.1.0",
+  "description": "React Native-first Google credential sign-in with Expo support.",
+  "license": "MIT",
+  "author": "Moussa Ibrahim",
+  "homepage": "https://github.com/moussa32/react-native-google-credential#readme",
+  "bugs": {
+    "url": "https://github.com/moussa32/react-native-google-credential/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moussa32/react-native-google-credential.git",
+    "directory": "packages/google-credential"
+  },
+  "main": "./src/index.ts",
+  "react-native": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "react-native": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./adapters": {
+      "react-native": "./src/adapters/index.ts",
+      "default": "./src/adapters/index.ts"
+    },
+    "./app.plugin": "./app.plugin.js",
+    "./package.json": "./package.json"
+  },
+  "codegenConfig": {
+    "name": "PricavaGoogleCredentialSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.pricava.googlecredential"
+    },
+    "ios": {
+      "modules": {
+        "PricavaGoogleCredential": {
+          "className": "PricavaGoogleCredential"
+        }
+      }
+    }
+  },
+  "files": [
+    "android",
+    "ios",
+    "plugin",
+    "src",
+    "adapters.ts",
+    "app.plugin.js",
+    "react-native.config.js",
+    "index.ts",
+    "README.md",
+    "IMPLEMENTATION.md"
+  ],
+  "scripts": {
+    "lint": "echo \"TODO: add package lint\"",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3"
+  }
+}

package/plugin/withGoogleCredentialIos.js

@@ -0,0 +1,39 @@
+const { IOSConfig, withInfoPlist } = require("@expo/config-plugins");
+
+function getTrimmedEnv(name) {
+  return process.env[name]?.trim() || null;
+}
+
+function getReversedGoogleClientId(clientId) {
+  const suffix = ".apps.googleusercontent.com";
+
+  if (!clientId?.endsWith(suffix)) {
+    return null;
+  }
+
+  return `com.googleusercontent.apps.${clientId.slice(0, -suffix.length)}`;
+}
+
+module.exports = function withGoogleCredentialIos(config, props = {}) {
+  return withInfoPlist(config, (config) => {
+    const iosClientId =
+      props.iosClientId?.trim?.() || getTrimmedEnv("GOOGLE_IOS_CLIENT_ID");
+    const explicitUrlScheme =
+      props.iosUrlScheme?.trim?.() || getTrimmedEnv("GOOGLE_IOS_URL_SCHEME");
+    const urlScheme =
+      explicitUrlScheme || getReversedGoogleClientId(iosClientId);
+
+    if (iosClientId) {
+      config.modResults.GIDClientID = iosClientId;
+    }
+
+    if (urlScheme && !IOSConfig.Scheme.hasScheme(urlScheme, config.modResults)) {
+      config.modResults = IOSConfig.Scheme.appendScheme(
+        urlScheme,
+        config.modResults,
+      );
+    }
+
+    return config;
+  });
+};

package/react-native.config.js

@@ -0,0 +1,15 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: "./android",
+        packageImportPath:
+          "import com.pricava.googlecredential.PricavaGoogleCredentialPackage;",
+        packageInstance: "new PricavaGoogleCredentialPackage()",
+      },
+      ios: {
+        podspecPath: "./ios/PricavaGoogleCredential.podspec",
+      },
+    },
+  },
+};

package/src/NativePricavaGoogleCredential.ts

@@ -0,0 +1,32 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+
+export type GoogleCredentialOptionsSpec = {
+  webClientId: string;
+  iosClientId?: string | null;
+  nonce?: string | null;
+  androidFlow: string;
+  androidAccountFilter: string;
+  androidAutoSelect: boolean;
+  webAutoSelect: boolean;
+  webUseFedCm: boolean;
+};
+
+export type GoogleCredentialResultSpec = {
+  idToken: string;
+  displayName: string | null;
+  email: string | null;
+  familyName: string | null;
+  givenName: string | null;
+  id: string | null;
+  phoneNumber: string | null;
+  profilePictureUri: string | null;
+};
+
+export interface Spec extends TurboModule {
+  isAvailableAsync(): Promise<boolean>;
+  signInAsync(options: GoogleCredentialOptionsSpec): Promise<GoogleCredentialResultSpec>;
+  clearCredentialStateAsync(): Promise<void>;
+}
+
+export default TurboModuleRegistry.get<Spec>("PricavaGoogleCredential");

package/src/PricavaGoogleCredentialModule.ts

@@ -0,0 +1,31 @@
+import { NativeModules } from "react-native";
+
+import type { PricavaGoogleCredentialNativeModule } from "./types";
+import NativePricavaGoogleCredential from "./NativePricavaGoogleCredential";
+
+const MODULE_NAME = "PricavaGoogleCredential";
+
+function getReactNativeModule() {
+  return (
+    NativePricavaGoogleCredential ??
+    (NativeModules[MODULE_NAME] as
+      | PricavaGoogleCredentialNativeModule
+      | undefined)
+  );
+}
+
+function requireGoogleCredentialModule() {
+  const nativeModule = getReactNativeModule();
+
+  if (!nativeModule) {
+    throw new Error(
+      `${MODULE_NAME} native module is not available. Install the native package and rebuild the React Native or Expo development app.`,
+    );
+  }
+
+  return nativeModule;
+}
+
+const PricavaGoogleCredentialModule = requireGoogleCredentialModule();
+
+export default PricavaGoogleCredentialModule;