A/B Testing iOS SDK

https://github.com/Abrova-co/abrova-ab-testing-ios-sdk.git

dependencies: [
    .package(url: "https://github.com/Abrova-co/abrova-ab-testing-ios-sdk.git", from: "0.2.3")
]

import AbrovaAbTesting

import AbrovaAbTesting

let config = AbrovaAbTestingConfig(
    apiKey: "YOUR_API_KEY",
    debug: true,           // Log to the console (development only)
    // flushInterval: 10.0, // Your own send interval in seconds. Leave it out to follow the console
    maxQueueSize: 100,     // Max events before auto-flush (default: 100)
    tokenProvider: { completion in
        // Ask YOUR backend for an Abrova user token (see step 3).
        // Complete with .failure while no one is signed in.
        MyBackend.fetchAbrovaToken { result in completion(result) }
    }
)

AbrovaAbTesting.shared.initialize(config: config, delegate: self)

curl -X POST https://auth.abrova.ir/users/token \
  -H "x-api-key: $ABROVA_API_KEY" \
  -H "x-server-secret: $ABROVA_SERVER_SECRET" \
  -H "Content-Type: application/json" \
  -d '{"userId": "user-123", "expiresIn": 3600}'

# → { "token": "eyJhbGciOi…", "userId": "user-123", "expiresIn": 3600, "expiresAt": "…" }

let tokenProvider: AbrovaTokenProvider = { completion in
    // No one signed in: complete with .failure. The SDK then waits for a token.
    guard let session = SessionStore.shared.current else {
        completion(.failure(AuthError.notSignedIn))
        return
    }
    MyBackend.fetchAbrovaToken(for: session) { result in
        completion(result) // Result<String, Error>
    }
}

AbrovaAbTesting.shared.onAwaitingUserToken = { /* e.g. show the default experience */ }

// After sign-in
AbrovaAbTesting.shared.refreshUserToken()      // with a tokenProvider: asks it again now
AbrovaAbTesting.shared.setUserToken(token)     // without one: hand the token over

// After sign-out
AbrovaAbTesting.shared.clearUserId()           // or setUserToken(nil)

// After login — use the same ID your backend mints the token for
AbrovaAbTesting.shared.setUserId("user-123")
AbrovaAbTesting.shared.refreshUserToken()   // or setUserToken(token) if you hand tokens over yourself

// After logout — forget the user and wait for the next token
AbrovaAbTesting.shared.clearUserId()

// Get current user ID
let userId = AbrovaAbTesting.shared.getUserId()

// Set attributes for targeting rules
AbrovaAbTesting.shared.setUserAttributes([
    "plan": "premium",
    "country": "US",
    "age": 28,
    "platform": "ios"
])

extension AppDelegate: AbrovaAbTestingDelegate {
    func abrovaAbTestingDidInitialize() {
        print("SDK initialized")
    }

    func abrovaAbTesting(didAssignVariant variantKey: String,
                         forExperiment experimentKey: String,
                         config: [String: Any]?) {
        print("Assigned: \(experimentKey) -> \(variantKey)")
    }

    func abrovaAbTesting(didRefreshExperiments experiments: [Experiment]) {
        print("Refreshed \(experiments.count) experiments")
    }

    func abrovaAbTesting(didRefreshFeatureFlags flags: [FeatureFlag]) {
        print("Refreshed \(flags.count) flags")
    }

    func abrovaAbTesting(didReceiveError error: AbrovaAbTestingError) {
        print("Error: \(error.localizedDescription)")
    }
}

// Asynchronous (recommended) — waits for the service's answer;
// completion runs on the main queue
AbrovaAbTesting.shared.getVariant(experimentKey: "checkout-redesign") { variant in
    switch variant {
    case "variant-a":
        self.showNewCheckout()
    default:
        self.showOriginalCheckout()
    }
}

// Synchronous — never blocks, safe on the main thread
let variant = AbrovaAbTesting.shared.getVariant(
    experimentKey: "checkout-redesign",
    defaultVariant: "control"  // returned until the service has answered
)

let config = AbrovaAbTesting.shared.getVariantConfig(experimentKey: "checkout-redesign")
let buttonColor = config?["button_color"] as? String ?? "#7C3AED"
let layout = config?["layout"] as? String ?? "default"

// Get all experiments
let experiments = AbrovaAbTesting.shared.getExperiments()
for exp in experiments {
    print("\(exp.key) [\(exp.status.rawValue)] - \(exp.variants.count) variants")
}

// Refresh from server
AbrovaAbTesting.shared.refreshExperiments {
    print("Experiments refreshed")
}

let darkMode = AbrovaAbTesting.shared.isFeatureEnabled("dark-mode")
if darkMode {
    enableDarkMode()
}

AbrovaAbTesting.shared.isFeatureEnabled("dark-mode", defaultValue: false) { enabled in
    if enabled {
        self.enableDarkMode()
    }
}

let maxUpload = AbrovaAbTesting.shared.getFeatureValue("max-upload-size", defaultValue: 10) as? Int ?? 10
let buttonColor = AbrovaAbTesting.shared.getFeatureValue("button-color", defaultValue: "#7C3AED") as? String ?? "#7C3AED"

