Menu Docs
Página inicial do Docs
/
MongoDB Atlas
/
Atlas Device SDKs

Início rápido - SDK do Node.js

Nesta página

  • Importar Realm
  • Definir seu modelo de objeto
  • Abrir um Realm
  • Encontrar, classificar e filtrar objetos
  • Criar, modificar e excluir Objeto de Realm
  • Assista a uma coleção
  • Fechar um Realm
  • Adicionar Device Sync (opcional)
  • Pré-requisitos
  • Inicialize o aplicativo
  • Autenticar um usuário
  • Definir um modelo de objeto
  • Abrir um realm sincronizado

Esta página contém informações para integrar o Realm à sua aplicação rapidamente.

Instale o Realm Node.js SDK, caso ainda não tenha feito isso.

Importar Realm

Na parte superior dos arquivos de origem onde você deseja usar Realm, adicione a seguinte linha para importar o SDK e a biblioteca BSON.

import Realm, { BSON } from "realm";

Definir seu modelo de objeto

O modelo de objeto do aplicativo define os dados que você pode armazenar no Realm.

Para definir um Tipo de objeto de Realm, crie um objeto de esquema que especifique o name e properties do Tipo de objeto de Realm. O nome do tipo deve ser exclusivo entre os Tipo de objeto de Realm em um Realm. Para obter detalhes sobre como definir propriedades específicas, consulte Definir propriedades do objeto.

O seguinte código mostra como definir um modelo de objeto para um objeto Task . Neste exemplo:

  • O primaryKey é o _id do tipo int. Outro tipo comum usado para chaves primárias é o ObjectId.

  • O campo name é obrigatório.

  • Os campos status e owner_id são opcionais, indicados pelo ponto de interrogação imediatamente após o tipo de dados.

export class QuickstartTask extends Realm.Object {
  static schema = {
    name: "Task",
    properties: {
      _id: "objectId",
      name: "string",
      status: "string?",
      owner_id: "string?",
    },
    primaryKey: "_id",
  };
}
export class QuickstartTask extends Realm.Object<Task> {
  _id!: BSON.ObjectID;
  name!: string;
  status?: string;
  owner_id?: string;
  static schema: ObjectSchema = {
    name: "Task",
    properties: {
      _id: "objectId",
      name: "string",
      status: "string?",
      owner_id: "string?",
    },
    primaryKey: "_id",
  };
}

Abrir um Realm

Para abrir um Realm , passe um objeto Realm .BaseConfiguration para Realm.open().

const realm = await Realm.open({
  schema: [QuickstartTask],
});

Encontrar, classificar e filtrar objetos

O seguinte código demonstra como:

  • Query para todas as instâncias do tipo de objeto "Tarefa".

  • Filtre a consulta para recuperar apenas as tarefas que são "Abertas".

  • Classifique as tarefas pelo nome em ordem crescente.

// Query for specific obect using primary key.
const specificTask = realm.objectForPrimaryKey(QuickstartTask, testId);
// Query realm for all instances of the "Task" type.
const tasks = realm.objects(QuickstartTask);
// Filter for all tasks with a status of "Open".
const openTasks = tasks.filtered("status = 'Open'");
// Sort tasks by name in ascending order.
const tasksByName = tasks.sorted("name");

Criar, modificar e excluir Objeto de Realm

Após abrir um realm, você pode criar, modificar e excluir objetos nele. Todas as operações de gravação devem ocorrer dentro de uma transação de escrita.

const allTasks = realm.objects(QuickstartTask);
// Add a couple of Tasks in a single, atomic transaction.
realm.write(() => {
  realm.create(QuickstartTask, {
    _id: firstId,
    name: "go grocery shopping",
    status: "Open",
  });
  realm.create(QuickstartTask, {
    _id: secondId,
    name: "go exercise",
    status: "Open",
  });
});
const task1 = allTasks.find(
  (task) => task._id.toString() == firstId.toString()
);
const task2 = allTasks.find(
  (task) => task._id.toString() == secondId.toString()
);
realm.write(() => {
  // Modify an object.
  task1!.status = "InProgress";
  // Delete an object.
  realm.delete(task2!);
});

