@tapayadot/accept-react-native 1.3.2 → 1.14.1

package/android/src/main/java/com/tapaya/acceptsdkreactnative/Errors.kt

@@ -0,0 +1,81 @@
+package com.tapaya.acceptsdkreactnative
+
+import com.tapaya.accept.AcceptException
+import com.tapaya.accept.AmountBelowMinimum
+import com.tapaya.accept.CurrencyNotAvailableForMerchant
+import com.tapaya.accept.MerchantOnboardingIncomplete
+import com.tapaya.accept.PaymentCreationFailed
+import com.tapaya.accept.PluginNotReadyForPayments
+import com.tapaya.accept.TransactionTimeoutOutOfRange
+import com.tapaya.accept.Unknown
+import com.tapaya.accept.UnknownEnvironment
+import com.tapaya.accept.UnsupportedCurrency
+import expo.modules.kotlin.exception.CodedException
+import kotlinx.coroutines.CancellationException
+import org.json.JSONObject
+
+/**
+ * The error code carried across the bridge for [this]. Mirrors the Kotlin type name exactly, so
+ * `AcceptError.code` on the JavaScript side is a discriminated union over the same names the
+ * Android SDK documents.
+ */
+internal fun AcceptException.errorCode(): String = this::class.simpleName ?: "Unknown"
+
+/**
+ * The payload-carrying fields of [this], keyed as the JavaScript `AcceptError` reads them.
+ * Errors without extra fields serialize to an empty map.
+ */
+internal fun AcceptException.errorDetails(): Map<String, Any?> = when (this) {
+    is MerchantOnboardingIncomplete -> mapOf("state" to state.name)
+    is UnsupportedCurrency -> mapOf("currency" to code)
+    is CurrencyNotAvailableForMerchant -> mapOf("currency" to code)
+    is AmountBelowMinimum -> mapOf("minimum" to minimum, "currency" to currency)
+    is TransactionTimeoutOutOfRange -> mapOf("transactionTimeoutMs" to transactionTimeout.inWholeMilliseconds)
+    is PluginNotReadyForPayments -> mapOf("status" to status.serialize())
+    is UnknownEnvironment -> mapOf("environment" to key)
+    is PaymentCreationFailed -> mapOf("cause" to cause.message)
+    is Unknown -> mapOf("cause" to cause.message)
+    else -> emptyMap()
+}
+
+/** [this] as the `{ code, message, ... }` shape the JavaScript `AcceptError` is built from. */
+internal fun AcceptException.serialize(): Map<String, Any?> =
+    mapOf("code" to errorCode(), "message" to (message ?: errorCode())) + errorDetails()
+
+/**
+ * Bridge-facing wrapper for an [AcceptException].
+ *
+ * Expo only carries a `code` and a `message` across the bridge, so the message is a JSON object
+ * holding the human-readable text alongside the error's own fields; the JavaScript wrapper parses
+ * it back into a typed `AcceptError`. A message that fails to parse there is surfaced verbatim, so
+ * an uncaught rejection still reads sensibly in a stack trace.
+ */
+internal class AcceptCodedException(
+    exception: AcceptException,
+) : CodedException(
+    exception.errorCode(),
+    JSONObject(exception.serialize()).toString(),
+    exception,
+)
+
+/**
+ * Runs [block], translating any [AcceptException] it raises into an [AcceptCodedException].
+ *
+ * [CancellationException] is rethrown untouched to keep structured concurrency intact; anything
+ * else is left to Expo's own `UnexpectedException` handling, which is the honest representation of
+ * a failure the SDK itself did not classify.
+ */
+internal suspend fun <T> sdkCall(block: suspend () -> T): T = try {
+    block()
+} catch (e: CancellationException) {
+    throw e
+} catch (e: AcceptException) {
+    throw AcceptCodedException(e)
+}
+
+/** Blocking counterpart of [sdkCall], for the SDK's non-suspending surfaces. */
+internal fun <T> sdkCallSync(block: () -> T): T = try {
+    block()
+} catch (e: AcceptException) {
+    throw AcceptCodedException(e)
+}

package/android/src/main/java/com/tapaya/acceptsdkreactnative/Parsing.kt

