Schema Types

Array

An array contains multiple values of a specific type. BSON array schemas use the standard JSON Schema array format.

{
  "bsonType": "array",
  "items": <Schema Document> | [<Schema Document>, ...],
  "additionalItems": <boolean> | <Schema Document>,
  "maxItems": <integer>,
  "minItems": <integer>,
  "uniqueItems": <boolean>
}

Boolean

A bool is either true or false.

{ "bsonType": "bool" }

Mixed

A mixed field may contain any schema type except for embedded objects, sets, or any SDK-supported counters. App Services does not enforce a consistent type across documents, so two different documents may have values of different types.

Mixed fields can store arrays and dictionaries of mixed data. Sync translates these to MongoDB as arrays and objects, respectively. These collections of mixed data can also contain other collections of mixed data, with a maximum depth of 100 levels. You can leverage this flexibility to store complex data structures that wouldn't otherwise fit into a pre-defined schema, such as variable JSON data or complex MongoDB documents.

Mixed fields can also represent relationships. Sync translates these relationships to MongoDB as a DBRef to preserve the database name, collection name, and primary key of the link.

{ "bsonType": "mixed" }

Number

A number generically configures some type of number. BSON schemas extend JSON Schema numerics with additional types to define integers, floats, and decimals.

{
  "bsonType": "number" | "int" | "long" | "double" | "decimal",
  "multipleOf": <number>,
  "maximum": <number>,
  "exclusiveMaximum": <boolean>,
  "minimum": <number>,
  "exclusiveMinimum": <boolean>
}

Object

An object is a structured object with string keys that each have a typed value. Objects represent Realm objects and embedded objects in synced realms as well as the documents they map to in MongoDB.

{
  "bsonType": "object",
  "title": "<Type Name>",
  "required": ["<Required Field Name>", ...],
  "properties": {
    "<Field Name>": <Schema Document>
  },
  "minProperties": <integer>,
  "maxProperties": <integer>,
  "patternProperties": {
    "<Field Name Regex>": <Schema Document>
  },
  "additionalProperties": <boolean> | <Schema Document>,
  "dependencies": {
    "<Field Name>": <Schema Document> | ["<Field Name>", ...]
  }
}

ObjectId

An objectId is a 12-byte identifier for BSON objects. ObjectId values are most commonly used as the unique _id values of documents in a MongoDB collection or objects in a synced realm.

{ "bsonType": "objectId" }

String

A string is text encoded as a series of characters. BSON string schemas use the standard JSON Schema string format.

{
  "bsonType": "string",
  "maxLength": <integer>,
  "minLength": <integer>,
  "pattern": "<Regular Expression>"
}

UUID

A uuid (Universal Unique Identifier) is a standardized 16-byte unique object identifier.

{ "bsonType": "uuid" }

Binary Data

A binData is a piece of unstructured binary data. Maps to the binary BSON type. Always uses subtype 0.

{ "bsonType": "binData" }

Counter

A counter is a special numerical type whose value can be incremented or decremented. It maps to the long number type in App Services.

{ "bsonType": "long" }

Counter data types are only supported in the following SDKs:

• Counters - Java SDK

• MutableRealmInt (Counter) - Kotlin SDK

• RealmInteger - .NET SDK

• Counters - Node.js SDK

Set

A set is a collection of unique values.

A set schema is an array schema where uniqueItems is set to true.

{
   "bsonType": "array",
   "uniqueItems": true,
   "items": {
      "bsonType": "long"
   }
}

Dictionary

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.

A dictionary schema is an object schema where properties is not defined and the value of additionalProperties is a schema for the dictionary value's type.

{
   "bsonType": "object",
      "additionalProperties": {
         "bsonType": "string"
      }
   }
}

{
   "bsonType": "object",
      "additionalProperties": true
   }
}

{
   "bsonType": "object",
      "additionalProperties": {
         "bsonType": "mixed"
      }
   }
}

{
   "bsonType": "object",
      "additionalProperties": {
         "bsonType": "object",
         "title": “Address”,
         "properties": {
           "streetNumber": { "bsonType": "string" },
           "street": { "bsonType": "string" },
           "city": { "bsonType": "string" },
           "province": { "bsonType": "string" },
           "country": { "bsonType": "string" },
           "postalCode": { "bsonType": "string" }
         }
   }
}

GeoJSON Point

A GeoJSON Point (GeoPoint) is a single location on the Earth's surface. The GeoPoint schema must be a required type field, of type string, which is always set to "Point".

You must also provide a coordinates field, which is an array of doubles. The coordinates array must contain at least 2 double values, and may contain a third:

• The first double is the longitude of the point, between -180 and 180.

• The second is the latitude, between -90 and 90.

• The optional third value represents the elevation/altitude of the point, in meters. Atlas ignores this value when performing queries.

If you are not using Device Sync, you can query your geospatial data with regular geospatial operators. However, if you are using Atlas Device Sync, the following rules also apply to the GeoPoint object:

• It must be of type object.

• It must be embedded within another type.

• Additional values are allowed within the coordinates array, as long as they are doubles.

• Additional properties in the GeoPoint object are also allowed.

The following is the Device Sync schema of an object with an embedded GeoPoint property named "location":

{
  "title": "MyObject",
  "properties": {
     "_id": {
       "bsonType": "objectId"
     },
     "location": {
       "bsonType": "object",
       "required": [ "type" ],
       "properties": {
         "type": {
           "bsonType": "string",
         },
         "coordinates": {
           "bsonType": "array",
           "items": {
             "bsonType": "double"
           }
         }
       }
     }
   }
}

The following code block shows a document that follows the schema. It has a single embedded GeoPoint object named "location".

{
  "_id": { "$oid": "65039d09fe4e46dddee31a3f" },
  "location": {
    "type": "Point",
    "coordinates": [-122.4, 48.12, 23.0]
   }
}