Assista a uma coleção

Você pode assistir a um domínio, coleção ou objeto para alterações registrando manipuladores de eventos com o Realm.addListener() Object.addListener() Métodos Collection.addListener() .

Importante

Questões importantes

Em manipuladores de notificações de collection, sempre execute alterações na seguinte ordem: exclusões, inserções e modificações. Manipular inserções antes de exclusões pode resultar em comportamento inesperado.

No exemplo a seguir, um desenvolvedor de aplicativos observa as alterações na coleção Task .

// Define the collection notification listener.
const listener = (tasks, changes) => {
  // Update UI in response to deleted objects.
  changes.deletions.forEach((index) => {
    // Deleted objects cannot be accessed directly,
    // but we can update a UI list, etc. knowing the index.
    console.log(`A task was deleted at the ${index} index.`);
    // ...
  });
  // Update UI in response to inserted objects.
  changes.insertions.forEach((index) => {
    const insertedTasks = tasks[index];
    console.log(`insertedTasks: ${JSON.stringify(insertedTasks, null, 2)}`);
    // ...
  });
  // Update UI in response to modified objects.
  // `newModifications` contains an index to the modified object's position
  // in the collection after all deletions and insertions have been applied.
  changes.newModifications.forEach((index) => {
    const modifiedTask = tasks[index];
    console.log(`modifiedTask: ${JSON.stringify(modifiedTask, null, 2)}`);
    // ...
  });
};
// Observe collection notifications.
tasks.addListener(listener);
// Define the collection notification listener.
//@ts-expect-error TYPEBUG: OrderedCollection is incorrectly implemented
const listener: Realm.CollectionChangeCallback = (
  tasks: Realm.OrderedCollection<QuickstartTask>,
  changes: Realm.CollectionChangeSet
) => {
  // Update UI in response to deleted objects.
  changes.deletions.forEach((index) => {
    // Deleted objects cannot be accessed directly,
    // but we can update a UI list, etc. knowing the index.
    console.log(`A task was deleted at the ${index} index.`);
    // ...
  });
  // Update UI in response to inserted objects.
  changes.insertions.forEach((index) => {
    const insertedTasks = tasks[index];
    console.log(`insertedTasks: ${JSON.stringify(insertedTasks, null, 2)}`);
    // ...
  });
  // Update UI in response to modified objects.
  // `newModifications` contains an index to the modified object's position
  // in the collection after all deletions and insertions have been applied.
  changes.newModifications.forEach((index) => {
    const modifiedTask = tasks[index];
    console.log(`modifiedTask: ${JSON.stringify(modifiedTask, null, 2)}`);
    // ...
  });
};
// Observe collection notifications.
//@ts-expect-error TYPEBUG: OrderedCollection is incorrectly implemented
tasks.addListener(listener);

Fechar um Realm

Ligue para o realm.close() método quando terminar com uma instância de realm para evitar vazamentos de memória.

// Close the realm.
realm.close();

Adicionar Device Sync (opcional)

Esta seção ilustra como autenticar com um usuário anônimo e abrir um domínio de Flexible Sync para sincronizar dados entre dispositivos.

Pré-requisitos

Inicialize o aplicativo

Para usar os recursos Atlas App Services , como autenticação e sincronização, primeiro você deve acessar seu Atlas App App Services App usando sua ID do aplicativo . Você pode encontrar sua ID do aplicativo na UI do Atlas App Services .

// Initialize your App.
const app = new Realm.App({
  id: "<yourAppId>",
});

Autenticar um usuário

