Concurrent atlas rule creation fails

Hello!

We are using the Admin API to create rules.. The rules creations used to work when executed in parallel. It appears that the outcome is now inconsistent. Out of the 3 rules that I need to create, most of the time, 1 is created, sometimes 2, rarely/never all 3.

If I execute them sequentially, all 3 rules are executed correctly. I checked that my code runs all the way and it waits for a API call to finish.

My code is in Typescript. Here is how I trigger all 3 Rule creations at once:

const collectionRuleResponse = await Promise.allSettled( [
  atlasRealm.createRealmRule(token, groupId, appId, serviceId, collectionName1, ruleCond1),
  atlasRealm.createRealmRule(token, groupId, appId, serviceId, collectionName2, ruleCond2),
  atlasRealm.createRealmRule(token, groupId, appId, serviceId, collectionName3, ruleCond3),
])

My createRealmRule function looks like this:

  async createRealmRule(token: string, groupId: string, appId: string, serviceId: string, collectionName: string, tenantId: string): Promise<string> {
    const atlasUrl = `https://realm.mongodb.com/api/admin/v3.0/groups/${groupId}/apps/${appId}/services/${serviceId}/rules`
    try {
      const payload = {
        "database": tenantId,
        "collection": collectionName,
        "roles": [
          {
            "name": "readAll",
            "name": "readAll",
            "apply_when": {
              "%%user.data.tenant_ids": tenantId
            },
            "document_filters": {
              "write": false,
              "read": true
            },
            "read": true,
            "write": false,
            "insert": false,
            "delete": false,
            "search": true
          }
        ],
        }
      const fetch_response = await fetch(
        atlasUrl,
        {
          headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${token}`
          },
          method: 'POST',
          body: JSON.stringify(payload)
        })

      if (!fetch_response.ok) {
        logger.error("createRealmRule: failed", {fetch_response: fetch_response, payload: payload})
        throw new Error("createRealmRule: failed")
      }

      const response = await fetch_response.json()
      return JSON.stringify(response)
    } catch (e) {
      logger.error('createRealmRule: error with atlas wrapper: ', {error: e as Error})
      throw e
    }
  }

If I execute them sequentially, it works fine:

await atlasRealm.createRealmRule(token, groupId, appId, serviceId, collectionName1, ruleCond1)
await atlasRealm.createRealmRule(token, groupId, appId, serviceId, collectionName1, ruleCond2)
await atlasRealm.createRealmRule(token, groupId, appId, serviceId, collectionName1, ruleCond3)

Here are my questions:
1/ Is this the expected behavior?
2/ Is concurrency of the rule creation allowed at the namespace level?
3/ where can I find the logs of successful and failed rule creations?