Gravar dados em um domínio sincronizado - Swift SDK

Configuração do App Services

O Realm Mobile Sync é configurado com os seguintes campo de query:

• _id (Sempre incluído)

• complexity

• ownerId

O App Services App tem permissões configuradas para permitir que os usuários leiam e escrevam somente seus próprios dados:

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

Modelo de dados Realm e configuração do cliente

Os exemplos nesta página usam o seguinte modelo de objeto:

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

Utilizando esse modelo de objetos, a configuração do Realm sincronizado sincroniza objeto que correspondem à query onde o valor da propriedade complexity é menor ou 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)")
}

Quais dados são sincronizados?

A query de assinatura combinada com as permissões significa que o domínio sincronizado sincroniza apenas objetos em que:

• O ownerId corresponde ao user.id do usuário conectado (a partir das permissões)

• O valor da propriedade complexity é menor ou igual a 4 (da query de assinatura)

Qualquer objeto na Atlas collection em que ownerId não corresponda ao user.id do usuário conectado ou em que o valor da propriedade complexity seja maior que 4 não pode ser sincronizado com esse Realm.

Gravações bem-sucedidas

Quando a gravação corresponde às permissões e à query de inscrição do Flexible Sync no cliente, o Realm Swift SDK pode gravar o objeto com êxito no domínio sincronizado. Este objeto é sincronizado com o backend do Atlas App Services quando o dispositivo tem uma conexão de rede.

// 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)")
}

Compensação de escritas

Em alguns casos, uma escrita que inicialmente parece bem-sucedida é, na verdade, uma escrita ilegal. Nesses casos, o objeto grava no reconhecimento de data center, mas quando o reconhecimento de data center sincroniza com o backend, o Realm reverte a escrita em uma operação de erro não fatal chamada escrita compensatória. As gravações compensatórias podem ocorrer quando:

• As gravações não correspondem à assinatura da query: O objeto gravado corresponde às permissões do usuário, mas não corresponde à assinatura da query.

• As gravações não correspondem às permissões: o objeto gravado corresponde à assinatura da query, mas não corresponde às permissões do usuário.

Em mais detalhes, quando você grava dados que estão fora dos limites de uma assinatura de query ou não correspondem às permissões do usuário, ocorre o seguinte:

1. Como o Realm do cliente não tem nenhum conceito de gravações "ilegais", a gravação inicialmente é bem-sucedida até que o Realm resolva o conjunto de alterações com o backend do App Services.

2. Após a sincronização, o servidor aplica as regras e permissões. O servidor determina que o usuário não tem autorização para realizar a gravação.

3. O servidor envia uma operação de reversão, chamada de "escrita compensatória", de volta ao cliente.

4. O Realm do cliente reverte a operação de escrita ilegal.

Qualquer escrita do lado do cliente em um determinado objeto entre uma escrita ilegal nesse objeto e a escrita compensatória correspondente será perdida.

Na prática, isso pode parecer um objeto sendo gravado no Realm e desaparecer depois que o servidor enviar a gravação compensatória de volta ao cliente.

Para saber mais sobre erros de permissão negada, erros de gravação compensatórios e outros tipos de erro do Device Sync , consulte Erros de sincronização na documentação do Atlas App Services .

Os registrosAtlas App Services contêm mais informações sobre o motivo de um erro de gravação compensatório.

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

Falhas relacionadas à abertura de um Realm sincronizado em vários processos

Se você tentar abrir um Realm sincronizado em uma Extensão de Compartilhamento ou outra Extensão de Aplicativo, e esse Realm não estiver aberto no aplicativo principal, uma gravação de uma Extensão de Compartilhamento poderá ser bem-sucedida. No entanto, se o Realm sincronizado já estiver aberto no aplicativo principal ou estiver sincronizando dados em segundo plano, você poderá ver uma falha relacionada a Realm::MultiSyncAgents. Nesse cenário, talvez seja necessário reiniciar o dispositivo.

Alternativas para escrever em um Realm sincronizado em uma extensão de aplicativo

Se você precisar ler ou gravar em um Realm a partir de uma extensão de aplicativo, existem algumas alternativas recomendadas:

• Offline-first: passe dados no disco de ou para o aplicativo principal

• Sempre atualizado : comunique-se diretamente com a collection de apoio do Atlas por meio de uma conexão de rede