Bugfix/#139 - iCloud 동기화 Pro 전용 게이팅 및 App Sandbox 배포 설정

Projects/DVData/Sources/RepositoryImpl/Settings/SettingsRepositoryImpl.swift

@@ -146,7 +146,8 @@ public struct SettingsRepositoryImpl: SettingsRepository, @unchecked Sendable {
       entitlement: cachedEntitlement(),
       productID: defaults.string(forKey: .cachedSubscriptionProductID),
       renewsAt: defaults.date(forKey: .cachedSubscriptionRenewsAt),
-      willAutoRenew: defaults.bool(forKey: .cachedSubscriptionWillAutoRenew)
+      willAutoRenew: defaults.bool(forKey: .cachedSubscriptionWillAutoRenew),
+      renewalProductID: defaults.string(forKey: .cachedSubscriptionRenewalProductID)
     )
   }
 
@@ -163,6 +164,11 @@ public struct SettingsRepositoryImpl: SettingsRepository, @unchecked Sendable {
       defaults.removeObject(forKey: .cachedSubscriptionRenewsAt)
     }
     defaults.set(status.willAutoRenew, forKey: .cachedSubscriptionWillAutoRenew)
+    if let renewalProductID = status.renewalProductID {
+      defaults.set(renewalProductID, forKey: .cachedSubscriptionRenewalProductID)
+    } else {
+      defaults.removeObject(forKey: .cachedSubscriptionRenewalProductID)
+    }
   }
 
   // MARK: - Security

Projects/DVData/Sources/RepositoryImpl/Settings/UserDefaultsKey.swift

@@ -36,6 +36,7 @@ enum UserDefaultsKey: String {
   case cachedSubscriptionProductID
   case cachedSubscriptionRenewsAt
   case cachedSubscriptionWillAutoRenew
+  case cachedSubscriptionRenewalProductID
 }
 
 extension UserDefaults {

Projects/DVData/Sources/ServiceImpl/Purchase/PurchaseServiceImpl.swift

@@ -135,7 +135,8 @@ public struct PurchaseServiceImpl: PurchaseService {
             productID: transaction.productID,
             renewsAt: transaction.expirationDate,
             willAutoRenew: renewal.willAutoRenew,
-            renewalProductID: renewal.autoRenewPreference
+            // 자동 갱신이 꺼져 있으면 다음 갱신 자체가 없으므로 예약 상품도 없다(있어도 "변경 예약"이 아니라 만료).
+            renewalProductID: renewal.willAutoRenew ? renewal.autoRenewPreference : nil
         )
     }
 

Projects/DVData/Tests/RepositoryImpl/Settings/SettingsRepositoryImplSubscriptionCacheTests.swift

@@ -0,0 +1,52 @@
+// Copyright © 2026 Devault. All rights reserved
+
+import Foundation
+import Testing
+
+import DVDomain
+@testable import DVData
+
+@Suite("SettingsRepositoryImpl - 구독 상태 캐시")
+struct SettingsRepositoryImplSubscriptionCacheTests {
+
+    private func makeSUT() -> SettingsRepositoryImpl {
+        let defaults = UserDefaults(suiteName: "SettingsRepositoryImplTests.\(UUID().uuidString)")!
+        return SettingsRepositoryImpl(defaults: defaults)
+    }
+
+    @Test("예약된 플랜 변경(renewalProductID)이 캐시 왕복에서 보존된다")
+    func renewalProductIDSurvivesRoundTrip() {
+        let sut = makeSUT()
+        sut.setCachedEntitlement(.pro)
+        sut.setCachedSubscriptionStatus(
+            SubscriptionStatus(
+                entitlement: .pro,
+                productID: "pro.monthly",
+                renewsAt: Date(timeIntervalSince1970: 1_700_000_000),
+                willAutoRenew: true,
+                renewalProductID: "pro.yearly"
+            )
+        )
+
+        let restored = sut.cachedSubscriptionStatus()
+
+        #expect(restored.renewalProductID == "pro.yearly")
+        #expect(restored.hasPendingPlanChange)
+    }
+
+    @Test("예약이 없으면 renewalProductID는 nil로 복원된다")
+    func renewalProductIDClearedWhenAbsent() {
+        let sut = makeSUT()
+        sut.setCachedEntitlement(.pro)
+        // 예약이 있던 상태를
+        sut.setCachedSubscriptionStatus(
+            SubscriptionStatus(entitlement: .pro, productID: "pro.monthly", willAutoRenew: true, renewalProductID: "pro.yearly")
+        )
+        // 예약 없는 상태로 덮어쓰면 캐시에서도 지워져야 한다
+        sut.setCachedSubscriptionStatus(
+            SubscriptionStatus(entitlement: .pro, productID: "pro.monthly", willAutoRenew: true, renewalProductID: nil)
+        )
+
+        #expect(sut.cachedSubscriptionStatus().renewalProductID == nil)
+    }
+}

