@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftData/Query.swift

@@ -0,0 +1,256 @@
+// SwiftData in views: `@Query`, the `modelContext` environment value and the
+// `.modelContainer` / `.modelContext` modifiers for views and scenes.
+
+import Foundation
+import Observation
+import SwiftUI
+
+/// What to fetch: a predicate, a sort order and a window of the results.
+public struct FetchDescriptor<T: PersistentModel> {
+    public var predicate: Predicate<T>?
+    public var sortBy: [SortDescriptor<T>]
+    public var fetchLimit: Int?
+    public var fetchOffset: Int?
+    public var includePendingChanges = true
+    public var propertiesToFetch: [PartialKeyPath<T>] = []
+    public var relationshipKeyPathsForPrefetching: [PartialKeyPath<T>] = []
+
+    public init(predicate: Predicate<T>? = nil, sortBy: [SortDescriptor<T>] = []) {
+        self.predicate = predicate
+        self.sortBy = sortBy
+    }
+}
+
+// MARK: - Environment
+
+private enum _ModelContextKey: EnvironmentKey {
+    static var defaultValue: ModelContext { _ModelContextFallback.context }
+}
+
+/// What `modelContext` is outside any `.modelContainer`: an empty in-memory
+/// container's context, as in SwiftUI.
+@MainActor
+enum _ModelContextFallback {
+    nonisolated(unsafe) private static var shared: ModelContext?
+
+    nonisolated static var context: ModelContext {
+        if let shared { return shared }
+        let container = try! ModelContainer(for: Schema([]), configurations: [ModelConfiguration(isStoredInMemoryOnly: true)])
+        let context = ModelContext(container)
+        shared = context
+        return context
+    }
+}
+
+extension EnvironmentValues {
+    /// The context `@Query` fetches from and views insert into.
+    public var modelContext: ModelContext {
+        get { self[_ModelContextKey.self] }
+        set { self[_ModelContextKey.self] = newValue }
+    }
+}
+
+// MARK: - @Query
+
+/// The models a fetch returns, kept current: the view re-runs when its
+/// context changes (an insert, a delete, a property set, a save).
+///
+/// `Result` is always `[Element]`; tying the two lets `@Query var books: [Book]`
+/// declare the wrapper with no initial value and assign it in `init`.
+@propertyWrapper
+public struct Query<Element: PersistentModel, Result>: DynamicProperty where Result: Sequence, Result.Element == Element {
+    let descriptor: FetchDescriptor<Element>
+    let animation: Animation?
+    let box = _QueryBox<Element>()
+
+    init(descriptor: FetchDescriptor<Element>, animation: Animation?) {
+        self.descriptor = descriptor
+        self.animation = animation
+    }
+
+    /// Every model of the type, unsorted. Declared here, without a
+    /// constraint, so that `@Query var items: [Item]` gives a view's
+    /// memberwise initializer a default for `items`, as Apple's does.
+    public init() {
+        self.init(descriptor: FetchDescriptor(), animation: nil)
+    }
+
+    public var wrappedValue: Result { box.results(for: descriptor) as! Result }
+
+    /// The error of the last fetch, if it failed.
+    public var fetchError: (any Error)? { box.error }
+
+    /// The context the query fetches from.
+    public var modelContext: ModelContext { box.context ?? _ModelContextFallback.context }
+}
+
+extension Query: _EnvironmentReading {
+    public func _resolve(in environment: EnvironmentValues) {
+        box.context = environment.modelContext
+    }
+}
+
+extension Query where Result == [Element] {
+
+    public init(_ descriptor: FetchDescriptor<Element>, animation: Animation = .default) {
+        self.init(descriptor: descriptor, animation: animation)
+    }
+
+    public init(_ descriptor: FetchDescriptor<Element>, transaction: Transaction?) {
+        self.init(descriptor: descriptor, animation: nil)
+    }
+
+    public init(filter: Predicate<Element>? = nil, sort: [SortDescriptor<Element>] = [], animation: Animation = .default) {
+        self.init(descriptor: FetchDescriptor(predicate: filter, sortBy: sort), animation: animation)
+    }
+
+    public init(filter: Predicate<Element>? = nil, sort: [SortDescriptor<Element>] = [], transaction: Transaction?) {
+        self.init(descriptor: FetchDescriptor(predicate: filter, sortBy: sort), animation: nil)
+    }
+
+    public init(filter: Predicate<Element>? = nil, sort: SortDescriptor<Element>, animation: Animation = .default) {
+        self.init(descriptor: FetchDescriptor(predicate: filter, sortBy: [sort]), animation: animation)
+    }
+
+    public init<Value: Comparable>(filter: Predicate<Element>? = nil, sort keyPath: any KeyPath<Element, Value> & Sendable, order: SortOrder = .forward, animation: Animation = .default) {
+        self.init(descriptor: FetchDescriptor(predicate: filter, sortBy: [SortDescriptor(keyPath, order: order)]), animation: animation)
+    }
+
+    public init<Value: Comparable>(filter: Predicate<Element>? = nil, sort keyPath: any KeyPath<Element, Value?> & Sendable, order: SortOrder = .forward, animation: Animation = .default) {
+        self.init(descriptor: FetchDescriptor(predicate: filter, sortBy: [SortDescriptor(keyPath, order: order)]), animation: animation)
+    }
+
+    public init<Value: Comparable>(filter: Predicate<Element>? = nil, sort keyPath: any KeyPath<Element, Value> & Sendable, order: SortOrder = .forward, transaction: Transaction?) {
+        self.init(descriptor: FetchDescriptor(predicate: filter, sortBy: [SortDescriptor(keyPath, order: order)]), animation: nil)
+    }
+}
+
+/// A query's context and its last results, which stay valid until the
+/// context changes.
+public final class _QueryBox<Element: PersistentModel> {
+    var context: ModelContext?
+    var error: (any Error)?
+    private var cached: [Element]?
+    private weak var cachedContext: ModelContext?
+    private var cachedGeneration = -1
+
+    func results(for descriptor: FetchDescriptor<Element>) -> [Element] {
+        let context = context ?? _ModelContextFallback.context
+        // Reading the generation makes the view's body depend on the context.
+        let generation = context.signal.generation
+        if let cached, cachedContext === context, cachedGeneration == generation { return cached }
+        let results: [Element]
+        do {
+            results = try context.fetch(descriptor)
+            error = nil
+        } catch {
+            self.error = error
+            results = []
+        }
+        cached = results
+        cachedContext = context
+        cachedGeneration = generation
+        return results
+    }
+}
+
+// MARK: - Modifiers
+
+/// Puts a container's main context into the environment.
+struct _ModelContainerModifier: ViewModifier {
+    let context: ModelContext
+
+    func body(content: Content) -> some View {
+        content.environment(\.modelContext, context)
+    }
+}
+
+/// The containers `.modelContainer(for:)` made, so that a body that runs
+/// again gets the same container.
+@MainActor
+enum _ModifierContainers {
+    private static var made: [String: ModelContainer] = [:]
+
+    static func container(for types: [any PersistentModel.Type], inMemory: Bool, autosave: Bool,
+                          onSetup: (Result<ModelContainer, any Error>) -> Void) -> ModelContainer {
+        let key = types.map { String(reflecting: $0) }.sorted().joined(separator: ",") + (inMemory ? "|memory" : "")
+        if let container = made[key] { return container }
+        let container: ModelContainer
+        do {
+            container = try ModelContainer(for: Schema(types), configurations: [ModelConfiguration(isStoredInMemoryOnly: inMemory)])
+            onSetup(.success(container))
+        } catch {
+            onSetup(.failure(error))
+            container = try! ModelContainer(for: Schema(types), configurations: [ModelConfiguration(isStoredInMemoryOnly: true)])
+        }
+        container.mainContext.autosaveEnabled = autosave
+        made[key] = container
+        return container
+    }
+}
+
+extension View {
+    /// Supplies the container's main context to the views below.
+    public func modelContainer(_ container: ModelContainer) -> some View {
+        modifier(_ModelContainerModifier(context: container.mainContext))
+    }
+
+    /// Supplies a container for these model types (made once) to the views below.
+    public func modelContainer(
+        for modelType: any PersistentModel.Type,
+        inMemory: Bool = false,
+        isAutosaveEnabled: Bool = true,
+        isUndoEnabled: Bool = false,
+        onSetup: @escaping (Result<ModelContainer, any Error>) -> Void = { _ in }
+    ) -> some View {
+        modelContainer(_ModifierContainers.container(for: [modelType], inMemory: inMemory, autosave: isAutosaveEnabled, onSetup: onSetup))
+    }
+
+    public func modelContainer(
+        for modelTypes: [any PersistentModel.Type],
+        inMemory: Bool = false,
+        isAutosaveEnabled: Bool = true,
+        isUndoEnabled: Bool = false,
+        onSetup: @escaping (Result<ModelContainer, any Error>) -> Void = { _ in }
+    ) -> some View {
+        modelContainer(_ModifierContainers.container(for: modelTypes, inMemory: inMemory, autosave: isAutosaveEnabled, onSetup: onSetup))
+    }
+
+    /// Supplies a context to the views below.
+    public func modelContext(_ modelContext: ModelContext) -> some View {
+        modifier(_ModelContainerModifier(context: modelContext))
+    }
+}
+
+extension Scene {
+    /// Supplies the container's main context to the scene's views.
+    public func modelContainer(_ container: ModelContainer) -> some Scene {
+        _modifyingRootView(_ModelContainerModifier(context: container.mainContext))
+    }
+
+    /// Supplies a container for these model types to the scene's views.
+    public func modelContainer(
+        for modelType: any PersistentModel.Type,
+        inMemory: Bool = false,
+        isAutosaveEnabled: Bool = true,
+        isUndoEnabled: Bool = false,
+        onSetup: @escaping (Result<ModelContainer, any Error>) -> Void = { _ in }
+    ) -> some Scene {
+        modelContainer(_ModifierContainers.container(for: [modelType], inMemory: inMemory, autosave: isAutosaveEnabled, onSetup: onSetup))
+    }
+
+    public func modelContainer(
+        for modelTypes: [any PersistentModel.Type],
+        inMemory: Bool = false,
+        isAutosaveEnabled: Bool = true,
+        isUndoEnabled: Bool = false,
+        onSetup: @escaping (Result<ModelContainer, any Error>) -> Void = { _ in }
+    ) -> some Scene {
+        modelContainer(_ModifierContainers.container(for: modelTypes, inMemory: inMemory, autosave: isAutosaveEnabled, onSetup: onSetup))
+    }
+
+    /// Supplies a context to the scene's views.
+    public func modelContext(_ modelContext: ModelContext) -> some Scene {
+        _modifyingRootView(_ModelContainerModifier(context: modelContext))
+    }
+}

