Fix toOne's w/ explicit Relationships

This fixes issue #19.

Author: helje5

Sources/ManagedModels/SchemaGeneration/NSEntityDescription+Generation.swift

@@ -130,7 +130,8 @@ extension NSEntityDescription {
 
       case .toMany(collectionType: _, modelType: _):
         let relationship = CoreData.NSRelationshipDescription()
-        relationship.valueType = valueType
+        relationship.valueType  = valueType
+        relationship.isOptional = valueType is any AnyOptional.Type
         fixup(relationship, targetType: valueType, isToOne: false,
               meta: propMeta)
         assert(relationship.maxCount != 1)
@@ -174,15 +175,25 @@ extension NSEntityDescription {
     // TBD: Rather throw?
     if relationship.name.isEmpty { relationship.name = meta.name }
 
-    if !isToOne {
+    if isToOne {
+      relationship.maxCount = 1 // toOne marker!
+    }
+    else {
       // Note: In SwiftData arrays are not ordered.
       relationship.isOrdered = targetType is NSOrderedSet.Type
+      assert(relationship.maxCount != 1, "toMany w/ maxCount 1?")
     }
 
     if relationship.keypath == nil { relationship.keypath = meta.keypath }
     if relationship.valueType == Any.self {
       relationship.valueType = targetType
     }
+    if relationship.valueType != Any.self {
+      relationship.isOptional = relationship.valueType is any AnyOptional.Type
+      if !isToOne {
+        relationship.isOrdered = relationship.valueType is NSOrderedSet.Type
+      }
+    }
   }
 
   private func fixupOrderedSet(_ relationship: NSRelationshipDescription,

Tests/ManagedModelTests/SchemaGenerationTests.swift

@@ -98,6 +98,7 @@ final class SchemaGenerationTests: XCTestCase {
     XCTAssertFalse (lastname.isRelationship)
     XCTAssertTrue  (toAddresses.isRelationship)
     XCTAssertFalse (toAddresses.isToOneRelationship)
+    XCTAssertTrue  (toAddresses.isToMany)
     XCTAssertEqual (toAddresses.destination, "Address")
     XCTAssertNotNil(toAddresses.destinationEntity)
 
@@ -106,6 +107,7 @@ final class SchemaGenerationTests: XCTestCase {
     let toPerson = try XCTUnwrap(address.relationshipsByName["person"])
     XCTAssertTrue (toPerson.isRelationship)
     XCTAssertTrue (toPerson.isToOneRelationship)
+    XCTAssertFalse(toPerson.isToMany)
     XCTAssertEqual(toPerson.destination, "Person")
 
     XCTAssertTrue(toAddresses.destinationEntity === address)
@@ -222,4 +224,43 @@ final class SchemaGenerationTests: XCTestCase {
       XCTAssertEqual(address.attributes.count, 2)
     }
   }
+  
+  func testOptionalBackRef() throws {
+    let cache  = SchemaBuilder()
+    let schema = NSManagedObjectModel(
+      versionedSchema: Fixtures.PersonAddressOptionalToOneSchema.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"])
+    
+    XCTAssertTrue(person.attributes.isEmpty)
+    XCTAssertEqual(person.relationships.count, 1)
+    let toAddresses = try XCTUnwrap(person.relationshipsByName["addresses"])
+    XCTAssertTrue  (toAddresses.isRelationship)
+    XCTAssertFalse (toAddresses.isToOneRelationship)
+    XCTAssertFalse (toAddresses.isOptional)
+    XCTAssertEqual (toAddresses.destination, "Address")
+    XCTAssertNotNil(toAddresses.destinationEntity)
+
+    XCTAssertTrue(address.attributes.isEmpty)
+    XCTAssertEqual(address.relationships.count, 1)
+    let toPerson = try XCTUnwrap(address.relationshipsByName["person"])
+    XCTAssertTrue (toPerson.isRelationship)
+    XCTAssertTrue (toPerson.isOptional)
+    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)
+  }
 }

Tests/ManagedModelTests/Schemas/PersonAddressOptionalToOne.swift

@@ -0,0 +1,28 @@
+//
+//  Created by Helge Heß.
+//  Copyright © 2023 ZeeZide GmbH.
+//
+
+import ManagedModels
+
+extension Fixtures {
+  
+  enum PersonAddressOptionalToOneSchema: VersionedSchema {
+    static var models : [ any PersistentModel.Type ] = [
+      Person.self,
+      Address.self
+    ]
+    
+    public static let versionIdentifier = Schema.Version(0, 1, 0)
+
+    
+    @Model class Person: NSManagedObject {
+      var addresses : Set<Address> // [ Address ]
+    }
+    
+    @Model class Address: NSManagedObject {
+      @Relationship(deleteRule: .nullify, originalName: "PERSON")
+      var person : Person?
+    }
+  }
+}

Tests/ManagedModelTests/Schemas/PersonAddressSchema.swift

@@ -21,19 +21,9 @@ extension Fixtures {
     @Model
     final class Person: NSManagedObject {
 
-      // TBD: Why are the inits required? *** NEED TO FIGURE THIS OUT
       var firstname : String
       var lastname  : String
       var addresses : Set<Address> // [ Address ]
-      
-      #if false
-      init(firstname: String, lastname: String, addresses: [ Address ]) {
-        self.init() // this does not work
-        self.firstname = firstname
-        self.lastname  = lastname
-        self.addresses = addresses
-      }
-      #endif
     }
 
     @Model

Tests/ManagedModelTests/Schemas/PersonAddressSchemaNoInverse.swift

@@ -19,15 +19,10 @@ extension Fixtures {
     @Model
     final class Person: NSManagedObject, PersistentModel {
 
-      // TBD: Why are the inits required? *** NEED TO FIGURE THIS OUT
       var firstname : String
       var lastname  : String
       var addresses : [ Address ]
 
-      // init() is a convenience initializer, it looks up the the entity for the
-      // object?
-      // Can we generate inits?
-      
       init(firstname: String, lastname: String, addresses: [ Address ]) {
         super.init(entity: Self._$entity, insertInto: nil)
         self.firstname = firstname