Using Tagged Types in SwiftData

[bradhowes]

I added an attribute to a SwiftData model that had a Tagged type with a raw type of Int. Everything compiled fine but during a context save, there is a sigabrt raised in Tagged.init(from decoder: Decoder) (line 74) with a log message "Could not cast value of type '__NSDictionaryM' (0x14402f3b8) to 'NSNumber' (0x1eae3f340)."

Here is my test model:

import Foundation
import SwiftData
import Tagged

public enum SchemaV1: VersionedSchema {
  public static var versionIdentifier: Schema.Version { .init(1, 0, 0) }

  public static var models: [any PersistentModel.Type] {
    [
      TaggedModel.self
    ]
  }
}

extension SchemaV1 {
  @Model
  public final class TaggedModel {
    public typealias Key = Tagged<TaggedModel, Int>

    public var key: Key
    public var name: String

    init(key: Key, name: String) {
      self.key = key
      self.name = name
    }
  }
}

And here is a simple test case that raises the error:

import ComposableArchitecture
import SwiftData
import Testing

@testable import Scratch

@MainActor
@Test func testCreatingTagged() throws {
  let schema = Schema(versionedSchema: SchemaV1.self)
  let config = ModelConfiguration(
    schema: schema,
    isStoredInMemoryOnly: true,
    groupContainer: .none,
    cloudKitDatabase: .none
  )

  let container = try ModelContainer(for: schema, migrationPlan: nil, configurations: config)
  let context = container.mainContext

  let m1 = SchemaV1.TaggedModel(key: .init(1), name: "Hello")
  context.insert(m1)
  try context.save() // <--- sigabrt raised here

  let found = try context.fetch(FetchDescriptor<SchemaV1.TaggedModel>())
  #expect(found.count == 1)
}

As a work-around for now, I'm saving the raw value and and exposing a computed property that returns a proper Tagged value.

[Aayush9029]

I'm running into the same issue where I get

*** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: 'Unexpected or improperly formatted UUID parameter with type __NSDictionaryM, expected NSUUID or well-formed NSString'

Also, using the computed taggedID and comparing the Predicate's .id to the .rawValue of taggedID works around this, which is not ideal.

@Model
final class Note {  ... }

extension Note {
    var taggedID: Tagged<Note, UUID> { .init(id) }
    public typealias Id = Tagged<Note, UUID>
}

---

As expected, SwiftData doesn't complain when using Tagged ID on Codable data!

enum NoteContent: Codable, Identifiable, Equatable { ... }

extension NoteContent {
    var id: Id { ... }
    typealias Id = Tagged<NoteContent, String>
}

[mbrandonw]

Hi @bradhowes and @Aayush9029, I don't believe you can just stick any kind of data into a Swift Data model. It has to be a subset of types that Swift Data / Core Data understands. Have either of you tried using value transformers to turn a Tagged value into something that Swift Data understands? Here are some docs.

[Aayush9029]

I remember trying to create a transformer by encoding and decoding a UUID string, but I ran into a runtime SwiftData bug.

Don't have the exact code in hand atm, however it was

TaggedUUIDTransformer<T>: ValueTransformer { ... }

Registering on @main's init(){} and using @Attribute(.transformable... on the Item's ID.

Could most definitely be due to lack of knowledge.

[bradhowes]

According to the (meager) SwiftData docs, "By default, SwiftData includes all noncomputed properties of a class as long as they use compatible types. The framework supports primitive types such as Bool, Int, and String, as well as complex value types such as structures, enumerations, and other value types that conform to the Codable protocol."

So I would assume that Tagged would be supported since it has both Encodable and Decodable conformances. However I posted as a discussion topic and not as an issue because it is not entirely clear if a Tagged value should be compatible with SwiftData. Regardless, I have a work-around for my use-case that is not too cumbersome.