Guardar datos en un Realm sincronizado - C++ SDK

Configuración de servicios de aplicaciones

Basado en el modelo de objeto de ejemplo anterior, Device Sync está configurado 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:

{
   "roles": [
      {
         "name": "readOwnWriteOwn",
         "apply_when": {},
         "document_filters": {
            "write": {
               "ownerId": "%%user.id"
            },
            "read": {
               "ownerId": "%%user.id"
            }
         },
         "read": true,
         "write": true,
         "insert": true,
         "delete": true,
         "search": true
      }
   ]
}

Cualquier objeto en la colección Atlas donde el ownerId no coincida con el user.identifier() del usuario que inició sesión no se puede sincronizar con este reino.

Modelo de datos del cliente y configuración

Los ejemplos en esta página utilizan la siguiente configuración Realm sincronizada con esta query de sincronización y Modelo de objeto:

auto appConfig = realm::App::configuration();
appConfig.app_id = APP_ID;
auto app = realm::App(appConfig);
auto user = app.login(realm::App::credentials::anonymous()).get();
auto dbConfig = user.flexible_sync_configuration();
auto syncRealm = realm::db(dbConfig);
// Add subscription
auto subscriptionUpdateSuccess =
    syncRealm.subscriptions()
        .update([](realm::mutable_sync_subscription_set &subs) {
          // Get Items from Atlas that match this query.
          // Uses the queryable field `complexity`.
          // Sync Item objects with complexity less than or equal to 4.
          subs.add<realm::Item>(
              "simple items", [](auto &obj) { return obj.complexity <= 4; });
        })
        .get();

struct Item {
  realm::primary_key<realm::object_id> _id{realm::object_id::generate()};
  std::string ownerId;
  std::string itemName;
  int64_t complexity;
};
REALM_SCHEMA(Item, _id, ownerId, itemName, complexity)

Con esta consulta de sincronización, cualquier objeto en la colección Atlas donde 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 del usuario y la suscripción de consulta en el cliente, el SDK de Realm C++ 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.

// Per the Device Sync permissions, users can only read and write data
// where the `Item.ownerId` property matches their own user ID.
auto simpleItem =
    realm::Item{.ownerId = user.identifier(),
                          .itemName = "This item meets sync criteria",
                          .complexity = 3};
// `simpleItem` successfully writes to the realm and syncs to Atlas
// because its data matches the subscription query (complexity <= 4)
// and its `ownerId` field matches the user ID.
syncRealm.write([&] { syncRealm.add(std::move(simpleItem)); });

Escrituras compensatorias

Cuando la escritura no coincide con la suscripción de consulta o los permisos del usuario, Realm revierte la escritura y proporciona una matriz de objetos compensating_write_error_info.

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 escritura del lado del cliente en un objeto determinado entre una escritura ilegal en ese objeto y la escritura compensatoria correspondiente se perderá. En la práctica, esto puede parecer una escritura exitosa, pero el objeto desaparece cuando Realm se sincroniza con el backend de App Services y realiza la escritura compensatoria.

Cuando esto ocurre, puede consultar los registros de App Services o usar la compensating_writes_info() función en el cliente para obtener más información sobre el error. Para más información, consulte la sección "Información sobre errores de escritura compensados" en esta página.

// The complexity of this item is `7`. This is outside the bounds
// of the subscription query, which triggers a compensating write.
auto complexItem =
    realm::Item{._id = primaryKey,
                          .ownerId = user.identifier(),
                          .itemName = "Test compensating writes",
                          .complexity = 7};
// This should trigger a compensating write error when it tries to sync
// due to server-side permissions, which gets logged with the error handler.
syncRealm.write([&] { syncRealm.add(std::move(complexItem)); });

Connection[2]: Session[10]: Received: ERROR "Client attempted a write that is not allowed; it has been reverted" (error_code=231, is_fatal=false, error_action=Warning)

Error:
Client attempted a write that is not allowed; it has been reverted (ProtocolErrorCode=231)
Details:
{
   "Item": {
      "ObjectID(\"6557ddb0bf050934870ca0f5\")": "write to ObjectID(\"6557ddb0bf050934870ca0f5\")
      in table \"Item\" not allowed; object is outside of
      the current query view"
   }
}

// 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, which
// triggers a compensating write.
auto itemWithWrongOwner = realm::Item{
    .ownerId = "not the current user",
    .itemName = "Trigger an incorrect permissions compensating write",
    .complexity = 1};
syncRealm.write([&] { syncRealm.add(std::move(itemWithWrongOwner)); });

Connection[2]: Session[11]: Received: ERROR "Client attempted a write that is not allowed; it has been reverted" (error_code=231, is_fatal=false, error_action=Warning)

Error:
Client attempted a write that is outside of permissions or query filters; it has been reverted (ProtocolErrorCode=231)
Details:
{
   "Item": {
      "ObjectID(\"6557ddbabf050934870ca0f8\")": "write to ObjectID(\"6557ddbabf050934870ca0f8\")
      in table \"Item\" was denied by write filter in role \"readOwnWriteOwn\""
   }
}

auto info = receivedSyncError.compensating_writes_info();
for (auto &v : info) {
  std::cout << "A write was rejected with a compensating write error.\n";
  std::cout << "An object of type " << v.object_name << "\n";
  std::cout << "was rejected because " << v.reason << ".\n";
}

A write was rejected with a compensating write error.
An object of type Item
was rejected because write to ObjectID("6557ddb0bf050934870ca0f5") in
table "Item" not allowed; object is outside of the current query view.