Docs Menu
Docs Home
/
MongoDB Atlas
/
SDK de dispositivos Atlas
Docs Home
/
MongoDB Atlas
/
SDK de dispositivos Atlas
Docs Home
/
MongoDB Atlas
/
SDK de dispositivos Atlas

Inicio rápido - SDK de Node.js

Esta página contiene información para integrar Realm rápidamente en su aplicación.

Si aún no lo ha hecho, instale el SDK Realm Node.js.

Reino de importación

En la parte superior de los archivos de origen donde desea utilizar Realm, agregue la siguiente línea para importar el SDK y la biblioteca BSON.

import Realm, { BSON } from "realm";

Define tu modelo de objeto

El modelo de objetos de su aplicación define los datos que puede almacenar dentro de Realm.

Para definir un tipo de objeto Realm, cree un objeto de esquema que especifique el tipo name propertiesy. El nombre del tipo debe ser único entre los tipos de objeto de un dominio. Para obtener más información sobre cómo definir propiedades específicas, consulte Definir propiedades de objeto.

El siguiente código muestra cómo definir un modelo de objeto para un objeto Task. En este ejemplo:

  • El primaryKey es el _id del tipo int. Otro tipo común usado para llaves primarias es ObjectId.

  • El campo name es obligatorio.

  • Los campos status y owner_id son opcionales y se indican mediante el signo de interrogación inmediatamente después del tipo de datos.

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 un reino

Para abrir un reino, pasa un Objeto Realm.BaseConfiguration para Realm.open().

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

Buscar, ordenar y filtrar objetos

El siguiente código demuestra cómo:

  • Consulta todas las instancias del tipo de objeto "Tarea".

  • Filtra la consulta para recuperar sólo las tareas que están "Abiertas".

  • Ordene las tareas por nombre en orden ascendente.

// 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");

Crear, modificar y eliminar objetos de Realm

Una vez abierto un reino, puede crear, modificar y eliminar objetos en él. Todas las operaciones de escritura deben realizarse dentro de una transacción de escritura.

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

Ver una colección

Puede observar un reino, una colección o un objeto en busca de cambios registrando controladores de eventos con los métodos Realm.addListener() Object.addListener() Collection.addListener().

Importante

El orden importa

En los controladores de notificaciones de colecciones, aplique siempre los cambios en el siguiente orden: eliminaciones, inserciones y modificaciones. Gestionar las inserciones antes de las eliminaciones puede provocar un comportamiento inesperado.

En el siguiente ejemplo, un desarrollador de aplicaciones observa los cambios en la colección 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);

Cerrar un reino

Llame al método realm.close() cuando termine con una instancia de realm para evitar pérdidas de memoria.

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

Agregar sincronización de dispositivos (opcional)

Esta sección ilustra cómo autenticarse con un usuario anónimo y abrir un ámbito de sincronización flexible para sincronizar datos entre dispositivos.

Requisitos previos

Inicializar la aplicación

Para usar las funciones de App Services, como la autenticación y la sincronización, primero debes acceder a tu aplicación de App Services con tu ID de aplicación. Puedes encontrar tu ID de aplicación en la interfaz de App Services.

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

Autenticar un usuario

Para autenticar e iniciar sesión a un usuario, llame a App.logIn(). Cuando la autenticación anónima está habilitada, los usuarios pueden iniciar sesión inmediatamente en su aplicación sin proporcionar información de identificación.

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

Define un modelo de objeto

Los modelos de objeto para dominios sincronizados funcionan igual que los dominios locales. Define tu modelo de objeto como lo harías para un dominio 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 un reino sincronizado

Una vez que hayas inicializado tu aplicación, autenticado un usuario y definido tu Modelo de objeto, puedes crear una SyncConfiguration.

Para abrir un dominio de Sincronización Flexible, llame a Realm.open(). Pase un objeto BaseConfiguration, que debe incluir la sync propiedad que define un objeto SyncConfiguration. Para usar la Sincronización Flexible, en SyncConfiguration, debe incluir user flexible: truey.

Además, necesitas al menos una suscripción antes de poder leer o guardar en el realm. Usa Configuration.sync.initialSubscriptions para definir el conjunto inicial de suscripciones cuando el archivo Realm se abre por primera 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);

La sintaxis para leer, escribir y observar cambios en un dominio sincronizado es idéntica a la sintaxis para dominios no sincronizados descrita anteriormente. Mientras trabaja con datos locales, un hilo en segundo plano integra, carga y descarga conjuntos de cambios de forma eficiente.

Next

Bienvenido a la Docs de Atlas Device SDK

En esta página