Define a Realm Object Model - Node.js SDK

Specify an Optional Property

Para marcar una propiedad como opcional, agregue un signo de interrogación ? a su tipo.

The following Car schema defines an optional miles property of type int.

class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: { type: "objectId", default: () => new Realm.BSON.ObjectId() },
      make: "string",
      model: "string",
      miles: "int?",
    },
    primaryKey: "_id",
  };
}

Specify a Primary Key

To specify a property as an object type's primary key, set the schema's primaryKey field to the property name.

The following Car object schema specifies the _id property as its primary key.

class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: { type: "objectId", default: () => new Realm.BSON.ObjectId() },
      make: "string",
      model: "string",
      miles: "int?",
    },
    primaryKey: "_id",
  };
}

Indexar una propiedad

Realm supports indexing for string, integer, boolean, Date, UUID, and ObjectId properties. To define an index for a given property, set indexed to true.

El siguiente esquema de objeto Car define un índice en la propiedad _id.

class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: { type: "objectId", indexed: true },
      make: "string",
      model_name: { type: "string", mapTo: "modelName" },
      miles: { type: "int", default: 0 },
    },
    primaryKey: "_id",
  };
}

Set a Full-Text Search Index

Además de los índices estándar, Realm también admite índices de búsqueda de texto completo (FTS) en propiedades de cadena. Si bien se puede consultar un campo de cadena con o sin un índice estándar, un índice FTS permite buscar múltiples palabras y frases, excluyendo otras.

For more information on querying FTS indexes, see Filter with Full-Text Search.

To create an FTS index, set the indexed type to 'full-text'. This enables full-text queries on the property. In the following example, we set the indexed type for the name property to 'full-text':

class Book extends Realm.Object<Book> {
  name!: string;
  price?: number;
  static schema: ObjectSchema = {
    name: "Book",
    properties: {
      name: { type: "string", indexed: "full-text" },
      price: "int?",
    },
  };
}

Define a Default Property Value

To define a default value, set the value of the property to an object with a type field and a default field.

El siguiente esquema de objeto Car especifica un valor predeterminado de 0 para la propiedad miles:

class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: { type: "objectId", indexed: true },
      make: "string",
      model_name: { type: "string", mapTo: "modelName" },
      miles: { type: "int", default: 0 },
    },
    primaryKey: "_id",
  };
}

Asignar una propiedad o clase a un nombre diferente

By default, Realm uses the name defined in the model class to represent classes and fields internally. In some cases, you might want to change this behavior. For example:

• Para facilitar el trabajo entre plataformas donde las convenciones de nomenclatura difieren. Por ejemplo, si los nombres de las propiedades del esquema de Device Sync usan snake case, mientras que tu proyecto usa camel case.

• To change a class or field name without forcing a migration.

• To support multiple model classes with the same name in different packages.

• To use a class name that is longer than the 57-character limit enforced by Realm.

Puede mapear el nombre de una clase o propiedad en su código a un nombre diferente para almacenar en un realm. Si escribe en un realm sincronizado, el esquema de sincronización ve los valores almacenados utilizando el nombre de clase o propiedad persistido.

Note that migrations must use the persisted class or property name, and any schema errors reported also use the persisted name.

class Task extends Realm.Object {
  static schema = {
    // Set the schema's `name` property to the name you want to store.
    // Here, we store items as `Todo_Item` instead of the class's `Task` name.
    name: "Todo_Item",
    properties: {
      _id: "int",
      name: "string",
      owner_id: "string?",
    },
    primaryKey: "_id",
  };
}
const config = {
  // Use the class name in the Configuration's `schema` property when
  // opening the realm.
  schema: [Task],
  sync: {
    user: anonymousUser,
    flexible: true,
    initialSubscriptions: {
      update: (subs, realm) => {
        subs.add(
          realm
            // Use the mapped name in Flexible Sync subscriptions.
            .objects(`Todo_Item`)
            .filtered(`owner_id == "${anonymousUser.id}"`)
        );
      },
    },
  },
};
const realm = await Realm.open(config);
realm.write(() => {
  // Use the mapped name when performing CRUD operations.
  realm.create(`Todo_Item`, {
    _id: 12342245,
    owner_id: anonymousUser.id,
    name: "Test the Todo_Item object name",
  });
});
// Use the mapped name when performing CRUD operations.
const assignedTasks = realm.objects(`Todo_Item`);

