react-native-credentials-manager 0.5.3 → 0.6.1

package/android/src/newarch/java/com/credentialsmanager/CredentialsManagerModule.kt

@@ -49,14 +49,34 @@ class CredentialsManagerModule(
     }
   }
 
-  override fun signUpWithPassword(credObject: ReadableMap) {
+  override fun signUpWithPassword(credObject: ReadableMap, promise: Promise) {
     val username = credObject.getString("username") ?: ""
     val password = credObject.getString("password") ?: ""
+    
+    if (username.isEmpty()) {
+      promise.reject("INVALID_USERNAME", "Username cannot be empty")
+      return
+    }
+    
+    if (password.isEmpty()) {
+      promise.reject("INVALID_PASSWORD", "Password cannot be empty")
+      return
+    }
+    
     coroutineScope.launch {
       try {
         credentialHandler.createPassword(username, password)
+        
+        // Create success response
+        val result = mapOf(
+          "type" to "password",
+          "username" to username,
+          "success" to true
+        )
+        promise.resolve(result)
       } catch (e: CreateCredentialException) {
         ErrorHandler.handleCredentialError(e)
+        promise.reject("CREDENTIAL_ERROR", e.message.toString())
       }
     }
   }
@@ -140,4 +160,11 @@ class CredentialsManagerModule(
       }
     }
   }
+
+  override fun signUpWithApple(params: ReadableMap, promise: Promise) {
+    promise.reject(
+      "PLATFORM_NOT_SUPPORTED",
+      "Sign up with Apple is only supported on iOS devices"
+    )
+  }
 }

package/android/src/oldarch/java/com/credentialsmanager/CredentialsManagerModule.kt

@@ -55,14 +55,34 @@ class CredentialsManagerModule(
   }
 
   @ReactMethod
-  fun signUpWithPassword(credObject: ReadableMap) {
+  fun signUpWithPassword(credObject: ReadableMap, promise: Promise) {
     val username = credObject.getString("username") ?: ""
     val password = credObject.getString("password") ?: ""
+    
+    if (username.isEmpty()) {
+      promise.reject("INVALID_USERNAME", "Username cannot be empty")
+      return
+    }
+    
+    if (password.isEmpty()) {
+      promise.reject("INVALID_PASSWORD", "Password cannot be empty")
+      return
+    }
+    
     coroutineScope.launch {
       try {
         credentialHandler.createPassword(username, password)
+        
+        // Create success response
+        val result = mapOf(
+          "type" to "password",
+          "username" to username,
+          "success" to true
+        )
+        promise.resolve(result)
       } catch (e: CreateCredentialException) {
         ErrorHandler.handleCredentialError(e)
+        promise.reject("CREDENTIAL_ERROR", e.message.toString())
       }
     }
   }
@@ -161,4 +181,13 @@ class CredentialsManagerModule(
       }
     }
   }
+
+  @ReactMethod
+  fun signUpWithApple(params: ReadableMap, promise: Promise) {
+    // Since this is an iOS-specific function, we just reject with an appropriate message on Android
+    promise.reject(
+      "PLATFORM_NOT_SUPPORTED",
+      "Sign up with Apple is only supported on iOS devices"
+    )
+  }
 }

package/ios/CredentialsManager.h

@@ -1,6 +1,12 @@
-
+#import <Foundation/Foundation.h>
+#import <AuthenticationServices/AuthenticationServices.h>
 #import "generated/RNCredentialsManagerSpec/RNCredentialsManagerSpec.h"
 
-@interface CredentialsManager : NSObject <NativeCredentialsManagerSpec>
+@interface CredentialsManager : NSObject <NativeCredentialsManagerSpec, ASAuthorizationControllerDelegate, ASAuthorizationControllerPresentationContextProviding>
+
+@property (nonatomic, strong) ASPresentationAnchor authenticationAnchor;
+@property (nonatomic, copy) RCTPromiseResolveBlock currentResolve;
+@property (nonatomic, copy) RCTPromiseRejectBlock currentReject;
+@property (nonatomic, strong) NSString *relyingPartyIdentifier;
 
 @end

package/ios/CredentialsManager.mm

