Data Model Mapping

Mapping with Development Mode

When you enable Development Mode in your Device Sync configuration, App Services can automatically create collections and schemas for Realm Database objects that you sync. It creates those collections in the database you specify when you enable Development Mode.

With Development Mode enabled, Sync looks for a collection whose App Services schema has a title that matches the name of your Realm Database object type. This collection could be in any database in your linked data source. It doesn't have to be in the database you add when you configure Development Mode.

If there is no corresponding title in any App Services schema in your linked data source, App Services creates a new collection for this object type. This collection is created in the database you specify when you enable Development Mode. The collection name matches the object's type, and the corresponding App Services schema has a title field whose value is the name of the object type. This creates the mapping between your Realm Database object and the new collection.

Type Name

The title field contains the name of the object type represented by the schema. This is equivalent to a class or schema name in an Atlas Device SDK. The type name must be unique among all schemas in your synced cluster but is otherwise arbitrary and does not need to match the collection name.

A conventional approach is to name each object type with a singular noun, like "Dog" or "Person". Schemas generated in development mode or by sampling existing documents use this convention.

Property Types

You can configure the following constraints for a given property:

For SDK-specific details about data types, refer to the following:

• Supported Types - C++ SDK

• Data Types - Flutter SDK

• Realm Data Types - Java SDK

• Supported Types - Kotlin SDK

• Field Types - .NET SDK

• Realm Data Types - Node.js SDK

• Property Types - React Native SDK

• Supported Property Types - Swift SDK

Array Properties

Both SDK object models and App Services schemas support array properties.

For SDK-specific details about array properties, refer to the following:

• Supported Types - C++ SDK

• Dart Types - Flutter SDK

• Lists - Java SDK

• Supported Types - Kotlin SDK

• Lists - .NET SDK

• Supported Property Types - Node.js SDK

• Supported Property Types - React Native SDK

• Supported Types - Swift SDK

For more information on modeling array properties in an App Services schema, refer to BSON Types - Array. App Services schemas support certain constraints that SDK object models do not, such as specifying the minimum and maximum number of items.

Mixed Properties

Both SDK object models and App Services schemas support mixed type properties.

A mixed field can contain any supported data type and functionally acts as an object or document without a pre-defined structure.

For more information on modeling mixed properties in an App Services schema, refer to Mixed - Schema Types.

Embedded Objects

Embedded objects are embedded as nested data inside of a parent object. An embedded object inherits the lifecycle of its parent object. It cannot exist as an independent database object.

For SDK-specific details about embedded objects, refer to the following:

• Define an Embedded Object - C++ SDK

• Embedded Objects - Flutter SDK

• Define an Embedded Object Field - Java SDK

• Embedded Objects - Kotlin SDK

• Embedded Objects - .NET SDK

• Embedded Objects - Node.js SDK

• Embedded Objects - React Native SDK

• Define an Embedded Object Property - Swift SDK

For more information on modeling to-one relationships in an App Services schema, refer to Embedded Object Relationships.

Sets

SDK object models and App Services schemas both support the Set data type. A set is a collection of unique values.

For SDK-specific details about sets, refer to the following:

• Set - C++ SDK

• RealmSet - Flutter SDK

• RealmSet - Java SDK

• RealmSet - Kotlin SDK

• Sets - .NET SDK

• Sets - Node.js SDK

• Sets - React Native SDK

• Mutable Set - Swift SDK

For more information on modeling sets in an App Services schema, refer to Set.

Dictionaries

SDK object models and App Services schemas both support the Dictionary data type. A set is a collection of unique values. A dictionary is a collection of dynamic and unique string keys paired with values of a given type. A dictionary is functionally an object or document without pre-defined field names.

For SDK-specific details about dictionaries, refer to the following:

• Map/Dictionary - C++ SDK

• RealmMap - Flutter SDK

• RealmDictionary - Java SDK

• RealmDictionary - Kotlin SDK

• Dictionaries - .NET SDK

• Dictionaries - Node.js SDK

