Write Data to a Synced Realm - Swift SDK

Configuración de servicios de aplicaciones

Sync de dispositivo se configura con los siguientes campos consultables:

• _id (siempre incluido)

• complexity

• ownerId

The App Services App has permissions configured to let users read and write only their own data:

{
  "name": "owner-read-write",
  "apply_when": {},
  "document_filters": {
    "read": { "ownerId": "%%user.id" },
    "write": { "ownerId": "%%user.id" }
  },
  "read": true,
  "write": true
}

Client Data Model and Configuration

Los ejemplos de esta página utilizan el siguiente modelo de objeto:

class Item: Object {
    @Persisted(primaryKey: true) var _id: ObjectId
    @Persisted var ownerId: String
    @Persisted var itemName: String
    @Persisted var complexity: Int
}

Al utilizar ese modelo de objeto, la configuración del reino sincronizado sincroniza los objetos que coinciden con la consulta de suscripción donde el valor de la propiedad complexity es menor o igual a 4:

let app = App(id: YOUR_APP_ID_HERE)
do {
    let user = try await app.login(credentials: Credentials.anonymous)
    do {
        var flexSyncConfig = user.flexibleSyncConfiguration()
        flexSyncConfig.objectTypes = [Item.self]
        let realm = try await Realm(configuration: flexSyncConfig)
        let subscriptions = realm.subscriptions
        try await subscriptions.update {
            subscriptions.append(
                QuerySubscription<Item>(name: "simple-items") {
                 $0.complexity <= 4
            })
        }
        print("Successfully opened realm: \(realm)")
    } catch {
        print("Failed to open realm: \(error.localizedDescription)")
        // handle error
    }
} catch {
    fatalError("Login failed: \(error.localizedDescription)")
}

¿Qué datos se sincronizan?

La consulta de suscripción combinada con los permisos significa que el realm sincronizado solo sincroniza objetos donde:

• The ownerId matches the user.id of the logged-in user (from the permissions)

• The complexity property's value is less than or equal to 4 (from the subscription query)

Any object in the Atlas collection where the ownerId does not match the user.id of the logged-in user, or the complexity property's value is greater than 4, cannot sync to this realm.

Successful Writes

Cuando la escritura coincide tanto con los permisos como con la query de suscripción Flexible Sync en el cliente, el SDK de Realm Swift puede escribir el objeto en el realm sincronizado. Este objeto se sincroniza con el backend de aplicación Services cuando el dispositivo tiene una conexión de red.

// This write falls within the subscription query and complies
// with the Device Sync permissions, so this write should succeed.
do {
    let learnRealm = Item()
    learnRealm.ownerId = user.id
    learnRealm.itemName = "Learn Realm CRUD stuff"
    learnRealm.complexity = 3
    try realm.write {
        realm.add(learnRealm)
    }
} catch {
    print("Failed to write to realm: \(error.localizedDescription)")
}

Compensating Writes

In some cases, a write that initially appears to succeed is actually an illegal write. In these cases, the object writes to the database, but when the database syncs to the backend, Realm reverts the write in a non-fatal error operation called a compensating write. Compensating writes can occur when:

• Las escrituras no coinciden con la suscripción de consulta: el objeto escrito coincide con los permisos del usuario, pero no coincide con la suscripción de consulta.

• Guardados no coinciden con los permisos: El objeto guardado coincide con la suscripción de la query, pero no coincide con los permisos del usuario.

In more detail, when you write data that is outside the bounds of a query subscription or does not match the user's permissions, the following occurs:

1. Como el realm del cliente no tiene concepto de guardados "ilegales", el guardado tiene éxito inicialmente hasta que realm resuelve el conjunto de cambios con el backend de Servicios de aplicación.

2. Upon sync, the server applies the rules and permissions. The server determines that the user does not have authorization to perform the write.

3. The server sends a revert operation, called a "compensating write", back to the client.

4. The client's realm reverts the illegal write operation.

