react-native-nitro-auth 0.1.0

package/app.plugin.js

@@ -0,0 +1,64 @@
+const {
+  withInfoPlist,
+  withEntitlementsPlist,
+  withStringsXml,
+  AndroidConfig,
+  createRunOncePlugin,
+} = require("@expo/config-plugins");
+
+const withNitroAuth = (config, props = {}) => {
+  const { ios = {}, android = {} } = props;
+
+  // 1. iOS Info.plist
+  config = withInfoPlist(config, (config) => {
+    if (ios.googleClientId) {
+      config.modResults.GIDClientID = ios.googleClientId;
+    }
+    if (ios.googleUrlScheme) {
+      const existingSchemes = config.modResults.CFBundleURLTypes || [];
+      if (
+        !existingSchemes.some((scheme) =>
+          scheme.CFBundleURLSchemes.includes(ios.googleUrlScheme)
+        )
+      ) {
+        config.modResults.CFBundleURLTypes = [
+          ...existingSchemes,
+          {
+            CFBundleURLSchemes: [ios.googleUrlScheme],
+          },
+        ];
+      }
+    }
+    return config;
+  });
+
+  // 2. iOS Entitlements
+  config = withEntitlementsPlist(config, (config) => {
+    config.modResults["com.apple.developer.applesignin"] = ["Default"];
+    return config;
+  });
+
+  // 3. Android Strings (for Google Client ID)
+  config = withStringsXml(config, (config) => {
+    if (android.googleClientId) {
+      config.modResults = AndroidConfig.Strings.setStringItem(
+        [
+          {
+            $: { name: "nitro_auth_google_client_id" },
+            _: android.googleClientId,
+          },
+        ],
+        config.modResults
+      );
+    }
+    return config;
+  });
+
+  return config;
+};
+
+module.exports = createRunOncePlugin(
+  withNitroAuth,
+  "react-native-nitro-auth",
+  "0.1.0"
+);

package/cpp/AuthCache.cpp

@@ -0,0 +1,105 @@
+#include "AuthCache.hpp"
+
+#ifdef __APPLE__
+#include <CoreFoundation/CoreFoundation.h>
+#endif
+
+#ifdef __ANDROID__
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#endif
+
+namespace margelo::nitro::NitroAuth {
+
+static const char* CACHE_KEY = "nitro_auth_user";
+
+#ifdef __APPLE__
+void AuthCache::setUserJson(const std::string& json) {
+    CFStringRef key = CFStringCreateWithCString(nullptr, CACHE_KEY, kCFStringEncodingUTF8);
+    CFStringRef value = CFStringCreateWithCString(nullptr, json.c_str(), kCFStringEncodingUTF8);
+    CFPreferencesSetAppValue(key, value, kCFPreferencesCurrentApplication);
+    CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication);
+    CFRelease(key);
+    CFRelease(value);
+}
+
+std::optional<std::string> AuthCache::getUserJson() {
+    CFStringRef key = CFStringCreateWithCString(nullptr, CACHE_KEY, kCFStringEncodingUTF8);
+    CFPropertyListRef value = CFPreferencesCopyAppValue(key, kCFPreferencesCurrentApplication);
+    CFRelease(key);
+
+    if (value && CFGetTypeID(value) == CFStringGetTypeID()) {
+        CFStringRef cfStr = (CFStringRef)value;
+        char buffer[4096];
+        if (CFStringGetCString(cfStr, buffer, sizeof(buffer), kCFStringEncodingUTF8)) {
+            CFRelease(value);
+            return std::string(buffer);
+        }
+    }
+    if (value) CFRelease(value);
+    return std::nullopt;
+}
+
+void AuthCache::clear() {
+    CFStringRef key = CFStringCreateWithCString(nullptr, CACHE_KEY, kCFStringEncodingUTF8);
+    CFPreferencesSetAppValue(key, nullptr, kCFPreferencesCurrentApplication);
+    CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication);
+    CFRelease(key);
+}
+#endif
+
+#ifdef __ANDROID__
+using namespace facebook::jni;
+
+struct JContext : JavaClass<JContext> {
+    static constexpr auto kJavaDescriptor = "Landroid/content/Context;";
+};
+
+struct JAuthAdapter : facebook::jni::JavaClass<JAuthAdapter> {
+    static constexpr auto kJavaDescriptor = "Lcom/auth/AuthAdapter;";
+    
+    static void setUserJson(facebook::jni::alias_ref<jobject> context, const std::string& json) {
+        static auto method = javaClassStatic()->getStaticMethod<void(alias_ref<JContext>, jstring)>("setUserJson");
+        method(javaClassStatic(), static_ref_cast<JContext>(context), make_jstring(json).get());
+    }
+
+    static facebook::jni::local_ref<jstring> getUserJson(facebook::jni::alias_ref<jobject> context) {
+        static auto method = javaClassStatic()->getStaticMethod<jstring(alias_ref<JContext>)>("getUserJson");
+        return method(javaClassStatic(), static_ref_cast<JContext>(context));
+    }
+
+    static void clearUser(facebook::jni::alias_ref<jobject> context) {
+        static auto method = javaClassStatic()->getStaticMethod<void(alias_ref<JContext>)>("clearUser");
+        method(javaClassStatic(), static_ref_cast<JContext>(context));
+    }
+};
+
+static facebook::jni::global_ref<jobject> gContext;
+
+void AuthCache::setAndroidContext(void* context) {
+    gContext = facebook::jni::make_global(static_cast<jobject>(context));
+}
+
+void* AuthCache::getAndroidContext() {
+    return gContext.get();
+}
+
+void AuthCache::setUserJson(const std::string& json) {
+    if (!gContext) return;
+    JAuthAdapter::setUserJson(gContext, json);
+}
+
+std::optional<std::string> AuthCache::getUserJson() {
+    if (!gContext) return std::nullopt;
+    auto result = JAuthAdapter::getUserJson(gContext);
+    if (!result) return std::nullopt;
+    return result->toStdString();
+}
+
+void AuthCache::clear() {
+    if (!gContext) return;
+    JAuthAdapter::clearUser(gContext);
+}
+#endif
+
+} // namespace margelo::nitro::NitroAuth

