Fix discovery of dependent entities

The resolver only returned the entities for the
types it was asked for, which is incorrect, it
also needs to return the dependencies for MOM
setup.

Author: helje5

Sources/ManagedModelMacros/ModelMacro/ModelMacro.swift

@@ -4,14 +4,4 @@
 //
 
 public enum ModelMacro {
-  /*
-   @attached(member, ...)
-   @attached(memberAttribute)
-   @attached(extension, conformances: // the protocols we add automagically
-     PersistentModel
-   )
-   
-   Note: @Model does not support `originalName`/`renamingIdentifier`?
-         We could. Some for that versionHash thing.
-   */
 }

Sources/ManagedModels/SchemaCompatibility/NSManagedObjectModel+Data.swift

@@ -23,7 +23,7 @@ public extension NSManagedObjectModel {
                    version: Schema.Version = Version(1, 0, 0))
   {
     self.init()
-    self.entities = SchemaBuilder.shared.resolve(types)
+    self.entities = SchemaBuilder.shared.lookupAllEntities(for: types)
   }
 
   @inlinable
@@ -80,7 +80,7 @@ internal extension NSManagedObjectModel {
                    schemaCache: SchemaBuilder)
   {
     self.init()
-    self.entities = schemaCache.resolve(types)
+    self.entities = schemaCache.lookupAllEntities(for: types)
   }
 
   /// Initializer for testing purposes.

Sources/ManagedModels/SchemaGeneration/SchemaBuilder.swift

