Configurar um Realm - React Native SDK

Pré-requisitos

Antes de configurar um domínio em um aplicativo React Native:

1. Instale o SDK nativo do Realm React

2. Instale o pacote @ Realm /react

Configurar um domínio sem sincronização

RealmProvider é um invólucro que expõe um domínio aos seus componentes secundários. Você configura seu domínio passando adereços para RealmProvider.

Quando RealmProvider é renderizado, ele abre o domínio. Isso significa que os componentes filhos não poderão acessar o realm se a renderização falhar.

Para configurar um domínio não sincronizado:

1. Importe RealmProvider de @realm/react.

2. Passe seus modelos de objeto para a propriedade schema .

3. Adicione outras propriedades de objeto de configuração como acessórios no RealmProvider para configurar seu domínio.

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

Para obter uma lista de provedores e ganchos usados em áreas não sincronizadas, consulte @realm/react Provedores e Ganchos.

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

Configurar um realm sincronizado

Para abrir um domínio que sincroniza dados com Atlas utilizando a Device Sync, consulte Abrir um Realm Sincronizado.

Exponha mais de um domínio

O @realm/react pacote expõe regiões em seu aplicação usando objetos React Context e componentes do provedor. Você pode acessar domínios com ganchos React.

Para expor mais de um domínio, considere o seguinte:

• Cada região precisa de seu próprio objeto Context, criado com createRealmContext().

• Os provedores e ganchos dentro de cada contexto devem ser nomeados para que seja fácil raciocinar sobre o domínio com o qual você está trabalhando.

• Se importar RealmProvider diretamente de @realm/react, é um objeto Contexto separado. Os provedores e ganchos deste objeto não podem ser desinstalados com objetos de contexto criados utilizando 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...
}

Acesse um domínio sem fornecer um esquema

Depois que um realm é criado em um dispositivo, você não precisa sempre passar um esquema para acessar o domínio. Em vez disso, você pode utilizar o RealmProvider sem passar quaisquer modelos de objeto para sua propriedade schema. O esquema do domínio é derivado do arquivo de domínio existente em Realm.defaultPath.

Acessar um domínio sem fornecer um esquema só funciona para domínios locais. Você deve sempre passar um esquema ao usar um domínio 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>
  );
}

@realm/react Providers and Hooks

@realm/react tem provedores e ganchos que simplificam o trabalho com seu domínio não sincronizado e seus dados.

const realm = useRealm();

const myTask = useObject(Task, _id);

const tasks = useQuery(Task);