Using Tagged with TCA Shared

[bradhowes]

Hi all, is there any way to have a Tagged type used in TCA @Shared(.appStorage) attribute? I am unable to get to a type that appStorage can handle. I can do so with UUID, but when it is embedded in Tagged, even though Tagged conforms to RawRepresentable, compile fails with "No exact matches in call to static method 'appStorage'".

In the code below, UUID works, but not Tagged<..., UUID>.

import ComposableArchitecture
import Foundation
import Tagged

extension PersistenceReaderKey where Self == AppStorageKey<UUID> {
  public static var uuidKey: Self { appStorage("uuidKey") }
}

extension PersistenceReaderKey where Self == PersistenceKeyDefault<AppStorageKey<UUID>> {
  public static var uuidKey: Self { PersistenceKeyDefault(.uuidKey, .init(0)) }
}

extension UUID : @retroactive RawRepresentable {
  public var rawValue: String { self.uuidString }

  public init?(rawValue: String) {
    if let value = UUID(uuidString: rawValue) {
      self = value
    } else {
      return nil
    }
  }
}

struct Foo {}
typealias FooKey = Tagged<Foo, UUID>

extension PersistenceReaderKey where Self == AppStorageKey<FooKey> {
  static var fooKey: Self { appStorage("fooKey") }
}

extension PersistenceReaderKey where Self == PersistenceKeyDefault<AppStorageKey<FooKey>> {
  static var fooKey: Self { PersistenceKeyDefault(.fooKey, .init(.init(0))) }
}

[bradhowes]

After some playing around, I was able to build a wrapper that seems to do the job:

public struct Foo {}
public typealias FooKey = Tagged<Foo, UUID>

public struct CustomAppStorageKey<Value: Sendable, Stored: Sendable> : Sendable {
  private let wrapped: AppStorageKey<Stored>
  private let encoder: @Sendable (Value) -> Stored
  private let decoder: @Sendable (Stored) -> Value

  public init(
    _ wrapped: AppStorageKey<Stored>,
    encoder: @escaping @Sendable (Value)-> Stored,
    decoder: @escaping @Sendable (Stored) -> Value
  ) {
    self.wrapped = wrapped
    self.encoder = encoder
    self.decoder = decoder
  }
}

extension PersistenceReaderKey where Self == CustomAppStorageKey<FooKey, UUID> {
  public static var fooKey: Self {
    return CustomAppStorageKey<FooKey, UUID>(
      .appStorage("fooKey"),
      encoder: { $0.rawValue },
      decoder: { .init(rawValue: $0) }
    )
  }
}

extension PersistenceReaderKey where Self == PersistenceKeyDefault<CustomAppStorageKey<FooKey, UUID>> {
  public static var fooKey: Self { PersistenceKeyDefault(.fooKey, .init(.init(0))) }
}

extension CustomAppStorageKey : PersistenceKey {
  public var id: AnyHashable { wrapped.id }

  public func load(initialValue: Value?) -> Value? {
    wrapped.load(initialValue: initialValue.flatMap(encoder)).flatMap(decoder)
  }

  public func save(_ value: Value) {
    wrapped.save(encoder(value))
  }

  public func subscribe(
    initialValue: Value?,
    didSet: @escaping @Sendable (_ newValue: Value?) -> Void
  ) -> Shared<Value>.Subscription {
    let subscription = wrapped.subscribe(initialValue: initialValue.flatMap(encoder)) { newValue in
      didSet(newValue.flatMap(decoder))
    }
    return Shared<Value>.Subscription {
      subscription.cancel()
    }
  }
}

[bradhowes]

And an alternative for Codable types:

public struct CodableAppStorageKey<Value: Sendable & Codable> : Sendable {
  private let wrapped: AppStorageKey<Data>

  public init(_ wrapped: AppStorageKey<Data>) {
    self.wrapped = wrapped
  }
}

extension CodableAppStorageKey : PersistenceKey {
  public var id: AnyHashable { wrapped.id }

  public func load(initialValue: Value?) -> Value? {
    wrapped.load(initialValue: initialValue.flatMap(Self.encoder)).flatMap(Self.decoder)
  }

  public func save(_ value: Value) {
    wrapped.save(Self.encoder(value))
  }

  public func subscribe(
    initialValue: Value?,
    didSet: @escaping @Sendable (_ newValue: Value?) -> Void
  ) -> Shared<Value>.Subscription {
    let subscription = wrapped.subscribe(initialValue: initialValue.flatMap(Self.encoder)) { newValue in
      didSet(newValue.flatMap(Self.decoder))
    }
    return Shared<Value>.Subscription {
      subscription.cancel()
    }
  }
}

extension CodableAppStorageKey {

  private static func encoder(_ value: Value) -> Data {
    (try? JSONEncoder().encode(value)) ?? Data()
  }

  private static func decoder(_ value: Data) -> Value? {
    try? JSONDecoder().decode(Value.self, from: value)
  }
}