package/cpp/AuthCache.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::NitroAuth {
+
+class AuthCache {
+public:
+  static void setUserJson(const std::string& json);
+  static std::optional<std::string> getUserJson();
+  static void clear();
+
+#ifdef __ANDROID__
+  static void setAndroidContext(void* context);
+  static void* getAndroidContext();
+#endif
+};
+
+} // namespace margelo::nitro::NitroAuth

package/cpp/HybridAuth.cpp

@@ -0,0 +1,213 @@
+#include "HybridAuth.hpp"
+#include "AuthCache.hpp"
+#include "JSONSerializer.hpp"
+#include "PlatformAuth.hpp"
+#include <NitroModules/NitroLogger.hpp>
+#include <chrono>
+
+namespace margelo::nitro::NitroAuth {
+
+HybridAuth::HybridAuth() : HybridObject(TAG) {
+  loadFromCache();
+}
+
+std::optional<AuthUser> HybridAuth::getCurrentUser() {
+  std::lock_guard<std::mutex> lock(_mutex);
+  return _currentUser;
+}
+
+std::vector<std::string> HybridAuth::getGrantedScopes() {
+  std::lock_guard<std::mutex> lock(_mutex);
+  return _grantedScopes;
+}
+
+bool HybridAuth::getHasPlayServices() {
+  return PlatformAuth::hasPlayServices();
+}
+
+void HybridAuth::loadFromCache() {
+  std::lock_guard<std::mutex> lock(_mutex);
+  auto json = AuthCache::getUserJson();
+  if (json) {
+    _currentUser = JSONSerializer::deserialize(*json);
+    if (_currentUser && _currentUser->scopes) {
+      _grantedScopes = *_currentUser->scopes;
+    }
+  }
+}
+
+void HybridAuth::saveToCache(const std::optional<AuthUser>& user) {
+  if (user) {
+    auto json = JSONSerializer::serialize(*user);
+    AuthCache::setUserJson(json);
+  } else {
+    AuthCache::clear();
+  }
+}
+
+void HybridAuth::notifyAuthStateChanged() {
+  std::optional<AuthUser> user;
+  std::vector<std::function<void(const std::optional<AuthUser>&)>> listeners;
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    user = _currentUser;
+    for (auto const& [id, listener] : _listeners) {
+      listeners.push_back(listener);
+    }
+  }
+  for (const auto& listener : listeners) {
+    listener(user);
+  }
+}
+
+std::function<void()> HybridAuth::onAuthStateChanged(const std::function<void(const std::optional<AuthUser>&)>& callback) {
+  std::lock_guard<std::mutex> lock(_mutex);
+  int id = _nextListenerId++;
+  _listeners[id] = callback;
+  
+  return [this, id]() {
+    std::lock_guard<std::mutex> lock(_mutex);
+    _listeners.erase(id);
+  };
+}
+
+void HybridAuth::logout() {
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    _currentUser = std::nullopt;
+    _grantedScopes.clear();
+    saveToCache(std::nullopt);
+  }
+  PlatformAuth::logout();
+  notifyAuthStateChanged();
+}
+
+std::shared_ptr<Promise<void>> HybridAuth::login(AuthProvider provider, const std::optional<LoginOptions>& options) {
+  auto promise = Promise<void>::create();
+  std::vector<std::string> scopes;
+  std::optional<std::string> loginHint;
+  if (options) {
+    if (options->scopes) scopes = *options->scopes;
+    loginHint = options->loginHint;
+  }
+  
+  auto loginPromise = PlatformAuth::login(provider, scopes, loginHint);
+  loginPromise->addOnResolvedListener([this, promise, scopes](const AuthUser& user) {
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      _currentUser = user;
+      _grantedScopes = scopes;
+      if (_currentUser) _currentUser->scopes = scopes;
+      saveToCache(_currentUser);
+    }
+    notifyAuthStateChanged();
+    promise->resolve();
+  });
+  
+  loginPromise->addOnRejectedListener([promise](const std::exception_ptr& error) {
+    promise->reject(error);
+  });
+  return promise;
+}
+
+std::shared_ptr<Promise<void>> HybridAuth::requestScopes(const std::vector<std::string>& scopes) {
+  auto promise = Promise<void>::create();
+  auto requestPromise = PlatformAuth::requestScopes(scopes);
+  requestPromise->addOnResolvedListener([this, promise, scopes](const AuthUser& user) {
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      _currentUser = user;
+      for (const auto& scope : scopes) {
+        if (std::find(_grantedScopes.begin(), _grantedScopes.end(), scope) == _grantedScopes.end()) {
+          _grantedScopes.push_back(scope);
+        }
+      }
+      if (_currentUser) _currentUser->scopes = _grantedScopes;
+      saveToCache(_currentUser);
+    }
+    notifyAuthStateChanged();
+    promise->resolve();
+  });
+  
+  requestPromise->addOnRejectedListener([promise](const std::exception_ptr& error) {
+    promise->reject(error);
+  });
+  return promise;
+}
+
+std::shared_ptr<Promise<void>> HybridAuth::revokeScopes(const std::vector<std::string>& scopes) {
+  auto promise = Promise<void>::create();
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    _grantedScopes.erase(
+      std::remove_if(_grantedScopes.begin(), _grantedScopes.end(),
+        [&scopes](const std::string& s) {
+          return std::find(scopes.begin(), scopes.end(), s) != scopes.end();
+        }),
+      _grantedScopes.end()
+    );
+    if (_currentUser) {
+      _currentUser->scopes = _grantedScopes;
+      saveToCache(_currentUser);
+    }
+  }
+  notifyAuthStateChanged();
+  promise->resolve();
+  return promise;
+}
+
+std::shared_ptr<Promise<std::optional<std::string>>> HybridAuth::getAccessToken() {
+  auto promise = Promise<std::optional<std::string>>::create();
+  bool needsRefresh = false;
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    if (_currentUser && _currentUser->accessToken) {
+      if (_currentUser->expirationTime) {
+        auto now = std::chrono::system_clock::now().time_since_epoch() / std::chrono::milliseconds(1);
+        if (now + 300000 > *_currentUser->expirationTime) needsRefresh = true;
+      }
+      if (!needsRefresh) {
+        promise->resolve(*_currentUser->accessToken);
+        return promise;
+      }
+    } else {
+      promise->resolve(std::nullopt);
+      return promise;
+    }
+  }
+
+  if (needsRefresh) {
+    auto refreshPromise = refreshToken();
+    refreshPromise->addOnResolvedListener([promise](const AuthTokens& tokens) {
+      promise->resolve(tokens.accessToken);
+    });
+    refreshPromise->addOnRejectedListener([promise](const std::exception_ptr& error) {
+      promise->reject(error);
+    });
+  }
+  return promise;
+}
+
+std::shared_ptr<Promise<AuthTokens>> HybridAuth::refreshToken() {
+  auto promise = Promise<AuthTokens>::create();
+  auto refreshPromise = PlatformAuth::refreshToken();
+  refreshPromise->addOnResolvedListener([this, promise](const AuthTokens& tokens) {
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      if (_currentUser) {
+        _currentUser->accessToken = tokens.accessToken;
+        _currentUser->idToken = tokens.idToken;
+        saveToCache(_currentUser);
+      }
+    }
+    notifyAuthStateChanged();
+    promise->resolve(tokens);
+  });
+  
+  refreshPromise->addOnRejectedListener([promise](const std::exception_ptr& error) {
+    promise->reject(error);
+  });
+  return promise;
+}
+
+} // namespace margelo::nitro::NitroAuth

