Configurar e abrir um domínio sincronizado Realm - do Node.js SDK

Domínios sincronizados

Você pode configurar um domínio para sincronizar automaticamente os dados entre vários dispositivos, cada um com sua própria cópia local dos dados. Os domínios sincronizados usam uma configuração diferente dos domínios somente locais e exigem um backend do Atlas App Services para lidar com o processo de sincronização.

Os aplicativos podem sempre criar, modificar e excluir objetos de Realm sincronizados localmente, mesmo quando estiver offline. Sempre que uma conexão de rede está disponível, o Realm SDK abre uma conexão com um servidor de aplicação e sincroniza as alterações de e para outros clientes. O protocolo Atlas Device Sync e as transformações operacionais do lado do servidor garantem que todas as instâncias totalmente sincronizadas de um Realm vejam exatamente os mesmos dados, mesmo que algumas alterações tenham ocorrido offline e/ou tenham sido recebidas fora de ordem.

Pré-requisitos

Antes de configurar um Realm com Flexible Sync em uma aplicação Node.js:

1. Habilitar Flexible Sync no backend. Você deve configurar o Flexible Sync no backend antes de poder usá-lo com seu aplicação cliente.

2. Inicialize a aplicação do cliente.

3. Autenticar um usuário em seu projeto de cliente.

Abrir um realm sincronizado

A primeira etapa na implementação do Device Sync é abrir o Realm sincronizado. As informações a seguir pertencem a um aplicativo que usa o Flexible Sync. Se o seu aplicativo existente usa a sincronização antiga baseada em partição, consulte Abrir um Realm sincronizado baseado em partição. Se você ainda não decidiu ou não sabe qual usar, leia a página Escolha seu modo de sincronização .

Para abrir um Realm usando o Flexible Sync, chame Realm.open(). Passe um objeto ConfigurationWithSync , que deve incluir a propriedade sync definindo um objeto SyncConfiguration . No SyncConfiguration, você deve incluir um user e flexible:true.

const realm = await Realm.open({
  schema: [TaskSchema, TeamSchema],
  sync: {
    user: app.currentUser,
    flexible: true,
  },
});

Por padrão, o Realm sincroniza todos os dados do servidor antes de retornar. Se você quiser sincronizar dados em segundo plano, leia a seção Abrir um Realm sincronizado enquanto estiver offline .

const app = new Realm.App({ id: APP_ID, baseFilePath: customPath });
const user = await app.logIn(Realm.Credentials.anonymous());
const realm = await Realm.open({
  schema: [Car],
  sync: {
    flexible: true,
    user,
  },
});

Abrir um Realm sincronizado enquanto estiver offline

Quando seu aplicativo Realm autentica um usuário, armazena em cache as credenciais do usuário. Você pode verificar as credenciais de usuário existentes para ignorar o fluxo de login e acessar o usuário em cache. Use isto para abrir um realm offline.

// Log user into your App Services App.
// On first login, the user must have a network connection.
const getUser = async () => {
  // If the device has no cached user credentials, log in.
  if (!app.currentUser) {
    const credentials = Realm.Credentials.anonymous();
    await app.logIn(credentials);
  }
  // If the app is offline, but credentials are
  // cached, return existing user.
  return app.currentUser!;
};

As subseções a seguir mostram como usar a sincronização de plano de fundo para acessar um domínio enquanto estiver off-line. Para fazer isso, use o usuário em cache e um objeto OpenRealmBehaviorConfiguration .

Na configuração de sincronização, defina os campos newRealmFileBehavior e existingRealmFileBehavior opcionais para o objeto OpenRealmBehaviorConfiguration para habilitar a sincronização em segundo plano.

