react-native-amwal-ecr 0.1.0

package/ios/AmwalEcr.swift

@@ -0,0 +1,424 @@
+import AmwalECR
+import Foundation
+import React
+
+@objc(AmwalEcrImpl)
+final class AmwalEcrImpl: NSObject {
+    private static let invalidArgument = "ECR_INVALID_ARGUMENT"
+    private static let internalError = "ECR_INTERNAL"
+    private static let cancelledMessage =
+        "The caller cancelled while the terminal had the request. "
+        + "The transaction may still have completed — inquire before retrying."
+
+    private let queue = DispatchQueue(
+        label: "com.amwalpay.react-native-ecr",
+        qos: .userInitiated,
+        attributes: .concurrent
+    )
+    private let lock = NSLock()
+    private var running: [String: RunningOperation] = [:]
+
+    @objc static func requiresMainQueueSetup() -> Bool { false }
+
+    @objc func isReachable(
+        _ request: [String: Any],
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            let call = try Call(request)
+            guard call.isIpTransport else {
+                resolve(false)
+                return
+            }
+            let session = try call.makeSession()
+            queue.async { resolve(session.probeReachability()?.reachable ?? false) }
+        } catch {
+            rejectError(error, reject)
+        }
+    }
+
+    @objc func sale(
+        _ request: [String: Any],
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        run(request, resolve, reject) { call, session in
+            ReactEcrMapping.result(
+                try session.sale(
+                    amount: try call.requiredAmount(),
+                    merchantReference: call.merchantReferenceId
+                )
+            )
+        }
+    }
+
+    @objc func voidTransaction(
+        _ request: [String: Any],
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        run(request, resolve, reject) { call, session in
+            ReactEcrMapping.result(
+                try session.void(
+                    receiptNumber: try call.requiredReceiptNumber("A void"),
+                    originalTerminalId: call.originalTerminalId,
+                    merchantReference: call.merchantReferenceId
+                )
+            )
+        }
+    }
+
+    @objc func refund(
+        _ request: [String: Any],
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        run(request, resolve, reject) { call, session in
+            ReactEcrMapping.result(
+                try session.refund(
+                    amount: try call.requiredAmount(),
+                    receiptNumber: try call.requiredReceiptNumber("A refund"),
+                    transactionDate: call.transactionDate,
+                    originalTerminalId: call.originalTerminalId,
+                    merchantReference: call.merchantReferenceId
+                )
+            )
+        }
+    }
+
+    @objc func inquire(
+        _ request: [String: Any],
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        run(request, resolve, reject) { call, session in
+            ReactEcrMapping.inquiry(
+                try session.inquire(
+                    receiptNumber: try call.requiredReceiptNumber("An inquiry"),
+                    transactionDate: call.transactionDate,
+                    originalTerminalId: call.originalTerminalId,
+                    merchantReference: call.merchantReferenceId
+                )
+            )
+        }
+    }
+
+    @objc func inquireByReference(
+        _ request: [String: Any],
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        run(request, resolve, reject) { call, session in
+            ReactEcrMapping.inquiry(
+                try session.inquireByReference(
+                    try call.requiredOriginalReference(),
+                    transactionDate: call.transactionDate,
+                    originalTerminalId: call.originalTerminalId,
+                    merchantReference: call.merchantReferenceId
+                )
+            )
+        }
+    }
+
+    @objc func receipt(
+        _ request: [String: Any],
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        run(request, resolve, reject) { call, session in
+            ReactEcrMapping.receipt(
+                try session.receipt(
+                    receiptNumber: try call.requiredReceiptNumber("A receipt"),
+                    transactionDate: call.transactionDate,
+                    originalTerminalId: call.originalTerminalId,
+                    merchantReference: call.merchantReferenceId
+                )
+            )
+        }
+    }
+
+    @objc func cancel(
+        _ operationId: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter _: @escaping RCTPromiseRejectBlock
+    ) {
+        lock.lock()
+        let operation = running.removeValue(forKey: operationId)
+        lock.unlock()
+
+        guard let operation else {
+            resolve(false)
+            return
+        }
+
+        operation.session.cancel()
+        operation.reply.resolve(
+            ReactEcrMapping.failedResult(
+                merchantReferenceId: operation.merchantReferenceId,
+                kind: ReactEcrMapping.cancelled,
+                message: Self.cancelledMessage
+            )
+        )
+        resolve(true)
+    }
+
+    @objc func invalidate() {
+        lock.lock()
+        let operations = Array(running.values)
+        running.removeAll()
+        lock.unlock()
+
+        for operation in operations {
+            operation.session.cancel()
+            operation.reply.resolve(
+                ReactEcrMapping.failedResult(
+                    merchantReferenceId: operation.merchantReferenceId,
+                    kind: ReactEcrMapping.cancelled,
+                    message: "The React Native host was invalidated while the terminal had the request. "
+                        + "The transaction may still have completed — inquire before retrying."
+                )
+            )
+        }
+    }
+
+    private func run(
+        _ request: [String: Any],
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        _ reject: @escaping RCTPromiseRejectBlock,
+        _ block: @escaping (Call, EcrOpenedSession) throws -> Any
+    ) {
+        do {
+            let call = try Call(request)
+            let reply = OneShotReply(resolve: resolve, reject: reject)
+
+            guard call.isSupportedTransport else {
+                reply.resolve(
+                    ReactEcrMapping.failedResult(
+                        merchantReferenceId: "",
+                        kind: ReactEcrMapping.unsupported,
+                        message: "This library drives a terminal over ethernet, wifi, or the Web Service "
+                            + "REST path. Transport '\(call.transport)' is not handled, so nothing was sent."
+                    )
+                )
+                return
+            }
+
+            let session = try call.makeSession()
+            let operation = RunningOperation(
+                session: session,
+                reply: reply,
+                merchantReferenceId: call.merchantReferenceId
+            )
+            lock.lock()
+            guard running[call.operationId] == nil else {
+                lock.unlock()
+                reply.reject(
+                    code: Self.invalidArgument,
+                    message: "operationId '\(call.operationId)' is already running",
+                    error: nil
+                )
+                return
+            }
+            running[call.operationId] = operation
+            lock.unlock()
+
+            queue.async { [weak self] in
+                defer { self?.deregister(call.operationId, operation) }
+                do {
+                    reply.resolve(try block(call, session))
+                } catch {
+                    self?.rejectError(error, reply)
+                }
+            }
+        } catch {
+            rejectError(error, reject)
+        }
+    }
+
+    private func deregister(_ operationId: String, _ operation: RunningOperation) {
+        lock.lock()
+        if running[operationId] === operation {
+            running.removeValue(forKey: operationId)
+        }
+        lock.unlock()
+    }
+
+    private func rejectError(_ error: Error, _ reject: RCTPromiseRejectBlock) {
+        if let invalid = error as? EcrInvalidArgument {
+            reject(Self.invalidArgument, invalid.message, invalid)
+        } else {
+            reject(Self.internalError, error.localizedDescription, error)
+        }
+    }
+
+    private func rejectError(_ error: Error, _ reply: OneShotReply) {
+        if let invalid = error as? EcrInvalidArgument {
+            reply.reject(
+                code: Self.invalidArgument,
+                message: invalid.message,
+                error: invalid
+            )
+        } else {
+            reply.reject(
+                code: Self.internalError,
+                message: error.localizedDescription,
+                error: error
+            )
+        }
+    }
+}
+
+private final class RunningOperation {
+    let session: EcrOpenedSession
+    let reply: OneShotReply
+    let merchantReferenceId: String
+
+    init(session: EcrOpenedSession, reply: OneShotReply, merchantReferenceId: String) {
+        self.session = session
+        self.reply = reply
+        self.merchantReferenceId = merchantReferenceId
+    }
+}
+
+private final class OneShotReply {
+    private let lock = NSLock()
+    private var answered = false
+    private let onResolve: RCTPromiseResolveBlock
+    private let onReject: RCTPromiseRejectBlock
+
+    init(
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        onResolve = resolve
+        onReject = reject
+    }
+
+    private func claim() -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        if answered { return false }
+        answered = true
+        return true
+    }
+
+    func resolve(_ value: Any?) {
+        if claim() { onResolve(value) }
+    }
+
+    func reject(code: String, message: String, error: Error?) {
+        if claim() { onReject(code, message, error) }
+    }
+}
+
+private struct Call {
+    let operationId: String
+    let transport: String
+    let transactionDate: String
+    let originalTerminalId: String
+    let merchantReferenceId: String
+    let host: String
+    let serialNumber: String
+    let config: EcrConfig
+    private let raw: [String: Any]
+
+    init(_ raw: [String: Any]) throws {
+        self.raw = raw
+        operationId = try Self.requiredString(raw, "operationId")
+        transport = raw["transport"] as? String ?? "wifi"
+        // The payment host addresses a Web Service terminal; only the IP
+        // transports dial an address of their own.
+        if transport == "ethernet" || transport == "wifi" {
+            host = try Self.requiredString(raw, "host")
+        } else {
+            host = (raw["host"] as? String)?.trimmed ?? ""
+        }
+        serialNumber = raw["serialNumber"] as? String ?? ""
+        transactionDate = raw["transactionDate"] as? String ?? ""
+        originalTerminalId = raw["originalTerminalId"] as? String ?? ""
+        merchantReferenceId = raw["merchantReferenceId"] as? String ?? ""
+        config = try Self.config(raw["config"] as? [String: Any])
+    }
+
+    var isIpTransport: Bool { transport == "ethernet" || transport == "wifi" }
+    var isWebService: Bool { transport == "webService" || transport == "web_service" }
+    var isSupportedTransport: Bool { isIpTransport || isWebService }
+
+    /// The SDK session for this call's transport: TCP for ethernet/wifi, the
+    /// hosted REST path for webService.
+    func makeSession() throws -> EcrOpenedSession {
+        let link: EcrLink = isWebService
+            ? .webService(merchantId: config.merchantId, terminalId: config.terminalId)
+            : .lan(host: host, port: config.port)
+        let plan = EcrSessions.plan(link: link, config: config)
+        guard plan.isReady else {
+            throw EcrInvalidArgument(plan.issues.joined(separator: "; "))
+        }
+        return EcrSessions.open(terminalSerial: serialNumber, plan: plan)
+    }
+
+    func requiredAmount() throws -> Decimal {
+        let text = try Self.requiredString(raw, "amount")
+        guard let amount = EcrDecimal.parse(text) else {
+            throw EcrInvalidArgument("'\(text)' is not a decimal amount")
+        }
+        return amount
+    }
+
+    func requiredReceiptNumber(_ operation: String) throws -> String {
+        let value = (raw["receiptNumber"] as? String)?.trimmed ?? ""
+        guard !value.isEmpty else {
+            throw EcrInvalidArgument("\(operation) needs the original receipt number")
+        }
+        return value
+    }
+
+    func requiredOriginalReference() throws -> String {
+        let value = (raw["originalMerchantReference"] as? String)?.trimmed ?? ""
+        guard !value.isEmpty else {
+            throw EcrInvalidArgument("An inquiry by reference needs the original reference")
+        }
+        return value
+    }
+
+    private static func requiredString(_ raw: [String: Any], _ key: String) throws -> String {
+        let value = (raw[key] as? String)?.trimmed ?? ""
+        guard !value.isEmpty else {
+            throw EcrInvalidArgument("'\(key)' is required and was missing")
+        }
+        return value
+    }
+
+    private static func config(_ raw: [String: Any]?) throws -> EcrConfig {
+        let raw = raw ?? [:]
+        var value = EcrConfig()
+        if let field = raw["ecrId"] as? String, !field.isEmpty { value.ecrId = field }
+        if let field = raw["currencyCode"] as? String, !field.isEmpty { value.currencyCode = field }
+        if let field = raw["minorUnitDigits"] as? NSNumber { value.minorUnitDigits = field.intValue }
+        if let field = raw["port"] as? NSNumber { value.port = field.intValue }
+        if let field = raw["connectTimeoutMs"] as? NSNumber { value.connectTimeout = field.doubleValue / 1000 }
+        if let field = raw["responseTimeoutMs"] as? NSNumber { value.responseTimeout = field.doubleValue / 1000 }
+        if let field = raw["probeTimeoutMs"] as? NSNumber { value.probeTimeout = field.doubleValue / 1000 }
+        if let field = raw["secureHashKey"] as? String { value.secureHashKey = field }
+        if let field = raw["autoInquireOnFailure"] as? NSNumber { value.autoInquireOnFailure = field.boolValue }
+        if let field = raw["merchantId"] as? String { value.merchantId = field }
+        if let field = raw["terminalId"] as? String { value.terminalId = field }
+        if let field = raw["environment"] as? String { value.environment = EcrEnvironment.fromName(field) }
+
+        guard (0 ... 4).contains(value.minorUnitDigits) else {
+            throw EcrInvalidArgument("minorUnitDigits must be between 0 and 4")
+        }
+        guard (1 ... 65_535).contains(value.port) else {
+            throw EcrInvalidArgument("port must be between 1 and 65535")
+        }
+        if let message = value.secureHashKeyError {
+            throw EcrInvalidArgument(message)
+        }
+        return value
+    }
+}
+
+private extension String {
+    var trimmed: String { trimmingCharacters(in: .whitespacesAndNewlines) }
+}