Cualquier guardado realizado del lado del cliente en un objeto determinado entre un guardado ilegal y el correspondiente guardado de compensación se perderá.

En la práctica, esto puede parecer que se escribe un objeto en el realm y luego desaparece después de que el servidor envía el guardado compensatorio de vuelta al cliente.

Para obtener más información sobre los errores de denegación de permisos, errores de escritura compensatoria y otros tipos de errores de Device Sync, consulta Errores de sincronización en la documentación de App Services.

The App Services logs contain more information about why a compensating write error occurs.

myApp.syncManager.errorHandler = { syncError, session in
    if let thisError = syncError as? SyncError {
        switch thisError.code {
        // ... additional SyncError.code cases ...
        case .writeRejected:
            if let compensatingWriteErrorInfo = thisError.compensatingWriteInfo {
                for anError in compensatingWriteErrorInfo {
                    print("A write was rejected with a compensating write error")
                    print("The write to object type: \(anError.objectType)")
                    print("With primary key of: \(anError.primaryKey)")
                    print("Was rejected because: \(anError.reason)")
                }
            }
        }
    }
}

A write was rejected with a compensating write error
The write to object type: Optional("Item")
With primary key of: objectId(641382026852d9220b2e2bbf)
Was rejected because: Optional("write to \"641382026852d9220b2e2bbf\" in table \"Item\" not
allowed; object is outside of the current query view")

do {
    let fixTheBug = Item()
    fixTheBug.ownerId = user.id
    fixTheBug.itemName = "Fix the bug with the failing method"
    // The complexity of this item is `7`. This is outside the bounds
    // of the subscription query, so this write triggers a compensating write.
    fixTheBug.complexity = 7
    try realm.write {
        realm.add(fixTheBug)
    }
} catch {
    print("Failed to write to realm: \(error.localizedDescription)")
}

Sync: Connection[1]: Session[1]: Received: ERROR "Client attempted a
write that is outside of permissions or query filters; it has been
reverted" (error_code=231, try_again=true, error_action=Warning)

"FlexibleSync_Item": {
    "63bdfc40f16be7b1e8c7e4b7": "write to \"63bdfc40f16be7b1e8c7e4b7\"
    in table \"FlexibleSync_Item\" not allowed; object is outside of
    the current query view"
}

do {
    let itemWithWrongOwner = Item()
    // The `ownerId` of this item does not match the `user.id` of the logged-in
    // user. The user does not have permissions to make this write, so
    // it triggers a compensating write.
    itemWithWrongOwner.ownerId = "This string does not match the user.id"
    itemWithWrongOwner.itemName = "Write code that generates a permission error"
    itemWithWrongOwner.complexity = 1
    try realm.write {
        realm.add(itemWithWrongOwner)
    }
} catch {
    print("Failed to write to realm: \(error.localizedDescription)")
}

Sync: Connection[1]: Session[1]: Received: ERROR "Client attempted a
write that is outside of permissions or query filters; it has been
reverted" (error_code=231, try_again=true, error_action=Warning)

"FlexibleSync_Item": {
    "63bdfc40f16be7b1e8c7e4b8": "write to \"63bdfc40f16be7b1e8c7e4b8\"
    in table \"FlexibleSync_Item\" was denied by write filter in role
    \"owner-read-write\""
}

Errores al abrir un Realm sincronizado en varios procesos

If you attempt to open a synced realm in a Share Extension or other App Extension, and that realm is not open in the main app, a write from a Share Extension may succeed. However, if the synced realm is already open in the main app, or is syncing data in the background, you may see a crash related to Realm::MultiSyncAgents. In this scenario, you may need to restart the device.

Alternatives to Writing to a Synced Realm in an App Extension

If you need to read from or write to a synced realm from an App Extension, there are a few recommended alternatives:

• Offline-first: pasar datos en disco desde o hacia la aplicación principal

• Siempre actualizado: comuníquese directamente con la colección Atlas de respaldo a través de una conexión de red