feat(KlaviyoSwift): wire KlaviyoInternal into IdentityStore and SDKConfigStore (MAGE-749)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: belleklaviyo

Sources/KlaviyoSwift/Klaviyo.swift

@@ -63,6 +63,7 @@ public struct KlaviyoSDK {
     /// - Returns: a KlaviyoSDK instance
     @discardableResult
     public func initialize(with apiKey: String) -> KlaviyoSDK {
+        KlaviyoInternal.setupSharedStores()
         dispatchOnMainThread(action: .initialize(apiKey))
         return self
     }

Sources/KlaviyoSwift/KlaviyoInternal.swift

@@ -29,6 +29,8 @@ package enum KlaviyoInternal {
     private static var apiKeyCancellable: Cancellable?
     private static let apiKeySubject = CurrentValueSubject<APIKeyResult, Never>(.failure(.notInitialized))
 
+    private static var sharedStoresCancellable: Cancellable?
+
     private static let profileEventSubject = PassthroughSubject<Event, Never>()
     private static var profileEventCancellable: Cancellable?
     private static let eventBuffer = EventBuffer(maxBufferSize: 10, maxBufferAge: 10)
@@ -109,17 +111,28 @@ package enum KlaviyoInternal {
                     return .failure(.notInitialized)
                 }
 
-                return .success(ProfileData(
-                    email: state.email,
-                    phoneNumber: state.phoneNumber,
-                    externalId: state.externalId,
-                    anonymousId: state.anonymousId
-                ))
+                return .success(state.identity)
             }
             .removeDuplicates()
             .subscribe(profileDataSubject)
     }
 
+    /// Mirrors initialized SDK state into the shared `KlaviyoCore` stores so other modules
+    /// (Forms, Location) can observe identity and API key without importing `KlaviyoSwift`.
+    package static func setupSharedStores() {
+        guard sharedStoresCancellable == nil else { return }
+        sharedStoresCancellable = klaviyoSwiftEnvironment.statePublisher()
+            .filter { $0.initalizationState == .initialized }
+            .map { (identity: $0.identity, apiKey: $0.apiKey) }
+            .removeDuplicates(by: { $0.identity == $1.identity && $0.apiKey == $1.apiKey })
+            // TCA dispatches state changes on the main thread, so these two sequential
+            // store writes are observed together rather than torn.
+            .sink { identity, apiKey in
+                IdentityStore.shared.update(identity)
+                SDKConfigStore.shared.update(KlaviyoConfig(apiKey: apiKey))
+            }
+    }
+
     /// Fetches the current profile data once.
     ///
     /// - Returns: The current profile data, if available.
@@ -154,6 +167,11 @@ package enum KlaviyoInternal {
         profileDataCancellable?.cancel()
         profileDataCancellable = nil
         profileDataSubject.send(.failure(.notInitialized))
+        sharedStoresCancellable?.cancel()
+        sharedStoresCancellable = nil
+        // Clear the shared stores so consumers don't read stale identity/config after reset.
+        IdentityStore.shared.update(ProfileData())
+        SDKConfigStore.shared.update(KlaviyoConfig())
     }
 
     // MARK: - Profile Event methods

Tests/KlaviyoSwiftTests/KlaviyoInternalTests.swift

@@ -26,6 +26,8 @@ final class KlaviyoInternalTests: XCTestCase {
         KlaviyoInternal.resetProfileDataSubject()
         KlaviyoInternal.resetEventSubject()
         KlaviyoInternal.clearEventBuffer()
+        IdentityStore.shared.update(ProfileData())
+        SDKConfigStore.shared.update(KlaviyoConfig())
     }
 
     // MARK: - Profile Data Tests
@@ -806,6 +808,71 @@ final class KlaviyoInternalTests: XCTestCase {
         XCTAssertEqual(currentState.queue.count, 0, "Queue should remain empty")
     }
 
+    // MARK: - Shared store wiring
+
+    @MainActor
+    func testSetupSharedStoresPushesIdentityOnChange() throws {
+        let testStore = Store(initialState: .test, reducer: KlaviyoReducer())
+        klaviyoSwiftEnvironment.statePublisher = { testStore.state.eraseToAnyPublisher() }
+
+        KlaviyoInternal.setupSharedStores()
+
+        _ = testStore.send(.setEmail("wired@example.com"))
+
+        let expectation = XCTestExpectation(description: "IdentityStore reflects email")
+        DispatchQueue.main.async {
+            XCTAssertEqual(IdentityStore.shared.current.email, "wired@example.com")
+            expectation.fulfill()
+        }
+        wait(for: [expectation], timeout: 1.0)
+    }
+
+    @MainActor
+    func testSetupSharedStoresPushesAPIKeyOnChange() throws {
+        // `.test` state is already `.initialized` with apiKey "foo".
+        let testStore = Store(initialState: .test, reducer: KlaviyoReducer())
+        klaviyoSwiftEnvironment.statePublisher = { testStore.state.eraseToAnyPublisher() }
+
+        let expectation = XCTestExpectation(description: "SDKConfigStore reflects api key")
+        SDKConfigStore.shared.publisher
+            .dropFirst() // skip the CurrentValueSubject's initial emission
+            .sink { config in
+                if config.apiKey == "foo" { expectation.fulfill() }
+            }
+            .store(in: &cancellables)
+
+        KlaviyoInternal.setupSharedStores()
+
+        wait(for: [expectation], timeout: 1.0)
+        XCTAssertEqual(SDKConfigStore.shared.current.apiKey, "foo")
+    }
+
+    @MainActor
+    func testResetClearsSharedStores() throws {
+        // `.test` state is `.initialized` with apiKey "foo"; mirror it into the stores.
+        let testStore = Store(initialState: .test, reducer: KlaviyoReducer())
+        klaviyoSwiftEnvironment.statePublisher = { testStore.state.eraseToAnyPublisher() }
+
+        KlaviyoInternal.setupSharedStores()
+        _ = testStore.send(.setEmail("wired@example.com"))
+
+        // Confirm the stores hold real data before resetting.
+        let propagated = XCTestExpectation(description: "identity mirrored before reset")
+        DispatchQueue.main.async {
+            XCTAssertEqual(IdentityStore.shared.current.email, "wired@example.com")
+            XCTAssertEqual(SDKConfigStore.shared.current.apiKey, "foo")
+            propagated.fulfill()
+        }
+        wait(for: [propagated], timeout: 1.0)
+
+        KlaviyoInternal.resetProfileDataSubject()
+
+        XCTAssertEqual(IdentityStore.shared.current, ProfileData(),
+                       "reset must clear identity back to empty")
+        XCTAssertNil(SDKConfigStore.shared.current.apiKey,
+                     "reset must clear the API key")
+    }
+
     @MainActor
     func testCreateGeofenceEvent_enqueuesEventWhenAPIKeyMatches() async throws {
         // Given: SDK is initialized with matching API key