@react-native-kakao/cert 0.0.0-stage → 3.1.0-next.2

package/CHANGELOG.md

@@ -0,0 +1,46 @@
+# @react-native-kakao/cert
+
+## 3.1.0-next.2
+
+### Patch Changes
+
+- f466ffa: Normalize APIs without success data to resolve without a value across platforms, while preserving friend-message results.
+- Updated dependencies [f466ffa]
+- Updated dependencies [f466ffa]
+- Updated dependencies [23ca142]
+- Updated dependencies [845f1f2]
+  - @react-native-kakao/user@3.1.0-next.2
+  - @react-native-kakao/core@3.1.0-next.2
+
+## 3.1.0-next.1
+
+### Minor Changes
+
+- 67cd4e2: Add Kakao certification login, device-local signing keys and sessions, abbreviated signatures, web certification authorization, and opt-in native callback configuration.
+- d81f9b7: Expose iOS authorization-code and certification-code token exchange with PKCE options, normalized web token issuance, and explicit unsupported-platform errors.
+
+### Patch Changes
+
+- e25e428: Allow explicit native tokens when refreshing and normalize remaining token lifetimes across native responses.
+- 87e8aa7: Allow a custom Android KakaoTalk login request code while preserving the SDK default when omitted. Accept the SDK's full 32-bit request code range for regular and certification login.
+- Updated dependencies [250d066]
+- Updated dependencies [3d92882]
+- Updated dependencies [d5c5fb8]
+- Updated dependencies [3027207]
+- Updated dependencies [f1fd1e2]
+- Updated dependencies [dfd32ca]
+- Updated dependencies [da4db1c]
+- Updated dependencies [f6e0207]
+- Updated dependencies [a8a2e24]
+- Updated dependencies [2b223bf]
+- Updated dependencies [67cd4e2]
+- Updated dependencies [d81f9b7]
+- Updated dependencies [7fe7820]
+- Updated dependencies [524be2c]
+- Updated dependencies [e25e428]
+- Updated dependencies [97a99b5]
+- Updated dependencies [b6ff8a9]
+- Updated dependencies [bd1bb64]
+- Updated dependencies [87e8aa7]
+  - @react-native-kakao/user@3.1.0-next.1
+  - @react-native-kakao/core@3.1.0-next.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2024 MJ Studio
+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
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,7 @@
-# Temporary Holding Version
+# React Native Kakao Cert
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`@react-native-kakao/cert` exposes Kakao certification login, abbreviated signatures, and device-local signing sessions. Certification requires an approved Kakao app and server integration.
+
+Install it with `@react-native-kakao/core` and `@react-native-kakao/user`. Native signing is available on Android and iOS; web supports the JavaScript SDK's certification authorization redirect.
+
+See the [usage and setup guide](https://rnkakao.mjstudio.net/docs/cert/intro).

package/RNCKakaoCert.podspec

@@ -0,0 +1,25 @@
+require "json"
+require_relative "../core/ios/kakao-sdk"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+core_package = JSON.parse(File.read(File.join(__dir__, "..", "core", "package.json")))
+sdk_version = core_package['sdkVersions']['ios']['cert']
+
+Pod::Spec.new do |s|
+  s.name = "RNCKakaoCert"
+  s.version = package["version"]
+  s.summary = package["description"]
+  s.homepage = package["homepage"]
+  s.license = package["license"]
+  s.authors = package["author"]
+  s.platforms = { :ios => min_ios_version_supported }
+  s.source = { :git => "https://github.com/mym0404/react-native-kakao.git", :tag => "#{s.version}" }
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.private_header_files = "ios/RNCKakaoCert.h"
+
+  install_modules_dependencies(s)
+  sdk_version = $KakaoCertSDKVersion if defined?($KakaoCertSDKVersion)
+  s.dependency 'RNCKakaoCore'
+  s.dependency 'RNCKakaoUser'
+  RNCKakaoSPM.dependency(s, sdk_version, %w[KakaoSDKCommon KakaoSDKAuth KakaoSDKUser KakaoSDKCert KakaoSDKCertCore])
+end

package/android/build.gradle

@@ -0,0 +1,43 @@
+apply from: file('./../../core/android/package-json.gradle')
+def Versions = project.ext.RNCKakaoSdkVersions
+Project coreProject = project.ext.getWorkspaceProject("core")
+
+project.ext.applyPlugins()
+
+android {
+    namespace "net.mjstudio.rnkakao.cert"
+
+    compileSdkVersion Versions.compileSdk
+
+    defaultConfig {
+        minSdkVersion Versions.minSdk
+        targetSdkVersion Versions.targetSdk
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    lintOptions {
+        disable "GradleCompatible"
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    implementation "com.facebook.react:react-android"
+
+    api coreProject
+    implementation "com.kakao.sdk:v2-cert:${Versions.cert}"
+}

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/java/net/mjstudio/rnkakao/cert/RNCKakaoCertModule.kt

@@ -0,0 +1,292 @@
+package net.mjstudio.rnkakao.cert
+
+import android.content.ActivityNotFoundException
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.kakao.sdk.auth.AuthCodeClient
+import com.kakao.sdk.auth.model.CertTokenInfo
+import com.kakao.sdk.auth.model.CertType
+import com.kakao.sdk.auth.model.IdentifyItem
+import com.kakao.sdk.auth.model.OAuthToken
+import com.kakao.sdk.auth.model.Prompt
+import com.kakao.sdk.cert.CertApiClient
+import com.kakao.sdk.cert.model.SessionInfo
+import net.mjstudio.rnkakao.core.util.RNCKakaoResponseNotFoundException
+import net.mjstudio.rnkakao.core.util.RNCKakaoUnsupportedPlatformException
+import net.mjstudio.rnkakao.core.util.argArr
+import net.mjstudio.rnkakao.core.util.argMap
+import net.mjstudio.rnkakao.core.util.filterIsInstance
+import net.mjstudio.rnkakao.core.util.getIntElseNull
+import net.mjstudio.rnkakao.core.util.onMain
+import net.mjstudio.rnkakao.core.util.pushStringList
+import net.mjstudio.rnkakao.core.util.putD
+import net.mjstudio.rnkakao.core.util.putL
+import net.mjstudio.rnkakao.core.util.rejectWith
+import net.mjstudio.rnkakao.core.util.unix
+import java.util.Date
+
+private const val TX_ID = "txId"
+private const val MILLISECONDS_PER_SECOND = 1000.0
+
+class RNCKakaoCertModule internal constructor(
+  context: ReactApplicationContext,
+) : NativeKakaoCertSpec(context) {
+  @ReactMethod
+  override fun certLoginWithKakaoTalk(
+    options: ReadableMap,
+    promise: Promise,
+  ) = login(options, true, promise)
+
+  @ReactMethod
+  override fun certLoginWithKakaoAccount(
+    options: ReadableMap,
+    promise: Promise,
+  ) = login(options, false, promise)
+
+  @ReactMethod
+  override fun issueCertTokenWithCode(
+    code: String,
+    codeVerifier: String?,
+    redirectUri: String?,
+    promise: Promise,
+  ) {
+    promise.rejectWith(RNCKakaoUnsupportedPlatformException("issueCertTokenWithCode", "iOS"))
+  }
+
+  private fun login(
+    options: ReadableMap,
+    isTalk: Boolean,
+    promise: Promise,
+  ) = withCert(promise) { client ->
+    val activity =
+      reactApplicationContext.currentActivity ?: run {
+        promise.rejectWith(ActivityNotFoundException())
+        return@withCert
+      }
+    val certType = CertType.valueOf(requireNotNull(options.getString("certType")))
+    val prompts =
+      options
+        .getArray("prompts")
+        ?.filterIsInstance<String>()
+        ?.map {
+          when (it) {
+            "Login" -> Prompt.LOGIN
+            "Create" -> Prompt.CREATE
+            "SelectAccount" -> Prompt.SELECT_ACCOUNT
+            else -> throw IllegalArgumentException("Unsupported certification prompt: $it")
+          }
+        }?.ifEmpty { null }
+    val identifyItems =
+      options
+        .getArray("identifyItems")
+        ?.filterIsInstance<String>()
+        ?.map {
+          when (it) {
+            "ci" -> IdentifyItem.CI
+            "name" -> IdentifyItem.NAME
+            "birthday" -> IdentifyItem.BIRTHDAY
+            "phone_number" -> IdentifyItem.PHONE_NUMBER
+            else -> throw IllegalArgumentException("Unsupported signer information: $it")
+          }
+        }?.ifEmpty { null }
+    val signData = options.getString("signData")
+    val settleId = options.getString("settleId")
+    val nonce = options.getString("nonce")
+    val android = options.getMap("android")
+    val channelOptions = if (isTalk) options else android
+    val channelPublicIds = channelOptions?.getArray("channelPublicIds")?.filterIsInstance<String>()?.ifEmpty { null }
+    val serviceTerms = channelOptions?.getArray("serviceTerms")?.filterIsInstance<String>()?.ifEmpty { null }
+    val callback: (CertTokenInfo?, Throwable?) -> Unit = { info, error ->
+      if (error != null) {
+        promise.rejectWith(error)
+      } else if (info == null) {
+        promise.rejectWith(RNCKakaoResponseNotFoundException("certTokenInfo"))
+      } else {
+        promise.resolve(
+          argMap().apply {
+            putString(TX_ID, info.txId)
+            putMap("token", mapToken(info.token))
+          },
+        )
+      }
+    }
+    if (isTalk) {
+      client.certLoginWithKakaoTalk(
+        context = activity,
+        certType = certType,
+        signData = signData,
+        settleId = settleId,
+        txId = options.getString(TX_ID),
+        prompts = prompts,
+        identifyItems = identifyItems,
+        requestCode = android?.getIntElseNull("requestCode") ?: AuthCodeClient.DEFAULT_REQUEST_CODE,
+        nonce = nonce,
+        channelPublicIds = channelPublicIds,
+        serviceTerms = serviceTerms,
+        callback = callback,
+      )
+    } else {
+      client.certLoginWithKakaoAccount(
+        context = activity,
+        certType = certType,
+        prompts = prompts,
+        identifyItems = identifyItems,
+        signData = signData,
+        settleId = settleId,
+        nonce = nonce,
+        loginHint = options.getString("loginHint"),
+        channelPublicIds = channelPublicIds,
+        serviceTerms = serviceTerms,
+        callback = callback,
+      )
+    }
+  }
+
+  @ReactMethod
+  override fun publicKey(
+    certType: String,
+    promise: Promise,
+  ) = withCert(promise) {
+    promise.resolve(it.publicKey(CertType.valueOf(certType)))
+  }
+
+  @ReactMethod
+  override fun sessionInfo(
+    certType: String,
+    promise: Promise,
+  ) = withCert(promise) {
+    promise.resolve(it.sessionInfo(CertType.valueOf(certType))?.let(::mapSession))
+  }
+
+  @ReactMethod
+  override fun fetchSessionInfo(
+    certType: String,
+    txId: String,
+    promise: Promise,
+  ) = withCert(promise) {
+    it.sessionInfo(CertType.valueOf(certType), txId, sessionCallback(promise))
+  }
+
+  @ReactMethod
+  override fun fetchSessionInfoByAppKey(
+    certType: String,
+    txId: String,
+    targetAppKey: String?,
+    promise: Promise,
+  ) = withCert(promise) {
+    it.sessionInfoByAppKey(CertType.valueOf(certType), txId, targetAppKey, sessionCallback(promise))
+  }
+
+  @ReactMethod
+  override fun isValidSession(
+    certType: String,
+    promise: Promise,
+  ) = withCert(promise) {
+    promise.resolve(it.isValidSession(CertType.valueOf(certType)))
+  }
+
+  @ReactMethod
+  override fun deleteKeyPair(
+    certType: String,
+    promise: Promise,
+  ) = withCert(promise) {
+    it.deleteKeyPair(CertType.valueOf(certType))
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  override fun reducedSign(
+    certType: String,
+    data: String,
+    promise: Promise,
+  ) = withCert(promise) {
+    it.reducedSign(CertType.valueOf(certType), data) { signature, error ->
+      if (error != null) {
+        promise.rejectWith(error)
+      } else if (signature == null) {
+        promise.rejectWith(RNCKakaoResponseNotFoundException("signature"))
+      } else {
+        promise.resolve(signature)
+      }
+    }
+  }
+
+  @ReactMethod
+  override fun isKakaoTalkSignAvailable(promise: Promise) =
+    withCert(promise) {
+      promise.resolve(it.isKakaoTalkSignAvailable(reactApplicationContext))
+    }
+
+  @ReactMethod
+  override fun signWithKakaoTalk(
+    txId: String,
+    targetAppKey: String?,
+    promise: Promise,
+  ) = withCert(promise) {
+    val activity =
+      reactApplicationContext.currentActivity ?: run {
+        promise.rejectWith(ActivityNotFoundException())
+        return@withCert
+      }
+    it.signWithKakaoTalk(activity, CertType.K3220, txId, targetAppKey) { status, error ->
+      if (error != null) {
+        promise.rejectWith(error)
+      } else if (status == null) {
+        promise.rejectWith(RNCKakaoResponseNotFoundException("signStatusInfo"))
+      } else {
+        promise.resolve(
+          argMap().apply {
+            putString(TX_ID, status.txId)
+            putD("requestedAt", status.requestedAt?.time?.div(MILLISECONDS_PER_SECOND))
+            putD("requestExpiredAt", status.requestExpiredAt?.time?.div(MILLISECONDS_PER_SECOND))
+            putD("signedAt", status.signedAt?.time?.div(MILLISECONDS_PER_SECOND))
+          },
+        )
+      }
+    }
+  }
+
+  private fun withCert(
+    promise: Promise,
+    operation: (CertApiClient) -> Unit,
+  ) = onMain {
+    try {
+      operation(CertApiClient.instance)
+    } catch (error: Exception) {
+      promise.rejectWith(error)
+    }
+  }
+
+  private fun sessionCallback(promise: Promise): (SessionInfo?, Throwable?) -> Unit =
+    { info, error ->
+      if (error != null) {
+        promise.rejectWith(error)
+      } else if (info == null) {
+        promise.rejectWith(RNCKakaoResponseNotFoundException("sessionInfo"))
+      } else {
+        promise.resolve(mapSession(info))
+      }
+    }
+
+  private fun mapSession(info: SessionInfo) =
+    argMap().apply {
+      putL("userId", info.userId)
+      putDouble("sessionStartAt", info.sessionStartAt.time / MILLISECONDS_PER_SECOND)
+      putDouble("sessionEndAt", info.sessionEndAt.time / MILLISECONDS_PER_SECOND)
+    }
+
+  private fun mapToken(token: OAuthToken) =
+    argMap().apply {
+      putString("accessToken", token.accessToken)
+      putString("refreshToken", token.refreshToken)
+      token.idToken?.let { putString("idToken", it) }
+      putDouble("accessTokenExpiresAt", token.accessTokenExpiresAt.unix.toDouble())
+      putDouble("refreshTokenExpiresAt", token.refreshTokenExpiresAt.unix.toDouble())
+      val now = Date().time
+      putDouble("accessTokenExpiresIn", (token.accessTokenExpiresAt.time - now) / MILLISECONDS_PER_SECOND)
+      putDouble("refreshTokenExpiresIn", (token.refreshTokenExpiresAt.time - now) / MILLISECONDS_PER_SECOND)
+      putArray("scopes", argArr().pushStringList(token.scopes.orEmpty()))
+    }
+}

package/android/src/main/java/net/mjstudio/rnkakao/cert/RNCKakaoCertPackage.kt

@@ -0,0 +1,34 @@
+package net.mjstudio.rnkakao.cert
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class RNCKakaoCertPackage : BaseReactPackage() {
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? =
+    if (name == NativeKakaoCertSpec.NAME) {
+      RNCKakaoCertModule(reactContext)
+    } else {
+      null
+    }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+    ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[NativeKakaoCertSpec.NAME] =
+        ReactModuleInfo(
+          NativeKakaoCertSpec.NAME,
+          RNCKakaoCertModule::class.java.name,
+          false, // canOverrideExistingModule
+          false, // needsEagerInit
+          false, // isCxxModule
+          true, // isTurboModule
+        )
+      moduleInfos
+    }
+}

package/ios/RNCKakaoCert.h

@@ -0,0 +1,4 @@
+#import "RNCKakaoCertSpec.h"
+
+@interface RNCKakaoCert : NSObject <NativeKakaoCertSpec>
+@end

package/ios/RNCKakaoCert.mm

@@ -0,0 +1,80 @@
+#import "RNCKakaoCert.h"
+
+#if __has_include("RNCKakaoCert-Swift.h")
+#import "RNCKakaoCert-Swift.h"
+#else
+#import <RNCKakaoCert/RNCKakaoCert-Swift.h>
+#endif
+
+@implementation RNCKakaoCert
+RCT_EXPORT_MODULE()
+
+- (RNCKakaoCertManager*)manager {
+  return [RNCKakaoCertManager shared];
+}
+
+RCT_EXPORT_METHOD(certLoginWithKakaoTalk : (NSDictionary*)options resolve : (RCTPromiseResolveBlock)
+                      resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] certLoginWithKakaoTalk:options resolve:resolve reject:reject];
+}
+RCT_EXPORT_METHOD(certLoginWithKakaoAccount : (NSDictionary*)options resolve : (
+    RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] certLoginWithKakaoAccount:options resolve:resolve reject:reject];
+}
+RCT_EXPORT_METHOD(issueCertTokenWithCode : (NSString*)code codeVerifier : (
+    NSString*)codeVerifier redirectUri : (NSString*)redirectUri resolve : (RCTPromiseResolveBlock)
+                      resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] issueCertTokenWithCode:code
+                            codeVerifier:codeVerifier
+                             redirectUri:redirectUri
+                                 resolve:resolve
+                                  reject:reject];
+}
+RCT_EXPORT_METHOD(publicKey : (NSString*)certType resolve : (RCTPromiseResolveBlock)
+                      resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] publicKey:certType resolve:resolve reject:reject];
+}
+RCT_EXPORT_METHOD(sessionInfo : (NSString*)certType resolve : (RCTPromiseResolveBlock)
+                      resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] sessionInfo:certType resolve:resolve reject:reject];
+}
+RCT_EXPORT_METHOD(fetchSessionInfo : (NSString*)certType txId : (NSString*)txId resolve : (
+    RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] fetchSessionInfo:certType txId:txId resolve:resolve reject:reject];
+}
+RCT_EXPORT_METHOD(fetchSessionInfoByAppKey : (NSString*)certType txId : (NSString*)
+                      txId targetAppKey : (NSString*)targetAppKey resolve : (RCTPromiseResolveBlock)
+                          resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] fetchSessionInfoByAppKey:certType
+                                      txId:txId
+                              targetAppKey:targetAppKey
+                                   resolve:resolve
+                                    reject:reject];
+}
+RCT_EXPORT_METHOD(isValidSession : (NSString*)certType resolve : (RCTPromiseResolveBlock)
+                      resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] isValidSession:certType resolve:resolve reject:reject];
+}
+RCT_EXPORT_METHOD(deleteKeyPair : (NSString*)certType resolve : (RCTPromiseResolveBlock)
+                      resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] deleteKeyPair:certType resolve:resolve reject:reject];
+}
+RCT_EXPORT_METHOD(reducedSign : (NSString*)certType data : (NSString*)data resolve : (
+    RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] reducedSign:certType data:data resolve:resolve reject:reject];
+}
+RCT_EXPORT_METHOD(isKakaoTalkSignAvailable : (RCTPromiseResolveBlock)
+                      resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] isKakaoTalkSignAvailable:resolve reject:reject];
+}
+RCT_EXPORT_METHOD(signWithKakaoTalk : (NSString*)txId targetAppKey : (NSString*)
+                      targetAppKey resolve : (RCTPromiseResolveBlock)
+                          resolve reject : (RCTPromiseRejectBlock)reject) {
+  [[self manager] signWithKakaoTalk:txId targetAppKey:targetAppKey resolve:resolve reject:reject];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams&)params {
+  return std::make_shared<facebook::react::NativeKakaoCertSpecJSI>(params);
+}
+@end