What is the best practice for store migration

[runjuu]

Like rename/add/remove some properties from version to version

[mergesort]

It's hard to answer this question without specific context, but maybe conceptualizing how Boutique persists its data will help figure out the best approach for you. When you add an item to the Store you're writing a Codable object to disk. That means we're working predominantly with files, which is relatively simple compared to migrations that occur with a true database. I would probably recommend one of these two paths, but can't say definitively because it's a choice for your app based on what you're needs are.

• If you want to migrate data from one version to another in a new version of your app, you may want to take the objects saved on disk and write a manual migration that updates the data from the old format to the new.
• If your user data is available on a server and you do a migration, the best approach might be to remove all of the data and download the server's data in a new format to replace the data you had in an old format.

There may be more strategies but it's important to know what exactly you're trying to accomplish before figuring out how to approach the problem, if you can share more about that.

[subdigital]

I've done this extensively on an important project with success. It can work, but you have to plan out a strategy.

There are a couple of approaches you might consider. If your data needs to be migrated from older versions (i.e. you can't just blow away the cache and save again with fresh data from the server) then you need some sort of versioning scheme.

Option A: Versioning in the model

This requires you to store the version of a model in the model's Codable data, so you can intelligently reason about the data that is being hydrated from data.

Something like:

struct Widget: Codable {
    let createdAt: Date

    enum Version: String {
       case v1
       case v2 // changed date format from Int seconds to ISO8601
    }

    init(from decoder: Decoder) throws {
        // do it manually, first decoding the version
    }
}

This approach pretty much requires you implement the decoding logic yourself so you have control over how to parse given different versions.

Option 2: Version the files

Maybe you have a v1/widgets directory, and in those you decode with V1.Widget, and when you need to make a migration, create V2.Widget and have a way to migrate in-memory all of the v1 objects to v2.

I don't love this approach because it sort of pollutes your namespaces with version numbers.

Option 3: Migrate the files

This one is a little tricky, as you need to consider all possible versions going back to the first one. So make sure you do them in order (v1 to v2, v2 to v3, etc). For this you might use JSONSerialization and untyped dictionaries. The benefit here is your model stays clean and on the latest version.

Hope this gives you some ideas on how to continue.