@velocitycareerlabs/vcl-react-native 2.9.0 → 2.9.1

package/VclReactNative.podspec

@@ -18,7 +18,7 @@ Pod::Spec.new do |s|
 
   s.swift_version = "5.0"
 
-  s.dependency "VCL", "2.9.0"
+  s.dependency "VCL", "2.9.3"
 
   install_modules_dependencies(s)
 end

package/android/build.gradle

@@ -76,7 +76,7 @@ dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
 //--------- Must: be added:
-  implementation "io.velocitycareerlabs:vcl:2.9.0"
+  implementation "io.velocitycareerlabs:vcl:2.9.2"
   implementation 'com.nimbusds:nimbus-jose-jwt:10.5'
   implementation "androidx.security:security-crypto:1.1.0"
 //-------------------------

package/android/src/main/java/io/velocitycareerlabs/reactnative/VclReactNativeModule.kt

@@ -38,7 +38,9 @@ import io.velocitycareerlabs.reactnative.utlis.Converter.verifiedProfileToMap
 import io.velocitycareerlabs.api.VCLProvider
 import io.velocitycareerlabs.api.entities.error.VCLError
 import io.velocitycareerlabs.api.entities.initialization.VCLInitializationDescriptor
-import io.velocitycareerlabs.reactnative.extensions.toThrowable
+import io.velocitycareerlabs.reactnative.extensions.VCLErrorBridgeConfig
+import io.velocitycareerlabs.reactnative.extensions.getIntOpt
+import io.velocitycareerlabs.reactnative.extensions.rejectBridgedVCLError
 import io.velocitycareerlabs.reactnative.utlis.Converter.authTokenToMap
 import io.velocitycareerlabs.reactnative.utlis.Converter.didJwkToMap
 import io.velocitycareerlabs.reactnative.utlis.Converter.mapToAuthToken
@@ -72,11 +74,25 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     GlobalConfig.IsDebugOn = initializationDescriptor.isDebugOn
   }
 
+  private inline fun withBridgedLocalExceptions(
+    promise: Promise,
+    block: () -> Unit
+  ) {
+    try {
+      block()
+    } catch (ex: Exception) {
+      promise.rejectBridgedVCLError(VCLError(ex))
+    }
+  }
+
   override fun initialize(
     initializationDescriptorMap: ReadableMap,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
+      VCLErrorBridgeConfig.updateNativeErrorStackFrameLimit(
+        initializationDescriptorMap.getIntOpt("nativeErrorStackFrameLimit")
+      )
       val initializationDescriptor = mapToInitializationDescriptor(
         initializationDescriptorMap
       )
@@ -88,37 +104,29 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
           promise.resolve("VCL initialization succeed!")
         },
         errorHandler = {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
   override fun getCountries(promise: Promise) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.countries?.let { promise.resolve(countriesToMap(it)) }
-        ?: promise.reject(VCLError(message = "Countries not found").toThrowable())
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
+        ?: promise.rejectBridgedVCLError(VCLError(message = "Countries not found"))
     }
   }
 
   override fun getCredentialTypeSchemas(promise: Promise) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.credentialTypeSchemas?.let { promise.resolve(credentialTypeSchemasToMap(it)) }
-        ?: promise.reject(VCLError(message = "Credential Types not found").toThrowable())
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
+        ?: promise.rejectBridgedVCLError(VCLError(message = "Credential Type Schemas not found"))
     }
   }
 
   override fun getCredentialTypes(promise: Promise) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.credentialTypes?.let { promise.resolve(credentialTypesToMap(it)) }
-        ?: promise.reject(VCLError(message = "Credential Types not found").toThrowable())
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
+        ?: promise.rejectBridgedVCLError(VCLError(message = "Credential Types not found"))
     }
   }
 