package/Sources/SwiftData/Schema.swift

@@ -0,0 +1,192 @@
+// The schema of a container: the model types, their persisted properties and
+// the options `@Attribute` and `@Relationship` gave them. `@Model` generates
+// each type's `schemaMetadata`; the store reads it to encode, decode and
+// relate records.
+
+import Foundation
+
+public final class Schema: Hashable, @unchecked Sendable {
+    public struct Version: Hashable, Comparable, Codable, Sendable, CustomStringConvertible {
+        public let major: Int
+        public let minor: Int
+        public let patch: Int
+
+        public init(_ major: Int, _ minor: Int, _ patch: Int) {
+            self.major = major
+            self.minor = minor
+            self.patch = patch
+        }
+
+        public static func < (lhs: Version, rhs: Version) -> Bool {
+            (lhs.major, lhs.minor, lhs.patch) < (rhs.major, rhs.minor, rhs.patch)
+        }
+
+        public var description: String { "\(major).\(minor).\(patch)" }
+    }
+
+    /// One model type of the schema.
+    public struct Entity: Hashable, @unchecked Sendable {
+        public let name: String
+        let type: any PersistentModel.Type
+
+        public var properties: [PropertyMetadata] { _Entity.of(type).properties }
+
+        public static func == (lhs: Entity, rhs: Entity) -> Bool { lhs.name == rhs.name }
+        public func hash(into hasher: inout Hasher) { hasher.combine(name) }
+    }
+
+    /// A persisted property of a model, as `@Model` describes it.
+    public struct PropertyMetadata: @unchecked Sendable {
+        public let name: String
+        public let keypath: AnyKeyPath
+        public let defaultValue: Any?
+        /// The `Schema.Attribute` or `Schema.Relationship` the property was
+        /// declared with, if any.
+        public let metadata: Any?
+        let property: _Property
+
+        public init<Model: PersistentModel, Value>(name: String, keyPath: KeyPath<Model, Value>, defaultValue: Value? = nil, metadata: Any? = nil) {
+            self.name = name
+            keypath = keyPath
+            self.defaultValue = defaultValue
+            self.metadata = metadata
+            property = _Property(name: name, keyPath: keyPath, defaultValue: defaultValue, metadata: metadata)
+        }
+    }
+
+    /// Options of a persisted attribute.
+    public struct Attribute: @unchecked Sendable {
+        public struct Option: Hashable, Sendable {
+            let name: String
+            /// Records may not share a value: inserting a model whose value
+            /// another record has updates that record instead (an upsert).
+            public static let unique = Option(name: "unique")
+            public static let externalStorage = Option(name: "externalStorage")
+            public static let allowsCloudEncryption = Option(name: "allowsCloudEncryption")
+            public static let preserveValueOnDeletion = Option(name: "preserveValueOnDeletion")
+            public static let ephemeral = Option(name: "ephemeral")
+            public static let spotlight = Option(name: "spotlight")
+            public static func transformable(by transformerName: String) -> Option { Option(name: "transformable") }
+            public static func transformable(by transformerType: Any.Type) -> Option { Option(name: "transformable") }
+        }
+
+        public let options: [Option]
+        public let originalName: String?
+        public let hashModifier: String?
+
+        public init(_ options: Option..., originalName: String? = nil, hashModifier: String? = nil) {
+            self.options = options
+            self.originalName = originalName
+            self.hashModifier = hashModifier
+        }
+
+        public var isUnique: Bool { options.contains(.unique) }
+    }
+
+    /// Options of a relationship between models.
+    public struct Relationship: @unchecked Sendable {
+        public enum DeleteRule: Hashable, Codable, Sendable {
+            /// Deleting the model deletes the related models.
+            case cascade
+            /// A model with related models cannot be deleted (its save fails).
+            case deny
+            /// Nothing happens to the related models.
+            case noAction
+            /// The related models stop referring to the deleted one.
+            case nullify
+        }
+
+        public struct Option: Hashable, Sendable {
+            let name: String
+            public static let unique = Option(name: "unique")
+        }
+
+        public let options: [Option]
+        public let deleteRule: DeleteRule
+        public let minimumModelCount: Int?
+        public let maximumModelCount: Int?
+        public let originalName: String?
+        public let inverseKeyPath: AnyKeyPath?
+        public let hashModifier: String?
+
+        public init(
+            _ options: Option...,
+            deleteRule: DeleteRule = .nullify,
+            minimumModelCount: Int? = 0,
+            maximumModelCount: Int? = 0,
+            originalName: String? = nil,
+            inverse: AnyKeyPath? = nil,
+            hashModifier: String? = nil
+        ) {
+            self.options = options
+            self.deleteRule = deleteRule
+            self.minimumModelCount = minimumModelCount
+            self.maximumModelCount = maximumModelCount
+            self.originalName = originalName
+            inverseKeyPath = inverse
+            self.hashModifier = hashModifier
+        }
+    }
+
+    public let entities: [Entity]
+    public let version: Version
+
+    public init(_ types: [any PersistentModel.Type], version: Version = Version(1, 0, 0)) {
+        var seen = Set<ObjectIdentifier>()
+        var entities: [Entity] = []
+        // The listed types and every type they relate to, as SwiftData infers them.
+        var queue = types
+        while !queue.isEmpty {
+            let type = queue.removeFirst()
+            guard seen.insert(ObjectIdentifier(type)).inserted else { continue }
+            let entity = _Entity.of(type)
+            entities.append(Entity(name: entity.name, type: type))
+            queue += entity.properties.compactMap { $0.property.relatedType }
+        }
+        self.entities = entities
+        self.version = version
+    }
+
+    public convenience init(_ types: any PersistentModel.Type..., version: Version = Version(1, 0, 0)) {
+        self.init(types, version: version)
+    }
+
+    public convenience init(versionedSchema: any VersionedSchema.Type) {
+        self.init(versionedSchema.models, version: versionedSchema.versionIdentifier)
+    }
+
+    public static func == (lhs: Schema, rhs: Schema) -> Bool { lhs.entities == rhs.entities && lhs.version == rhs.version }
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(entities)
+        hasher.combine(version)
+    }
+
+    public var entitiesByName: [String: Entity] {
+        Dictionary(entities.map { ($0.name, $0) }, uniquingKeysWith: { first, _ in first })
+    }
+}
+
+/// A version of an app's schema, for migration plans.
+public protocol VersionedSchema {
+    static var versionIdentifier: Schema.Version { get }
+    static var models: [any PersistentModel.Type] { get }
+}
+
+/// How to migrate between versioned schemas. Records are decoded on demand
+/// (a property missing from a record takes its initial value), which covers
+/// what a lightweight migration does; custom stages' closures run against the
+/// container's main context.
+public protocol SchemaMigrationPlan {
+    static var schemas: [any VersionedSchema.Type] { get }
+    static var stages: [MigrationStage] { get }
+}
+
+public enum MigrationStage: @unchecked Sendable {
+    case lightweight(fromVersion: any VersionedSchema.Type, toVersion: any VersionedSchema.Type)
+    case custom(
+        fromVersion: any VersionedSchema.Type,
+        toVersion: any VersionedSchema.Type,
+        willMigrate: ((ModelContext) throws -> Void)?,
+        didMigrate: ((ModelContext) throws -> Void)?
+    )
+}