@@ -1,18 +1,410 @@
 #import "CredentialsManager.h"
+#import <React/RCTUtils.h>
+#import <React/RCTLog.h>
+#import <AuthenticationServices/AuthenticationServices.h>
 
 @implementation CredentialsManager
-RCT_EXPORT_MODULE()
 
-- (NSNumber *)multiply:(double)a b:(double)b {
-    NSNumber *result = @(a * b);
+RCT_EXPORT_MODULE()
 
-    return result;
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        // Default relying party identifier - should be configurable
+        self.relyingPartyIdentifier = @"www.benjamineruvieru.com";
+        
+        // Get the main window as the authentication anchor
+        dispatch_async(dispatch_get_main_queue(), ^{
+            UIWindow *keyWindow = nil;
+            for (UIWindowScene *windowScene in [UIApplication sharedApplication].connectedScenes) {
+                if (windowScene.activationState == UISceneActivationStateForegroundActive) {
+                    for (UIWindow *window in windowScene.windows) {
+                        if (window.isKeyWindow) {
+                            keyWindow = window;
+                            break;
+                        }
+                    }
+                }
+            }
+            self.authenticationAnchor = keyWindow;
+        });
+    }
+    return self;
 }
 
+#pragma mark - TurboModule
+
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params
 {
     return std::make_shared<facebook::react::NativeCredentialsManagerSpecJSI>(params);
 }
 