package/cpp/HybridAuth.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "HybridAuthSpec.hpp"
+#include "AuthUser.hpp"
+#include "LoginOptions.hpp"
+#include "AuthTokens.hpp"
+#include <optional>
+#include <mutex>
+#include <memory>
+#include <string>
+#include <map>
+
+namespace margelo::nitro::NitroAuth {
+
+class HybridAuth: public HybridAuthSpec {
+public:
+  HybridAuth();
+
+  std::optional<AuthUser> getCurrentUser() override;
+  std::vector<std::string> getGrantedScopes() override;
+  bool getHasPlayServices() override;
+
+  std::shared_ptr<Promise<void>> login(AuthProvider provider, const std::optional<LoginOptions>& options) override;
+  std::shared_ptr<Promise<void>> requestScopes(const std::vector<std::string>& scopes) override;
+  std::shared_ptr<Promise<void>> revokeScopes(const std::vector<std::string>& scopes) override;
+  std::shared_ptr<Promise<std::optional<std::string>>> getAccessToken() override;
+  std::shared_ptr<Promise<AuthTokens>> refreshToken() override;
+
+  void logout() override;
+  std::function<void()> onAuthStateChanged(const std::function<void(const std::optional<AuthUser>&)>& callback) override;
+
+private:
+  void loadFromCache();
+  void saveToCache(const std::optional<AuthUser>& user);
+  void notifyAuthStateChanged();
+
+private:
+  std::optional<AuthUser> _currentUser;
+  std::vector<std::string> _grantedScopes;
+  std::map<int, std::function<void(const std::optional<AuthUser>&)>> _listeners;
+  int _nextListenerId = 0;
+  std::mutex _mutex;
+
+  static constexpr auto TAG = "Auth";
+};
+
+} // namespace margelo::nitro::NitroAuth