package/Sources/SwiftData/Store.swift

@@ -0,0 +1,146 @@
+// A store: the saved records of one `ModelConfiguration`, kept in memory for
+// the run. The page reads the app's IndexedDB database before it starts the
+// module and hands every store in through `SB_SWIFTDATA`; each save sends
+// what changed back as a `swiftdata` op, which the page writes to IndexedDB
+// (docs/ops-protocol.md, "Phase 18"). Fetches are evaluated here, against
+// the records and the contexts' unsaved changes, so they stay synchronous as
+// SwiftData's are.
+
+import Foundation
+import SwiftUI
+
+/// A saved model: its entity name and its properties' JSON.
+struct _Record: Equatable {
+    var entity: String
+    var values: [String: _JSON]
+}
+
+final class _Store {
+    /// The store's name: the configuration URL's last path component
+    /// (`default.store`).
+    let identifier: String
+    /// Whether saves reach the host; in-memory stores keep nothing.
+    let persistent: Bool
+    private(set) var records: [Int64: _Record] = [:]
+    /// Record keys per entity, in insertion order.
+    private var keysByEntity: [String: [Int64]] = [:]
+    private var contexts: [_WeakContext] = []
+
+    private init(identifier: String, persistent: Bool, records: [Int64: _Record]) {
+        self.identifier = identifier
+        self.persistent = persistent
+        self.records = records
+        for key in records.keys.sorted() { keysByEntity[records[key]!.entity, default: []].append(key) }
+    }
+
+    // MARK: Opening
+
+    nonisolated(unsafe) private static var opened: [String: _Store] = [:]
+
+    /// The persistent store with this name (shared by every container that
+    /// opens it), or a new in-memory store.
+    static func open(identifier: String, inMemory: Bool) -> _Store {
+        if inMemory { return _Store(identifier: identifier, persistent: false, records: [:]) }
+        if let store = opened[identifier] { return store }
+        let store = _Store(identifier: identifier, persistent: true, records: launchRecords[identifier] ?? [:])
+        opened[identifier] = store
+        return store
+    }
+
+    /// The stores the host handed in (`SB_SWIFTDATA`):
+    /// `{"<store>": [{"id": 1, "entity": "Book", "values": {…}}, …]}`.
+    nonisolated(unsafe) private static var launchRecords: [String: [Int64: _Record]] = {
+        guard let text = _environment("SB_SWIFTDATA"), !text.isEmpty else { return [:] }
+        guard let json = try? _JSON.parse(text), case .object(let stores) = json else {
+            print("[SwiftData] ignoring malformed SB_SWIFTDATA")
+            return [:]
+        }
+        var result: [String: [Int64: _Record]] = [:]
+        for (name, items) in stores {
+            guard case .array(let items) = items else { continue }
+            var records: [Int64: _Record] = [:]
+            for item in items {
+                guard case .object(let fields) = item, case .number(let id)? = fields["id"],
+                      case .string(let entity)? = fields["entity"] else { continue }
+                var values: [String: _JSON] = [:]
+                if case .object(let stored)? = fields["values"] { values = stored }
+                records[Int64(id)] = _Record(entity: entity, values: values)
+            }
+            result[name] = records
+        }
+        return result
+    }()
+
+    // MARK: Keys
+
+    /// Model keys are unique across every store of the app, increasing, and
+    /// continue after the largest key the host handed in.
+    nonisolated(unsafe) private static var nextPrimaryKey: Int64 = {
+        let largest = launchRecords.values.flatMap(\.keys).max() ?? 0
+        return largest + 1
+    }()
+
+    static func allocatePrimaryKey() -> Int64 {
+        defer { nextPrimaryKey += 1 }
+        return nextPrimaryKey
+    }
+
+    /// Clears every opened store's in-memory state (tests).
+    static func _resetForTesting(launch: [String: [Int64: _Record]] = [:]) {
+        opened = [:]
+        launchRecords = launch
+        nextPrimaryKey = (launch.values.flatMap(\.keys).max() ?? 0) + 1
+    }
+
+    // MARK: Reading
+
+    func keys(of entity: String) -> [Int64] { keysByEntity[entity] ?? [] }
+
+    func record(_ key: Int64) -> _Record? { records[key] }
+
+    // MARK: Contexts
+
+    func register(_ context: ModelContext) {
+        contexts.removeAll { $0.context == nil }
+        contexts.append(_WeakContext(context: context))
+    }
+
+    // MARK: Writing
+
+    /// Applies one save: `put` records (new or changed) and `delete` keys,
+    /// tells the host, and lets the store's other contexts catch up.
+    func commit(put: [(Int64, _Record)], delete: [Int64], clear: Bool = false, from origin: ModelContext?) {
+        if clear {
+            records.removeAll()
+            keysByEntity.removeAll()
+        }
+        for key in delete {
+            guard let removed = records.removeValue(forKey: key) else { continue }
+            keysByEntity[removed.entity]?.removeAll { $0 == key }
+        }
+        for (key, record) in put {
+            if records[key] == nil { keysByEntity[record.entity, default: []].append(key) }
+            records[key] = record
+        }
+        if persistent {
+            var change: [String: _JSON] = ["store": .string(identifier)]
+            if clear { change["clear"] = .bool(true) }
+            change["put"] = .array(put.map { key, record in
+                .object(["id": .number(Double(key)), "entity": .string(record.entity), "values": .object(record.values)])
+            })
+            change["delete"] = .array(delete.map { .number(Double($0)) })
+            let json = _JSON.object(change)
+            MainActor.assumeIsolated { _Runtime.shared.storeSwiftData(json) }
+        }
+        let changed = Set(put.map(\.0))
+        let deleted = Set(delete)
+        for weak in contexts {
+            guard let context = weak.context, context !== origin else { continue }
+            context._storeDidChange(changed: changed, deleted: deleted, cleared: clear)
+        }
+    }
+}
+
+struct _WeakContext {
+    weak var context: ModelContext?
+}