Configurar un dominio - SDK de React Native

Requisitos previos

Antes de configurar un reino en una aplicación React Native:

1. Instalar el SDK de React Native de Realm

2. Instala el Paquete @realm/react

Configurar un reino sin sincronización

RealmProvider es un contenedor que expone un dominio a sus componentes secundarios. El dominio se configura pasando RealmProvider propiedades a.

Al renderizar RealmProvider, se abre el dominio. Esto significa que los componentes secundarios no pueden acceder al dominio si falla el renderizado.

Para configurar un reino no sincronizado:

1. Importar RealmProvider desde @realm/react.

2. Pase sus modelos de objetos a la propiedad schema.

3. Agregue otras propiedades de objeto de configuración como accesorios a RealmProvider para configurar su reino.

import React from 'react';
import {RealmProvider} from '@realm/react';
function AppWrapperLocal() {
  return (
    <RealmProvider schema={[YourObjectModel]}>
      <RestOfApp />
    </RealmProvider>
  );
}

Para obtener una lista de proveedores y ganchos utilizados en un reino no sincronizado, consulte Proveedores y ganchos de @realm/react.

import React from 'react';
import {Realm, RealmProvider} from '@realm/react';
function AppWrapperLocal() {
  return (
    <RealmProvider inMemory={true}>
      <RestOfApp />
    </RealmProvider>
  );
}

Configurar un reino sincronizado

Para abrir un reino que sincronice datos con Atlas mediante Sincronización de dispositivos, consulte Abrir un reino sincronizado.

Exponer más de un reino

El @realm/react paquete expone dominios en tu aplicación mediante objetos de contexto de React y componentes de proveedor. Puedes acceder a los dominios con ganchos de React.

Para exponer más de un reino, considere lo siguiente:

• Cada reino necesita su propio objeto Context, creado con createRealmContext().

• Los proveedores y ganchos dentro de cada contexto deben tener espacios de nombres para que sea fácil razonar sobre el ámbito con el que estás trabajando.

• Si importa RealmProvider directamente desde @realm/react, se trata de un objeto Context independiente. Los proveedores y ganchos de ese objeto no pueden desincronizarse con los objetos Context creados con createRealmContext.

import React from 'react';
import {
  Realm,
  AppProvider,
  UserProvider,
  createRealmContext,
} from '@realm/react';
class SharedDocument extends Realm.Object {
  static schema = {
    name: 'SharedDocument',
    properties: {
      _id: 'objectId',
      owner_id: 'objectId',
      title: 'string',
      createdDate: 'date',
    },
    primaryKey: '_id',
  };
}
class LocalDocument extends Realm.Object {
  static schema = {
    name: 'LocalDocument',
    properties: {
      _id: 'objectId',
      name: 'string',
      createdDate: 'date',
    },
  };
}
// Create Shared Document context object.
const SharedRealmContext = createRealmContext({
  schema: [SharedDocument],
});
// Create Local Document context object.
const LocalRealmContext = createRealmContext({
  schema: [LocalDocument],
});

import React from 'react';
import {
  Realm,
  AppProvider,
  UserProvider,
  createRealmContext,
} from '@realm/react';
class SharedDocument extends Realm.Object<SharedDocument> {
  _id!: Realm.BSON.ObjectId;
  owner_id!: Realm.BSON.ObjectId;
  title!: string;
  createdDate?: Date;
  static schema: ObjectSchema = {
    name: 'SharedDocument',
    properties: {
      _id: 'objectId',
      owner_id: 'objectId',
      title: 'string',
      createdDate: 'date',
    },
    primaryKey: '_id',
  };
}
class LocalDocument extends Realm.Object<LocalDocument> {
  _id!: Realm.BSON.ObjectId;
  name!: string;
  createdDate?: Date;
  static schema: ObjectSchema = {
    name: 'LocalDocument',
    properties: {
      _id: 'objectId',
      name: 'string',
      createdDate: 'date',
    },
  };
}
// Create Shared Document context object.
const SharedRealmContext = createRealmContext({
  schema: [SharedDocument],
});
// Create Local Document context object.
const LocalRealmContext = createRealmContext({
  schema: [LocalDocument],
});

// Namespace the Shared Document context's providers and hooks.
const {
  RealmProvider: SharedDocumentRealmProvider,
  useRealm: useSharedDocumentRealm,
} = SharedRealmContext;
// Namespace the Local Document context's providers and hooks.
const {
  RealmProvider: LocalDocumentRealmProvider,
  useRealm: useLocalDocumentRealm,
} = LocalRealmContext;

function TwoRealmsWrapper() {
  return (
    <View>
      <AppProvider id={APP_ID}>
        <UserProvider fallback={LogIn}>
          {/* This is a Flexible Sync realm. */}
          <SharedDocumentRealmProvider sync={{flexible: true}}>
            <AppSectionOne />
          </SharedDocumentRealmProvider>
        </UserProvider>
      </AppProvider>
      {/* This is a separate local-only realm. */}
      <LocalDocumentRealmProvider>
        <AppSectionTwo />
      </LocalDocumentRealmProvider>
    </View>
  );
}
function AppSectionOne() {
  const realm = useSharedDocumentRealm();
  // Work with shared documents...
}
function AppSectionTwo() {
  const realm = useLocalDocumentRealm();
  // Work with local documents...
}

Acceder a un dominio sin proporcionar un esquema

Tras crear un dominio en un dispositivo, no es necesario pasar siempre un esquema para acceder a él. En su lugar, se puede usar RealmProvider sin pasar ningún modelo de objeto a su propiedad schema. El esquema del dominio se deriva del archivo de dominio existente en Realm.defaultPath.

Acceder a un dominio sin proporcionar un esquema solo funciona con dominios locales. Siempre debe proporcionar un esquema al usar un dominio sincronizado.

import React from 'react';
import {RealmProvider} from '@realm/react';
function AppWrapper() {
  return (
    // To access a realm at the default path, do not pass any configuration.
    // Requires a realm that has already been created.
    <RealmProvider>
      <RestOfApp />
    </RealmProvider>
  );
}

Proveedores y ganchos de @realm/react

@realm/react tiene proveedores y ganchos que simplifican el trabajo con su reino no sincronizado y sus datos.

const realm = useRealm();

const myTask = useObject(Task, _id);

const tasks = useQuery(Task);