package/cpp/JSONSerializer.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "AuthUser.hpp"
+#include <string>
+#include <optional>
+#include <vector>
+
+namespace margelo::nitro::NitroAuth {
+
+class JSONSerializer {
+public:
+    static std::string serialize(const AuthUser& user) {
+        std::string json = "{";
+        json += "\"provider\":\"" + (user.provider == AuthProvider::GOOGLE ? std::string("google") : std::string("apple")) + "\",";
+        if (user.email) json += "\"email\":\"" + *user.email + "\",";
+        if (user.name) json += "\"name\":\"" + *user.name + "\",";
+        if (user.photo) json += "\"photo\":\"" + *user.photo + "\",";
+        if (user.idToken) json += "\"idToken\":\"" + *user.idToken + "\",";
+        if (user.scopes) {
+            json += "\"scopes\":[";
+            for (size_t i = 0; i < user.scopes->size(); ++i) {
+                json += "\"" + (*user.scopes)[i] + "\"";
+                if (i < user.scopes->size() - 1) json += ",";
+            }
+            json += "],";
+        }
+        if (json.back() == ',') json.pop_back();
+        json += "}";
+        return json;
+    }
+
+    static std::optional<AuthUser> deserialize(const std::string& json) {
+        if (json.find("{") == std::string::npos) return std::nullopt;
+        
+        AuthUser user;
+        user.provider = (json.find("\"provider\":\"google\"") != std::string::npos) ? AuthProvider::GOOGLE : AuthProvider::APPLE;
+        
+        auto extract = [&](const std::string& key) -> std::optional<std::string> {
+            std::string searchKey = "\"" + key + "\":\"";
+            size_t start = json.find(searchKey);
+            if (start == std::string::npos) return std::nullopt;
+            start += searchKey.length();
+            size_t end = json.find("\"", start);
+            if (end == std::string::npos) return std::nullopt;
+            return json.substr(start, end - start);
+        };
+
+        user.email = extract("email");
+        user.name = extract("name");
+        user.photo = extract("photo");
+        user.idToken = extract("idToken");
+        
+        return user;
+    }
+};
+
+} // namespace margelo::nitro::NitroAuth

package/cpp/PlatformAuth.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "AuthProvider.hpp"
+#include "AuthUser.hpp"
+#include "AuthTokens.hpp"
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include <vector>
+#include <string>
+
+namespace margelo::nitro::NitroAuth {
+
+using namespace margelo::nitro;
+
+class PlatformAuth {
+public:
+  static std::shared_ptr<Promise<AuthUser>> login(AuthProvider provider, const std::vector<std::string>& scopes = {}, const std::optional<std::string>& loginHint = std::nullopt);
+  static std::shared_ptr<Promise<AuthUser>> requestScopes(const std::vector<std::string>& scopes);
+  static std::shared_ptr<Promise<AuthTokens>> refreshToken();
+  static std::shared_ptr<Promise<std::optional<AuthUser>>> silentRestore();
+  static bool hasPlayServices();
+  static void logout();
+};
+
+} // namespace margelo::nitro::NitroAuth