Configure y abra un Synced Realm - Node.js SDK

Realms sincronizados

Puedes configurar un dominio para que sincronice automáticamente datos entre varios dispositivos, cada uno con su propia copia local. Los dominios sincronizados utilizan una configuración diferente a la de los dominios locales y requieren un backend de Atlas App Services para gestionar el proceso de sincronización.

Las aplicaciones siempre pueden crear, modificar y eliminar objetos de dominio sincronizados localmente, incluso sin conexión. Siempre que haya una conexión de red disponible, el SDK de dominio abre una conexión con un servidor de aplicaciones y sincroniza los cambios con y desde otros clientes. El protocolo Atlas Device Sync y las transformaciones operativas del lado del servidor garantizan que todas las instancias totalmente sincronizadas de un reino vean exactamente los mismos datos, incluso si algunos cambios ocurrieron sin conexión y/o se recibieron fuera de orden.

Requisitos previos

Antes de configurar un reino con sincronización flexible en una aplicación Node.js:

1. Habilite la sincronización flexible en el backend. Debe configurar la sincronización flexible en el backend para poder usarla con su aplicación cliente.

2. Inicializar el cliente de la aplicación.

3. Autenticar un usuario en su proyecto cliente.

Abrir un reino sincronizado

El primer paso para implementar la Sincronización de Dispositivos es abrir el dominio sincronizado. La siguiente información corresponde a una aplicación que utiliza la Sincronización Flexible. Si su aplicación utiliza la sincronización basada en particiones, consulte "Abrir un dominio sincronizado basado en particiones". Si aún no ha decidido o no está seguro de cuál usar, consulte la página "Elija su modo de sincronización".

Para abrir un reino usando Sincronización flexible, llame a Realm.open(). Pase un objeto ConfigurationWithSync, que debe incluir el sync Propiedad que define un objeto SyncConfiguration. En SyncConfiguration, debe incluir user flexible:truey.

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

De forma predeterminada, Realm sincroniza todos los datos del servidor antes de regresar. Si desea sincronizar datos en segundo plano, consulte la sección "Abrir un Realm sincronizado sin conexión".

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 un reino sincronizado sin conexión

Cuando tu aplicación Realm autentica a un usuario, almacena en caché las credenciales del usuario. Puedes comprobar si existen credenciales de usuario para omitir el flujo de inicio de sesión y acceder al usuario almacenado en caché. Usa esto para abrir un realm sin conexión.

// 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!;
};

Las siguientes subsecciones muestran cómo usar la sincronización en segundo plano para acceder a un dominio sin conexión. Para ello, utilice el usuario en caché y un objeto OpenRealmBehaviorConfiguration.

Dentro de su configuración de sincronización, configure los campos opcionales newRealmFileBehavior y existingRealmFileBehavior en su objeto OpenRealmBehaviorConfiguration para habilitar la sincronización en 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 cambios en segundo plano

Es posible que desee sincronizar los cambios en segundo plano para mostrar datos parciales al usuario mientras el dominio sincronizado descarga datos del servidor, lo que evita que la experiencia del usuario se vea bloqueada. Recomendamos sincronizar los cambios en segundo plano para las aplicaciones en las que el dispositivo del usuario pueda desconectarse. Para sincronizar los cambios en segundo plano, abra un dominio sincronizado sincrónicamente.

Cree un objeto OpenRealmBehaviorConfiguration y establezca su type "openImmediately"en.

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

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

Cree un objeto Configuration, que debe incluir la sync propiedad que define un objeto SyncConfiguration. Establezca este OpenRealmBehaviorConfiguration objeto como valor para los newRealmFileBehavior existingRealmFileBehavior campos y SyncConfiguration de.

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,
  },
};

Finalmente, llama a Realm.open() para abrir un reino sincronizado. Esto creará una sesión de sincronización y comenzará a descargar los datos existentes del servidor en segundo plano.

const realm = await Realm.open(config);

Cancelar operaciones asincrónicas después de un tiempo de espera

Puede especificar una cancelWaitsOnNonFatalErrors propiedad en su objeto BaseSyncConfiguration.

trueCuando, el SDK de Node.js cancela las operaciones asíncronas, como la espera de cargas o descargas, al transcurrir un tiempo de espera. Puede definir el tiempo de espera para esta opción en AppConfiguration. Para ver un ejemplo, consulte Configurar un tiempo de espera para el cliente de la aplicación.

Esta propiedad tiene como valor predeterminado false si no especifica un 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,
  },
};