@@ -72,31 +72,13 @@ public final class SchemaBuilder {
    * Thread Safety: This is a thread-safe operation. Do NOT modify the returned
    *                Schema objects.
    */
-  func resolve(_ modelTypes: [ any PersistentModel.Type ])
+  func lookupAllEntities(for modelTypes: [ any PersistentModel.Type ])
        -> [ NSEntityDescription ]
   {
-    var entities       = [ NSEntityDescription ]()
-    var entitiesByName = [ String : NSEntityDescription ]()
+    var entities = [ NSEntityDescription ]()
 
     lock.lock()
-    process(modelTypes)
-    
-    for modelType in modelTypes {
-      guard let entity = lookupEntity(modelType) else {
-        fatalError(
-          """
-          Could not construct `NSEntityDescription` for `PersistentModel` type
-          
-            \(modelType)
-          
-          """
-        )
-      }
-      // Return just the ones we need.
-      entities.append(entity)
-      precondition(entity.name != nil, "Entity w/o a name? \(entity)")
-      if let name = entity.name { entitiesByName[name] = entity }
-    }
+    process(modelTypes, entities: &entities)
     lock.unlock()
 
     return entities
@@ -115,10 +97,11 @@ public final class SchemaBuilder {
   public func _entity<M>(for modelType: M.Type) -> NSEntityDescription
     where M: PersistentModel
   {
+    var entities = [ NSEntityDescription ]()
     let modelTypes = [ modelType ]
     lock.lock()
     let entity = lookupEntity(modelType) ?? {
-      process(modelTypes)
+      process(modelTypes, entities: &entities)
       guard let entity = lookupEntity(modelType) else {
         fatalError(
           "Could not construct Entity for PersistentModel type: \(modelType)")
@@ -132,29 +115,33 @@ public final class SchemaBuilder {
 
   // MARK: - Things that run in the lock!
 
-  private func process(_ modelTypes: [ any PersistentModel.Type ]) {
+  private func process(_ modelTypes: [ any PersistentModel.Type ],
+                       entities: inout [ NSEntityDescription ])
+  {
     // Note: This is called recursively
     var allFrozen = false
 
     // Create the basic entity and property data
     for modelType in modelTypes {
       guard !isFrozen(modelType) else { continue }
       allFrozen = false
-      /* newEntity */ _ = processModel(modelType)
+      if let newEntity = processModel(modelType) {
+        entities.append(newEntity)
+      }
     }
     if allFrozen { return } // all have been processed already
 
     // TBD: The following does too much work, we might only need the
     //      most of those on the "new models"
 
     // This recurses into `process`, if necessary.
-    discoverTargetTypes(entitiesByType.values)
+    discoverTargetTypes(in: entities, allEntities: &entities)
 
     // Collect destination entity names in relships based on the modelType!
-    fillDestinationEntityNamesInRelationships(entitiesByType.values)
+    fillDestinationEntityNamesInRelationships(entities)
 
     // Lookup inverse relationships
-    fillInverseRelationshipData(entitiesByType.values)
+    fillInverseRelationshipData(entities)
 
     frozenTypes.formUnion(entitiesByType.keys)
   }
@@ -164,21 +151,26 @@ public final class SchemaBuilder {
    * model type they point to is already tracked as an entity.
    * Recurses until all relationships have been processed.
    */
-  private func discoverTargetTypes<S>(_ entities: S)
-    where S: Sequence, S.Element == NSEntityDescription
+  private func discoverTargetTypes(in entities: [ NSEntityDescription ],
+                                   allEntities: inout [ NSEntityDescription ])
   {
     var newEntities = [ NSEntityDescription ]()
     for entity in entities {
       for relationship in entity.relationships {
-        guard let targetType = relationship.modelType else { continue }
-        if let newEntity = processModel(targetType) {
-          newEntities.append(newEntity)
+        guard let targetType = relationship.modelType else {
+          assertionFailure("Missing type for relationship \(relationship)")
+          continue
         }
+        // This returns nil if the model is already processed.
+        guard let newEntity = processModel(targetType) else { continue }
+        
+        allEntities.append(newEntity)
+        newEntities.append(newEntity)
       }
     }
 
     if !newEntities.isEmpty { // recurse if necessary
-      discoverTargetTypes(newEntities)
+      discoverTargetTypes(in: newEntities, allEntities: &allEntities)
     }
   }
 

Tests/ManagedModelTests/SchemaGenerationTests.swift

@@ -75,7 +75,48 @@ final class SchemaGenerationTests: XCTestCase {
     XCTAssertTrue (toAddresses.keypath        == toPerson.inverseKeyPath)
     XCTAssertTrue (toAddresses.inverseKeyPath == toPerson.keypath)
   }
-  
+
+  func testAutomaticDependencies() throws {
+    let cache  = SchemaBuilder()
+    let schema = NSManagedObjectModel(
+      [ Fixtures.PersonAddressSchema.Person.self ],
+      schemaCache: cache
+    )
+    
+    XCTAssertEqual(schema.entities.count, 2)
+    XCTAssertEqual(schema.entitiesByName.count, 2)
+    
+    let person  = try XCTUnwrap(schema.entitiesByName["Person"])
+    let address = try XCTUnwrap(schema.entitiesByName["Address"])
+    
+    XCTAssertEqual(person.attributes.count, 2)
+    XCTAssertEqual(person.relationships.count, 1)
+    let firstname   = try XCTUnwrap(person.attributesByName["firstname"])
+    let lastname    = try XCTUnwrap(person.attributesByName["lastname"])
+    let toAddresses = try XCTUnwrap(person.relationshipsByName["addresses"])
+    XCTAssertFalse (firstname.isTransient)
+    XCTAssertFalse (lastname.isRelationship)
+    XCTAssertTrue  (toAddresses.isRelationship)
+    XCTAssertFalse (toAddresses.isToOneRelationship)
+    XCTAssertEqual (toAddresses.destination, "Address")
+    XCTAssertNotNil(toAddresses.destinationEntity)
+
+    XCTAssertEqual(address.attributes.count, 2)
+    XCTAssertEqual(address.relationships.count, 1)
+    let toPerson = try XCTUnwrap(address.relationshipsByName["person"])
+    XCTAssertTrue (toPerson.isRelationship)
+    XCTAssertTrue (toPerson.isToOneRelationship)
+    XCTAssertEqual(toPerson.destination, "Person")
+
+    XCTAssertTrue(toAddresses.destinationEntity === address)
+    XCTAssertTrue(toPerson   .destinationEntity === person)
+
+    XCTAssertEqual(toPerson   .inverseName, "addresses")
+    XCTAssertEqual(toAddresses.inverseName, "person")
+    XCTAssertTrue (toAddresses.keypath        == toPerson.inverseKeyPath)
+    XCTAssertTrue (toAddresses.inverseKeyPath == toPerson.keypath)
+  }
+
   func testMissingInverse() throws {
     let cache = SchemaBuilder()