react-native-rook-sdk 2.1.2 → 4.0.0-beta.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Rook
+Copyright (c) 2025 ROOK
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights

package/README.md

@@ -1,5 +1,37 @@
-# Rook SDK
+# react-native-rook-sdk
 
-This SDK enables apps to extract and upload data from Health Connect, with this sdk you will be able to extract and upload data from health connect, [if you need check our app demo](https://github.com/RookeriesDevelopment/rook_demo_app_android_react_native_rook_sdk/tree/main)
+Extract health data from health connect, apple health and samsung health to transform to a RookScore
 
-If you need more information please refer to the [official documentation](https://docs.tryrook.io/docs/category/reactnative)
+## Installation
+
+
+```sh
+npm install react-native-rook-sdk
+```
+
+
+## Usage
+
+
+```js
+import { multiply } from 'react-native-rook-sdk';
+
+// ...
+
+const result = multiply(3, 7);
+```
+
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/RNRookSdk.podspec

@@ -0,0 +1,22 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "RNRookSdk"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.dependency "RookSDK", "4.0.0-beta.1"
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://docs.tryrook.io/docs/category/reactnative.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -1,6 +1,7 @@
 buildscript {
-  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
-  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["RookSdk_kotlinVersion"]
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['RNRookSdk_' + name]
+  }
 
   repositories {
     google()
@@ -8,57 +9,34 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:7.2.1"
+    classpath "com.android.tools.build:gradle:8.7.2"
     // noinspection DifferentKotlinGradleVersion
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
   }
 }
 
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
-}
 
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
 
-if (isNewArchitectureEnabled()) {
-  apply plugin: "com.facebook.react"
-}
-
-def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["RookSdk_" + name]
-}
+apply plugin: "com.facebook.react"
 
 def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RookSdk_" + name]).toInteger()
 }
 
-def supportsNamespace() {
-  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
-  def major = parsed[0].toInteger()
-  def minor = parsed[1].toInteger()
-
-  // Namespace support was added in 7.3.0
-  return (major == 7 && minor >= 3) || major >= 8
-}
-
 android {
-  if (supportsNamespace()) {
-    namespace "com.rooksdk"
-
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
-    }
-  }
+  namespace "com.rooksdk"
 
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
 