const behaviorConfiguration = {
  type: "openImmediately",
};
const config = {
  schema: [Car],
  sync: {
    user: await getUser(),
    flexible: true,
    newRealmFileBehavior: behaviorConfiguration,
    existingRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);

const behaviorConfiguration: Realm.OpenRealmBehaviorConfiguration = {
  type: "openImmediately",
};
const config: Realm.Configuration = {
  schema: [Car],
  sync: {
    user: await getUser(),
    flexible: true,
    newRealmFileBehavior: behaviorConfiguration,
    existingRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);

const behaviorConfiguration = {
  type: "openImmediately",
  timeOut: 1000,
  timeOutBehavior: "openLocalRealm",
};
const config = {
  schema: [Car],
  sync: {
    flexible: true,
    user: await getUser(),
    existingRealmFileBehavior: behaviorConfiguration,
    newRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);

const behaviorConfiguration: Realm.OpenRealmBehaviorConfiguration = {
  type: "openImmediately",
  timeOut: 1000,
  timeOutBehavior: "openLocalRealm",
};
const config: Realm.Configuration = {
  schema: [Car],
  sync: {
    flexible: true,
    user: await getUser(),
    existingRealmFileBehavior: behaviorConfiguration,
    newRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);

Sincronizar alterações em segundo plano

Talvez você queira sincronizar as alterações em segundo plano para exibir dados parciais para o usuário enquanto o domínio sincronizado baixa os dados do servidor, evitando que a experiência do usuário seja bloqueada. Recomendamos sincronizar alterações em segundo plano para aplicativos em que o dispositivo do usuário possa ficar off-line. Para sincronizar alterações no plano de fundo, abra um domínio sincronizado de forma sincronizada.

Crie um objeto OpenRealmBehaviorConfiguration e defina seu type como "openImmediately".

const behaviorConfiguration = {
  type: "openImmediately",
};

const behaviorConfiguration: Realm.OpenRealmBehaviorConfiguration = {
  type: Realm.OpenRealmBehaviorType.OpenImmediately,
};

Crie um objeto de configuração , que deve incluir a propriedade sync definindo um objeto SyncConfiguration . Defina este objeto OpenRealmBehaviorConfiguration como o valor para os campos newRealmFileBehavior e existingRealmFileBehavior do SyncConfiguration.

const config = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser,
    partitionValue: "MyPartitionValue",
    // The behavior to use when this is the first time opening a realm.
    newRealmFileBehavior: behaviorConfiguration,
    // The behavior to use when a realm file already exists locally,
    // i.e. you have previously opened the realm.
    existingRealmFileBehavior: behaviorConfiguration,
  },
};

const config: Realm.Configuration = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser!,
    partitionValue: "MyPartitionValue",
    // The behavior to use when this is the first time opening a realm.
    newRealmFileBehavior: behaviorConfiguration,
    // The behavior to use when a realm file already exists locally,
    // i.e. you have previously opened the realm.
    existingRealmFileBehavior: behaviorConfiguration,
  },
};

Por fim, chame Realm.open() para abrir um Realm sincronizado. Isso criará uma sessão de sincronização e começará a baixar todos os dados existentes do servidor em segundo plano.

const realm = await Realm.open(config);

Cancelar operações assíncronas após um tempo-limite

Você pode especificar uma propriedade cancelWaitsOnNonFatalErrors em seu objeto BaseSyncConfiguration .

Quando true, o Node.js SDK cancela operações assíncronas, como esperar por uploads ou downloads, quando um período de tempo limite termina. Você pode definir o tempo limite para essa opção no AppConfiguration. Para obter um exemplo, consulte Configurar um tempo limite para o cliente do aplicativo.

Esta propriedade é padronizada para false se você não especificar um valor.

const config = {
  schema: [Doggie],
  sync: {
    flexible: true,
    user: app.currentUser,
    // When `true`, upload and download waits are canceled on any
    // error, such as a timeout, instead of just a fatal error.
    // You can provide an optional timeouts property in milliseconds.
    cancelWaitsOnNonFatalError: true,
  },
};

const config: Realm.Configuration = {
  schema: [Doggie],
  sync: {
    flexible: true,
    user: app.currentUser!,
    // When `true`, upload and download waits are canceled on any
    // error, such as a timeout, instead of just a fatal error.
    // You can provide an optional timeouts property in milliseconds.
    cancelWaitsOnNonFatalError: true,
  },
};