Definir um modelo de objeto de domínio - SDK do Node.js

Especificar uma propriedade opcional

Para marcar uma propriedade como opcional, anexe um ponto de interrogação ? ao seu tipo.

O seguinte esquema Car define uma propriedade miles opcional do 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 uma chave primária

Para especificar uma propriedade como uma chave primária do tipo de objeto, configure o campo primaryKey do esquema para o nome da propriedade.

O seguinte esquema de objeto do Car especifica a propriedade _id como sua chave primária.

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

Indexe uma propriedade

O Realm permite a indexação para propriedades de string, inteiros, booleanos, Date, UUID e ObjectId. Para definir um índice para uma determinada propriedade, defina indexed para true.

O seguinte esquema de objeto do Car define um índice na propriedade _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",
  };
}

Definir um índices the busca de texto completa

Além dos índices padrão, o Realm também suporta índices de Pesquisa de Texto Completo (FTS) em propriedades de string. Embora você possa query um campo de string com ou sem um índice padrão, um índice FTS permite pesquisar várias palavras e frases e excluir outras.

Para obter mais informações sobre como fazer queries em índices FTS, consulte Filtrar com Full Text Search.

Para criar um índice FTS, configure o tipo indexado para 'full-text'. Isso permite queries de texto completo na propriedade. No exemplo a seguir, definimos o tipo indexado para a propriedade name como '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?",
    },
  };
}

Definir um valor de propriedade padrão

Para definir um valor padrão, configure o valor da propriedade para um objeto com um campo type e um campo default.

O seguinte esquema de objeto Car especifica um valor padrão de 0 para a propriedade 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",
  };
}

Mapear uma propriedade ou classe para um nome diferente

Por padrão, o Realm utiliza o nome definido na classe de modelo para representar classes e campos internamente. Em alguns casos, você pode querer alterar esse comportamento. Por exemplo:

• Para facilitar o trabalho em plataformas onde as convenções de nomenclatura são diferentes. Por exemplo, se os nomes das propriedades do esquema Device Sync usarem snake case, enquanto seu projeto usa camel case.

• Para alterar um nome de campo ou classe sem forçar uma migração.

• Para oferecer suporte a várias classes de modelo com o mesmo nome em pacotes diferentes.

• Para usar um nome de classe maior que o limite de 57 caracteres imposto pelo Realm.

Você pode mapear uma classe ou nome de propriedade em seu código para um nome diferente para armazenar em um domínio. Se você gravar em um domínio sincronizado, o esquema Sync verá os valores armazenados usando a classe persistente ou o nome da propriedade.

Observe que as migrações devem usar o nome de classe ou propriedade persistente, e quaisquer erros de esquema relatados também usam o nome 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 uma propriedade de relacionamento um-para-um

Um relacionamento para-um mapeia uma propriedade para uma instância única de outro tipo de objeto. Por exemplo, pode modelar um fabricante com, no máximo, um automóvel como uma relação entre si.

Para definir uma propriedade de relacionamento entre um, especifique o nome do tipo de objeto relacionado como o tipo de propriedade.

O esquema de objeto Manufacturer a seguir especifica que um fabricante pode ou não fazer um único Car. Se eles fizerem um Car, o Realm vinculará a ele através da propriedade 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 uma propriedade de relacionamento um-para-muitos

Uma relação para-muitos mapeia uma propriedade para zero ou mais instâncias de outro tipo de objeto. Por exemplo, você pode modelar um fabricante com qualquer número de carros como uma relação para-muitos.

Para definir uma propriedade de relacionamento entre muitos, especifique o nome do tipo de objeto relacionado como uma lista.

Um aplicativo poderia usar os seguintes esquemas de objeto para indicar que um Manufacturer pode criar vários objetos Car, incluindo-os em sua propriedade 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 uma propriedade de relacionamento inversa

Uma propriedade relacionamento inverso é um relacionamento de backlink automático. O Realm atualiza automaticamente os relacionamentos implícitos sempre que um objeto é adicionado ou removido em uma lista de itens correspondentes. Você não pode definir manualmente o valor de uma propriedade de relacionamento inversa.

Para definir uma propriedade de relacionamento inversa, configure o tipo de propriedade para linkingObjects e especifique o tipo de objeto e o nome da propriedade que define o relacionamento para inverter.

Um aplicativo poderia usar os seguintes esquemas de objetos para indicar que um Manufacturer pode criar muitos objetos Car e que cada Car deve controlar automaticamente qual Manufacturer o cria.

• A propriedade Manufacturer do objeto cars é definida como uma relação entre muitos

  com Car objetos e contém todos os carros de um determinado fabricante.

• A propriedade Car do objeto assignee inverte a relação e

  atualizações automáticas para referir-se a qualquer objecto Manufacturer que contenha o veículo na sua propriedade 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 uma propriedade de objeto embarcado

Para definir um modelo de objeto de Realm com um objeto incorporado (objeto de Realm aninhado), defina embedded como true.

Existe um objeto incorporado como dados aninhados dentro de um único objeto principal específico. Ele herda o ciclo de vida de seu objeto principal e não pode existir como um objeto de Realm independente. O Realm exclui automaticamente os objetos incorporados se o objeto principal for excluído ou quando for substituído por uma nova instância de objeto incorporado. Objetos incorporados não podem ter uma chave primária.

Você pode referenciar um tipo de objeto incorporado a partir de tipos de objeto principal da mesma maneira que um relacionamento.

O exemplo seguinte exige dois esquemas principais, Manufacturer e Car. O aplicativo requer um esquema secundário incorporado Warranty. Um objeto Manufacturer pode incorporar uma lista de objetos Warranty, enquanto um objeto Car só pode incorporar um ú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",
    },
  };
}