@@ -0,0 +1,166 @@
+package com.tapaya.acceptsdkreactnative
+
+import com.tapaya.accept.AcceptLogLevel
+import com.tapaya.accept.domain.data.AcceptTheme
+import com.tapaya.accept.domain.data.AcceptThemeColors
+import com.tapaya.accept.domain.data.AcceptThemeImages
+import com.tapaya.accept.domain.data.AcceptThemeVariant
+import com.tapaya.accept.domain.data.DismissBehavior
+import com.tapaya.accept.domain.data.NfcPositionConfig
+import com.tapaya.accept.domain.data.OnDeviceSurface
+import com.tapaya.accept.domain.data.PaymentDisplay
+import com.tapaya.accept.domain.data.PaymentReceiptConfig
+import com.tapaya.accept.domain.data.ReceiptPrintBehavior
+import com.tapaya.accept.domain.data.RefundReason
+import expo.modules.kotlin.exception.CodedException
+import kotlin.time.Duration.Companion.milliseconds
+
+/**
+ * Parsers turning the plain maps the bridge carries into the Android SDK's domain types.
+ *
+ * The TypeScript side is the contract, so a shape that doesn't match one of the cases here is a
+ * programming error rather than user input: it raises a coded `ERR_INVALID_ARGUMENT` instead of
+ * silently falling back to a default, which would take a payment on settings the caller didn't ask
+ * for.
+ */
+
+private fun invalid(what: String, value: Any?): Nothing =
+    throw CodedException("ERR_INVALID_ARGUMENT", "unsupported $what: $value", null)
+
+@Suppress("UNCHECKED_CAST")
+private fun Map<String, Any?>.map(key: String): Map<String, Any?>? = this[key] as? Map<String, Any?>
+
+private fun Map<String, Any?>.string(key: String): String? = this[key] as? String
+
+private fun Map<String, Any?>.bool(key: String, default: Boolean): Boolean = this[key] as? Boolean ?: default
+
+/** JavaScript hands every number over as a `Double`; a few arrive already narrowed. */
+private fun Map<String, Any?>.long(key: String): Long? = when (val value = this[key]) {
+    is Number -> value.toLong()
+    else -> null
+}
+
+private fun Map<String, Any?>.float(key: String): Float? = when (val value = this[key]) {
+    is Number -> value.toFloat()
+    else -> null
+}
+
+private fun Map<String, Any?>.int(key: String): Int? = when (val value = this[key]) {
+    is Number -> value.toInt()
+    else -> null
+}
+
+internal fun parseLogLevel(level: String): AcceptLogLevel =
+    AcceptLogLevel.entries.firstOrNull { it.name.equals(level, ignoreCase = true) }
+        ?: invalid("log level", level)
+
+internal fun parseRefundReason(reason: String): RefundReason =
+    RefundReason.entries.firstOrNull { it.name.equals(reason, ignoreCase = true) }
+        ?: invalid("refund reason", reason)
+
+internal fun parsePaymentDisplay(display: Map<String, Any?>): PaymentDisplay =
+    when (val type = display.string("type")) {
+        "default" -> PaymentDisplay.Default
+        "customerFacing" -> PaymentDisplay.CustomerFacing
+        "specific" -> PaymentDisplay.Specific(display.int("displayId") ?: invalid("display id", display["displayId"]))
+        else -> invalid("payment display", type)
+    }
+
+internal fun parseNfcPosition(config: Map<String, Any?>): NfcPositionConfig =
+    when (val type = config.string("type")) {
+        "unspecified" -> NfcPositionConfig.Unspecified
+        "externalAbove" -> NfcPositionConfig.ExternalAbove
+        "externalReader" -> NfcPositionConfig.ExternalReader(config.string("message"))
+        "onDevice" -> NfcPositionConfig.OnDevice(
+            surface = when (val surface = config.string("surface")) {
+                "back" -> OnDeviceSurface.BACK
+                "frontScreen" -> OnDeviceSurface.FRONT_SCREEN
+                else -> invalid("NFC surface", surface)
+            },
+            xFraction = config.float("xFraction") ?: invalid("xFraction", config["xFraction"]),
+            yFraction = config.float("yFraction") ?: invalid("yFraction", config["yFraction"]),
+        )
+
+        else -> invalid("NFC position", type)
+    }
+
+internal fun parseReceiptConfig(config: Map<String, Any?>): PaymentReceiptConfig =
+    when (val type = config.string("type")) {
+        "dismissImmediately" -> PaymentReceiptConfig.DismissImmediately
+        "show" -> PaymentReceiptConfig.Show(
+            showQrCodeReceipt = config.bool("showQrCodeReceipt", default = true),
+            dismissBehavior = config.map("dismissBehavior")?.let(::parseDismissBehavior) ?: DismissBehavior.Manual,
+            printBehavior = config.string("printBehavior")?.let(::parsePrintBehavior) ?: ReceiptPrintBehavior.OnDemand,
+        )
+
+        else -> invalid("receipt config", type)
+    }
+
+private fun parseDismissBehavior(behavior: Map<String, Any?>): DismissBehavior =
+    when (val type = behavior.string("type")) {
+        "manual" -> DismissBehavior.Manual
+        "delayed" -> DismissBehavior.Delayed(
+            (behavior.long("delayMs") ?: invalid("dismiss delay", behavior["delayMs"])).milliseconds,
+        )
+
+        else -> invalid("dismiss behavior", type)
+    }
+
+private fun parsePrintBehavior(behavior: String): ReceiptPrintBehavior = when (behavior) {
+    "automatic" -> ReceiptPrintBehavior.Automatic
+    "onDemand" -> ReceiptPrintBehavior.OnDemand
+    "disabled" -> ReceiptPrintBehavior.Disabled
+    else -> invalid("print behavior", behavior)
+}
+
+internal fun parseTheme(theme: Map<String, Any?>): AcceptTheme = AcceptTheme(
+    light = theme.map("light")?.let(::parseThemeVariant),
+    dark = theme.map("dark")?.let(::parseThemeVariant),
+)
+
+private fun parseThemeVariant(variant: Map<String, Any?>): AcceptThemeVariant = AcceptThemeVariant(
+    colors = variant.map("colors")?.let(::parseThemeColors) ?: AcceptThemeColors(),
+    images = variant.map("images")?.let(::parseThemeImages) ?: AcceptThemeImages(),
+)
+
+private fun parseThemeColors(colors: Map<String, Any?>): AcceptThemeColors = AcceptThemeColors(
+    primary = colors.string("primary"),
+    onPrimary = colors.string("onPrimary"),
+    primaryContainer = colors.string("primaryContainer"),
+    onPrimaryContainer = colors.string("onPrimaryContainer"),
+    secondary = colors.string("secondary"),
+    onSecondary = colors.string("onSecondary"),
+    secondaryContainer = colors.string("secondaryContainer"),
+    onSecondaryContainer = colors.string("onSecondaryContainer"),
+    error = colors.string("error"),
+    onError = colors.string("onError"),
+    errorContainer = colors.string("errorContainer"),
+    onErrorContainer = colors.string("onErrorContainer"),
+    background = colors.string("background"),
+    onBackground = colors.string("onBackground"),
+    surface = colors.string("surface"),
+    onSurface = colors.string("onSurface"),
+    surfaceVariant = colors.string("surfaceVariant"),
+    onSurfaceVariant = colors.string("onSurfaceVariant"),
+    outline = colors.string("outline"),
+    outlineVariant = colors.string("outlineVariant"),
+    warning = colors.string("warning"),
+    onWarning = colors.string("onWarning"),
+    warningContainer = colors.string("warningContainer"),
+    onWarningContainer = colors.string("onWarningContainer"),
+    success = colors.string("success"),
+    onSuccess = colors.string("onSuccess"),
+    successContainer = colors.string("successContainer"),
+    onSuccessContainer = colors.string("onSuccessContainer"),
+)
+
+private fun parseThemeImages(images: Map<String, Any?>): AcceptThemeImages = AcceptThemeImages(
+    logoText = images.string("logoText"),
+    logoTextSolid = images.string("logoTextSolid"),
+    logoSymbol = images.string("logoSymbol"),
+    logoSymbolWithBackground = images.string("logoSymbolWithBackground"),
+)
+
+/** The `metadata` map attached to a payment; the SDK takes string values only. */
+internal fun parseMetadata(metadata: Map<String, Any?>?): Map<String, String> =
+    metadata.orEmpty().mapNotNull { (key, value) -> (value as? String)?.let { key to it } }.toMap()

