Delete Error with Realm SDK

Hi @Bruno_Nobre,

Can you please clarify what too many documents means in this context? The deleteMany({}) command is executed as a function call from the SDK, and as such is subject to the constraints for functions. If you’re on a low tier, you’re also subject to limitations of your throughput: the combinations of these factors dictates the limits you’re likely hitting. Raising the tier would certainly help, you should take into consideration how frequent this type of operation is to size the app properly.

Do you have Sync enabled on that collection?

I’ve tried to reproduce the issue, and indeed there’s an odd behaviour for the deleteMany(…) function, when called from the SDK: we’ll raise an internal ticket for this.

As a workaround, you can try to implement your own Realm function within your app on the portal, something like, say, wipeCollection defined as

exports = async function(collectionName){
  const mdb = context.services.get('mongodb-atlas');
  const db = mdb.db('database');
  
  return await db.collection(collectionName).deleteMany({});
};

and from your app code, do

const result = await app.currentUser.callFunction('wipeCollection', [collection]);

They aren’t meant to overlap, the functionality you’ve been using (MongoDB Data Access) is built for convenience to allow simple interaction with the remote DB, however, from a mobile device, the developer will likely either:

1. Use the powerful local object DB that Realm provides, with automatic synching with the backend, powered by MongoDB (Mobile-first approach): DB logic is then at home on the device, with the possibility of some further processing on the backend, if needed.
2. Build an online-only app by leveraging the backend functionality, with Triggers, Functions, Webhooks, … (Backend-first approach): the Functions will have the full access to the MongoDB Driver, implement the core logic, and at the same time deliver a clean and secure range of services to the mobile side, without the risk of allowing full access to the DB from mobile clients.

I guess you’re referring to your other post: however, replaceOne(…) is indeed available within a Realm Function, are you experiencing any error there?

I’ve just tested the following:

exports = async function(collectionName){
  const db = context.services.get('mongodb-atlas').db("database");
  const collection = db.collection(collectionName);
  
  try {
    let result = await collection.findOne({<query>});
    
    console.log(JSON.stringify(result));
    
    result.fieldValue = 123.4;
    
    return await collection.replaceOne({<query>}, result);
  } catch (error) {
    console.error(error);
    
    return null;
  }
};

and it works as expected.

This brings us to my previous question:

The reason is that, when Sync is enabled on a collection, every change needs to be recorded to be transmitted to the mobile clients, that will in turn reflect that change on the local DB (see the Mobile-first approach I indicated in an earlier comment). This process limits the amount of changes that can be recorded in a given time, before the Function hits the timeout.

If, OTOH, you plan to use the Backend-first approach, and handle everything via Functions/Webhooks/…, with no local DB on the devices, then having Sync active makes little sense, and you can get a better performance (within the Service Limitations, obviously) by disabling it.