// Get all flags
let flags = AbrovaAbTesting.shared.getFeatureFlags()
for flag in flags {
    print("\(flag.key): enabled=\(flag.enabled), rollout=\(flag.rolloutPercentage)%")
}

// Refresh from server
AbrovaAbTesting.shared.refreshFeatureFlags {
    print("Flags refreshed")
}

AbrovaAbTesting.shared.trackView(experimentKey: "experiment-key")
AbrovaAbTesting.shared.trackClick(experimentKey: "experiment-key")
AbrovaAbTesting.shared.trackConversion(experimentKey: "experiment-key", value: 1000000)

// Custom event
AbrovaAbTesting.shared.trackCustomEvent(
    experimentKey: "experiment-key",
    eventName: "button_tap",
    properties: ["element": "cta_button", "duration_ms": 1500]
)

AbrovaAbTesting.shared.trackAddToCart(experimentKey: "experiment-key", value: 300000, productId: "sku-123", properties: ["quantity": 2])
AbrovaAbTesting.shared.trackRemoveFromCart(experimentKey: "experiment-key", value: 300000, productId: "sku-123")
AbrovaAbTesting.shared.trackBeginCheckout(experimentKey: "experiment-key", value: 600000)
AbrovaAbTesting.shared.trackPurchase(experimentKey: "experiment-key", value: 890000, transactionId: "txn-456", properties: ["currency": "Toman"])

AbrovaAbTesting.shared.trackScroll(experimentKey: "experiment-key", depth: 75.0)
AbrovaAbTesting.shared.trackFormSubmit(experimentKey: "experiment-key", formName: "signup")
AbrovaAbTesting.shared.trackSearch(experimentKey: "experiment-key", query: "shoes")
AbrovaAbTesting.shared.trackShare(experimentKey: "experiment-key", method: "twitter")

AbrovaAbTesting.shared.trackVideoStart(experimentKey: "experiment-key", videoId: "vid-001")
AbrovaAbTesting.shared.trackVideoComplete(experimentKey: "experiment-key", videoId: "vid-001")

AbrovaAbTesting.shared.trackSignUp(experimentKey: "experiment-key", method: "apple")
AbrovaAbTesting.shared.trackLogin(experimentKey: "experiment-key", method: "biometric")
AbrovaAbTesting.shared.trackLogout(experimentKey: "experiment-key")

AbrovaAbTesting.shared.track(
    experimentKey: "experiment-key",
    eventType: .custom,
    eventName: "page_load_time",
    eventValue: 2.3,
    properties: ["page": "/checkout", "cached": false]
)

import SwiftUI
import AbrovaAbTesting

@main
struct MyApp: App {
    init() {
        AbrovaAbTesting.shared.initialize(config: AbrovaAbTestingConfig(
            apiKey: "YOUR_API_KEY",
            tokenProvider: { completion in
                MyBackend.fetchAbrovaToken { result in completion(result) }
            }
        ))
    }

    var body: some Scene {
        WindowGroup { ContentView() }
    }
}

// In your login flow, once your backend knows the user
func onLoggedIn(_ user: User) {
    AbrovaAbTesting.shared.setUserId(user.id)   // the ID your backend puts in the token
    AbrovaAbTesting.shared.refreshUserToken()   // asks tokenProvider again now
    AbrovaAbTesting.shared.setUserAttributes(["plan": user.plan])
}

// In your logout flow
func onLoggedOut() {
    AbrovaAbTesting.shared.clearUserId()
}

struct ContentView: View {
    @State private var variant = "control"
    @State private var darkMode = false

    var body: some View {
        VStack(spacing: 20) {
            // Feature flag: dark mode
            Toggle("Dark Mode", isOn: $darkMode)
                .padding()

            // A/B test: checkout button
            Button(action: {
                AbrovaAbTesting.shared.trackClick(experimentKey: "checkout-button")
                checkout()
            }) {
                Text(variant == "variant-a" ? "Buy Now" : "Checkout")
                    .foregroundColor(.white)
                    .padding()
                    .frame(maxWidth: .infinity)
                    .background(variant == "variant-a" ? Color.green : Color.blue)
                    .cornerRadius(12)
            }
            .padding(.horizontal)
        }
        .onAppear {
            // Check feature flag
            darkMode = AbrovaAbTesting.shared.isFeatureEnabled("dark-mode")

            // Get variant, then track the view
            AbrovaAbTesting.shared.getVariant(experimentKey: "checkout-button") { v in
                self.variant = v
                AbrovaAbTesting.shared.trackView(experimentKey: "checkout-button")
            }
        }
    }

    func checkout() {
        AbrovaAbTesting.shared.trackConversion(experimentKey: "checkout-button", value: 500000)
        AbrovaAbTesting.shared.trackPurchase(experimentKey: "checkout-button", value: 500000, transactionId: "txn-123")
        AbrovaAbTesting.shared.flush()
    }
}

// Refresh experiments from server
AbrovaAbTesting.shared.refreshExperiments()

// Refresh feature flags from server
AbrovaAbTesting.shared.refreshFeatureFlags()

// Flush pending events
AbrovaAbTesting.shared.flush()

// Clear cached experiments, flags, assignments and the token.
// Mainly for tests — call initialize(config:) again before using the SDK.
AbrovaAbTesting.shared.reset()