I created a generic repository that gets a PersistentContainer injected (I followed you instructions up to there):

public class BaseRepository<T>: Repository where T: ManagedObjectConvertible {
	
	public var persistentContainer: PersistentContainer
	
	init(persistentContainer: PersistentContainer) {
		
		self.persistentContainer = persistentContainer
	}
	
	public func allItems() throws -> [T] {

		try self.persistentContainer.perform { context in
			
			try context.fetch(T.all).map { try $0.decode() }
		}
	}
	
	public func create(_ item: T) throws {
		try self.persistentContainer.perform { context in
			
			try context.insert(item)
		}
	}
	
	public func remove(_ item: T) throws {
		try self.persistentContainer.perform { context in
			
			try context.delete(item)
		}
	}
} 

However, the "remove" function where the delete operation on the context is used, throws a build error:

Cannot convert value of type 'T' to expected argument type 'ManagedObject<PlainObject>'

I tried around, but I cannot figure out how to fix this. Do you have any ideas?

The calling part looks like this (a repository factory):

	public func makeRepository<R>(for storyType: StoreType) -> R where R: Repository {

		switch storyType {
			case .country:
				return BaseRepository<Country>(persistentContainer: persistentContainer) as! R
				
			case .location:
				return BaseRepository<Location>(persistentContainer: persistentContainer) as! R
		}
	}

where

public protocol Repository {
	associatedtype T: ManagedObjectConvertible
	
	var persistentContainer: PersistentContainer { get }
	
	func allItems() throws -> [T]
}

Thanks for your support!

Hello again,

I'm struggling with relations and their handling. The use case is:

• There are companies, that have a many-to-many-relationship with persons
• I create a company, and I create some persons.
• I want to assign the persons to the company.

Actually, pretty simple.

The test case is:

		let domainStore: DomainStore = .init(kind: .temporary)

		let companyStore = GenericAPI<Company>(domainStore: domainStore)
		let personStore = GenericAPI<Person>(domainStore: domainStore)
		
		companyStore.refresh()
		personStore.refresh()
		
		XCTAssertEqual(companyStore.list, [])
		XCTAssertEqual(personStore.list, [])

		// Add some persons.
		var new1: Person = personStore.add()
		new1.name = "Paul"
		personStore.save(new1)
		
		var new2: Person = personStore.add()
		new2.name = "Peter"
		personStore.save(new2)
		
		XCTAssertEqual(personStore.list.count, 2)
		
		// Add a company.
		var new3: Company = companyStore.add()
		new3.name = "The AG"
		companyStore.save(new3)
				
		XCTAssertEqual(companyStore.list.count, 1)
		XCTAssertEqual(companyStore.list[0].name, "The AG")
		
		new3.persons = [new1, new2]

The error occurts in the last line, where the compiler says: "Value of type Company has no member persons."

Now, Company is defined such:

public struct Company: DomainType {
	
	public init(uuid: UUID, name: String) {
		self.uuid = uuid
		self.name = name
	}
	
	public var uuid: UUID
	public var name: String
}

extension Company {
	
	public static var idKeyPath: KeyPath<Company, UUID> {
		\.uuid
	}
	
	public init() {
		self.uuid = .init()
		self.name = .init()
	}
	
	public static let entityName = "CompanyMO"
	
	public static let attributes: Set<Attribute<Company>> = [
		
		.init(\.uuid, "uuid"),
		.init(\.name, "name"),
	]
	
	public struct Relations {
		public init() {}
		public let persons = ToManyRelation<Person>("persons")
	}
	
	public static let relations = Relations()
}

So, actually everything as stated in your directions and test cases, where a Book has authors.

The public init() was kind of desperation task, cause I thought it may be a visiblity problem (the domain types are defined in a package), but it did not change anything.

So it seems I'm doing something wrong - but what?

Thanks in advance for your help!

Hi

Is it possible to use Swarm as change tracker in CoreData? If not Could you give advise how implement this functionality in cooperation with Sworm?

Thank you

Just for better understanding: There is no "update" method in Sworm, just insert and delete. How is an existing object updated?

My use case is an editor sheet, that provides "cancel" and "save" operations. This includes (a) the need for a rollback, and (b) the need for an update.

The missing "update" operation may be interpreted in a way that Sworm updates "on-the-fly" whenever an attribute changes.

So, how does Sworm work in this context? How should an update intentionally be handled?

.... 
In addition to accessing graphics, ManagedObject has a set of paired `encode` / `decode` methods 
that allow you to read / write data models or attributes separately.

from here

I'm following the guidance in basic usage docs and I have hit a snag with the package.

The following throws a compile time error of Key path value type 'WritableKeyPath<Forecast, Date>' cannot be converted to contextual type 'KeyPath<Forecast, Date>'.

Any tips?

XCode 14.1 targeting iOS 16

import Foundation
import Sworm

struct Forecast {
    let date: Date    
    let area: Area
    
    init(date: Date, area: Area) {
        self.date = date
        self.area = area
    }
}

extension Forecast : ManagedObjectConvertible {
    init() {
    }
    
    static let entityName = "Forecast"

    static let attributes: Set<Attribute<Forecast>> = [
        .init(\.date, "date") // Key path value type 'WritableKeyPath<Forecast, Date>' cannot be converted to contextual type 'KeyPath<Forecast, Date>'
    ]

    struct Relations {
        let area = ToOneRelation<Area>("area")
    }

    static let relations = Relations()
}