Bulk Check

To perform bulk permission checks, the permit.BulkCheck function can be leveraged. This allows you to validate multiple permission requests in a single call.

Basic Usage

The permit.BulkCheck function accepts an array of individual check requests as input:

Node.js

const { Permit } = require("permitio");

const permit = new Permit({token: "<YOUR_API_KEY>", ...});
await permit.bulkCheck([
    { user: "john@doe.com", action: 'read', resource: "document" },
    { user: "jane@doe.com", action: 'create', resource: "document" },
]);

Java

import io.permit.sdk.Permit;
import io.permit.sdk.PermitConfig;
import io.permit.sdk.enforcement.*;
import java.util.Arrays;


Permit permit = new Permit(
    new PermitConfig.Builder("[YOUR_API_KEY]").build()
);

boolean[] checks = permit.bulkCheck(Arrays.asList(
    // positive permission check
    new CheckQuery(
        User.fromString("john@doe.com"),
        "read",
        new Resource.Builder("document").withTenant(tenant.key).build()
    ),
    // negative permission check
    new CheckQuery(
        User.fromString("john@doe.com"),
        "create",
        new Resource.Builder("document").withTenant(tenant.key).build()
    )
));

GoLang

package main

import (
    "fmt"
)
import p "github.com/permitio/permit-golang/pkg/permit"
import "github.com/permitio/permit-golang/pkg/config"
import "github.com/permitio/permit-golang/pkg/enforcement"

func main() {
    // Create permit client
    permitConfig := config.NewConfigBuilder("").Build()
    permit := p.New(permitConfig)

    requestContext := map[string]string{
        "source": "docs",
    }

    usersToCheck := []string{
        "john@doe.com",
        "jane@doe.com",
    }
    checkRequests := make([]enforcement.CheckRequest, len(usersToCheck))
    // Create the requests to check
    resource := enforcement.ResourceBuilder("document").Build()
    for i, userKey := range usersToCheck {
        user := enforcement.UserBuilder(userKey).Build()
        checkRequests[i] = *enforcement.NewCheckRequest(user, "read", resource, requestContext)
    }
    var results []bool
    // Perform the bulk check
    results, err := permit.BulkCheck(checkRequests...)
    if err != nil {
        fmt.Printf("Error enforcing permissions: %s", err)
    } else {
        // The response indexes correspond to the request indexes
        for i, request := range checkRequests {
            if results[i] {
                fmt.Printf("%d. User '%s' is PERMITTED to '%s' a '%s'\n",
                i, request.User.Key, request.Action, request.Resource.Type,
                )
            } else {
                fmt.Printf("%d. User '%s' is NOT PERMITTED to '%s' a '%s'\n",
                i, request.User.Key, request.Action, request.Resource.Type,
                )
            }
        }
    }
}

note

Please note that the "Bulk Check" feature might have degraded performance if you're checking permissions for different tenants. This is because we split the requests by tenant in order for the request to reach the relevant PDP instance. This is done for it to be compatible with the current PDP Sharding setup, in which that instance only contains data for a few tenants, not all of them.