Recuperação manual de dados de redefinição do cliente - React Native SDK

Rastrear alterações por estratégia de objeto

A estratégia de recuperação de dados de reinício do cliente de objeto permite recuperar dados já gravados no Arquivo de Realm do cliente, mas ainda não sincronizados com o backend.

Nesta estratégia, você adiciona um "horário da última atualização" a cada modelo de objeto para acompanhar quando cada objeto foi alterado pela última vez. Observaremos para determinar quando o Realm carregou pela última vez seu estado para o back-end.

Quando o backend invoca um reinício do cliente, localize objetos que foram excluídos, criados ou atualizados desde a última sincronização com o backend. Em seguida, copie esses dados do Realm de backup para o novo Realm.

As etapas a seguir demonstram a implementação do processo em um alto nível:

1. Erro de reinício do cliente: sua aplicação recebe um código de erro de reinício do cliente do backend.

2. Implementação da estratégia: o SDK chama a implementação da estratégia.

3. Feche todas as instâncias do Realm: Feche todas as instâncias abertas do Realm que estão enfrentando o reinício do cliente. Se a arquitetura da sua aplicação dificultar isso (por exemplo, se a sua aplicação usar muitas Instância de Realm simultaneamente em ouvintes em toda a aplicação), pode ser mais fácil reiniciar a aplicação. Você pode fazer isso programaticamente ou por meio de uma solicitação direta ao usuário em uma caixa de diálogo.

4. Mova o domínio para um arquivo de backup: Ligue para o Realm.App.Sync.initiateClientReset() método estático. Este método move a cópia atual do arquivo de domínio do cliente para um arquivo de backup.

5. Abra uma nova instância do Realm: Abra uma nova instância do Realm usando sua configuração de sincronização típica. Se a sua aplicação usar vários Realms, você poderá identificar o Realm que está enfrentando um reinício do cliente a partir do nome do arquivo de backup.

6. Baixar todos os dados do domínio do backend: Baixe todo o conjunto de dados no domínio antes de prosseguir. Este é o comportamento padrão do objeto FlexibleSyncConfiguration .

7. Open the Realm backup: Use o objeto error.config passado como argumento para a função de chamada de resposta SyncConfiguration.error .

8. Migrar alterações não sincronizadas: Query o Realm de backup para obter dados a serem recuperados. Insira, exclua ou atualize dados no novo Realm adequadamente.

const DogSchema = {
  name: "Dog",
  properties: {
    name: "string",
    age: "int?",
    lastUpdated: "int",
  },
};

const config = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser,
    partitionValue: "MyPartitionValue",
    clientReset: {
      mode: "manual",
    },
    error: handleSyncError, // callback function defined later
  },
};

const LastSyncedSchema = {
  name: "LastSynced",
  properties: {
    realmTracked: "string",
    timestamp: "int?",
  },
  primaryKey: "realmTracked",
};
const lastSyncedConfig = { schema: [LastSyncedSchema] };
const lastSyncedRealm = await Realm.open(lastSyncedConfig);
lastSyncedRealm.write(() => {
  lastSyncedRealm.create("LastSynced", {
    realmTracked: "Dog",
  });
});

// Listens for changes to the Dogs collection
realm.objects("Dog").addListener(async () => {
  // only update LastSynced if sync session is connected
  // and all local changes are synced
  if (realm.syncSession.isConnected()) {
    await realm.syncSession.uploadAllLocalChanges();
    lastSyncedRealm.write(() => {
      lastSyncedRealm.create("LastSynced", {
        realmTracked: "Dog",
        timestamp: Date.now(),
      });
    });
  }
});

async function handleSyncError(_session, error) {
  if (error.name === "ClientReset") {
    const realmPath = realm.path; // realm.path will not be accessible after realm.close()
    realm.close(); // you must close all realms before proceeding
    // pass your realm app instance and realm path to initiateClientReset()
    Realm.App.Sync.initiateClientReset(app, realmPath);
    // Redownload the realm
    realm = await Realm.open(config);
    const oldRealm = await Realm.open(error.config);
    const lastSyncedTime = lastSyncedRealm.objectForPrimaryKey(
      "LastSynced",
      "Dog"
    ).timestamp;
    const unsyncedDogs = oldRealm
      .objects("Dog")
      .filtered(`lastUpdated > ${lastSyncedTime}`);
    // add unsynced dogs to synced realm
    realm.write(() => {
      unsyncedDogs.forEach((dog) => {
        realm.create("Dog", dog, "modified");
      });
    });
    // delete dogs from synced realm that were deleted locally
    const syncedDogs = realm
      .objects("Dog")
      .filtered(`lastUpdated <= ${lastSyncedTime}`);
    realm.write(() => {
      syncedDogs.forEach((dog) => {
        if (!oldRealm.objectForPrimaryKey("Dog", dog._id)) {
          realm.delete(dog);
        }
      });
    });
    // make sure everything syncs and close old realm
    await realm.syncSession.uploadAllLocalChanges();
    oldRealm.close();
  } else {
    console.log(`Received error ${error.message}`);
  }
}

Estratégias alternativas

Possíveis implementações alternativas incluem:

• Substitua todo o backend pelo estado do backup: sem "hora da última atualização" ou "hora da última sincronização", faça o upsert de todos os objeto do Realm de backup no novo Realm. Não há como recuperar exclusões não sincronizadas com essa abordagem. Essa abordagem substitui todos os dados gravados no backend por outros clientes desde a última sincronização. Recomendado para aplicação em que apenas um usuário grava em cada Realm.

• Rastrear alterações por campo: em vez de rastrear uma "hora da última atualização" para cada objeto, acompanhe a "hora da última atualização" de cada campo. Atualize os campos individualmente usando essa lógica para evitar a substituição de gravações de campos de outros clientes por dados antigos. Recomendado para aplicativos com muitos campos por objeto onde os conflitos devem ser resolvidos no nível do campo.

• Acompanhe as atualizações separadamente dos objetos: em vez de acompanhar uma "hora da última atualização" no esquema de cada objeto, crie outro modelo no seu esquema chamado Updates. Toda vez que qualquer campo em qualquer objeto (além Updates) for atualizado, registre a chave primária, o campo e a hora da atualização. Durante um reinício do cliente, "reescreva" todos os evento Update que ocorreram após o "último tempo sincronizado" usando o valor mais recente desse campo no Realm de backup. Essa abordagem deve replicar todas as alterações locais não sincronizadas no novo Realm sem substituir nenhum campo por dados obsoletos. No entanto, armazenar a collection de atualizações pode se tornar caro se sua aplicação for gravado com frequência. Recomendado para aplicativos em que adicionar campos "lastUpdated" a modelos de objetos não é desejável.