Give InMemoryModelStorage the same relationship-materialization and partial-update behavior as SQL/Core Data

insert() now merges into an existing row instead of replacing it outright, so
providing only some attributes/relationships preserves whatever the row already
had for the rest — the same "only touch the columns you provided" semantics a
SQL ON CONFLICT DO UPDATE or a Core Data managed object gives for free. Without
this, re-inserting a row from a batch that doesn't touch every relationship
(e.g. a catalog sync that doesn't restate reservations written by an unrelated
flow) silently wiped those links.

fetch() now materializes every to-many relationship the schema declares, the
way a SQL row or a Core Data managed object does automatically on read. Neither
backend actually stores a to-many value on the row that owns it: a one-to-many
(whose inverse is a to-one foreign key) is answered by scanning the destination
table for rows whose foreign key points back, and a many-to-many (whose inverse
is also to-many) by a join table either side can add a link to. This store kept
only what insert() was given, with no such derivation — a to-many relationship
that's supposed to be entirely computed and never assigned (which describes
every one-to-many) always decoded as either an empty collection regardless of
what actually pointed to it, or keyNotFound if nothing had ever touched that
key at all. Both are now derived correctly. To-one relationships are left
alone: an absent required reference is a real problem, not a default.

Author: colemancda

Sources/CoreModel/InMemoryStorage.swift

@@ -52,18 +52,75 @@ public final class InMemoryStorage {
     public func fetch(_ entity: EntityName, for id: ObjectID) throws(CoreModelError) -> ModelData? {
         try withLock { () throws(CoreModelError) in
             try validate(entity)
-            return objects[entity]?[id]
+            return objects[entity]?[id].map { normalized(entity: entity, $0) }
         }
     }
 
     public func fetch(_ fetchRequest: FetchRequest) throws(CoreModelError) -> [ModelData] {
         try withLock { () throws(CoreModelError) in
             try validate(fetchRequest.entity)
-            let values = objects[fetchRequest.entity].map { Array($0.values) } ?? []
+            let values = (objects[fetchRequest.entity].map { Array($0.values) } ?? [])
+                .map { normalized(entity: fetchRequest.entity, $0) }
             return fetchRequest.evaluate(values, functions: functions)
         }
     }
 
+    /// Materializes every to-many relationship the schema declares, the way a SQL row or a
+    /// Core Data managed object does automatically on read.
+    ///
+    /// Neither backend actually stores a to-many value on the row that owns it — a
+    /// one-to-many (whose inverse is a to-one foreign key, e.g. `WalletCard.user` → `User`)
+    /// is answered by scanning the destination table for rows whose foreign key points back
+    /// here, and a many-to-many (whose inverse is also to-many) by a join table either side
+    /// can add a link to. This store keeps only what `insert` was given with no such
+    /// derivation, so a row whose to-many relationship key was never explicitly set — which
+    /// includes every one-to-many that's supposed to be entirely computed, never assigned —
+    /// previously decoded as `keyNotFound` instead of the collection it actually has.
+    ///
+    /// To-one relationships are left alone: an absent required reference is a real data
+    /// problem, not an empty-collection default.
+    private func normalized(entity: EntityName, _ value: ModelData) -> ModelData {
+        guard let description = model[entity] else { return value }
+        var value = value
+        for relationship in description.relationships where relationship.type == .toMany {
+            guard let destination = model[relationship.destinationEntity],
+                let inverse = destination.relationships.first(where: { $0.id == relationship.inverseRelationship })
+            else {
+                if value.relationships[relationship.id] == nil {
+                    value.relationships[relationship.id] = .toMany([])
+                }
+                continue
+            }
+            let candidates = objects[relationship.destinationEntity].map { Array($0.values) } ?? []
+            switch inverse.type {
+            case .toOne:
+                // One-to-many: always derived live from the destination rows' foreign key,
+                // matching SQL/Core Data — this row never stores it itself.
+                let derived = candidates
+                    .filter { $0.relationships[inverse.id] == .toOne(value.id) }
+                    .map { $0.id }
+                value.relationships[relationship.id] = .toMany(derived)
+            case .toMany:
+                // Many-to-many: no join table here, so union whatever this row already
+                // records with anything the destination rows record pointing back — a link
+                // added from either side is visible from both.
+                var ids = Set<ObjectID>()
+                if case let .toMany(existing)? = value.relationships[relationship.id] {
+                    ids.formUnion(existing)
+                }
+                for candidate in candidates {
+                    if case let .toMany(backLinks)? = candidate.relationships[inverse.id],
+                        backLinks.contains(value.id)
+                    {
+                        ids.insert(candidate.id)
+                    }
+                }
+                value.relationships[relationship.id] = .toMany(Array(ids))
+            }
+        }
+        return value
+    }
+
     public func fetchID(_ fetchRequest: FetchRequest) throws(CoreModelError) -> [ObjectID] {
         try fetch(fetchRequest).map { $0.id }
     }
@@ -75,7 +132,20 @@ public final class InMemoryStorage {
     public func insert(_ value: ModelData) throws(CoreModelError) {
         try withLock { () throws(CoreModelError) in
             try validate(value.entity)
-            objects[value.entity, default: [:]][value.id] = value
+            // A key present in `value` overrides; a key the existing row already had that
+            // `value` doesn't mention is preserved — the same "only touch the columns you
+            // provided" semantics a SQL `ON CONFLICT DO UPDATE` or a Core Data managed object
+            // gives for free. Without this, re-inserting a row from a batch that doesn't
+            // touch every relationship (e.g. a site catalog refresh that never re-states
+            // `parkingReservations`, which is written by an entirely separate sync) would
+            // silently wipe those links instead of leaving them alone.
+            if var existing = objects[value.entity]?[value.id] {
+                existing.attributes.merge(value.attributes) { _, new in new }
+                existing.relationships.merge(value.relationships) { _, new in new }
+                objects[value.entity, default: [:]][value.id] = existing
+            } else {
+                objects[value.entity, default: [:]][value.id] = value
+            }
         }
     }