+#pragma mark - NativeCredentialsManagerSpec
+
+- (void)signUpWithPasskeys:(NSDictionary *)requestJson
+preferImmediatelyAvailableCredentials:(BOOL)preferImmediatelyAvailableCredentials
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject {
+    
+    dispatch_async(dispatch_get_main_queue(), ^{
+        self.currentResolve = resolve;
+        self.currentReject = reject;
+        
+        // Extract challenge and user info from requestJson
+        NSString *challengeString = requestJson[@"challenge"];
+        NSDictionary *userInfo = requestJson[@"user"];
+        NSDictionary *rpInfo = requestJson[@"rp"];
+        
+        if (!challengeString || !userInfo || !rpInfo) {
+            reject(@"INVALID_REQUEST", @"Missing required fields in request JSON", nil);
+            return;
+        }
+        
+        // Decode base64 challenge
+        NSData *challenge = [[NSData alloc] initWithBase64EncodedString:challengeString options:0];
+        if (!challenge) {
+            reject(@"INVALID_CHALLENGE", @"Invalid base64 challenge", nil);
+            return;
+        }
+        
+        // Extract user information
+        NSString *userName = userInfo[@"name"];
+        NSString *userIdString = userInfo[@"id"];
+        
+        // Decode user ID
+        NSData *userId = [[NSData alloc] initWithBase64EncodedString:userIdString options:0];
+        if (!userId) {
+            // If not base64, use the string directly
+            userId = [userIdString dataUsingEncoding:NSUTF8StringEncoding];
+        }
+        
+        // Update relying party identifier
+        NSString *rpId = rpInfo[@"id"];
+        if (rpId) {
+            self.relyingPartyIdentifier = rpId;
+        }
+        
+        // Create the passkey registration request using Apple's Authentication Services
+        ASAuthorizationPlatformPublicKeyCredentialProvider *provider = 
+            [[ASAuthorizationPlatformPublicKeyCredentialProvider alloc] initWithRelyingPartyIdentifier:self.relyingPartyIdentifier];
+        
+        ASAuthorizationPlatformPublicKeyCredentialRegistrationRequest *registrationRequest = 
+            [provider createCredentialRegistrationRequestWithChallenge:challenge name:userName userID:userId];
+        
+        // Configure the request 
+        registrationRequest.userVerificationPreference = ASAuthorizationPublicKeyCredentialUserVerificationPreferenceRequired;
+        
+        // Create and configure the authorization controller
+        ASAuthorizationController *authController = [[ASAuthorizationController alloc] initWithAuthorizationRequests:@[registrationRequest]];
+        authController.delegate = self;
+        authController.presentationContextProvider = self;
+        
+        // Perform the request
+        [authController performRequests];
+    });
+}
+
+- (void)signUpWithPassword:(JS::NativeCredentialsManager::CredObject &)credObject
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject {
+    // Apple's Authentication Services only supports AutoFill passwords, not manual credential storage
+    // Manual keychain storage is not part of Authentication Services framework
+    reject(@"UNSUPPORTED_OPERATION", @"Manual password storage is not supported. Use AutoFill passwords through signIn method instead.", nil);
+}
+
+- (void)signIn:(NSArray *)options
+        params:(JS::NativeCredentialsManager::SpecSignInParams &)params
+       resolve:(RCTPromiseResolveBlock)resolve
+        reject:(RCTPromiseRejectBlock)reject {
+    
+    dispatch_async(dispatch_get_main_queue(), ^{
+        self.currentResolve = resolve;
+        self.currentReject = reject;
+        
+        NSMutableArray<ASAuthorizationRequest *> *authRequests = [[NSMutableArray alloc] init];
+        
+        for (NSString *option in options) {
+            if ([option isEqualToString:@"passkeys"]) {
+                // Extract passkeys parameters from the params object
+                id passkeyParams = params.passkeys();
+                if (!passkeyParams || ![passkeyParams isKindOfClass:[NSDictionary class]]) {
+                    RCTLogError(@"Missing or invalid passkeys parameters");
+                    continue;
+                }
+                
+                NSDictionary *passkeyDict = (NSDictionary *)passkeyParams;
+                NSString *challengeString = passkeyDict[@"challenge"];
+                
+                if (!challengeString || ![challengeString isKindOfClass:[NSString class]]) {
+                    RCTLogError(@"Missing or invalid challenge in passkeys parameters");
+                    continue;
+                }
+                
+                NSData *challenge = [[NSData alloc] initWithBase64EncodedString:challengeString options:0];
+                
+                if (challenge) {
+                    // Update relying party identifier if provided
+                    NSString *rpId = passkeyDict[@"rpId"];
+                    if (rpId && [rpId isKindOfClass:[NSString class]]) {
+                        self.relyingPartyIdentifier = rpId;
+                    }
+                    
+                    ASAuthorizationPlatformPublicKeyCredentialProvider *provider = 
+                        [[ASAuthorizationPlatformPublicKeyCredentialProvider alloc] initWithRelyingPartyIdentifier:self.relyingPartyIdentifier];
+                    
+                    ASAuthorizationPlatformPublicKeyCredentialAssertionRequest *assertionRequest = 
+                        [provider createCredentialAssertionRequestWithChallenge:challenge];
+                    assertionRequest.userVerificationPreference = ASAuthorizationPublicKeyCredentialUserVerificationPreferenceRequired;
+                    
+                    [authRequests addObject:assertionRequest];
+                } else {
+                    RCTLogError(@"Failed to decode challenge for passkey authentication");
+                }
+            } else if ([option isEqualToString:@"password"]) {
+                // Use Apple's AutoFill password provider (not manual keychain)
+                ASAuthorizationPasswordProvider *passwordProvider = [[ASAuthorizationPasswordProvider alloc] init];
+                ASAuthorizationPasswordRequest *passwordRequest = [passwordProvider createRequest];
+                [authRequests addObject:passwordRequest];
+            } else if ([option isEqualToString:@"apple-signin"]) {
+                // Apple Sign In is supported by Authentication Services
+                ASAuthorizationAppleIDProvider *appleIDProvider = [[ASAuthorizationAppleIDProvider alloc] init];
+                ASAuthorizationAppleIDRequest *appleIDRequest = [appleIDProvider createRequest];
+                
+                // Default scopes - always use these
+                NSArray<ASAuthorizationScope> *defaultScopes = @[ASAuthorizationScopeFullName, ASAuthorizationScopeEmail];
+                appleIDRequest.requestedScopes = defaultScopes;
+                
+                [authRequests addObject:appleIDRequest];
+            } else if ([option isEqualToString:@"google-signin"]) {
+                // Google Sign In is not part of Apple's Authentication Services framework
+                RCTLogError(@"Google Sign In is not supported on iOS. Use Apple Sign In instead.");
+                continue;
+            }
+        }
+        
+        if (authRequests.count == 0) {
+            reject(@"NO_AUTH_METHODS", @"No valid authentication methods provided", nil);
+            return;
+        }
+        
+        // Create and configure the authorization controller
+        ASAuthorizationController *authController = [[ASAuthorizationController alloc] initWithAuthorizationRequests:authRequests];
+        authController.delegate = self;
+        authController.presentationContextProvider = self;
+        
+        // Perform the request
+        [authController performRequests];
+    });
+}
+
+- (void)signUpWithGoogle:(JS::NativeCredentialsManager::GoogleSignInParams &)params
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject {
+    // Google Sign In is not part of Apple's Authentication Services framework
+    // This should be handled at the JavaScript layer for cross-platform compatibility
+    reject(@"UNSUPPORTED_OPERATION", @"Google Sign In is not available on iOS. Use Apple Sign In instead.", nil);
+}
+
+- (void)signUpWithApple:(JS::NativeCredentialsManager::AppleSignInParams &)params
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject {
+    
+    dispatch_async(dispatch_get_main_queue(), ^{
+        self.currentResolve = resolve;
+        self.currentReject = reject;
+        
+        // Apple Sign In is officially supported by Authentication Services framework
+        ASAuthorizationAppleIDProvider *appleIDProvider = [[ASAuthorizationAppleIDProvider alloc] init];
+        ASAuthorizationAppleIDRequest *appleIDRequest = [appleIDProvider createRequest];
+        
+        // Always use the default scopes
+        appleIDRequest.requestedScopes = @[ASAuthorizationScopeFullName, ASAuthorizationScopeEmail];
+        
+        ASAuthorizationController *authController = [[ASAuthorizationController alloc] initWithAuthorizationRequests:@[appleIDRequest]];
+        authController.delegate = self;
+        authController.presentationContextProvider = self;
+        
+        [authController performRequests];
+    });
+}
+
+- (void)signOut:(RCTPromiseResolveBlock)resolve
+         reject:(RCTPromiseRejectBlock)reject {
+    // Apple's Authentication Services doesn't provide a direct sign-out method
+    // Sign-out is typically handled at the application level
+    // AutoFill passwords and passkeys are managed by the system
+    resolve([NSNull null]);
+}
+
+#pragma mark - ASAuthorizationControllerDelegate
+
+- (void)authorizationController:(ASAuthorizationController *)controller didCompleteWithAuthorization:(ASAuthorization *)authorization {
+    if (!self.currentResolve) {
+        return;
+    }
+    
+    RCTPromiseResolveBlock resolve = self.currentResolve;
+    self.currentReject = nil;
+    self.currentResolve = nil;
+    
+    if ([authorization.credential isKindOfClass:[ASAuthorizationPlatformPublicKeyCredentialRegistration class]]) {
+        // Passkey registration - handled by Apple's Authentication Services
+        ASAuthorizationPlatformPublicKeyCredentialRegistration *registration = (ASAuthorizationPlatformPublicKeyCredentialRegistration *)authorization.credential;
+        
+        NSDictionary *result = @{
+            @"id": registration.credentialID ? [registration.credentialID base64EncodedStringWithOptions:0] : @"",
+            @"rawId": registration.credentialID ? [registration.credentialID base64EncodedStringWithOptions:0] : @"",
+            @"response": @{
+                @"attestationObject": registration.rawAttestationObject ? [registration.rawAttestationObject base64EncodedStringWithOptions:0] : @"",
+                @"clientDataJSON": registration.rawClientDataJSON ? [registration.rawClientDataJSON base64EncodedStringWithOptions:0] : @""
+            },
+            @"type": @"public-key"
+        };
+        
+        resolve(result);
+        return;
+    } else if ([authorization.credential isKindOfClass:[ASAuthorizationPlatformPublicKeyCredentialAssertion class]]) {
+        // Passkey authentication - handled by Apple's Authentication Services
+        ASAuthorizationPlatformPublicKeyCredentialAssertion *assertion = (ASAuthorizationPlatformPublicKeyCredentialAssertion *)authorization.credential;
+        
+        NSDictionary *result = @{
+            @"type": @"passkey",
+            @"authenticationResponseJson": [self createAuthenticationResponseJSON:assertion]
+        };
+        
+        resolve(result);
+        return;
+    } else if ([authorization.credential isKindOfClass:[ASPasswordCredential class]]) {
+        // AutoFill password authentication - handled by Apple's Authentication Services
+        ASPasswordCredential *passwordCredential = (ASPasswordCredential *)authorization.credential;
+        
+        NSDictionary *result = @{
+            @"type": @"password",
+            @"username": passwordCredential.user,
+            @"password": passwordCredential.password
+        };
+        
+        resolve(result);
+        return;
+    } else if ([authorization.credential isKindOfClass:[ASAuthorizationAppleIDCredential class]]) {
+        // Apple Sign In - officially supported by Authentication Services
+        ASAuthorizationAppleIDCredential *appleIDCredential = (ASAuthorizationAppleIDCredential *)authorization.credential;
+        
+        NSMutableDictionary *result = [@{
+            @"type": @"apple-signin",
+            @"id": appleIDCredential.user,
+            @"idToken": appleIDCredential.identityToken ? [[NSString alloc] initWithData:appleIDCredential.identityToken encoding:NSUTF8StringEncoding] : @""
+        } mutableCopy];
+        
+        if (appleIDCredential.fullName) {
+            if (appleIDCredential.fullName.givenName) {
+                result[@"givenName"] = appleIDCredential.fullName.givenName;
+            }
+            if (appleIDCredential.fullName.familyName) {
+                result[@"familyName"] = appleIDCredential.fullName.familyName;
+            }
+            if (appleIDCredential.fullName.givenName || appleIDCredential.fullName.familyName) {
+                NSString *fullName = [NSString stringWithFormat:@"%@ %@", 
+                    appleIDCredential.fullName.givenName ?: @"", 
+                    appleIDCredential.fullName.familyName ?: @""];
+                result[@"displayName"] = [fullName stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
+            }
+        }
+        
+        if (appleIDCredential.email) {
+            result[@"email"] = appleIDCredential.email;
+        }
+        
+        resolve([result copy]);
+        return;
+    }
+    
+    // If we reach here, we couldn't handle the credential type
+    resolve(@{@"type": @"unknown"});
+}
+
+- (void)authorizationController:(ASAuthorizationController *)controller didCompleteWithError:(NSError *)error {
+    if (!self.currentReject) {
+        return;
+    }
+    
+    RCTPromiseRejectBlock reject = self.currentReject;
+    self.currentResolve = nil;
+    self.currentReject = nil;
+    
+    NSString *errorCode = @"UNKNOWN_ERROR";
+    NSString *errorMessage = error.localizedDescription;
+    
+    if ([error.domain isEqualToString:ASAuthorizationErrorDomain]) {
+        switch (error.code) {
+            case ASAuthorizationErrorCanceled:
+                errorCode = @"USER_CANCELED";
+                errorMessage = @"User canceled the authorization request";
+                break;
+            case ASAuthorizationErrorFailed:
+                errorCode = @"AUTHORIZATION_FAILED";
+                break;
+            case ASAuthorizationErrorInvalidResponse:
+                errorCode = @"INVALID_RESPONSE";
+                break;
+            case ASAuthorizationErrorNotHandled:
+                errorCode = @"NOT_HANDLED";
+                break;
+            case ASAuthorizationErrorUnknown:
+                errorCode = @"UNKNOWN_ERROR";
+                break;
+        }
+    }
+    
+    reject(errorCode, errorMessage, error);
+}
+
+#pragma mark - ASAuthorizationControllerPresentationContextProviding
+
+- (ASPresentationAnchor)presentationAnchorForAuthorizationController:(ASAuthorizationController *)controller {
+    if (self.authenticationAnchor) {
+        return self.authenticationAnchor;
+    }
+    
+    // Fallback to finding a key window
+    UIWindow *keyWindow = nil;
+    for (UIWindowScene *windowScene in [UIApplication sharedApplication].connectedScenes) {
+        if (windowScene.activationState == UISceneActivationStateForegroundActive) {
+            for (UIWindow *window in windowScene.windows) {
+                if (window.isKeyWindow) {
+                    keyWindow = window;
+                    break;
+                }
+            }
+        }
+    }
+    
+    return keyWindow ?: [[UIApplication sharedApplication] windows].firstObject;
+}
+
+#pragma mark - Helper Methods
+
+- (NSString *)createAuthenticationResponseJSON:(ASAuthorizationPlatformPublicKeyCredentialAssertion *)assertion {
+    NSDictionary *response = @{
+        @"id": assertion.credentialID ? [assertion.credentialID base64EncodedStringWithOptions:0] : @"",
+        @"rawId": assertion.credentialID ? [assertion.credentialID base64EncodedStringWithOptions:0] : @"",
+        @"response": @{
+            @"authenticatorData": assertion.rawAuthenticatorData ? [assertion.rawAuthenticatorData base64EncodedStringWithOptions:0] : @"",
+            @"clientDataJSON": assertion.rawClientDataJSON ? [assertion.rawClientDataJSON base64EncodedStringWithOptions:0] : @"",
+            @"signature": assertion.signature ? [assertion.signature base64EncodedStringWithOptions:0] : @"",
+            @"userHandle": assertion.userID ? [assertion.userID base64EncodedStringWithOptions:0] : @""
+        },
+        @"type": @"public-key"
+    };
+    
+    NSError *error;
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:response options:0 error:&error];
+    if (error) {
+        return @"{}";
+    }
+    
+    return [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
+}
+
 @end

package/ios/generated/RNCredentialsManagerSpec/RNCredentialsManagerSpec-generated.mm

@@ -35,6 +35,12 @@
   return facebook::react::managedPointer<JS::NativeCredentialsManager::GoogleSignInParams>(json);
 }
 @end
