Sync Errors

This error indicates that the client attempted to open a realm with a partition value of the wrong type. For example, you might see the error message "attempted to bind on illegal realm partition: expected partition to have type objectId but found string".

To recover from this error, ensure that the type of the partition value used to open the realm matches the partition key type in your Device Sync configuration.

This error indicates the client query is invalid or malformed. This error includes a message that provides details about why the query is invalid.

To recover from this error, you may need to verify the query syntax is correct, and that you are using query operators that are supported on the server. Additionally, confirm you are querying a queryable field in your Flexible Sync configuration. If your query uses an indexed queryable field, ensure that it meets the requirements for valid client-side queries for indexed queryable fields.

This error indicates that server permissions for the file ident have changed since the last time it was used.

This error triggers a client reset. To recover from this error, perform a client reset.

This error indicates that the client tried to open a session before the initial sync was complete. This may occur when the app has just enabled Sync, and is still in the process of building the Sync history.

The client attempts to reconnect until this process is complete. Then, this error resolves and Sync begins working normally.

This non-fatal error occurs when a client attempts an "illegal" write. The following are considered illegal writes:

• Creating an object before opening a subscription

• Creating an object that would be outside of the client's query view. "Query view" includes both the client's subscriptions and the client's read permissions.

• Modifying an object that is outside of the client's query view

• Creating, deleting, or modifying an object or field that the client does not have write permissions to.

• Modifying an object in such a way that client would no longer have write permissions on that object or field after the write.

Because the local realm has no concept of "illegal" writes, the write will always succeed locally. Upon sync, the server will notice the illegal write. The server then undoes the change. The undo operation, called a "compensating write", syncs back to the client so the client's realm no longer has the illegal write. The server also sends this error to let the client know what has happened.

Any local writes to a given object between an illegal write to that object and the corresponding compensating write will be lost.

obj1.fieldA = 10 // illegal due to field-level permissions
obj1.fieldB = 5 // legal
DELETE obj1 // legal
DELETE obj2 // legal

The illegal write appears in the applog as a non-fatal error. Illegal writes might indicate that your application code is doing something you didn't intend.

In the following cases, you'll see ErrorWriteNotAllowed instead of ErrorCompensatingWrite after an "illegal" write:

• When using older SDK versions that are linked to a realm-core version before realm-core 12.1.0. In this case, the server will not undo the illegal write, and you will need to perform a manual client reset.

• When modifying an object in a collection with Data Ingest enabled. In this case, the error is non-fatal and does not trigger a client reset. The server skips over the illegal change and does not apply it to the synced MongoDB cluster.