react-native-nitro-auth 0.5.5 → 0.5.6

package/android/src/main/java/com/auth/GoogleSignInActivity.kt

@@ -21,13 +21,15 @@ class GoogleSignInActivity : ComponentActivity() {
         private const val EXTRA_SCOPES = "scopes"
         private const val EXTRA_LOGIN_HINT = "login_hint"
         private const val EXTRA_FORCE_PICKER = "force_picker"
-        
-        fun createIntent(context: Context, clientId: String, scopes: Array<String>, loginHint: String?, forcePicker: Boolean = false): Intent {
+        private const val EXTRA_ORIGIN = "origin"
+
+        fun createIntent(context: Context, clientId: String, scopes: Array<String>, loginHint: String?, forcePicker: Boolean = false, origin: String = "login"): Intent {
             return Intent(context, GoogleSignInActivity::class.java).apply {
                 putExtra(EXTRA_CLIENT_ID, clientId)
                 putExtra(EXTRA_SCOPES, scopes)
                 putExtra(EXTRA_LOGIN_HINT, loginHint)
                 putExtra(EXTRA_FORCE_PICKER, forcePicker)
+                putExtra(EXTRA_ORIGIN, origin)
                 addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
             }
         }
@@ -36,13 +38,14 @@ class GoogleSignInActivity : ComponentActivity() {
     private val signInLauncher = registerForActivityResult(
         ActivityResultContracts.StartActivityForResult()
     ) { result ->
+        val origin = intent.getStringExtra(EXTRA_ORIGIN) ?: "login"
         try {
             val task = GoogleSignIn.getSignedInAccountFromIntent(result.data)
             val account = task.getResult(ApiException::class.java)
             val scopes = intent.getStringArrayExtra(EXTRA_SCOPES)?.toList() ?: emptyList()
-            AuthAdapter.onSignInSuccess(account, scopes)
+            AuthAdapter.onSignInSuccess(account, scopes, origin)
         } catch (e: ApiException) {
-            AuthAdapter.onSignInError(e.statusCode, e.message)
+            AuthAdapter.onSignInError(e.statusCode, e.message, origin)
         }
         finish()
     }
@@ -54,8 +57,9 @@ class GoogleSignInActivity : ComponentActivity() {
         val loginHint = intent.getStringExtra(EXTRA_LOGIN_HINT)
         val forcePicker = intent.getBooleanExtra(EXTRA_FORCE_PICKER, false)
         
+        val origin = intent.getStringExtra(EXTRA_ORIGIN) ?: "login"
         if (clientId == null) {
-            AuthAdapter.onSignInError(8, "Missing client ID")
+            AuthAdapter.onSignInError(8, "Missing client ID", origin)
             finish()
             return
         }

package/cpp/HybridAuth.cpp

@@ -1,23 +1,21 @@
 #include "HybridAuth.hpp"
 #include "PlatformAuth.hpp"
-#include <NitroModules/NitroLogger.hpp>
+#include <algorithm>
 #include <chrono>
 
 namespace margelo::nitro::NitroAuth {
- 
-bool HybridAuth::sLoggingEnabled = false;
 
 HybridAuth::HybridAuth() : HybridObject(TAG) {
   // In-memory only - no internal persistence.
 }
 
 std::optional<AuthUser> HybridAuth::getCurrentUser() {
-  std::lock_guard<std::mutex> lock(_mutex);
+  std::lock_guard<std::recursive_mutex> lock(_mutex);
   return _currentUser;
 }
 
 std::vector<std::string> HybridAuth::getGrantedScopes() {
-  std::lock_guard<std::mutex> lock(_mutex);
+  std::lock_guard<std::recursive_mutex> lock(_mutex);
   return _grantedScopes;
 }
 
@@ -29,7 +27,7 @@ void HybridAuth::notifyAuthStateChanged() {
   std::optional<AuthUser> user;
   std::vector<std::function<void(const std::optional<AuthUser>&)>> listeners;
   {
-    std::lock_guard<std::mutex> lock(_mutex);
+    std::lock_guard<std::recursive_mutex> lock(_mutex);
     user = _currentUser;
     for (auto const& [id, listener] : _listeners) {
       listeners.push_back(listener);
@@ -41,30 +39,38 @@ void HybridAuth::notifyAuthStateChanged() {
 }
 
 std::function<void()> HybridAuth::onAuthStateChanged(const std::function<void(const std::optional<AuthUser>&)>& callback) {
-  std::lock_guard<std::mutex> lock(_mutex);
-  int id = _nextListenerId++;
+  std::lock_guard<std::recursive_mutex> lock(_mutex);
+  uint64_t id = _nextListenerId++;
   _listeners[id] = callback;
   
-  return [this, id]() {
-    std::lock_guard<std::mutex> lock(_mutex);
-    _listeners.erase(id);
+  auto weak = weak_from_this();
+  return [weak, id]() {
+    auto self = weak.lock();
+    if (!self) return;
+    auto* auth = dynamic_cast<HybridAuth*>(self.get());
+    std::lock_guard<std::recursive_mutex> lock(auth->_mutex);
+    auth->_listeners.erase(id);
   };
 }
 
 std::function<void()> HybridAuth::onTokensRefreshed(const std::function<void(const AuthTokens&)>& callback) {
-  std::lock_guard<std::mutex> lock(_mutex);
-  int id = _nextTokenListenerId++;
+  std::lock_guard<std::recursive_mutex> lock(_mutex);
+  uint64_t id = _nextTokenListenerId++;
   _tokenListeners[id] = callback;
-  
-  return [this, id]() {
-    std::lock_guard<std::mutex> lock(_mutex);
-    _tokenListeners.erase(id);
+
+  auto weak = weak_from_this();
+  return [weak, id]() {
+    auto self = weak.lock();
+    if (!self) return;
+    auto* auth = dynamic_cast<HybridAuth*>(self.get());
+    std::lock_guard<std::recursive_mutex> lock(auth->_mutex);
+    auth->_tokenListeners.erase(id);
   };
 }
 
 void HybridAuth::logout() {
   {
-    std::lock_guard<std::mutex> lock(_mutex);
+    std::lock_guard<std::recursive_mutex> lock(_mutex);
     _currentUser = std::nullopt;
     _grantedScopes.clear();
   }
@@ -75,22 +81,24 @@ void HybridAuth::logout() {
 std::shared_ptr<Promise<void>> HybridAuth::silentRestore() {
   auto promise = Promise<void>::create();
   auto silentPromise = PlatformAuth::silentRestore();
-  silentPromise->addOnResolvedListener([this, promise](const std::optional<AuthUser>& user) {
+  auto self = shared_from_this();
+  silentPromise->addOnResolvedListener([self, promise](const std::optional<AuthUser>& user) {
+    auto* auth = dynamic_cast<HybridAuth*>(self.get());
     {
-      std::lock_guard<std::mutex> lock(_mutex);
-      _currentUser = user;
+      std::lock_guard<std::recursive_mutex> lock(auth->_mutex);
+      auth->_currentUser = user;
       if (user) {
         if (user->scopes) {
-          _grantedScopes = *user->scopes;
+          auth->_grantedScopes = *user->scopes;
         } else {
-          _grantedScopes.clear();
+          auth->_grantedScopes.clear();
         }
       } else {
-        _grantedScopes.clear();
+        auth->_grantedScopes.clear();
       }
     }
     // Always resolve - no session is not an error, just means user is logged out
-    notifyAuthStateChanged();
+    auth->notifyAuthStateChanged();
     promise->resolve();
   });
   
@@ -104,25 +112,27 @@ std::shared_ptr<Promise<void>> HybridAuth::silentRestore() {
 std::shared_ptr<Promise<void>> HybridAuth::login(AuthProvider provider, const std::optional<LoginOptions>& options) {
   auto promise = Promise<void>::create();
   
+  auto self = shared_from_this();
   auto loginPromise = PlatformAuth::login(provider, options);
-  loginPromise->addOnResolvedListener([this, promise, options](const AuthUser& user) {
+  loginPromise->addOnResolvedListener([self, promise, options](const AuthUser& user) {
+    auto* auth = dynamic_cast<HybridAuth*>(self.get());
     {
-      std::lock_guard<std::mutex> lock(_mutex);
-      _currentUser = user;
+      std::lock_guard<std::recursive_mutex> lock(auth->_mutex);
+      auth->_currentUser = user;
       if (user.scopes && !user.scopes->empty()) {
-        _grantedScopes = *user.scopes;
+        auth->_grantedScopes = *user.scopes;
       } else if (options && options->scopes && !options->scopes->empty()) {
-        _grantedScopes = *options->scopes;
+        auth->_grantedScopes = *options->scopes;
       } else {
-        _grantedScopes.clear();
+        auth->_grantedScopes.clear();
       }
-      if (_currentUser) {
-        _currentUser->scopes = _grantedScopes.empty()
+      if (auth->_currentUser) {
+        auth->_currentUser->scopes = auth->_grantedScopes.empty()
           ? std::nullopt
-          : std::make_optional(_grantedScopes);
+          : std::make_optional(auth->_grantedScopes);
       }
     }
-    notifyAuthStateChanged();
+    auth->notifyAuthStateChanged();
     promise->resolve();
   });
   
@@ -134,19 +144,21 @@ std::shared_ptr<Promise<void>> HybridAuth::login(AuthProvider provider, const st
 
 std::shared_ptr<Promise<void>> HybridAuth::requestScopes(const std::vector<std::string>& scopes) {
   auto promise = Promise<void>::create();
+  auto self = shared_from_this();
   auto requestPromise = PlatformAuth::requestScopes(scopes);
-  requestPromise->addOnResolvedListener([this, promise, scopes](const AuthUser& user) {
+  requestPromise->addOnResolvedListener([self, promise, scopes](const AuthUser& user) {
+    auto* auth = dynamic_cast<HybridAuth*>(self.get());
     {
-      std::lock_guard<std::mutex> lock(_mutex);
-      _currentUser = user;
+      std::lock_guard<std::recursive_mutex> lock(auth->_mutex);
+      auth->_currentUser = user;
       for (const auto& scope : scopes) {
-        if (std::find(_grantedScopes.begin(), _grantedScopes.end(), scope) == _grantedScopes.end()) {
-          _grantedScopes.push_back(scope);
+        if (std::find(auth->_grantedScopes.begin(), auth->_grantedScopes.end(), scope) == auth->_grantedScopes.end()) {
+          auth->_grantedScopes.push_back(scope);
         }
       }
-      if (_currentUser) _currentUser->scopes = _grantedScopes;
+      if (auth->_currentUser) auth->_currentUser->scopes = auth->_grantedScopes;
     }
-    notifyAuthStateChanged();
+    auth->notifyAuthStateChanged();
     promise->resolve();
   });
   
@@ -159,7 +171,7 @@ std::shared_ptr<Promise<void>> HybridAuth::requestScopes(const std::vector<std::
 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);
+    std::lock_guard<std::recursive_mutex> lock(_mutex);
     _grantedScopes.erase(
       std::remove_if(_grantedScopes.begin(), _grantedScopes.end(),
         [&scopes](const std::string& s) {
@@ -180,7 +192,7 @@ 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);
+    std::lock_guard<std::recursive_mutex> lock(_mutex);
     if (_currentUser && _currentUser->accessToken) {
       if (_currentUser->expirationTime) {
         auto now = std::chrono::system_clock::now().time_since_epoch() / std::chrono::milliseconds(1);
@@ -211,7 +223,7 @@ std::shared_ptr<Promise<std::optional<std::string>>> HybridAuth::getAccessToken(
 std::shared_ptr<Promise<AuthTokens>> HybridAuth::refreshToken() {
   std::shared_ptr<Promise<AuthTokens>> promise;
   {
-    std::lock_guard<std::mutex> lock(_mutex);
+    std::lock_guard<std::recursive_mutex> lock(_mutex);
     if (_refreshInFlight) {
       return _refreshInFlight;
     }
@@ -219,38 +231,41 @@ std::shared_ptr<Promise<AuthTokens>> HybridAuth::refreshToken() {
     _refreshInFlight = promise;
   }
 
+  auto self = shared_from_this();
   auto refreshPromise = PlatformAuth::refreshToken();
-  refreshPromise->addOnResolvedListener([this, promise](const AuthTokens& tokens) {
+  refreshPromise->addOnResolvedListener([self, promise](const AuthTokens& tokens) {
+    auto* auth = dynamic_cast<HybridAuth*>(self.get());
     {
-      std::lock_guard<std::mutex> lock(_mutex);
-      if (_currentUser) {
+      std::lock_guard<std::recursive_mutex> lock(auth->_mutex);
+      if (auth->_currentUser) {
         if (tokens.accessToken.has_value()) {
-          _currentUser->accessToken = tokens.accessToken;
+          auth->_currentUser->accessToken = tokens.accessToken;
         }
         if (tokens.idToken.has_value()) {
-          _currentUser->idToken = tokens.idToken;
+          auth->_currentUser->idToken = tokens.idToken;
         }
         if (tokens.refreshToken.has_value()) {
-          _currentUser->refreshToken = tokens.refreshToken;
+          auth->_currentUser->refreshToken = tokens.refreshToken;
         }
         if (tokens.expirationTime.has_value()) {
-          _currentUser->expirationTime = tokens.expirationTime;
+          auth->_currentUser->expirationTime = tokens.expirationTime;
         }
       }
-      if (_refreshInFlight == promise) {
-        _refreshInFlight = nullptr;
+      if (auth->_refreshInFlight == promise) {
+        auth->_refreshInFlight = nullptr;
       }
     }
-    notifyTokensRefreshed(tokens);
-    notifyAuthStateChanged();
+    auth->notifyTokensRefreshed(tokens);
+    auth->notifyAuthStateChanged();
     promise->resolve(tokens);
   });
-  
-  refreshPromise->addOnRejectedListener([this, promise](const std::exception_ptr& error) {
+
+  refreshPromise->addOnRejectedListener([self, promise](const std::exception_ptr& error) {
+    auto* auth = dynamic_cast<HybridAuth*>(self.get());
     {
-      std::lock_guard<std::mutex> lock(_mutex);
-      if (_refreshInFlight == promise) {
-        _refreshInFlight = nullptr;
+      std::lock_guard<std::recursive_mutex> lock(auth->_mutex);
+      if (auth->_refreshInFlight == promise) {
+        auth->_refreshInFlight = nullptr;
       }
     }
     promise->reject(error);
@@ -258,14 +273,14 @@ std::shared_ptr<Promise<AuthTokens>> HybridAuth::refreshToken() {
   return promise;
 }
  
-void HybridAuth::setLoggingEnabled(bool enabled) {
-  sLoggingEnabled = enabled;
+void HybridAuth::setLoggingEnabled(bool /* enabled */) {
+    // Reserved for future use — logging not yet implemented in C++ layer
 }
 
 void HybridAuth::notifyTokensRefreshed(const AuthTokens& tokens) {
   std::vector<std::function<void(const AuthTokens&)>> listeners;
   {
-    std::lock_guard<std::mutex> lock(_mutex);
+    std::lock_guard<std::recursive_mutex> lock(_mutex);
     for (auto const& [id, listener] : _tokenListeners) {
       listeners.push_back(listener);
     }

package/cpp/HybridAuth.hpp

@@ -4,6 +4,7 @@
 #include "AuthUser.hpp"
 #include "LoginOptions.hpp"
 #include "AuthTokens.hpp"
+#include <cstdint>
 #include <optional>
 #include <mutex>
 #include <memory>
@@ -41,17 +42,18 @@ private:
 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::map<int, std::function<void(const AuthTokens&)>> _tokenListeners;
-  int _nextTokenListenerId = 0;
+  std::map<uint64_t, std::function<void(const std::optional<AuthUser>&)>> _listeners;
+  uint64_t _nextListenerId = 0;
+
+  std::map<uint64_t, std::function<void(const AuthTokens&)>> _tokenListeners;
+  uint64_t _nextTokenListenerId = 0;
   std::shared_ptr<Promise<AuthTokens>> _refreshInFlight;
   
-  std::mutex _mutex;
+  // recursive_mutex: listeners resolved inside a lock scope may re-enter Auth methods
+  // that also acquire _mutex, causing deadlock with a non-recursive mutex.
+  std::recursive_mutex _mutex;
 
   static constexpr auto TAG = "Auth";
-  static bool sLoggingEnabled;
 };
 
 } // namespace margelo::nitro::NitroAuth

package/cpp/JSONSerializer.hpp

@@ -1,3 +1,6 @@
+// ⚠️ TEST-ONLY: This serializer is used exclusively by unit tests.
+// It does NOT escape strings and does NOT handle all providers.
+// Do NOT use in production code — platform-native JSON APIs are used instead.
 #pragma once
 
 #include "AuthUser.hpp"