• Dictionaries - React Native SDK

• Map/Dictionary - Swift SDK

For more information on modeling dictionaries in an App Services schema, refer to Dictionary.

App Services Schema

This App Services schema creates the Dog data model used by Device Sync.

{
  "title": "Dog",
  "bsonType": "object",
  "required": [
    "_id",
    "name"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    },
    "age": {
      "bsonType": "int"
    }
    "breed": {
      "bsonType": "string"
    }
    "details": {
      "bsonType": "mixed"
    }
  }
}

SDK object model

The following code examples create the Dog SDK object model in each of the Atlas Device SDKs.

import Foundation
import RealmSwift
class Dog: Object {
    @Persisted(primaryKey: true) var _id: ObjectId
    @Persisted var age: Int?
    @Persisted var breed: String?
    @Persisted var name: String = ""
    @Persisted var details: AnyRealmValue
}

import io.realm.RealmObject;
import org.bson.types.ObjectId;
public class Dog extends RealmObject {
    @PrimaryKey
    @Required
    private ObjectId _id;
    private Integer age;
    private String breed;
    @Required
    private String name;
    private RealmAny details;
    // Standard getters & setters
    public ObjectId getId() { return _id; }
    public void setId(ObjectId _id) { this._id = _id; }
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
    public String getBreed() { return breed; }
    public void setBreed(String breed) { this.breed = breed; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public RealmAny getDetails() { return details; }
    public void setDetails(RealmAny details) { this.details = details; }
}

import io.realm.RealmObject;
import org.bson.types.ObjectId;
open class Dog : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId(),
    var age: Int? = null,
    var breed: String? = null,
    var name: String = ""
    var details: RealmValue? = null
}

import 'package:realm/realm.dart';
part 'realm_models.realm.dart';
@RealmModel()
class _Dog {
  @PrimaryKey()
  @MapTo('_id')
  late ObjectId id;
  int? age;
  String? breed;
  late String name;
  late RealmValue details;
}

using System;
using System.Collections.Generic;
using Realms;
using MongoDB.Bson;
public class Dog : RealmObject
{
    [MapTo("_id")]
    [PrimaryKey]
    public ObjectId Id { get; set; }
    [MapTo("age")]
    public int? Age { get; set; }
    [MapTo("breed")]
    public string Breed { get; set; }
    [MapTo("name")]
    [Required]
    public string Name { get; set; }
    [MapTo("details")]
    public RealmValue Details { get; set; }
}

export const DogSchema = {
  name: 'Dog',
  properties: {
    _id: 'objectId',
    age: 'int?',
    breed: 'string?',
    name: 'string',
  },
  primaryKey: '_id',
  details: 'mixed',
};

export const DogSchema = {
   class Dog extends Realm.Object<Dog> {
     _id!: Realm.BSON.ObjectId;
       age?: number;
       breed?: string;
       name!: string;
       details?: Realm.Mixed;
     static schema: ObjectSchema = {
       name: 'Dog',
         properties: {
           _id: 'objectId',
           age: 'int?',
           breed: 'string?',
           name: 'string',
           details: 'mixed?',
         },
       primaryKey: '_id',
};

Data in Atlas

An application using Device Sync for the Dog data model creates MongoDB documents in Atlas based on the previous schemas.

{
  "_id": ObjectId('616f44305a205add93ff1081'),
  "age": 8,
  "breed": "Golden Retriever",
  "name": "Jasper",
  "details": null
}

{
  "_id": ObjectId('616f44305a205add93ff1081'),
  "age": 8,
  "breed": "Golden Retriever",
  "name": "Jasper",
  "details": {
    "vaccinations": ["rabies", "distemper"],
    "weight": 65.5,
    "isNeutered": true,
    "vetVisits": [
      {
        "date": 2002-08-18T04:56:07.000+00:00,
        "reason": "annual checkup"
      },
      {
        "date": 2003-08-18T04:56:07.000+00:00,
        "reason": "annual checkup"
      }
    ]
  }
}