package/ios/EcrMapping.swift

@@ -0,0 +1,142 @@
+import AmwalECR
+import Foundation
+
+enum ReactEcrMapping {
+    static let cancelled = "cancelled"
+    static let unsupported = "unsupported"
+
+    static func result(_ result: EcrResult) -> [String: Any] {
+        switch result {
+        case let .approved(value):
+            return [
+                "outcome": "approved",
+                "merchantReferenceId": value.merchantReference,
+                "amount": value.amount,
+                "responseCode": value.responseCode,
+                "rrn": value.rrn,
+                "authCode": value.authCode,
+                "maskedPan": value.maskedPan,
+                "partialApproval": value.partialApproval,
+                "requestedAmount": value.requestedAmount,
+                "raw": value.raw,
+            ]
+        case let .declined(value):
+            return [
+                "outcome": "declined",
+                "merchantReferenceId": value.merchantReference,
+                "responseCode": value.responseCode,
+                "reason": value.reason,
+                "nextStep": value.nextStep.rawValue,
+                "raw": value.raw,
+            ]
+        case let .failed(reference, failure, recovered):
+            var value: [String: Any] = [
+                "outcome": "failed",
+                "merchantReferenceId": reference,
+                "failure": self.failure(failure),
+            ]
+            if let recovered {
+                value["recovered"] = inquiry(recovered)
+            }
+            return value
+        }
+    }
+
+    static func inquiry(_ inquiry: EcrInquiry) -> [String: Any] {
+        switch inquiry {
+        case let .found(reference, transaction, raw):
+            return [
+                "outcome": "found",
+                "merchantReferenceId": reference,
+                "transaction": self.transaction(transaction),
+                "raw": raw,
+            ]
+        case let .notFound(reference, reason, raw):
+            return [
+                "outcome": "notFound",
+                "merchantReferenceId": reference,
+                "reason": reason,
+                "raw": raw,
+            ]
+        case let .failed(reference, failure):
+            return [
+                "outcome": "failed",
+                "merchantReferenceId": reference,
+                "failure": self.failure(failure),
+            ]
+        }
+    }
+
+    static func receipt(_ receipt: EcrReceipt) -> [String: Any] {
+        switch receipt {
+        case let .ready(reference, url, raw):
+            return [
+                "outcome": "ready",
+                "merchantReferenceId": reference,
+                "url": url,
+                "raw": raw,
+            ]
+        case let .unavailable(reference, reason, raw):
+            return [
+                "outcome": "unavailable",
+                "merchantReferenceId": reference,
+                "reason": reason,
+                "raw": raw,
+            ]
+        case let .failed(reference, failure):
+            return [
+                "outcome": "failed",
+                "merchantReferenceId": reference,
+                "failure": self.failure(failure),
+            ]
+        }
+    }
+
+    static func failedResult(
+        merchantReferenceId: String,
+        kind: String,
+        message: String
+    ) -> [String: Any] {
+        [
+            "outcome": "failed",
+            "merchantReferenceId": merchantReferenceId,
+            "failure": ["kind": kind, "message": message],
+        ]
+    }
+
+    private static func failure(_ failure: EcrFailure) -> [String: Any] {
+        let kind: String
+        switch failure {
+        case .unreachable: kind = "unreachable"
+        case .timeout: kind = "timeout"
+        case .malformed: kind = "malformed"
+        case .connectionLost: kind = "connectionLost"
+        case .unauthenticated: kind = "unauthenticated"
+        }
+        return ["kind": kind, "message": failure.message]
+    }
+
+    private static func transaction(_ value: EcrTransaction) -> [String: Any] {
+        [
+            "transactionId": value.transactionId,
+            "stan": value.stan,
+            "type": value.type,
+            "status": value.status,
+            "amount": value.amount,
+            "totalAmount": value.totalAmount,
+            "currency": value.currency,
+            "transactionTime": value.transactionTime,
+            "maskedPan": value.maskedPan,
+            "cardHolderName": value.cardHolderName,
+            "rrn": value.rrn,
+            "authCode": value.authCode,
+            "batchId": value.batchId,
+            "terminalId": value.terminalId,
+            "isRefunded": value.isRefunded,
+            "canVoid": value.canVoid,
+            "canRefund": value.canRefund,
+            "partialApproval": value.partialApproval,
+            "authorizedAmount": value.authorizedAmount,
+        ]
+    }
+}