@@ -126,7 +134,7 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     presentationRequestDescriptorMap: ReadableMap,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.getPresentationRequest(
         presentationRequestDescriptor = mapTopPresentationRequestDescriptor(
           presentationRequestDescriptorMap
@@ -135,10 +143,8 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
           promise.resolve(presentationRequestToMap(it))
         },
         errorHandler = {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -147,7 +153,7 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     authTokenMap: ReadableMap?,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.submitPresentation(
         presentationSubmission = mapToPresentationSubmission(presentationSubmissionMap),
         authToken = mapToAuthToken(authTokenMap),
@@ -155,10 +161,8 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
           promise.resolve(presentationSubmissionResultToMap(it))
         },
         errorHandler = {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -166,16 +170,14 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     exchangeDescriptorMap: ReadableMap,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.getExchangeProgress(mapToExchangeDescriptor(exchangeDescriptorMap),
         {
           promise.resolve(exchangeToMap(it))
         },
         {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -183,17 +185,15 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     organizationsSearchDescriptorMap: ReadableMap,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.searchForOrganizations(
         mapToOrganizationsSearchDescriptor(organizationsSearchDescriptorMap),
         {
           promise.resolve(organizationsToMap(it))
         },
         {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -201,7 +201,7 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     credentialManifestDescriptorMap: ReadableMap,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       VCLLog.d(TAG, "credentialManifestDescriptorMap map: $credentialManifestDescriptorMap")
       mapToCredentialManifestDescriptor(credentialManifestDescriptorMap)?.let { credentialManifestDescriptor ->
         VCLLog.d(
@@ -214,13 +214,15 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
             promise.resolve(credentialManifestToMap(it))
           },
           errorHandler = {
-            promise.reject(it.toThrowable())
+            promise.rejectBridgedVCLError(it)
           })
       } ?: run {
-        promise.reject(VCLError("Unexpected Credential Credential Manifest Descriptor: $credentialManifestDescriptorMap").toThrowable())
+        promise.rejectBridgedVCLError(
+          VCLError(
+            message = "Unexpected Credential Manifest Descriptor"
+          )
+        )
       }
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -228,17 +230,15 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     generateOffersDescriptorMap: ReadableMap,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.generateOffers(
         generateOffersDescriptor = mapToGenerateOffersDescriptor(generateOffersDescriptorMap),
         successHandler = {
           promise.resolve(offersToMap(it))
         },
         errorHandler = {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -247,7 +247,7 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     sessionTokenMap: ReadableMap,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.checkForOffers(
         mapToGenerateOffersDescriptor(generateOffersDescriptorMap),
         mapToToken(sessionTokenMap),
@@ -255,10 +255,8 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
           promise.resolve(offersToMap(it))
         },
         {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -267,7 +265,7 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     sessionTokenMap: ReadableMap,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.finalizeOffers(
         finalizeOffersDescriptor = mapToFinalizedOffersDescriptor(finalizeOffersDescriptorMap),
         sessionToken = mapToToken(sessionTokenMap),
@@ -275,10 +273,8 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
           promise.resolve(jwtVerifiableCredentialsToMap(it))
         },
         errorHandler = {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -286,17 +282,15 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     authTokenDescriptorMap: ReadableMap,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.getAuthToken(
         authTokenDescriptor = mapToAuthTokenDescriptor(authTokenDescriptorMap),
         successHandler = {
           promise.resolve(authTokenToMap(it))
         },
         errorHandler = {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -304,18 +298,16 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     credentialTypesUIFormSchemaDescriptorMap: ReadableMap,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.getCredentialTypesUIFormSchema(
         mapToCredentialTypesUIFormSchemaDescriptor(credentialTypesUIFormSchemaDescriptorMap),
         {
           promise.resolve(credentialTypesFormSchemaToMap(it))
         },
         {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         }
       )
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -323,16 +315,14 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     verifiedProfileDescriptorMap: ReadableMap,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.getVerifiedProfile(mapToVerifiedProfileDescriptor(verifiedProfileDescriptorMap),
         {
           promise.resolve(verifiedProfileToMap(it))
         },
         {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -342,7 +332,7 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     remoteCryptoServicesTokenMap: ReadableMap?,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.verifyJwt(
         jwt = mapToJwt(jwtMap),
         publicJwk = mapToPublicJwk(publicJwkMap),
@@ -351,10 +341,8 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
           promise.resolve(it)
         },
         errorHandler = {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -364,7 +352,7 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     remoteCryptoServicesTokenMap: ReadableMap?,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.generateSignedJwt(
         jwtDescriptor = mapToJwtDescriptor(jwtDescriptorMap),
         didJwk = mapToDidJwk(didJwkMap),
@@ -373,10 +361,8 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
           promise.resolve(Converter.jwtToMap(it))
         },
         errorHandler = {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 
@@ -384,17 +370,15 @@ class VclReactNativeModule(val reactContext: ReactApplicationContext) :
     didJwkDescriptorMap: ReadableMap?,
     promise: Promise
   ) {
-    try {
+    withBridgedLocalExceptions(promise) {
       vcl.generateDidJwk(
         didJwkDescriptor = mapToDidJwkDescriptor(didJwkDescriptorMap),
         successHandler = {
           promise.resolve(didJwkToMap(it))
         },
         errorHandler = {
-          promise.reject(it.toThrowable())
+          promise.rejectBridgedVCLError(it)
         })
-    } catch (ex: Exception) {
-      promise.reject(VCLError(ex).toThrowable())
     }
   }
 }

package/android/src/main/java/io/velocitycareerlabs/reactnative/extensions/VCLErrorExtensions.kt

@@ -7,7 +7,67 @@
 
 package io.velocitycareerlabs.reactnative.extensions
 
+import com.facebook.react.bridge.Promise
 import io.velocitycareerlabs.api.entities.error.VCLError
+import org.json.JSONArray
+import org.json.JSONObject
 
-fun VCLError.toThrowable() =
-  Throwable(this.toJsonObject().toString())
+const val BRIDGED_VCL_ERROR_CODE = "VCL_BRIDGED_ERROR_V1"
+private const val DEFAULT_NATIVE_ERROR_STACK_FRAME_LIMIT = 5
+private const val MAX_NATIVE_ERROR_STACK_FRAME_LIMIT = 20
+
+object VCLErrorBridgeConfig {
+  var nativeErrorStackFrameLimit = DEFAULT_NATIVE_ERROR_STACK_FRAME_LIMIT
+    private set
+
+  fun updateNativeErrorStackFrameLimit(nativeErrorStackFrameLimit: Int?) {
+    this.nativeErrorStackFrameLimit =
+      nativeErrorStackFrameLimit
+        ?.coerceIn(0, MAX_NATIVE_ERROR_STACK_FRAME_LIMIT)
+        ?: DEFAULT_NATIVE_ERROR_STACK_FRAME_LIMIT
+  }
+}
+
+fun Promise.rejectBridgedVCLError(error: VCLError) {
+  val serializedError =
+    error.toBridgedJsonObject(VCLErrorBridgeConfig.nativeErrorStackFrameLimit).toString()
+  reject(BRIDGED_VCL_ERROR_CODE, serializedError, error)
+}
+
+private fun VCLError.toBridgedJsonObject(
+  nativeErrorStackFrameLimit: Int
+) = JSONObject().apply {
+  putOpt("payload", payload)
+  putOpt("error", error)
+  putOpt("errorCode", errorCode)
+  putOpt("requestId", requestId)
+  putOpt("message", message)
+  putOpt("statusCode", statusCode)
+  put("diagnostics", toDiagnosticsJsonObject(nativeErrorStackFrameLimit))
+}
+
+private fun VCLError.toDiagnosticsJsonObject(
+  nativeErrorStackFrameLimit: Int
+) = JSONObject().apply {
+  put("nativePlatform", "android")
+  put("nativeType", this@toDiagnosticsJsonObject::class.java.name)
+  putOpt("nativeStackFrames", stackTrace.toStackFramesJsonArray(nativeErrorStackFrameLimit))
+  cause?.let { put("nativeCause", it.toNativeCauseJsonObject(nativeErrorStackFrameLimit)) }
+}
+
+private fun Throwable.toNativeCauseJsonObject(
+  nativeErrorStackFrameLimit: Int
+) = JSONObject().apply {
+  put("type", javaClass.name)
+  put("message", message ?: toString())
+  putOpt("stackFrames", stackTrace.toStackFramesJsonArray(nativeErrorStackFrameLimit))
+}
+
+private fun Array<StackTraceElement>.toStackFramesJsonArray(
+  nativeErrorStackFrameLimit: Int
+): JSONArray? =
+  takeIf { nativeErrorStackFrameLimit > 0 }
+    ?.take(nativeErrorStackFrameLimit)
+    ?.map { it.toString() }
+    ?.takeIf { it.isNotEmpty() }
+    ?.let { JSONArray(it) }

package/ios/VCLErrorBridge.swift

@@ -0,0 +1,89 @@
+//
+//  VCLErrorBridge.swift
+//  vcl-react-native
+//
+//  Copyright 2022 Velocity Career Labs inc.
+//  SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+import React
+import VCL
+
+final class VCLErrorBridge {
+
+  private static let bridgedVCLErrorCode = "VCL_BRIDGED_ERROR_V1"
+  private static let defaultNativeErrorStackFrameLimit = 5
+  private static let maxNativeErrorStackFrameLimit = 20
+  private static let nativeStackFramesDictionaryKey = "callStackSymbols"
+
+  private var nativeErrorStackFrameLimit = VCLErrorBridge.defaultNativeErrorStackFrameLimit
+
+  func updateConfiguration(_ initializationDescriptorDictionary: [String: Any]) {
+    let stackFrameLimit = initializationDescriptorDictionary["nativeErrorStackFrameLimit"] as? Int
+    nativeErrorStackFrameLimit =
+      stackFrameLimit.map { min(max($0, 0), Self.maxNativeErrorStackFrameLimit) }
+      ?? Self.defaultNativeErrorStackFrameLimit
+  }
+
+  func rejectBridgedVCLError(
+    _ reject: @escaping RCTPromiseRejectBlock,
+    error: VCLError
+  ) {
+    let serializedError =
+      bridgedVCLErrorPayload(error).toJsonString()
+      ?? error.message
+      ?? "Unexpected VCLError"
+    reject(Self.bridgedVCLErrorCode, serializedError, error)
+  }
+
+  private func bridgedVCLErrorPayload(_ error: VCLError) -> [String: Any] {
+    var payload = error.toDictionary().compactMapValues { $0 }
+    payload.removeValue(forKey: Self.nativeStackFramesDictionaryKey)
+    payload["diagnostics"] = bridgedDiagnostics(error)
+    return payload
+  }
+
+  private func bridgedDiagnostics(_ error: VCLError) -> [String: Any] {
+    var diagnostics: [String: Any] = [
+      "nativePlatform": "ios",
+      "nativeType": String(describing: type(of: error)),
+    ]
+
+    if let nativeStackFrames =
+      limitedStackFrames(
+        error.toDictionary()[Self.nativeStackFramesDictionaryKey] as? [String]
+      )
+    {
+      diagnostics["nativeStackFrames"] = nativeStackFrames
+    }
+
+    if let cause = error.cause {
+      var nativeCause: [String: Any] = [
+        "type": String(describing: type(of: cause)),
+        "message": String(describing: cause),
+      ]
+
+      if let stackFrames =
+        limitedStackFrames(
+          (cause as? VCLError)?.toDictionary()[Self.nativeStackFramesDictionaryKey] as? [String]
+        )
+      {
+        nativeCause["stackFrames"] = stackFrames
+      }
+
+      diagnostics["nativeCause"] = nativeCause
+    }
+
+    return diagnostics
+  }
+
+  private func limitedStackFrames(_ stackFrames: [String]?) -> [String]? {
+    guard nativeErrorStackFrameLimit > 0, let stackFrames else {
+      return nil
+    }
+
+    let trimmedStackFrames = Array(stackFrames.prefix(nativeErrorStackFrameLimit))
+    return trimmedStackFrames.isEmpty ? nil : trimmedStackFrames
+  }
+}