Tutorial: Atlas Device Sync for Swift with Swift UI

Add a Property to the Model

Now that you have confirmed everything is working as expected, we can add changes. In this tutorial, we have decided that we want to add a "priority" property to each Item so that we can filter Items by their priorities. The priority property uses a PriorityLevel enum to constrain the possible values.

To do this, follow these steps:

1. Open the App.xcodeproj in Xcode.

2. Open the Item.swift class file.

3. Add the following property to the Item class:

   @Persisted var priority: PriorityLevel

4. Also add a PriorityLevel PersistableEnum below the Item class:

   class Item: Object, ObjectKeyIdentifiable {
      @Persisted(primaryKey: true) var _id: ObjectId
      @Persisted var isComplete = false
      @Persisted var summary: String
      @Persisted var owner_id: String
      @Persisted var priority: PriorityLevel
   }
   enum PriorityLevel: Int, PersistableEnum, CaseIterable {
      case severe = 0
      case high = 1
      case medium = 2
      case low = 3
      var description: String {
         switch self {
         case .severe: return "Severe"
         case .high: return "High"
         case .medium: return "Medium"
         case .low: return "Low"
         }
      }
   }

   PersistableEnum is the protocol that marks enum types as persistable directly in Realm. We set the enum's type as Int here instead of String so we can query based on a numeric priority level later. We use a description computed property to display a string representation of the priority in the UI.

Set the Priority when Creating a New Item

1. In the Views directory, go to CreateItemView.swift. Add a new @State property under the existing itemSummary property. For now, set the default value to medium priority:

   @State var itemSummary = ""
   @State var priority = PriorityLevel.medium

2. Now, in the Form body, add a Picker that enables the user to choose which priority level to set on the new Item. Locate the Section that contains the buttons, and insert the following code above it:

   Section(header: Text("Priority")) {
       Picker(selection: $priority, label: Text("Set priority")) {
           ForEach(PriorityLevel.allCases, id: \.self) { priority in
               Text(priority.description)
           }
       }
   }

3. Now, move down to the Button(action: that sets the values of the newItem when the user presses the Save button. Add a line below newItem.summary to also set the priority property:

   newItem.summary = itemSummary
   newItem.priority = priority

Run and Test

At this point, you can run the application again. Log in using the account you created earlier in this tutorial. You will see the one Item you previously created. Add a new Item, and you will see that you can now set the priority. Choose High for the priority and save the Item.

Now switch back to the Atlas data page in your browser, and refresh the Item collection. You should now see the new Item with the priority field added and set to 1. The existing Item does not have a priority field.

click to enlarge

Update the subscription

In the ContentView.swift file, we create the Flexible Sync subscription that defines which documents we sync with the user's device & account. Look for the let config = user.flexibleSyncConfiguration(initialSubscriptions: variable where we set the initial subscriptions. Within the subscriptions.append() method, you can see that we are currently subscribing to all documents where the owner_id property matches the authenticated user's id. We want to maintain that, but only sync Items that are marked as High or Severe priority.

This is why we set the PriorityLevel enum to type Int, where the highest priority (severe) has a value of 0, and the lowest priority (low) has a value of 3. We can make direct comparisons between an Int and the priority property. To do so, update the query statement to include documents where the priority is equal to or less than PriorityLevel.High (or 1), as shown here.

We'll also add the reRunOnOpen bool, and set it to true, to force the subscription query to recalculate which documents to sync every time we open the app.

let config = user.flexibleSyncConfiguration(initialSubscriptions: { subs in
   if let foundSubscription = subs.first(named: Constants.myItems) {
      foundSubscription.updateQuery(toType: Item.self, where: {
         $0.owner_id == user.id && $0.priority <= PriorityLevel.high
      })
   } else {
      // No subscription - create it
      subs.append(QuerySubscription<Item>(name: Constants.myItems) {
         $0.owner_id == user.id && $0.priority <= PriorityLevel.high
      })
   }
}, rerunOnOpen: true)

Run and Test

Run the application again. Log in using the account you created earlier in this tutorial. Because we added reRunOnOpen, the app should re-sync only the documents that match the Flexible Sync query. After an initial moment when Realm resyncs the document collection, you will only see the new Item of High priority that you created.

The Item document you initially created is not synced, because it does not have a priority field. If you want this Item to be synced, you can edit the document in the Atlas UI and add a value for the priority field.

If you want to further test the functionality, you can create Items of various priorities. You will see that a new Item with a lower priority briefly appears in the list of Items and then disappears. The Sync error handler helpfully provides a message describing this behavior:

ERROR
"Client attempted a write that is outside
of permissions or query filters; it has been reverted"

You can also see this message in the console log.

In this scenario, Realm creates the Item locally, syncs it with the backend, and then reverts the write because it doesn't meet the subscription rules.