package/lib/module/EcrOperation.js

@@ -0,0 +1,18 @@
+"use strict";
+
+export class EcrOperation {
+  cancelRequested = false;
+  constructor(operationId, result, onCancel) {
+    this.operationId = operationId;
+    this.result = result;
+    this.onCancel = onCancel;
+  }
+  get isCancelRequested() {
+    return this.cancelRequested;
+  }
+  cancel() {
+    this.cancelRequested = true;
+    return this.onCancel(this.operationId);
+  }
+}
+//# sourceMappingURL=EcrOperation.js.map

package/lib/module/EcrOperation.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EcrOperation","cancelRequested","constructor","operationId","result","onCancel","isCancelRequested","cancel"],"sourceRoot":"../../src","sources":["EcrOperation.ts"],"mappings":";;AAAA,OAAO,MAAMA,YAAY,CAAI;EAInBC,eAAe,GAAG,KAAK;EAE/BC,WAAWA,CACTC,WAAmB,EACnBC,MAAkB,EAClBC,QAAmD,EACnD;IACA,IAAI,CAACF,WAAW,GAAGA,WAAW;IAC9B,IAAI,CAACC,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,QAAQ,GAAGA,QAAQ;EAC1B;EAEA,IAAIC,iBAAiBA,CAAA,EAAY;IAC/B,OAAO,IAAI,CAACL,eAAe;EAC7B;EAEAM,MAAMA,CAAA,EAAqB;IACzB,IAAI,CAACN,eAAe,GAAG,IAAI;IAC3B,OAAO,IAAI,CAACI,QAAQ,CAAC,IAAI,CAACF,WAAW,CAAC;EACxC;AACF","ignoreList":[]}