Relationships & Embedded Objects - React Native SDK

One-to-One Relationship

A one-to-one relationship means an object is related to at most one other object of a particular type. To define a one-to-one relationship, specify the property type as the related Realm object type.

class ToOneManufacturer extends Realm.Object {
  _id!: BSON.ObjectId;
  name!: string;
  car?: Car;
  static schema: Realm.ObjectSchema = {
    name: 'ToOneManufacturer',
    properties: {
      _id: 'objectId',
      name: 'string',
      // A manufacturer that may have one Car object
      car: 'Car?',
    },
  };
}
class Car extends Realm.Object {
  _id!: BSON.ObjectId;
  model!: string;
  miles?: number;
  static schema: Realm.ObjectSchema = {
    name: 'Car',
    properties: {
      _id: 'objectId',
      model: 'string',
      miles: 'int?',
    },
  };
}

One-to-Many Relationship

A one-to-many relationship means an object may be related to multiple objects. To define a to-many relationship, specify a property where the type is a list or array of the related Realm object type in its object schema.

class ToManyManufacturer extends Realm.Object {
  _id!: BSON.ObjectId;
  name!: string;
  cars!: Realm.List<LinkedCar>;
  static schema: Realm.ObjectSchema = {
    name: 'ToManyManufacturer',
    properties: {
      _id: 'objectId',
      name: 'string',
      // A manufacturer's related LinkedCar objects
      cars: 'LinkedCar[]',
    },
  };
}
class LinkedCar extends Realm.Object {
  _id!: BSON.ObjectId;
  model!: string;
  miles?: number;
  static schema: Realm.ObjectSchema = {
    name: 'LinkedCar',
    properties: {
      _id: 'objectId',
      model: 'string',
      miles: 'int?',
      // A car's related ToManyManufacturer objects
      manufacturer: {
        type: 'linkingObjects',
        objectType: 'ToManyManufacturer',
        property: 'cars',
      },
    },
  };
}

Inverse Relationship

An inverse relationship links an object back to any other objects that refer to it in a defined to-one or to-many relationship. Relationship definitions are unidirectional by default. You must explicitly define a property in the object's model as an inverse relationship.

For example, the to-many relationship "Manufacturer has many Cars" does not automatically create the inverse relationship "Car belongs to Manufacturer". If you don't specify the inverse relationship in the object model, you need to run a separate query to look up the manufacturer who makes a car.

class ManufacturerInverse extends Realm.Object {
  _id!: BSON.ObjectId;
  name!: string;
  cars!: Realm.List<CarInverse>;
  static schema: Realm.ObjectSchema = {
    name: 'ManufacturerInverse',
    properties: {
      _id: 'objectId',
      name: 'string',
      // A manufacturer's related CarInverse objects
      cars: 'CarInverse[]',
    },
  };
}
class CarInverse extends Realm.Object {
  _id!: BSON.ObjectId;
  model!: string;
  manufacturer!: Realm.List<ManufacturerInverse>;
  miles?: number;
  static schema: Realm.ObjectSchema = {
    name: 'CarInverse',
    properties: {
      _id: 'objectId',
      model: 'string',
      miles: 'int?',
      // A car's related ManufacturerInverse objects
      manufacturer: {
        type: 'linkingObjects',
        objectType: 'ManufacturerInverse',
        property: 'cars',
      },
    },
  };
}

const getLinkedManufacturer = (car: LinkedCar): string => {
  const manufacturer = car.linkingObjects<ToManyManufacturer>(
    'ToManyManufacturer',
    'cars',
  )[0];
  // Returns 'Nissan', as only one manufacturer is linked
  // to this car object.
  return manufacturer.name;
};

Embedded Objects

An embedded object is a special type of Realm object that models complex data about a specific object. Embedded objects are similar to relationships, but they provide additional constraints and map more naturally to the denormalized MongoDB document model.

Realm enforces unique ownership constraints that treat each embedded object as nested data inside a single, specific parent object. An embedded object inherits the lifecycle of its parent object and can't exist as an independent Realm object. This means that embedded objects can't have a primary key and that Realm automatically deletes embedded objects if their parent object is deleted.

class Manufacturer extends Realm.Object {
  _id!: BSON.ObjectId;
  name!: string;
  cars!: Realm.List<CarWithEmbed>;
  warranties!: Realm.List<Warranty>;
  static schema: Realm.ObjectSchema = {
    name: 'Manufacturer',
    properties: {
      _id: 'objectId',
      name: 'string',
      cars: 'CarWithEmbed[]',
      // Embed an array of objects
      warranties: 'Warranty[]',
    },
  };
}
class CarWithEmbed extends Realm.Object {
  _id!: BSON.ObjectId;
  model!: string;
  miles?: number;
  warranty?: Warranty;
  static schema: Realm.ObjectSchema = {
    name: 'CarWithEmbed',
    properties: {
      _id: 'objectId',
      model: 'string',
      miles: 'int?',
      // Embed one object
      warranty: 'Warranty?',
    },
  };
}
class Warranty extends Realm.Object {
  name!: string;
  termLength!: number;
  cost!: number;
  static schema: Realm.ObjectSchema = {
    name: 'Warranty',
    embedded: true,
    properties: {
      name: 'string',
      termLength: 'int',
      cost: 'int',
    },
  };
}