class Task extends Realm.Object<Task> {
  _id!: number;
  name!: string;
  owner_id?: string;
  static schema: ObjectSchema = {
    // Set the schema's `name` property to the name you want to store.
    // Here, we store items as `Todo_Item` instead of the class's `Task` name.
    name: "Todo_Item",
    properties: {
      _id: "int",
      name: "string",
      owner_id: "string?",
    },
    primaryKey: "_id",
  };
}
const config: Realm.Configuration = {
  // Use the class name in the Configuration's `schema` property when
  // opening the realm.
  schema: [Task],
  sync: {
    user: anonymousUser,
    flexible: true,
    initialSubscriptions: {
      update: (subs, realm) => {
        subs.add(
          realm
            // Use the mapped name in Flexible Sync subscriptions.
            .objects(`Todo_Item`)
            .filtered(`owner_id == "${anonymousUser.id}"`)
        );
      },
    },
  },
};
const realm = await Realm.open(config);
realm.write(() => {
  // Use the mapped name when performing CRUD operations.
  realm.create(`Todo_Item`, {
    _id: 12342245,
    owner_id: anonymousUser.id,
    name: "Test the Todo_Item object name",
  });
});
// Use the mapped name when performing CRUD operations.
const assignedTasks = realm.objects(`Todo_Item`);

class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: { type: "objectId", indexed: true },
      make: "string",
      model_name: { type: "string", mapTo: "modelName" },
      miles: { type: "int", default: 0 },
    },
    primaryKey: "_id",
  };
}

Definir una propiedad de relación uno a uno

A to-one relationship maps one property to a single instance of another object type. For example, you can model a manufacturer having at most one car as a to-one relationship.

To define a to-one relationship property, specify the related object type name as the property type.

El siguiente esquema de objeto Manufacturer especifica que un fabricante puede o no fabricar un solo Car. Si fabrican un Car, Realm lo vincula a través de la propiedad car:

class Manufacturer extends Realm.Object {
  static schema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      // A manufacturer that may have one car
      car: "Car?",
    },
  };
}
class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: "objectId",
      make: "string",
      model: "string",
      miles: "int?",
    },
  };
}

Define a To-Many Relationship Property

A to-many relationship maps one property to zero or more instances of another object type. For example, you can model a manufacturer having any number of cars as a to-many relationship.

To define a to-many relationship property, specify the related object type name as a list.

An application could use the following object schemas to indicate that a Manufacturer may make multiple Car objects by including them in its cars property:

class Manufacturer extends Realm.Object {
  static schema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      // A manufacturer that may have many cars
      cars: "Car[]",
    },
  };
}
class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: "objectId",
      make: "string",
      model: "string",
      miles: "int?",
    },
  };
}

Definir una propiedad de relación inversa

An inverse relationship property is an automatic backlink relationship. Realm automatically updates implicit relationships whenever an object is added or removed in a corresponding to-many list. You cannot manually set the value of an inverse relationship property.

Para definir una propiedad de relación inversa, establezca el tipo de propiedad en linkingObjects y especifique el tipo de objeto y el nombre de la propiedad que definen la relación a invertir.

Una aplicación puede utilizar los siguientes esquemas de objetos para indicar que un Manufacturer puede crear muchos objetos Car y que cada Car debe llevar automáticamente un registro de qué Manufacturer lo crea.

• The Manufacturer object's cars property is defined as a to-many relationship

  with Car objects and contains all of a given manufacturer's cars.

• La propiedad assignee del objeto Car invierte la relación y

  automatically updates to refer back to any Manufacturer object that contains the car in its cars property.

class Manufacturer extends Realm.Object {
  static schema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      // A manufacturer that may have many cars
      cars: "Car[]",
    },
  };
}
class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: "objectId",
      make: "string",
      model: "string",
      miles: "int?",
      // Backlink to the manufacturer. This is automatically updated whenever
      // this car is added to or removed from a manufacturer's cars list.
      assignee: {
        type: "linkingObjects",
        objectType: "Manufacturer",
        property: "cars",
      },
    },
  };
}

Define an Embedded Object Property

Para definir un modelo de objeto Realm con un objeto incrustado (objeto Realm anidado), configure embedded en true.

Un objeto incrustado existe como datos anidados dentro de un único objeto principal específico. Hereda el ciclo de vida de su objeto principal y no puede existir como un objeto independiente de Realm. Realm elimina automáticamente los objetos incrustados si se elimina su objeto principal o si se sobrescriben con una nueva instancia de objeto incrustado. Los objetos incrustados no pueden tener una clave principal.

Puede hacer referencia a un tipo de objeto incrustado desde tipos de objetos principales de la misma manera que una relación.

El siguiente ejemplo requiere dos esquemas principales, Manufacturer y Car. La aplicación requiere un esquema secundario Warranty incrustado. Un objeto Manufacturer puede incrustar una lista de Warranty objetos, mientras que un objeto Car solo puede incrustar un único objeto Warranty.

class Manufacturer extends Realm.Object {
  static schema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      name: "string",
      // Embed an array of objects
      warranties: { type: "list", objectType: "Warranty" },
    },
  };
}
class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: "objectId",
      make: "string",
      model: "string",
      miles: "int?",
      // Embed one object
      warranty: "Warranty",
    },
  };
}
class Warranty extends Realm.Object {
  static schema = {
    name: "Warranty",
    embedded: true,
    properties: {
      name: "string",
      termLength: "int",
      cost: "int",
    },
  };
}