@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftData/PersistentModel.swift

@@ -0,0 +1,238 @@
+// A persistent model and the data behind it. `@Model` turns each persisted
+// property into accessors over the model's `_ModelBacking`, which holds the
+// property values: live Swift values once set or read, or the JSON a record
+// was stored with until a property is first read (decoding is lazy, so a
+// fetch does not decode what a screen never shows, and a related model is
+// looked up only when the relationship is followed).
+
+import Foundation
+import Observation
+import SwiftUI
+
+public protocol PersistentModel: AnyObject, Observable, Hashable, Identifiable, _RelationshipValue {
+    /// The values behind the model's persisted properties.
+    var persistentBackingData: _ModelBacking { get set }
+    /// The persisted properties, as `@Model` describes them.
+    static var schemaMetadata: [Schema.PropertyMetadata] { get }
+    /// Creates a model over existing data; a context does this to
+    /// materialize a stored record.
+    init(backingData: _ModelBacking)
+    var _$observationRegistrar: ObservationRegistrar { get }
+}
+
+/// The type of the placeholder peers `@Model` adds next to each persisted
+/// property, so that definite initialization still requires the class's
+/// initializers to give every persisted property a value.
+public struct _SwiftDataNoType {
+    public init() {}
+}
+
+/// The identity of a model: its entity and its record in a store.
+public struct PersistentIdentifier: Hashable, Comparable, Codable, Sendable, CustomStringConvertible {
+    public let entityName: String
+    /// The store the model was saved to; nil until it is inserted.
+    public let storeIdentifier: String?
+    let primaryKey: Int64
+
+    init(entityName: String, storeIdentifier: String?, primaryKey: Int64) {
+        self.entityName = entityName
+        self.storeIdentifier = storeIdentifier
+        self.primaryKey = primaryKey
+    }
+
+    public static func == (lhs: PersistentIdentifier, rhs: PersistentIdentifier) -> Bool {
+        lhs.primaryKey == rhs.primaryKey && lhs.entityName == rhs.entityName
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(entityName)
+        hasher.combine(primaryKey)
+    }
+
+    public static func < (lhs: PersistentIdentifier, rhs: PersistentIdentifier) -> Bool {
+        (lhs.primaryKey, lhs.entityName) < (rhs.primaryKey, rhs.entityName)
+    }
+
+    public var description: String { "\(entityName)/\(primaryKey)" }
+}
+
+/// One property's value in a model's backing data.
+enum _Slot {
+    /// A Swift value of the property's type.
+    case live(Any)
+    /// The JSON of a stored record, decoded at first read.
+    case stored(_JSON)
+}
+
+/// The data behind a model: its property values, identity and context.
+public final class _ModelBacking {
+    let modelType: any PersistentModel.Type
+    var slots: [String: _Slot] = [:]
+    /// Assigned when the model is first identified (hashed, inserted).
+    var primaryKey: Int64?
+    var storeIdentifier: String?
+    weak var context: ModelContext?
+    var isDeleted = false
+
+    public init<Model: PersistentModel>(for type: Model.Type) {
+        modelType = type
+    }
+
+    init(type: any PersistentModel.Type, primaryKey: Int64, storeIdentifier: String, stored values: [String: _JSON]) {
+        modelType = type
+        self.primaryKey = primaryKey
+        self.storeIdentifier = storeIdentifier
+        for (key, value) in values { slots[key] = .stored(value) }
+    }
+
+    /// Resolved on first use: a model's initial values may themselves create
+    /// models, so the entity is not looked up while the model initializes.
+    lazy var entity: _Entity = _Entity.of(modelType)
+
+    var identifier: PersistentIdentifier {
+        if primaryKey == nil { primaryKey = _Store.allocatePrimaryKey() }
+        return PersistentIdentifier(entityName: entity.name, storeIdentifier: storeIdentifier, primaryKey: primaryKey!)
+    }
+
+    /// Called by a persisted property's `init` accessor.
+    public func _setInitialValue<Value>(_ value: Value, forKey key: String) {
+        slots[key] = .live(value)
+    }
+
+    /// The property's value as a Swift value, decoding a stored one.
+    func value(of property: _Property) -> Any {
+        switch slots[property.name] {
+        case .live(let value)?:
+            return value
+        case .stored(let json)?:
+            let value = decode(json, for: property)
+            slots[property.name] = .live(value)
+            return value
+        case nil:
+            if let initial = property.defaultValue { return initial }
+            if property.isRelationship { return property.make([]) }
+            if property.isOptional, let none = try? property.decode(.null) { return none }
+            fatalError("SwiftData: this \(entity.name) has no value for \(property.name), a property added without an initial value. Give it one, or clear the app's data.")
+        }
+    }
+
+    private func decode(_ json: _JSON, for property: _Property) -> Any {
+        switch property.kind {
+        case .attribute:
+            do {
+                return try property.decode(json)
+            } catch {
+                if let initial = property.defaultValue { return initial }
+                fatalError("SwiftData: cannot read \(entity.name).\(property.name) from \(json.serialized): \(error)")
+            }
+        case .toOne, .toMany:
+            let keys: [Int64] = switch json {
+            case .number(let n): [Int64(n)]
+            case .array(let items): items.compactMap { if case .number(let n) = $0 { Int64(n) } else { nil } }
+            default: []
+            }
+            let models = keys.compactMap { context?._model(primaryKey: $0, type: property.relatedType!) }
+            return property.make(models)
+        }
+    }
+
+    /// The JSON of a property's current value, for a record.
+    func json(of property: _Property) -> _JSON {
+        switch slots[property.name] {
+        case .stored(let json)?:
+            return json
+        case .live(let value)?:
+            switch property.kind {
+            case .attribute:
+                return property.encode(value)
+            case .toOne:
+                let keys = property.models(value).compactMap { $0.persistentBackingData.savedKey }
+                return keys.first.map { .number(Double($0)) } ?? .null
+            case .toMany:
+                return .array(property.models(value).compactMap { $0.persistentBackingData.savedKey.map { .number(Double($0)) } })
+            }
+        case nil:
+            if let initial = property.defaultValue, property.kind == .attribute { return property.encode(initial) }
+            return property.kind == .toMany ? .array([]) : .null
+        }
+    }
+
+    /// The key a relationship stores for this model: none once it is deleted
+    /// or when it belongs to no context.
+    private var savedKey: Int64? {
+        guard !isDeleted, context != nil else { return nil }
+        return primaryKey
+    }
+
+    /// The models a relationship currently holds.
+    func relatedModels(_ property: _Property) -> [any PersistentModel] {
+        property.models(value(of: property))
+    }
+}
+
+extension PersistentModel {
+    public var persistentModelID: PersistentIdentifier { persistentBackingData.identifier }
+
+    public var id: PersistentIdentifier { persistentModelID }
+
+    /// The context the model was inserted into or fetched from.
+    public var modelContext: ModelContext? { persistentBackingData.context }
+
+    /// Whether the model was deleted from its context.
+    public var isDeleted: Bool { persistentBackingData.isDeleted }
+
+    /// Whether the model has changes its context has not saved.
+    public var hasChanges: Bool {
+        guard let context = persistentBackingData.context else { return false }
+        return context._hasChanges(persistentModelID)
+    }
+
+    public static func == (lhs: Self, rhs: Self) -> Bool {
+        lhs === rhs || lhs.persistentModelID == rhs.persistentModelID
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(persistentModelID)
+    }
+
+    // MARK: Accessors
+
+    /// A persisted property's value (called by the property's getter).
+    public func _$getValue<Value>(forKey key: String) -> Value {
+        let backing = persistentBackingData
+        guard let property = backing.entity.property(key) else {
+            if case .live(let value)? = backing.slots[key] { return value as! Value }
+            fatalError("SwiftData: \(Self.self) has no persisted property \(key)")
+        }
+        return backing.value(of: property) as! Value
+    }
+
+    /// Sets a persisted property (called by the property's setter). A
+    /// relationship keeps its inverse in step and brings the models it now
+    /// holds into the model's context.
+    public func _$setValue<Value>(_ value: Value, forKey key: String) {
+        let backing = persistentBackingData
+        guard let context = backing.context, !backing.isDeleted, let property = backing.entity.property(key) else {
+            backing.slots[key] = .live(value)
+            return
+        }
+        if property.isRelationship {
+            let old = backing.relatedModels(property)
+            backing.slots[key] = .live(value)
+            context._relationship(property, of: self, changedFrom: old, to: property.models(value))
+        } else {
+            backing.slots[key] = .live(value)
+        }
+        context._modelDidChange(self)
+    }
+
+    /// A persisted property's value, by key path.
+    public func getValue<Value>(forKey keyPath: KeyPath<Self, Value>) -> Value {
+        self[keyPath: keyPath]
+    }
+
+    /// Sets a persisted property, by key path.
+    public func setValue<Value>(forKey keyPath: ReferenceWritableKeyPath<Self, Value>, to value: Value) {
+        self[keyPath: keyPath] = value
+    }
+}