Projects/DVDomain/Sources/Entity/SubscriptionStatus.swift

@@ -41,7 +41,8 @@ public struct SubscriptionStatus: Equatable, Sendable {
 
     /// 다음 갱신에 다른 플랜으로 바뀌도록 예약돼 있는지.
     public var hasPendingPlanChange: Bool {
-        guard let productID, let renewalProductID else { return false }
+        // 자동 갱신이 꺼져 있으면 갱신 자체가 없다 — autoRenewPreference가 남아 있어도 "변경 예약"이 아니라 만료다.
+        guard willAutoRenew, let productID, let renewalProductID else { return false }
         return renewalProductID != productID
     }
 

Projects/DVDomain/Sources/UseCase/Impl/Settings/ICloudSettingsUseCaseImpl.swift

@@ -31,8 +31,15 @@ public struct ICloudSettingsUseCaseImpl: ICloudSettingsUseCase {
     if enabled, !entitlementUseCase.canEnableICloudSync() {
       throw EntitlementError.requiresPro
     }
-    try await iCloudService.configureStorage(iCloudSyncEnabled: enabled)
-    repository.setICloudSyncEnabled(enabled)
+    guard enabled else {
+      // 끄기는 fail-safe: 전환이 실패해도 플래그를 먼저 false로 확정한다(실패가 "free인데 동기화"로 남지 않게).
+      repository.setICloudSyncEnabled(false)
+      try await iCloudService.configureStorage(iCloudSyncEnabled: false)
+      return
+    }
+    // 켜기는 fail-secure: 저장소 전환이 성공해야 플래그를 올린다(실패를 켜짐으로 오인 금지).
+    try await iCloudService.configureStorage(iCloudSyncEnabled: true)
+    repository.setICloudSyncEnabled(true)
   }
 
   public func accountStatus() async -> ICloudAccountStatus {

Projects/DVDomain/Tests/Core/Entity/SubscriptionStatusTests.swift

@@ -40,6 +40,17 @@ struct SubscriptionStatusTests {
         #expect(status.hasPendingPlanChange == false)
     }
 
+    @Test("자동 갱신이 꺼져 있으면 다음 갱신 상품이 달라도 변경 예약이 아니다(만료)")
+    func notPendingWhenAutoRenewOff() {
+        let status = SubscriptionStatus(
+            entitlement: .pro,
+            productID: "pro.monthly",
+            willAutoRenew: false,
+            renewalProductID: "pro.yearly"
+        )
+        #expect(status.hasPendingPlanChange == false)
+    }
+
     @Test("무료(현재 상품 없음)면 변경 예약이 아니다")
     func notPendingWhenFree() {
         #expect(SubscriptionStatus.free.hasPendingPlanChange == false)

Projects/DVDomain/Tests/Core/UseCase/Settings/ICloudSettingsUseCaseImplTests.swift

@@ -56,6 +56,26 @@ struct ICloudSettingsUseCaseImplTests {
         #expect(repository.isICloudSyncEnabled() == false)
     }
 
+    // 끄기는 fail-safe여야 한다: 저장소 전환이 실패해도 free가 계속 동기화되면 안 된다.
+    @Test("동기화 끄기: 저장소 전환이 실패해도 플래그는 false로 확정된다")
+    func disableForcesFlagOffEvenWhenStorageSwitchFails() async {
+        let repository = FakeSettingsRepository()
+        repository.setICloudSyncEnabled(true) // 이미 켜진 상태에서 다운그레이드
+        let sut = ICloudSettingsUseCaseImpl(
+            repository: repository,
+            iCloudService: StubICloudService(
+                status: .available,
+                configurationFails: true
+            ),
+            entitlementUseCase: StubEntitlementUseCase()
+        )
+
+        await #expect(throws: StubICloudService.Error.configurationFailed) {
+            try await sut.setEnabled(false)
+        }
+        #expect(repository.isICloudSyncEnabled() == false) // 전환 실패해도 플래그는 꺼짐
+    }
+
     @Test("iCloud 원격 변경 스트림을 Service에 위임한다")
     func remoteChangeStreamUsesService() async {
         let sut = ICloudSettingsUseCaseImpl(

Projects/DVPresentation/Resources/Localizable.xcstrings

@@ -4319,6 +4319,17 @@
         }
       }
     },
+    "Changes to %@ at your next renewal" : {
+      "comment" : "Subscription screen: a plan change is scheduled for the next renewal but the renewal date is unavailable. The argument is the upcoming plan name.",
+      "localizations" : {
+        "ko" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "다음 갱신부터 %@ 적용 예정"
+          }
+        }
+      }
+    },
     "Changes to %@ on %@" : {
       "comment" : "Shown on the subscription screen when the plan will switch to a different one at the next renewal. First argument is the upcoming plan name, second is the renewal date.",
       "localizations" : {

Projects/DVPresentation/Sources/Dependencies/App/AppLaunchClient.swift

@@ -20,6 +20,8 @@ public struct AppLaunchClient: Sendable {
     }
     /// 마지막 CloudKit 원격 변경 감지 시각을 저장한다.
     public var setICloudLastUpdateDetectedAt: @Sendable (Date) -> Void
+    /// 등급이 free로 내려갔을 때 호출한다. iCloud 동기화가 켜져 있으면 끈다(로컬 데이터는 유지, 미러링만 중단).
+    public var disableICloudSyncForDowngrade: @Sendable () async -> Void
 }
 
 extension AppLaunchClient: TestDependencyKey {
@@ -31,7 +33,8 @@ extension AppLaunchClient: TestDependencyKey {
         requestNotificationAuthorization: { true },
         syncExpiryNotifications: {},
         iCloudRemoteChangeStream: { AsyncStream { $0.finish() } },
-        setICloudLastUpdateDetectedAt: { _ in }
+        setICloudLastUpdateDetectedAt: { _ in },
+        disableICloudSyncForDowngrade: {}
     )
 }
 

Projects/DVPresentation/Sources/Features/AppFeature.swift

@@ -54,6 +54,7 @@ public struct AppFeature {
     case iCloudRemoteChangeDetected
     case iCloudRemoteChangeHandled
     case entitlementChanged
+    case entitlementSettledAtLaunch(isFree: Bool)
 
     // MARK: - Child
 
@@ -152,7 +153,18 @@ public struct AppFeature {
 
       case .entitlementChanged:
         // 등급이 바뀌면 만료 알림 시점 한도가 달라진다. 예약은 저장된 선택이 아니라 등급을 함께 보고 계산되므로, 다시 예약해야 강등 뒤에도 무료 한도가 지켜진다.
-        return .run { _ in await appLaunchClient.syncExpiryNotifications() }
+        return .merge(
+          .run { _ in await appLaunchClient.syncExpiryNotifications() },
+          // iCloud 동기화는 Pro 전용이라, free로 내려가면 자동으로 끈다(로컬 데이터는 유지, 미러링만 중단).
+          entitlementClient.current() == .free
+            ? .run { _ in await appLaunchClient.disableICloudSyncForDowngrade() }
+            : .none
+        )
+
+      case let .entitlementSettledAtLaunch(isFree):
+        // 앱 꺼진 사이 만료돼 free로 시작하면 여기서 동기화를 끈다(bootstrap이 stale .pro로 켜뒀어도 정리). Pro면 무시.
+        guard isFree else { return .none }
+        return .run { _ in await appLaunchClient.disableICloudSyncForDowngrade() }
 
       case .iCloudRemoteChangeHandled:
         guard state.main != nil else { return .none }
@@ -244,12 +256,14 @@ private extension AppFeature {
   func entitlementWatchEffect() -> Effect<Action> {
     .run { send in
       var isFirst = true
-      for await _ in entitlementClient.stream() {
-        guard !isFirst else {
+      for await entitlement in entitlementClient.stream() {
+        if isFirst {
           isFirst = false
-          continue
+          // 첫 방출은 알림 재동기화(.task가 이미 함)는 건너뛰되, 이미 free면 동기화 종료는 처리한다.
+          await send(.entitlementSettledAtLaunch(isFree: entitlement == .free))
+        } else {
+          await send(.entitlementChanged)
         }
-        await send(.entitlementChanged)
       }
     }
     .cancellable(id: CancelID.entitlementWatch, cancelInFlight: true)

Projects/DVPresentation/Sources/Features/Onboarding/OnboardingFeature.swift

@@ -26,6 +26,8 @@ public struct OnboardingFeature {
     public var step: Step = .welcome
     public var isEnablingSync = false
     @Presents var alert: AlertState<Action.Alert>?
+    /// free 사용자가 Enable Sync를 누르면 여기로 업그레이드 시트를 띄운다. 구매를 마치면 자동으로 동기화를 켠다.
+    @Presents var paywall: DevaultProPaywallFeature.State?
 
     public init(step: Step = .welcome) {
       self.step = step
@@ -58,10 +60,12 @@ public struct OnboardingFeature {
     case touchIDAuthFailed(UserAuthenticationError)
     case iCloudSyncStatusResponse(ICloudAccountStatus)
     case enableSyncCompleted
+    case entitlementRechecked
 
     // MARK: - Child
 
     case alert(PresentationAction<Alert>)
+    case paywall(PresentationAction<DevaultProPaywallFeature.Action>)
 
     // MARK: - Delegate
 
@@ -81,6 +85,8 @@ public struct OnboardingFeature {
   // MARK: - Dependencies
 
   @Dependency(\.onboardingClient) var onboardingClient
+  @Dependency(\.entitlementClient) var entitlementClient
+  @Dependency(\.purchaseClient) var purchaseClient
   @Dependency(\.continuousClock) var clock
 
   // MARK: - Init
@@ -122,15 +128,25 @@ public struct OnboardingFeature {
 
       case .didTapEnableSync:
         state.isEnablingSync = true
+        // 이미 Pro면(다른 기기 구독 포함 — 대개 실행 시 이미 반영됨) 페이월 없이 바로 켠다.
+        if entitlementClient.canEnableICloudSync() {
+          return enableICloudSyncEffect()
+        }
+        // 아직 free로 보이면 스토어에 한 번 더 물어 다른 기기 구독을 인식한 뒤 판정한다.
         return .run { send in
-          do {
-            let status = try await onboardingClient.enableICloudSync()
-            await send(.iCloudSyncStatusResponse(status))
-          } catch {
-            await send(.iCloudSyncStatusResponse(.configurationUnavailable))
-          }
+          await purchaseClient.refreshEntitlement()
+          await send(.entitlementRechecked)
         }
 
+      case .entitlementRechecked:
+        // 재조회 후에도 Pro가 아니면 진짜 free — 페이월을 띄운다. Pro면 그대로 켠다.
+        guard entitlementClient.canEnableICloudSync() else {
+          state.isEnablingSync = false
+          state.paywall = DevaultProPaywallFeature.State()
+          return .none
+        }
+        return enableICloudSyncEffect()
+
       case .iCloudSyncStatusResponse(let status):
         guard status == .available else {
           state.isEnablingSync = false
@@ -149,6 +165,16 @@ public struct OnboardingFeature {
           await send(.delegate(.completed))
         }
 
+      case .paywall(.presented(.delegate(.didFinish))):
+        // 구매/복원 성공 → 이제 Pro. 페이월을 닫고 자동으로 동기화를 켠다.
+        state.paywall = nil
+        guard entitlementClient.canEnableICloudSync() else { return .none }
+        state.isEnablingSync = true
+        return enableICloudSyncEffect()
+
+      case .paywall:
+        return .none
+
       case .alert(.presented(.retry)):
         return .send(.didTapEnableSync)
 
@@ -167,6 +193,9 @@ public struct OnboardingFeature {
       }
     }
     .ifLet(\.$alert, action: \.alert)
+    .ifLet(\.$paywall, action: \.paywall) {
+      DevaultProPaywallFeature()
+    }
   }
 }
 
@@ -187,6 +216,18 @@ private extension OnboardingFeature {
     )
   }
 
+  /// iCloud 계정 상태를 확인하고 동기화를 켠다. Pro가 확정된 뒤에만 호출한다(계정 미가용은 응답에서 알럿으로 처리).
+  func enableICloudSyncEffect() -> Effect<Action> {
+    .run { send in
+      do {
+        let status = try await onboardingClient.enableICloudSync()
+        await send(.iCloudSyncStatusResponse(status))
+      } catch {
+        await send(.iCloudSyncStatusResponse(.configurationUnavailable))
+      }
+    }
+  }
+
   func continueWithoutICloudEffect() -> Effect<Action> {
     .run { send in
       await onboardingClient.continueWithoutICloud()

Projects/DVPresentation/Sources/Features/Onboarding/OnboardingView.swift

@@ -25,6 +25,9 @@ public struct OnboardingView: View {
     content
       .dvScreenBackground()
       .alert($store.scope(state: \.alert, action: \.alert))
+      .sheet(item: $store.scope(state: \.paywall, action: \.paywall)) { paywallStore in
+        DevaultProPaywallView(store: paywallStore)
+      }
   }
 }
 

Projects/DVPresentation/Sources/Features/Settings/DevaultPro/DevaultProSettingsView.swift

@@ -137,12 +137,16 @@ extension DevaultProSettingsView {
   }
 
   private var renewalDescription: String? {
-    guard let renewsAt = store.subscriptionStatus.renewsAt else { return nil }
-    let dateText = renewsAt.formatted(date: .abbreviated, time: .omitted)
+    let dateText = store.subscriptionStatus.renewsAt?.formatted(date: .abbreviated, time: .omitted)
     // 변경 예약이 있으면(다음 갱신부터 다른 플랜) 그걸 우선 안내한다 — "현재는 1개월인데 3개월로 바꿨다"는 혼란을 없앤다.
+    // 갱신일이 없어도(드묾) 예약 사실 자체는 알려, 예약 안내가 날짜 유무에 가려지지 않게 한다.
     if let renewalPlanName = store.renewalPlanName {
+      guard let dateText else {
+        return String(format: String.module("Changes to %@ at your next renewal"), renewalPlanName)
+      }
       return String(format: String.module("Changes to %@ on %@"), renewalPlanName, dateText)
     }
+    guard let dateText else { return nil }
     return store.subscriptionStatus.willAutoRenew
       ? String(format: String.module("Renews on %@"), dateText)
       : String(format: String.module("Expires on %@"), dateText)