+@implementation RCTCxxConvert (NativeCredentialsManager_AppleSignInParams)
++ (RCTManagedPointer *)JS_NativeCredentialsManager_AppleSignInParams:(id)json
+{
+  return facebook::react::managedPointer<JS::NativeCredentialsManager::AppleSignInParams>(json);
+}
+@end
 @implementation RCTCxxConvert (NativeCredentialsManager_SpecSignInParams)
 + (RCTManagedPointer *)JS_NativeCredentialsManager_SpecSignInParams:(id)json
 {
@@ -48,7 +54,7 @@ namespace facebook::react {
     }
 
     static facebook::jsi::Value __hostFunction_NativeCredentialsManagerSpecJSI_signUpWithPassword(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
-      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "signUpWithPassword", @selector(signUpWithPassword:), args, count);
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "signUpWithPassword", @selector(signUpWithPassword:resolve:reject:), args, count);
     }
 
     static facebook::jsi::Value __hostFunction_NativeCredentialsManagerSpecJSI_signIn(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
@@ -59,6 +65,10 @@ namespace facebook::react {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "signUpWithGoogle", @selector(signUpWithGoogle:resolve:reject:), args, count);
     }
 
+    static facebook::jsi::Value __hostFunction_NativeCredentialsManagerSpecJSI_signUpWithApple(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "signUpWithApple", @selector(signUpWithApple:resolve:reject:), args, count);
+    }
+
     static facebook::jsi::Value __hostFunction_NativeCredentialsManagerSpecJSI_signOut(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "signOut", @selector(signOut:reject:), args, count);
     }