package/Sources/SwiftData/Properties.swift

@@ -0,0 +1,261 @@
+// What the store knows about each persisted property, worked out once per
+// model type from `@Model`'s generated `schemaMetadata`, where each
+// property's static type is still known: how to encode and decode its value,
+// whether it relates to other models, and how to notify its observers.
+
+import Foundation
+import Observation
+import SwiftUI
+
+/// A value of a relationship property: a model, an optional model, or an
+/// array (optional or not) or set of models.
+public protocol _RelationshipValue {
+    static var _relatedType: any PersistentModel.Type { get }
+    static var _isToMany: Bool { get }
+    var _relatedModels: [any PersistentModel] { get }
+    static func _make(_ models: [any PersistentModel]) -> Self
+}
+
+extension PersistentModel {
+    public static var _relatedType: any PersistentModel.Type { Self.self }
+    public static var _isToMany: Bool { false }
+    public var _relatedModels: [any PersistentModel] { [self] }
+    public static func _make(_ models: [any PersistentModel]) -> Self {
+        guard let model = models.first else {
+            fatalError("SwiftData: the non-optional relationship to \(Self.self) has no model")
+        }
+        return model as! Self
+    }
+}
+
+extension Optional: _RelationshipValue where Wrapped: _RelationshipValue {
+    public static var _relatedType: any PersistentModel.Type { Wrapped._relatedType }
+    public static var _isToMany: Bool { Wrapped._isToMany }
+    public var _relatedModels: [any PersistentModel] { self?._relatedModels ?? [] }
+    public static func _make(_ models: [any PersistentModel]) -> Self {
+        if !Wrapped._isToMany, models.isEmpty { return nil }
+        return Wrapped._make(models)
+    }
+}
+
+extension Array: _RelationshipValue where Element: PersistentModel {
+    public static var _relatedType: any PersistentModel.Type { Element.self }
+    public static var _isToMany: Bool { true }
+    public var _relatedModels: [any PersistentModel] { map { $0 } }
+    public static func _make(_ models: [any PersistentModel]) -> Self { models.map { $0 as! Element } }
+}
+
+extension Set: _RelationshipValue where Element: PersistentModel {
+    public static var _relatedType: any PersistentModel.Type { Element.self }
+    public static var _isToMany: Bool { true }
+    public var _relatedModels: [any PersistentModel] { map { $0 } }
+    public static func _make(_ models: [any PersistentModel]) -> Self { Set(models.map { $0 as! Element }) }
+}
+
+/// Optionals of attribute values: nil travels as JSON `null`.
+protocol _AnyOptional {
+    static var _none: Any { get }
+    static func _unwrap(_ value: Any) -> Any?
+    static func _decodeWrapped(_ json: _JSON) throws -> Any
+}
+
+extension Optional: _AnyOptional {
+    static var _none: Any { Optional<Wrapped>.none as Any }
+    static func _unwrap(_ value: Any) -> Any? { (value as! Wrapped?).map { $0 as Any } }
+    static func _decodeWrapped(_ json: _JSON) throws -> Any {
+        let wrapped: Wrapped = try _decodeAttribute(json)
+        return Optional(wrapped) as Any
+    }
+}
+
+final class _Property {
+    enum Kind { case attribute, toOne, toMany }
+
+    let name: String
+    let keyPath: AnyKeyPath
+    let kind: Kind
+    /// The model type a relationship points at.
+    let relatedType: (any PersistentModel.Type)?
+    let attribute: Schema.Attribute?
+    let relationship: Schema.Relationship?
+    let isOptional: Bool
+    let hasDefault: Bool
+
+    /// The initial value (`= …` in the class), typed as the property.
+    let defaultValue: Any?
+    /// Encodes a value of the property (an attribute; relationships store ids).
+    let encode: (Any) -> _JSON
+    /// Decodes a stored attribute value.
+    let decode: (_JSON) throws -> Any
+    /// A relationship value from its models.
+    let make: ([any PersistentModel]) -> Any
+    /// The models a relationship value holds.
+    let models: (Any) -> [any PersistentModel]
+    /// Tells the property's observers on `model` that it changed.
+    let notify: (AnyObject) -> Void
+
+    init<Model: PersistentModel, Value>(name: String, keyPath: KeyPath<Model, Value>, defaultValue: Value?, metadata: Any?) {
+        self.name = name
+        self.keyPath = keyPath
+        attribute = metadata as? Schema.Attribute
+        relationship = metadata as? Schema.Relationship
+        isOptional = Value.self is any _AnyOptional.Type
+        hasDefault = defaultValue != nil
+        self.defaultValue = defaultValue.map { $0 as Any }
+        if let relation = Value.self as? any _RelationshipValue.Type {
+            kind = relation._isToMany ? .toMany : .toOne
+            relatedType = relation._relatedType
+            make = { models in relation._make(models) }
+            models = { value in (value as! any _RelationshipValue)._relatedModels }
+        } else {
+            kind = .attribute
+            relatedType = nil
+            make = { _ in fatalError("SwiftData: \(name) is not a relationship") }
+            models = { _ in [] }
+        }
+        encode = { value in _encodeAttribute(value as! Value) }
+        decode = { json in try _decodeAttribute(json) as Value }
+        notify = { object in
+            let model = object as! Model
+            model._$observationRegistrar.withMutation(of: model, keyPath: keyPath) {}
+        }
+    }
+
+    var isRelationship: Bool { kind != .attribute }
+    var deleteRule: Schema.Relationship.DeleteRule { relationship?.deleteRule ?? .nullify }
+    var isUnique: Bool { attribute?.isUnique ?? false }
+}
+
+// MARK: - Attribute values
+
+/// The JSON an attribute value is stored as: strings, numbers and booleans as
+/// themselves, `Date` as seconds since 1970, nil as `null`, anything else
+/// `Codable` as `JSONEncoder` writes it (dates inside it as seconds since 1970).
+func _encodeAttribute<Value>(_ value: Value) -> _JSON {
+    if let optional = Value.self as? any _AnyOptional.Type {
+        guard let wrapped = optional._unwrap(value) else { return .null }
+        return _encodeAny(wrapped)
+    }
+    return _encodeAny(value)
+}
+
+private func _encodeAny(_ value: Any) -> _JSON {
+    switch value {
+    case let v as String: return .string(v)
+    case let v as Bool: return .bool(v)
+    case let v as Int: return .number(Double(v))
+    case let v as Double: return .number(v)
+    case let v as Date: return .number(v.timeIntervalSince1970)
+    default: break
+    }
+    guard let encodable = value as? any Encodable else {
+        print("[SwiftData] cannot save a value of type \(type(of: value)); make it Codable")
+        return .null
+    }
+    do {
+        let data = try _jsonEncoder.encode(encodable)
+        return try _JSON.parse(String(decoding: data, as: UTF8.self))
+    } catch {
+        print("[SwiftData] cannot encode \(type(of: value)): \(error)")
+        return .null
+    }
+}
+
+func _decodeAttribute<Value>(_ json: _JSON) throws -> Value {
+    if let optional = Value.self as? any _AnyOptional.Type {
+        if json == .null { return optional._none as! Value }
+        return try optional._decodeWrapped(json) as! Value
+    }
+    switch json {
+    case .string(let s) where Value.self == String.self: return s as! Value
+    case .bool(let b) where Value.self == Bool.self: return b as! Value
+    case .number(let n) where Value.self == Int.self && n == n.rounded(): return Int(n) as! Value
+    case .number(let n) where Value.self == Double.self: return n as! Value
+    case .number(let n) where Value.self == Date.self: return Date(timeIntervalSince1970: n) as! Value
+    default: break
+    }
+    guard let decodable = Value.self as? any Decodable.Type else {
+        throw SwiftDataError(._decodeFailed, "\(Value.self) is not Decodable")
+    }
+    let decoded = try _jsonDecoder.decode(decodable, from: Data(json.serialized.utf8))
+    return decoded as! Value
+}
+
+nonisolated(unsafe) private let _jsonEncoder: JSONEncoder = {
+    let encoder = JSONEncoder()
+    encoder.dateEncodingStrategy = .secondsSince1970
+    encoder.outputFormatting = [.sortedKeys]
+    return encoder
+}()
+
+nonisolated(unsafe) private let _jsonDecoder: JSONDecoder = {
+    let decoder = JSONDecoder()
+    decoder.dateDecodingStrategy = .secondsSince1970
+    return decoder
+}()
+
+// MARK: - Entities
+
+/// A model type's persisted properties, in declaration order.
+final class _Entity {
+    let name: String
+    let type: any PersistentModel.Type
+    let properties: [Schema.PropertyMetadata]
+    private let byName: [String: _Property]
+    private let byKeyPath: [AnyKeyPath: _Property]
+    let relationships: [_Property]
+    let uniqueAttributes: [_Property]
+    private var inverses: [String: _Property?] = [:]
+
+    private init(type: any PersistentModel.Type) {
+        self.type = type
+        name = String(describing: type)
+        properties = type.schemaMetadata
+        byName = Dictionary(properties.map { ($0.name, $0.property) }, uniquingKeysWith: { first, _ in first })
+        byKeyPath = Dictionary(properties.map { ($0.keypath, $0.property) }, uniquingKeysWith: { first, _ in first })
+        relationships = properties.map(\.property).filter(\.isRelationship)
+        uniqueAttributes = properties.map(\.property).filter(\.isUnique)
+    }
+
+    nonisolated(unsafe) private static var byType: [ObjectIdentifier: _Entity] = [:]
+    nonisolated(unsafe) private(set) static var byEntityName: [String: _Entity] = [:]
+
+    static func of(_ type: any PersistentModel.Type) -> _Entity {
+        let key = ObjectIdentifier(type)
+        if let known = byType[key] { return known }
+        let entity = _Entity(type: type)
+        byType[key] = entity
+        if byEntityName[entity.name] == nil { byEntityName[entity.name] = entity }
+        return entity
+    }
+
+    func property(_ name: String) -> _Property? { byName[name] }
+    func property(_ keyPath: AnyKeyPath) -> _Property? { byKeyPath[keyPath] }
+
+    /// The property on the related type that mirrors `property`: the one
+    /// `@Relationship(inverse:)` names (on either side), else the only
+    /// relationship of the related type that points back at this type.
+    func inverse(of property: _Property) -> _Property? {
+        if let known = inverses[property.name] { return known }
+        let found = findInverse(of: property)
+        inverses[property.name] = .some(found)
+        return found
+    }
+
+    private func findInverse(of property: _Property) -> _Property? {
+        guard let relatedType = property.relatedType else { return nil }
+        let target = _Entity.of(relatedType)
+        if let keyPath = property.relationship?.inverseKeyPath {
+            return target.property(keyPath)
+        }
+        if let declared = target.relationships.first(where: { $0.relationship?.inverseKeyPath == property.keyPath }) {
+            return declared
+        }
+        let candidates = target.relationships.filter { candidate in
+            candidate !== property
+                && candidate.relatedType.map { ObjectIdentifier($0) == ObjectIdentifier(type) } == true
+                && candidate.relationship?.inverseKeyPath == nil
+        }
+        return candidates.count == 1 ? candidates[0] : nil
+    }
+}