Definir un modelo de objeto de reino - SDK de Node.js

Especificar una propiedad opcional

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

El siguiente esquema Car define una propiedad miles opcional de tipo 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",
  };
}

Especificar una clave principal

Para especificar una propiedad como clave principal de un tipo de objeto, establezca el campo primaryKey del esquema en el nombre de la propiedad.

El siguiente esquema de objeto Car especifica la propiedad _id como su clave principal.

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 admite la indexación de propiedades de cadena, entero, booleano, Date, UUID y ObjectId. Para definir un índice para una propiedad determinada, establezca indexed en 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",
  };
}

Establecer un índice de búsqueda de texto completo

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.

Para obtener más información sobre cómo consultar índices FTS, consulte Filtrar con búsqueda de texto completo.

Para crear un índice FTS, establezca el tipo de indexación 'full-text' en. Esto permite realizar consultas de texto completo en la propiedad. En el siguiente ejemplo, establecemos el tipo de indexación de la name propiedad 'full-text' en:

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

Definir un valor de propiedad predeterminado

Para definir un valor predeterminado, establezca el valor de la propiedad en un objeto con un campo type y un campo default.

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

De forma predeterminada, Realm usa el nombre definido en la clase del modelo para representar internamente las clases y los campos. En algunos casos, podría ser conveniente cambiar este comportamiento. Por ejemplo:

• Para facilitar el trabajo en plataformas donde las convenciones de nomenclatura difieren. Por ejemplo, si los nombres de las propiedades del esquema de sincronización de dispositivos usan mayúsculas y minúsculas, mientras que el proyecto usa mayúsculas y minúsculas.

• Para cambiar un nombre de clase o campo sin forzar una migración.

• Para admitir múltiples clases de modelos con el mismo nombre en diferentes paquetes.

• Para utilizar un nombre de clase que sea más largo que el límite de 57caracteres impuesto por Realm.

Puedes asignar el nombre de una clase o propiedad en tu código a otro nombre para almacenarlo en un dominio. Si escribes en un dominio sincronizado, el esquema de sincronización ve los valores almacenados con el nombre de la clase o propiedad persistente.

Tenga en cuenta que las migraciones deben usar el nombre de propiedad o clase persistente, y cualquier error de esquema informado también usa el nombre persistente.

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 de uno a uno

Una relación de uno a uno asigna una propiedad a una sola instancia de otro tipo de objeto. Por ejemplo, se puede modelar un fabricante con un solo coche como máximo como una relación de uno a uno.

Para definir una propiedad de relación de uno a uno, especifique el nombre del tipo de objeto relacionado como el tipo de propiedad.

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?",
    },
  };
}

Definir una propiedad de relación de muchos

Una relación a muchos asigna una propiedad a cero o más instancias de otro tipo de objeto. Por ejemplo, se puede modelar un fabricante con cualquier número de automóviles como una relación a muchos.

Para definir una propiedad de relación de muchos, especifique el nombre del tipo de objeto relacionado como una lista.

Una aplicación podría usar los siguientes esquemas de objetos para indicar que un Manufacturer puede crear múltiples objetos Car incluyéndolos en su propiedad cars:

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

Una propiedad de relación inversa es una relación de retroenlace automática. Realm actualiza automáticamente las relaciones implícitas al añadir o eliminar un objeto en una lista de correspondencia múltiple. No se puede establecer manualmente el valor de una propiedad de relación inversa.

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 podría utilizar los siguientes esquemas de objetos para indicar que un Manufacturer puede crear muchos objetos Car y que cada Car debería realizar un seguimiento automático de cuál Manufacturer lo crea.

• La propiedad cars del objeto Manufacturer se define como una relación de muchos

  con Car objetos y contiene todos los automóviles de un fabricante determinado.

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

  se actualiza automáticamente para hacer referencia a cualquier objeto Manufacturer que contenga el automóvil en su propiedad cars.

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",
      },
    },
  };
}

Definir una propiedad de objeto incrustado

Para definir un modelo de objeto Realm con un objeto incrustado (objeto Realm anidado), establezca 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",
    },
  };
}