Escribir datos en un dominio sincronizado - Swift SDK

Configuración de servicios de aplicaciones

La sincronización del dispositivo está configurada con los siguientes campos consultables:

• _id (siempre incluido)

• complexity

• ownerId

La aplicación Servicios de aplicaciones tiene permisos configurados para permitir a los usuarios leer y escribir solo sus propios datos:

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

Modelo de datos del cliente y configuración

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

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 reino sincronizado solo sincroniza objetos donde:

• El ownerId coincide con el user.id del usuario que inició sesión (de los permisos)

• El valor de la propiedad complexity es menor o igual a 4 (de la consulta de suscripción)

Cualquier objeto en la colección Atlas donde ownerId no coincida con user.id del usuario que inició sesión, o el valor de la propiedad complexity sea mayor que 4, no se puede sincronizar con este reino.

Escrituras exitosas

Cuando la escritura coincide con los permisos y la consulta de suscripción de Sincronización Flexible en el cliente, el SDK de Realm Swift puede escribir correctamente el objeto en el dominio sincronizado. Este objeto se sincroniza con el backend de App Services cuando el dispositivo tiene 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)")
}

Escrituras compensatorias

En algunos casos, una escritura que inicialmente parece correcta es en realidad una escritura ilegal. En estos casos, el objeto escribe en la base de datos, pero cuando esta se sincroniza con el backend, Realm revierte la escritura mediante una operación de compensación de errores no fatales. Las escrituras de compensación pueden ocurrir cuando:

• 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.

En más detalle, cuando se escriben datos que están fuera de los límites de una suscripción de consulta o no coinciden con los permisos del usuario, ocurre lo siguiente:

1. Debido a que el ámbito del cliente no tiene el concepto de escrituras "ilegales", la escritura inicialmente tiene éxito hasta que el ámbito resuelve el conjunto de cambios con el backend de App Services.

2. Tras la sincronización, el servidor aplica las reglas y los permisos. El servidor determina que el usuario no tiene autorización para realizar la escritura.

3. El servidor envía una operación de reversión, denominada "escritura compensatoria", al cliente.

4. El reino del cliente revierte la operación de escritura ilegal.

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 como un objeto que se escribe en el reino y luego desaparece después de que el servidor envía la escritura compensatoria al cliente.

Para obtener más información sobre errores de permiso denegado, compensación de errores de escritura y otros tipos de errores de sincronización de dispositivos, consulte Errores de sincronización en la documentación de App Services.

Los registros de App Services contienen más información sobre por qué ocurre un error de escritura compensatoria.

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\""
}

Fallos relacionados con la apertura de un dominio sincronizado en varios procesos

Si intenta abrir un dominio sincronizado en una extensión compartida u otra extensión de la aplicación, y dicho dominio no está abierto en la aplicación principal, es posible que la escritura desde una extensión compartida se realice correctamente. Sin embargo, si el dominio sincronizado ya está abierto en la aplicación principal o está sincronizando datos en segundo plano, podría aparecer un fallo relacionado con Realm::MultiSyncAgents. En este caso, es posible que deba reiniciar el dispositivo.

Alternativas a escribir en un dominio sincronizado en una extensión de aplicación

Si necesita leer o escribir en un reino sincronizado desde una extensión de aplicación, existen algunas alternativas recomendadas:

• Primero sin conexión: pasa datos del disco hacia o desde 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