+  buildFeatures {
+    buildConfig true
   }
 
   buildTypes {
@@ -75,6 +53,15 @@ android {
     sourceCompatibility JavaVersion.VERSION_1_8
     targetCompatibility JavaVersion.VERSION_1_8
   }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
 }
 
 repositories {
@@ -85,14 +72,6 @@ repositories {
 def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {
-  // For < 0.71, this will be from the local maven repo
-  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
-  //noinspection GradleDynamicVersion
-  implementation "com.facebook.react:react-native:+"
+  implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation 'com.google.code.gson:gson:2.13.0'
-
-  implementation("io.tryrook.android:rook-sdk-samsung:1.1.0")
-  implementation 'com.rookmotion.android:rook-sdk:2.4.0'
 }
-

package/android/gradle.properties

@@ -1,5 +1,5 @@
-RookSdk_kotlinVersion=1.7.0
-RookSdk_minSdkVersion=21
-RookSdk_targetSdkVersion=31
-RookSdk_compileSdkVersion=31
-RookSdk_ndkversion=21.4.7075529
+RookSdk_kotlinVersion=2.0.21
+RookSdk_minSdkVersion=24
+RookSdk_targetSdkVersion=34
+RookSdk_compileSdkVersion=35
+RookSdk_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,2 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.rooksdk">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 </manifest>

package/android/src/main/java/com/rooksdk/RookSdkModule.kt

@@ -1,239 +1,28 @@
 package com.rooksdk
 
-import android.content.IntentFilter
-import android.util.Log
-import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.rookmotion.rook.sdk.RookConfigurationManager
-import com.rookmotion.rook.sdk.RookPermissionsManager
-import com.rookmotion.rook.sdk.domain.analytics.HCRookAnalytics
-import com.rookmotion.rook.sdk.domain.analytics.HCRookFramework
-import com.rookmotion.rook.sdk.domain.environment.RookEnvironment
-import com.rookmotion.rook.sdk.domain.model.RookConfiguration
-import com.rooksdk.broadcasts.AndroidPermissionsReceiverTransmitter
-import com.rooksdk.broadcasts.HealthConnectPermissionsReceiverTransmitter
-import com.rooksdk.broadcasts.SamsungHealthPermissionsReceiverTransmitter
-import com.rooksdk.utils.ReadableToWritable
-import com.rooksdk.utils.SamsungAvailability
-import io.tryrook.sdk.samsung.RookSamsung
-import io.tryrook.sdk.samsung.domain.analytics.SHRookAnalytics
-import io.tryrook.sdk.samsung.domain.analytics.SHRookFramework
-import io.tryrook.sdk.samsung.domain.enums.SamsungHealthAvailability
-import io.tryrook.sdk.samsung.domain.enums.SamsungHealthPermission
-import io.tryrook.sdk.samsung.domain.environment.SHEnvironment
-import io.tryrook.sdk.samsung.domain.model.SHConfiguration
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.launch
+import com.facebook.react.module.annotations.ReactModule
 
-/**
- * The `RookSdkHealthConnectModule` class is a React Native module that interfaces
- * with the Rook SDK for managing and syncing health data using Android's Health Connect.
- * It provides methods for initializing the SDK, handling user configuration, syncing
- * health data, and managing permissions.
- *
- * Main Responsibilities:
- * - Initialize and configure the Rook SDK.
- * - Manage user-related information such as user ID.
- * - Sync health-related summaries and events (e.g., sleep, body metrics, physical activities).
- * - Handle Health Connect permissions and check availability.
- * - Transmit permission changes through Android and Health Connect.
- * - Provide the ability to listen to permission changes using Android broadcast receivers.
- * - Expose methods to JavaScript for requesting or syncing data.
- *
- * Key Components:
- * - `RookConfigurationManager`: Manages configuration settings for the SDK.
- * - `RookSummaryManager`: Handles syncing health data summaries (e.g., sleep, physical, body).
- * - `RookEventManager`: Manages the synchronization of health-related events (e.g., physical activities, blood pressure, etc.).
- * - `RookPermissionsManager`: Handles permission management and availability checks for Health Connect.
- * - `RookStepsManager`: Manages steps data synchronization.
- * - `CoroutineScope`: Used to launch asynchronous operations.
- */
-class RookSdkModule(
-  reactContext: ReactApplicationContext,
-  private val rookConfigurationManager: RookConfigurationManager,
-  private val rookSamsung: RookSamsung
-): ReactContextBaseJavaModule(reactContext) {
-
-  private var scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
-  private var listenerCount = 0
-
-  private val stepsScope: CoroutineScope by lazy {
-    CoroutineScope(SupervisorJob() + Dispatchers.Main)
-  }
-
-  private val androidPermissionsReceiverTransmitter: AndroidPermissionsReceiverTransmitter by lazy {
-    AndroidPermissionsReceiverTransmitter()
-  }
-
-  private val hcPermissionsReceiverTransmitter: HealthConnectPermissionsReceiverTransmitter by lazy {
-    HealthConnectPermissionsReceiverTransmitter()
-  }
-
-  private val shHealthPermissionsReceiverTransmitter: SamsungHealthPermissionsReceiverTransmitter by lazy {
-    SamsungHealthPermissionsReceiverTransmitter()
-  }
+@ReactModule(name = RookSdkModule.NAME)
+class RookSdkModule(reactContext: ReactApplicationContext) :
+  NativeRookSdkSpec(reactContext) {
 
   override fun getName(): String {
     return NAME
   }
 
-  @ReactMethod
-  fun addListener(eventName: String) {
-    if (listenerCount == 0) {
-      androidPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
-      hcPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
-      shHealthPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
-
-      ContextCompat.registerReceiver(
-        reactApplicationContext,
-        androidPermissionsReceiverTransmitter,
-        IntentFilter(RookPermissionsManager.ACTION_ANDROID_PERMISSIONS),
-        ContextCompat.RECEIVER_EXPORTED
-      )
-
-      ContextCompat.registerReceiver(
-        reactApplicationContext,
-        hcPermissionsReceiverTransmitter,
-        IntentFilter(RookPermissionsManager.ACTION_HEALTH_CONNECT_PERMISSIONS),
-        ContextCompat.RECEIVER_EXPORTED,
-      )
-
-      ContextCompat.registerReceiver(
-        reactApplicationContext,
-        shHealthPermissionsReceiverTransmitter,
-        IntentFilter(SamsungHealthPermission.ACTION_SAMSUNG_HEALTH_PERMISSIONS),
-        ContextCompat.RECEIVER_EXPORTED
-      )
-    }
-
-    listenerCount += 1
+  // Example method
+  // See https://reactnative.dev/docs/native-modules-android
+  override fun multiply(a: Double, b: Double): Double {
+    return a * b
   }
 
-  @ReactMethod
-  fun removeListeners(count: Int) {
-    listenerCount -= count
-    if (listenerCount == 0) {
-      stepsScope.cancel()
-
-      reactApplicationContext.unregisterReceiver(hcPermissionsReceiverTransmitter)
-      reactApplicationContext.unregisterReceiver(androidPermissionsReceiverTransmitter)
-    }
-  }
-
-  /**
-   * Initializes the Rook SDK with the specified configuration settings (environment, clientUUID, secretKey).
-   * This is required before any data synchronization or user management can occur.
-   * @param config A map containing the environment, clientUUID, secretKey, and other settings.
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun initRook(config: ReadableMap,promise: Promise) {
-    try {
-      val clientUUID = config.getString("clientUUID")?.trim() ?: ""
-      val secretKey = config.getString("password")?.trim() ?: ""
-
-      if (clientUUID.isBlank() || secretKey.isBlank()) {
-        promise.reject("Invalid Credentials", "Invalid credentials")
-        return
-      }
-
-      var environment = RookEnvironment.SANDBOX
-      var shEnv = SHEnvironment.SANDBOX
-
-      if (config.getString("environment") == "production") {
-        environment = RookEnvironment.PRODUCTION
-        shEnv = SHEnvironment.SANDBOX
-      }
-
-      val rookConfiguration = RookConfiguration(
-        environment = environment,
-        clientUUID = clientUUID,
-        secretKey = secretKey
-      )
-
-      val shConfig = SHConfiguration(
-        environment = shEnv,
-        clientUUID = clientUUID,
-        secretKey = secretKey
-      )
-
-      val enableLogs = config.getBoolean("enableLogs")
-      if(enableLogs) {
-        rookConfigurationManager.enableLocalLogs()
-        rookSamsung.enableLocalLogs()
-      }
-
-      rookConfigurationManager.setConfiguration(rookConfiguration)
-
-      HCRookAnalytics.setFramework(HCRookFramework.REACT_NATIVE)
-      SHRookAnalytics.setFramework(SHRookFramework.REACT_NATIVE)
-
-      scope.launch {
-        try {
-          val result = rookConfigurationManager.initRook()
-          result.getOrThrow()
-
-          val availableResult = SamsungAvailability.getSamsungHealthAvailabilityOrDefault(rookSamsung)
-
-          if (availableResult == SamsungHealthAvailability.INSTALLED) {
-            rookSamsung.initRook(shConfig)
-            tryToSetSamsungUserId()
-          }
-
-          promise.resolve(true)
-        } catch (e: Throwable) {
-          promise.reject(e)
-        }
-      }
-    }
-    catch (e: Exception) {
-      promise.reject(e)
-    }
-
-  }
-
-  private fun tryToSetSamsungUserId() {
-    scope.launch {
-      val result = rookConfigurationManager.getUserID()
-
-      if (result != null) {
-        val user =  rookSamsung.updateUserID(result)
-        user.getOrNull()
-      }
-    }
-  }
-
-  /**
-   * Sends a broadcast message to the React Native layer.
-   * This method emits a message event to the React Native side via the
-   * `ROOK_NOTIFICATION` channel, allowing communication from the native module.
-   *
-   * @param message A ReadableMap containing the message data to send.
-   * @param promise A promise object that resolves with true if the message was sent successfully.
-   */
-  @ReactMethod
-  fun sendMessageToBroadcast(message: ReadableMap, promise: Promise) {
-    if (listenerCount <= 0) return
-
-    val hash = ReadableToWritable.readableMapToHashMap(message)
-    val writable = ReadableToWritable.hashMapToWritableMap(hash)
-
-    reactApplicationContext
-      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-      .emit("ROOK_NOTIFICATION", writable)
-
-    promise.resolve(true)
+  override fun simplePromise(promise: Promise?) {
+    TODO("Not yet implemented")
   }
 
   companion object {
-    const val NAME = "RookSdk"
+    const val NAME = "RNRookSdk"
   }
 }

package/android/src/main/java/com/rooksdk/RookSdkPackage.kt

@@ -1,42 +1,33 @@
 package com.rooksdk
 
-import RookSyncModule
-import com.facebook.react.ReactPackage
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
-import com.rookmotion.rook.sdk.RookConfigurationManager
-import com.rooksdk.modules.RookBackgroundSyncModule
-import com.rooksdk.modules.RookConfigurationModule
-import com.rooksdk.modules.RookLocalData
-import com.rooksdk.modules.RookPermissionsModule
-import com.rooksdk.modules.RookStepsModule
-import io.tryrook.sdk.samsung.RookSamsung
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
 
-
-class RookSdkPackage : ReactPackage {
-  private var rookConfigurationManager: RookConfigurationManager? = null
-  private var rookSamsung: RookSamsung? = null
-
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    if (rookConfigurationManager == null)
-      rookConfigurationManager = RookConfigurationManager(reactContext)
-
-    if (rookSamsung == null)
-      rookSamsung = RookSamsung(reactContext)
-
-    return listOf(
-      RookSdkModule(reactContext, rookConfigurationManager!!, rookSamsung!!),
-      RookPermissionsModule(reactContext, rookSamsung!!),
-      RookConfigurationModule(reactContext, rookConfigurationManager!!, rookSamsung!!),
-      RookSyncModule(reactContext, rookSamsung!!),
-      RookBackgroundSyncModule(reactContext),
-      RookStepsModule(reactContext),
-      RookLocalData(reactContext, rookSamsung!!)
-    )
+class RookSdkPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == RookSdkModule.NAME) {
+      RookSdkModule(reactContext)
+    } else {
+      null
+    }
   }
 
-  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return emptyList()
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[RookSdkModule.NAME] = ReactModuleInfo(
+        RookSdkModule.NAME,
+        RookSdkModule.NAME,
+        canOverrideExistingModule = false,  // canOverrideExistingModule
+        needsEagerInit = false,  // needsEagerInit
+        isCxxModule = false,  // isCxxModule
+        isTurboModule = true // isTurboModule
+      )
+      moduleInfos
+    }
   }
 }

package/ios/DateHelper.swift

@@ -0,0 +1,55 @@
+//
+//  File.swift
+//  RNRookSdk
+//
+//  Created by Javier Villanueva on 18/12/25.
+//
+
+import Foundation
+
+protocol DateHelperProtocol {
+  func getDateFromString(stringDate: String) -> Date?
+  func getISO8601StringDate(date: Date, timeZone: TimeZone) -> String
+}
+
+struct DateHelper: DateHelperProtocol {
+
+  private static let dateISOFormatterDateLocal: DateFormatter = {
+    let dateFormatter = DateFormatter()
+    dateFormatter.locale = Locale(identifier: Locale.preferredLanguages[0])
+    dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS"
+    return dateFormatter
+  }()
+
+  private let dateIonicFormatterDate: DateFormatter = {
+    let dateFormatter = DateFormatter()
+    dateFormatter.locale = Locale(identifier: Locale.preferredLanguages[0])
+    dateFormatter.dateFormat = "yyyy-MM-dd"
+    return dateFormatter
+  }()
+
+  func getDateFromString(stringDate: String) -> Date? {
+    return dateIonicFormatterDate.date(from: stringDate)
+  }
+
+  func getISO8601StringDate(date: Date, timeZone: TimeZone = .current) -> String {
+    let dateFormat = DateHelper.dateISOFormatterDateLocal
+    dateFormat.timeZone = timeZone
+    let dateString: String = dateFormat.string(from: date)
+    let timeZoneHours: Int = offsetInHours(timeZone: timeZone)
+    let timeHoursString: String = String(format: "%02d", abs(timeZoneHours))
+    let stringMinutes: String = String(format: "%02d", abs(minutes(timeZone: timeZone)))
+    let toReturn: String = "\(dateString)\(timeZoneHours >= 0 ? "+" : "-")\(timeHoursString):\(stringMinutes)"
+    return toReturn
+  }
+
+  private func offsetInHours(timeZone: TimeZone = .current) -> Int {
+    let hours = (timeZone.secondsFromGMT()) / (3600)
+    return hours
+  }
+
+  private func minutes(timeZone: TimeZone = TimeZone.current) -> Int {
+    let minutes = abs((timeZone.secondsFromGMT() % 3600) / 60)
+    return minutes
+  }
+}

package/ios/Encodable.swift

@@ -0,0 +1,25 @@
+//
+//  Encodable.swift
+//  RNRookSdk
+//
+//  Created by Javier Villanueva on 17/12/25.
+//
+
+extension Encodable {
+  func toDictionary() -> [String: Any] {
+      let encoder = JSONEncoder()
+      
+      let dateFormatter = DateFormatter()
+      dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZ"
+      
+      encoder.dateEncodingStrategy = .formatted(dateFormatter)
+
+      guard let data = try? encoder.encode(self),
+            let dictionary = try? JSONSerialization.jsonObject(with: data, options: .allowFragments) as? [String: Any]
+      else {
+          return [:]
+      }
+      
+      return dictionary
+  }
+}

package/ios/EncodableDataSource.swift

@@ -1,11 +1,10 @@
 //
 //  EncodableDataSource.swift
-//  react-native-rook-sdk
+//  RNRookSdk
 //
-//  Created by Javier Villanueva on 09/10/25.
+//  Created by Javier Villanueva on 17/12/25.
 //
 
-import Foundation
 import RookSDK
 
 struct EncodableDataSource: Encodable {
@@ -25,8 +24,8 @@ struct EncodableDataSource: Encodable {
     func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)
 
-        try container.encode(dataSource.source, forKey: .name)
-        try container.encode(dataSource.status, forKey: .authorized)
-        try container.encode(dataSource.imageURL, forKey: .imageUrl)
+        try container.encode(dataSource.name, forKey: .name)
+        try container.encode(dataSource.authorized, forKey: .authorized)
+        try container.encode(dataSource.imageUrl, forKey: .imageUrl)
     }
 }

package/ios/EncodableDataSourceAuthorizer.swift

@@ -1,10 +1,9 @@
 //
 //  EncodableDataSourceAuthorizer.swift
-//  react-native-rook-sdk
+//  RNRookSdk
 //
-//  Created by Javier Villanueva on 08/10/25.
+//  Created by Javier Villanueva on 17/12/25.
 //
-
 import RookSDK
 import Foundation
 
@@ -27,6 +26,6 @@ struct EncodableDataSourceAuthorizer: Encodable {
 
         try container.encode(authorizer.dataSource, forKey: .dataSource)
         try container.encode(authorizer.authorized, forKey: .authorized)
-        try container.encode(authorizer.authorizationURL, forKey: .authorizationUrl)
+        try container.encode(authorizer.authorizationUrl, forKey: .authorizationUrl)
     }
 }