package/android/src/main/java/com/tapaya/acceptsdkreactnative/Serialization.kt

@@ -0,0 +1,216 @@
+package com.tapaya.acceptsdkreactnative
+
+import com.tapaya.accept.ActivateTerminalResult
+import com.tapaya.accept.SdkState
+import com.tapaya.accept.domain.data.AcceptDisplay
+import com.tapaya.accept.domain.data.AcceptTheme
+import com.tapaya.accept.domain.data.AcceptThemeColors
+import com.tapaya.accept.domain.data.AcceptThemeImages
+import com.tapaya.accept.domain.data.AcceptThemeVariant
+import com.tapaya.accept.domain.data.MerchantConfig
+import com.tapaya.accept.domain.data.MerchantInformation
+import com.tapaya.accept.domain.data.MinimumAmount
+import com.tapaya.accept.domain.data.OnboardingStatus
+import com.tapaya.accept.domain.data.PayResult
+import com.tapaya.accept.domain.data.PaymentEvent
+import com.tapaya.accept.domain.data.PaymentStatus
+import com.tapaya.accept.domain.data.PluginStatus
+import com.tapaya.accept.domain.data.PluginUpdateInfo
+import com.tapaya.accept.domain.data.ReceiptDetails
+
+/**
+ * Serializers turning the Android SDK's domain types into the plain maps the bridge carries.
+ *
+ * Sealed hierarchies become a `type` discriminator plus that case's fields, matching the tagged
+ * unions declared in `src/Accept.types.ts`; enums become their `name`, which is what the
+ * TypeScript string-literal unions spell.
+ */
+
+internal fun SdkState.serialize(): String = when (this) {
+    SdkState.Idle -> "idle"
+    SdkState.Initialized -> "initialized"
+    SdkState.Authenticated -> "authenticated"
+}
+
+internal fun MinimumAmount.serialize(): Map<String, Any?> = mapOf(
+    "currency" to currency,
+    "amount" to amount,
+)
+
+internal fun MerchantConfig.serialize(): Map<String, Any?> = mapOf(
+    "availableCurrencies" to availableCurrencies,
+    "currency" to currency,
+)
+
+internal fun MerchantInformation.serialize(): Map<String, Any?> = mapOf(
+    "merchantId" to merchantId.toString(),
+    "email" to email,
+    "businessType" to businessType.name,
+    "legalName" to legalName,
+    "registrationNumber" to registrationNumber,
+    "mcc" to mcc,
+    "addressLine1" to addressLine1,
+    "city" to city,
+    "country" to country,
+    "vatNumber" to vatNumber,
+    "incorporationDate" to incorporationDate,
+    "addressLine2" to addressLine2,
+    "postalCode" to postalCode,
+    "state" to state,
+    "phone" to phone,
+    "averageItemValue" to averageItemValue,
+    "expectedMonthlyTurnover" to expectedMonthlyTurnover,
+    "businessModelDescription" to businessModelDescription,
+    "numberOfEmployees" to numberOfEmployees,
+    "annualTurnover" to annualTurnover,
+    "balanceSheetTotal" to balanceSheetTotal,
+    "statementDescriptor" to statementDescriptor,
+    "termsVersion" to termsVersion,
+)
+
+internal fun OnboardingStatus.serialize(): Map<String, Any?> = when (this) {
+    OnboardingStatus.ReadyForPayments -> mapOf("type" to "readyForPayments")
+    is OnboardingStatus.RequiresAction -> mapOf("type" to "requiresAction", "state" to state.name)
+}
+
+internal fun PaymentStatus.serialize(): Map<String, Any?> = mapOf(
+    "state" to state.name,
+    "paymentToken" to paymentToken,
+    "requestedAmount" to requestedAmount,
+    "requestedCurrency" to requestedCurrency,
+    "settlementAmount" to settlementAmount,
+    "settlementCurrency" to settlementCurrency,
+    "createdAt" to createdAt,
+    "receiptUrl" to receiptUrl,
+    "processedAt" to processedAt,
+)
+
+internal fun ReceiptDetails.serialize(): Map<String, Any?> = mapOf(
+    "merchantId" to merchantId,
+    "terminalId" to terminalId,
+    "cardBrand" to cardBrand,
+    "appLabel" to appLabel,
+    "aid" to aid,
+    "maskedPan" to maskedPan,
+    "responseCode" to responseCode,
+    "transactionTimestamp" to transactionTimestamp,
+)
+
+internal fun PayResult.serialize(): Map<String, Any?> = when (this) {
+    is PayResult.Success -> mapOf(
+        "type" to "success",
+        "paymentToken" to paymentToken,
+        "metadata" to metadata,
+        "authCode" to authCode,
+        "receiptDetails" to receiptDetails?.serialize(),
+        "receiptUrl" to receiptUrl,
+    )
+
+    is PayResult.Declined -> mapOf(
+        "type" to "declined",
+        "metadata" to metadata,
+        "receiptDetails" to receiptDetails?.serialize(),
+        "receiptUrl" to receiptUrl,
+    )
+
+    is PayResult.Canceled -> mapOf(
+        "type" to "canceled",
+        "metadata" to metadata,
+    )
+
+    is PayResult.Failed -> mapOf(
+        "type" to "failed",
+        "reason" to reason.name,
+        "metadata" to metadata,
+    )
+}
+
+internal fun PaymentEvent.serialize(): Map<String, Any?> = when (this) {
+    PaymentEvent.Creating -> mapOf("type" to "creating")
+    PaymentEvent.Launched -> mapOf("type" to "launched")
+    is PaymentEvent.Created -> mapOf(
+        "type" to "created",
+        "paymentToken" to paymentToken,
+        "receiptUrl" to receiptUrl,
+    )
+
+    is PaymentEvent.Result -> mapOf("type" to "result", "payResult" to payResult.serialize())
+    is PaymentEvent.CreationFailed -> mapOf("type" to "creationFailed", "error" to cause.serialize())
+}
+
+internal fun PluginStatus.serialize(): String = when (this) {
+    PluginStatus.NotInstalled -> "notInstalled"
+    PluginStatus.NotAuthenticated -> "notAuthenticated"
+    PluginStatus.Authenticated -> "authenticated"
+    PluginStatus.ReadyForPayments -> "readyForPayments"
+    PluginStatus.MerchantMismatch -> "merchantMismatch"
+}
+
+internal fun PluginUpdateInfo.serialize(): Map<String, Any?> = when (this) {
+    PluginUpdateInfo.UpToDate -> mapOf("type" to "upToDate")
+    PluginUpdateInfo.Unknown -> mapOf("type" to "unknown")
+    is PluginUpdateInfo.UpdateAvailable -> mapOf("type" to "updateAvailable", "priority" to priority)
+}
+
+internal fun ActivateTerminalResult.serialize(): Map<String, Any?> = when (this) {
+    ActivateTerminalResult.Success -> mapOf("type" to "success")
+    ActivateTerminalResult.Canceled -> mapOf("type" to "canceled")
+    is ActivateTerminalResult.Failed -> mapOf("type" to "failed", "reason" to reason.name)
+}
+
+internal fun AcceptDisplay.serialize(): Map<String, Any?> = mapOf(
+    "id" to id,
+    "name" to name,
+    "isPrimary" to isPrimary,
+    "isPresentation" to isPresentation,
+    "widthPx" to widthPx,
+    "heightPx" to heightPx,
+)
+
+internal fun AcceptTheme.serialize(): Map<String, Any?> = mapOf(
+    "light" to light?.serialize(),
+    "dark" to dark?.serialize(),
+)
+
+private fun AcceptThemeVariant.serialize(): Map<String, Any?> = mapOf(
+    "colors" to colors.serialize(),
+    "images" to images.serialize(),
+)
+
+private fun AcceptThemeColors.serialize(): Map<String, Any?> = mapOf(
+    "primary" to primary,
+    "onPrimary" to onPrimary,
+    "primaryContainer" to primaryContainer,
+    "onPrimaryContainer" to onPrimaryContainer,
+    "secondary" to secondary,
+    "onSecondary" to onSecondary,
+    "secondaryContainer" to secondaryContainer,
+    "onSecondaryContainer" to onSecondaryContainer,
+    "error" to error,
+    "onError" to onError,
+    "errorContainer" to errorContainer,
+    "onErrorContainer" to onErrorContainer,
+    "background" to background,
+    "onBackground" to onBackground,
+    "surface" to surface,
+    "onSurface" to onSurface,
+    "surfaceVariant" to surfaceVariant,
+    "onSurfaceVariant" to onSurfaceVariant,
+    "outline" to outline,
+    "outlineVariant" to outlineVariant,
+    "warning" to warning,
+    "onWarning" to onWarning,
+    "warningContainer" to warningContainer,
+    "onWarningContainer" to onWarningContainer,
+    "success" to success,
+    "onSuccess" to onSuccess,
+    "successContainer" to successContainer,
+    "onSuccessContainer" to onSuccessContainer,
+)
+
+private fun AcceptThemeImages.serialize(): Map<String, Any?> = mapOf(
+    "logoText" to logoText,
+    "logoTextSolid" to logoTextSolid,
+    "logoSymbol" to logoSymbol,
+    "logoSymbolWithBackground" to logoSymbolWithBackground,
+)

package/app.json

@@ -1,5 +1,5 @@
 {
   "plugins": [
-    "./plugin/withCustomRepoModule.js"
+    "./plugin/withAcceptSdk.js"
   ]
-}
+}

package/app.plugin.js

@@ -1 +1 @@
-module.exports = require("./plugin/withCustomRepoModule");
+module.exports = require("./plugin/withAcceptSdk");