Para autenticar e fazer login de um usuário, chame App.logIn(). Quando a autenticação anônima está ativada, os usuários podem fazer login imediatamente no seu aplicativo sem fornecer nenhuma informação de identificação:

// Initialize your App.
const app = new Realm.App({
  id: "<yourAppId>",
});
// Authenticate an anonymous user.
const anonymousUser = await app.logIn(Realm.Credentials.anonymous());

Definir um modelo de objeto

Os modelos de objetos para domínios sincronizados funcionam da mesma forma que os Realms somente locais. Defina seu modelo de objeto como faria para um Realm somente local.

export class QuickstartTask extends Realm.Object {
  static schema = {
    name: "Task",
    properties: {
      _id: "objectId",
      name: "string",
      status: "string?",
      owner_id: "string?",
    },
    primaryKey: "_id",
  };
}
export class QuickstartTask extends Realm.Object<Task> {
  _id!: BSON.ObjectID;
  name!: string;
  status?: string;
  owner_id?: string;
  static schema: ObjectSchema = {
    name: "Task",
    properties: {
      _id: "objectId",
      name: "string",
      status: "string?",
      owner_id: "string?",
    },
    primaryKey: "_id",
  };
}

Abrir um realm sincronizado

Quando tiver inicializado sua aplicação, autenticado um usuário e definido seu modelo de objeto, você poderá criar uma SyncConfiguration.

Para abrir um domínio de Flexible Sync, chame Realm.open(). Passe um objeto BaseConfiguration , que deve incluir a propriedade sync definindo um objeto SyncConfiguration . Para usar o Flexible Sync, na SyncConfiguration, você deve incluir um user e flexible: true.

Além disso, você precisa de pelo menos uma assinatura antes de ler ou escrever no domínio. Use Configuration.sync.initialSubscriptions para definir o conjunto de assinaturas iniciais quando o arquivo Realm for aberto pela primeira vez.

// Initialize your App.
const app = new Realm.App({
  id: "<yourAppId>",
});
// Authenticate an anonymous user.
const anonymousUser = await app.logIn(Realm.Credentials.anonymous());
// Create a `SyncConfiguration` object.
const config = {
  schema: [QuickstartTask],
  sync: {
    // Use the previously-authenticated anonymous user.
    user: anonymousUser,
    // Set flexible sync to true to enable sync.
    flexible: true,
    // Define initial subscriptions to start syncing data as soon as the
    // realm is opened.
    initialSubscriptions: {
      update: (subs, realm) => {
        subs.add(
          // Get objects that match your object model, then filter them by
          // the `owner_id` queryable field
          realm
            .objects(QuickstartTask)
            .filtered(`owner_id == "${anonymousUser.id}"`)
        );
      },
    },
  },
};
const realm = await Realm.open(config);
// Initialize your App.
const app = new Realm.App({
  id: "<yourAppId>",
});
// Authenticate an anonymous user.
const anonymousUser = await app.logIn(Realm.Credentials.anonymous());
// Create a `SyncConfiguration` object.
const config: Realm.Configuration = {
  schema: [QuickstartTask],
  sync: {
    // Use the previously-authenticated anonymous user.
    user: anonymousUser,
    // Set flexible sync to true to enable sync.
    flexible: true,
    // Define initial subscriptions to start syncing data as soon as the
    // realm is opened.
    initialSubscriptions: {
      update: (subs, realm) => {
        subs.add(
          // Get objects that match your object model, then filter them by
          // the `owner_id` queryable field
          realm
            .objects(QuickstartTask)
            .filtered(`owner_id == "${anonymousUser.id}"`)
        );
      },
    },
  },
};
const realm = await Realm.open(config);

A sintaxe para ler, gravar e observar alterações em um domínio sincronizado é idêntica à sintaxe para domínios não sincronizados acima. Enquanto você trabalha com dados locais, um thread faz a integração, envia e baixa conjuntos de alterações no background.

Próximo

Bem-vindo aos Docs do Atlas Device SDK