@@ -78,6 +88,9 @@ namespace facebook::react {
         methodMap_["signUpWithGoogle"] = MethodMetadata {1, __hostFunction_NativeCredentialsManagerSpecJSI_signUpWithGoogle};
         setMethodArgConversionSelector(@"signUpWithGoogle", 0, @"JS_NativeCredentialsManager_GoogleSignInParams:");
         
+        methodMap_["signUpWithApple"] = MethodMetadata {1, __hostFunction_NativeCredentialsManagerSpecJSI_signUpWithApple};
+        setMethodArgConversionSelector(@"signUpWithApple", 0, @"JS_NativeCredentialsManager_AppleSignInParams:");
+        
         methodMap_["signOut"] = MethodMetadata {0, __hostFunction_NativeCredentialsManagerSpecJSI_signOut};
         
   }

package/ios/generated/RNCredentialsManagerSpec/RNCredentialsManagerSpec.h

@@ -65,11 +65,28 @@ namespace JS {
 @interface RCTCxxConvert (NativeCredentialsManager_GoogleSignInParams)
 + (RCTManagedPointer *)JS_NativeCredentialsManager_GoogleSignInParams:(id)json;
 @end
+namespace JS {
+  namespace NativeCredentialsManager {
+    struct AppleSignInParams {
+      NSString *nonce() const;
+      facebook::react::LazyVector<NSString *> requestedScopes() const;
+
+      AppleSignInParams(NSDictionary *const v) : _v(v) {}
+    private:
+      NSDictionary *_v;
+    };
+  }
+}
+
+@interface RCTCxxConvert (NativeCredentialsManager_AppleSignInParams)
++ (RCTManagedPointer *)JS_NativeCredentialsManager_AppleSignInParams:(id)json;
+@end
 namespace JS {
   namespace NativeCredentialsManager {
     struct SpecSignInParams {
       id<NSObject> _Nullable passkeys() const;
       std::optional<JS::NativeCredentialsManager::GoogleSignInParams> googleSignIn() const;
+      std::optional<JS::NativeCredentialsManager::AppleSignInParams> appleSignIn() const;
 
       SpecSignInParams(NSDictionary *const v) : _v(v) {}
     private:
@@ -87,7 +104,9 @@ namespace JS {
 preferImmediatelyAvailableCredentials:(BOOL)preferImmediatelyAvailableCredentials
                    resolve:(RCTPromiseResolveBlock)resolve
                     reject:(RCTPromiseRejectBlock)reject;
-- (void)signUpWithPassword:(JS::NativeCredentialsManager::CredObject &)credObject;
+- (void)signUpWithPassword:(JS::NativeCredentialsManager::CredObject &)credObject
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject;
 - (void)signIn:(NSArray *)options
         params:(JS::NativeCredentialsManager::SpecSignInParams &)params
        resolve:(RCTPromiseResolveBlock)resolve
@@ -95,6 +114,9 @@ preferImmediatelyAvailableCredentials:(BOOL)preferImmediatelyAvailableCredential
 - (void)signUpWithGoogle:(JS::NativeCredentialsManager::GoogleSignInParams &)params
                  resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject;
+- (void)signUpWithApple:(JS::NativeCredentialsManager::AppleSignInParams &)params
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject;
 - (void)signOut:(RCTPromiseResolveBlock)resolve
          reject:(RCTPromiseRejectBlock)reject;
 
@@ -143,6 +165,16 @@ inline bool JS::NativeCredentialsManager::GoogleSignInParams::autoSelectEnabled(
   id const p = _v[@"autoSelectEnabled"];
   return RCTBridgingToBool(p);
 }
+inline NSString *JS::NativeCredentialsManager::AppleSignInParams::nonce() const
+{
+  id const p = _v[@"nonce"];
+  return RCTBridgingToString(p);
+}
+inline facebook::react::LazyVector<NSString *> JS::NativeCredentialsManager::AppleSignInParams::requestedScopes() const
+{
+  id const p = _v[@"requestedScopes"];
+  return RCTBridgingToVec(p, ^NSString *(id itemValue_0) { return RCTBridgingToString(itemValue_0); });
+}
 inline id<NSObject> _Nullable JS::NativeCredentialsManager::SpecSignInParams::passkeys() const
 {
   id const p = _v[@"passkeys"];
@@ -153,5 +185,10 @@ inline std::optional<JS::NativeCredentialsManager::GoogleSignInParams> JS::Nativ
   id const p = _v[@"googleSignIn"];
   return (p == nil ? std::nullopt : std::make_optional(JS::NativeCredentialsManager::GoogleSignInParams(p)));
 }
+inline std::optional<JS::NativeCredentialsManager::AppleSignInParams> JS::NativeCredentialsManager::SpecSignInParams::appleSignIn() const
+{
+  id const p = _v[@"appleSignIn"];
+  return (p == nil ? std::nullopt : std::make_optional(JS::NativeCredentialsManager::AppleSignInParams(p)));
+}
 NS_ASSUME_NONNULL_END
 #endif // RNCredentialsManagerSpec_H