Add files using upload-large-folder tool

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/conv/casbin_types.go

@@ -0,0 +1,545 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package conv
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/weaviate/weaviate/usecases/auth/authentication"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+)
+
+const (
+	// https://casbin.org/docs/rbac/#how-to-distinguish-role-from-user
+	// ROLE_NAME_PREFIX to prefix role to help casbin to distinguish on Enforcing
+	ROLE_NAME_PREFIX = "role" + PREFIX_SEPARATOR
+	// OIDC_GROUP_NAME_PREFIX to prefix role to help casbin to distinguish on Enforcing
+	OIDC_GROUP_NAME_PREFIX = "group" + PREFIX_SEPARATOR
+	PREFIX_SEPARATOR       = ":"
+
+	// CRUD allow all actions on a resource
+	// this is internal for casbin to handle admin actions
+	CRUD = "(C)|(R)|(U)|(D)"
+	// CRU allow all actions on a resource except DELETE
+	// this is internal for casbin to handle editor actions
+	CRU         = "(C)|(R)|(U)"
+	VALID_VERBS = "(C)|(R)|(U)|(D)|(A)"
+	// InternalPlaceHolder is a place holder to mark empty roles
+	InternalPlaceHolder = "wv_internal_empty"
+)
+
+var (
+	BuiltInPolicies = map[string]string{
+		authorization.Viewer:   authorization.READ,
+		authorization.Admin:    VALID_VERBS,
+		authorization.Root:     VALID_VERBS,
+		authorization.ReadOnly: authorization.READ,
+	}
+	weaviate_actions_prefixes = map[string]string{
+		CRUD:                           "manage",
+		CRU:                            "manage",
+		authorization.ROLE_SCOPE_MATCH: "manage",
+		authorization.CREATE:           "create",
+		authorization.READ:             "read",
+		authorization.UPDATE:           "update",
+		authorization.DELETE:           "delete",
+		authorization.USER_AND_GROUP_ASSIGN_AND_REVOKE: "assign_and_revoke",
+	}
+)
+
+var resourcePatterns = []string{
+	fmt.Sprintf(`^%s/.*$`, authorization.GroupsDomain),
+	fmt.Sprintf(`^%s/[^/]+$`, authorization.GroupsDomain),
+	fmt.Sprintf(`^%s/.*$`, authorization.UsersDomain),
+	fmt.Sprintf(`^%s/[^/]+$`, authorization.UsersDomain),
+	fmt.Sprintf(`^%s/.*$`, authorization.RolesDomain),
+	fmt.Sprintf(`^%s/[^/]+$`, authorization.RolesDomain),
+	fmt.Sprintf(`^%s/.*$`, authorization.ClusterDomain),
+	fmt.Sprintf(`^%s/verbosity/minimal$`, authorization.NodesDomain),
+	fmt.Sprintf(`^%s/verbosity/verbose/collections/[^/]+$`, authorization.NodesDomain),
+	fmt.Sprintf(`^%s/verbosity/verbose/collections/[^/]+$`, authorization.NodesDomain),
+	fmt.Sprintf(`^%s/collections/.*$`, authorization.BackupsDomain),
+	fmt.Sprintf(`^%s/collections/[^/]+$`, authorization.BackupsDomain),
+	fmt.Sprintf(`^%s/collections/.*$`, authorization.SchemaDomain),
+	fmt.Sprintf(`^%s/collections/[^/]+$`, authorization.SchemaDomain),
+	fmt.Sprintf(`^%s/collections/[^/]+/shards/.*$`, authorization.SchemaDomain),
+	fmt.Sprintf(`^%s/collections/[^/]+/shards/[^/]+/objects/.*$`, authorization.DataDomain),
+	fmt.Sprintf(`^%s/collections/[^/]+/shards/[^/]+/objects/[^/]+$`, authorization.DataDomain),
+	fmt.Sprintf(`^%s/collections/[^/]+/shards/[^/]+$`, authorization.ReplicateDomain),
+	fmt.Sprintf(`^%s/collections/[^/]+/aliases/[^/]+$`, authorization.AliasesDomain),
+}
+
+func newPolicy(policy []string) *authorization.Policy {
+	return &authorization.Policy{
+		Resource: fromCasbinResource(policy[1]),
+		Verb:     policy[2],
+		Domain:   policy[3],
+	}
+}
+
+func fromCasbinResource(resource string) string {
+	return strings.ReplaceAll(resource, ".*", "*")
+}
+
+func CasbinClusters() string {
+	return fmt.Sprintf("%s/.*", authorization.ClusterDomain)
+}
+
+func CasbinNodes(verbosity, class string) string {
+	class = schema.UppercaseClassesNames(class)[0]
+	if verbosity == "minimal" {
+		return fmt.Sprintf("%s/verbosity/minimal", authorization.NodesDomain)
+	}
+	if class == "" {
+		class = "*"
+	}
+	class = strings.ReplaceAll(class, "*", ".*")
+	return fmt.Sprintf("%s/verbosity/verbose/collections/%s", authorization.NodesDomain, class)
+}
+
+func CasbinBackups(class string) string {
+	class = schema.UppercaseClassesNames(class)[0]
+	if class == "" {
+		class = "*"
+	}
+	class = strings.ReplaceAll(class, "*", ".*")
+	return fmt.Sprintf("%s/collections/%s", authorization.BackupsDomain, class)
+}
+
+func CasbinUsers(user string) string {
+	if user == "" {
+		user = "*"
+	}
+	user = strings.ReplaceAll(user, "*", ".*")
+	return fmt.Sprintf("%s/%s", authorization.UsersDomain, user)
+}
+
+func CasbinGroups(group string, groupType string) string {
+	if group == "" {
+		group = "*"
+	}
+	group = strings.ReplaceAll(group, "*", ".*")
+	return fmt.Sprintf("%s/%s/%s", authorization.GroupsDomain, groupType, group)
+}
+
+func CasbinRoles(role string) string {
+	if role == "" {
+		role = "*"
+	}
+	role = strings.ReplaceAll(role, "*", ".*")
+	return fmt.Sprintf("%s/%s", authorization.RolesDomain, role)
+}
+
+func CasbinSchema(collection, shard string) string {
+	collection = schema.UppercaseClassesNames(collection)[0]
+	if collection == "" {
+		collection = "*"
+	}
+	if shard == "" {
+		shard = "*"
+	}
+	collection = strings.ReplaceAll(collection, "*", ".*")
+	shard = strings.ReplaceAll(shard, "*", ".*")
+	return fmt.Sprintf("%s/collections/%s/shards/%s", authorization.SchemaDomain, collection, shard)
+}
+
+func CasbinReplicate(collection, shard string) string {
+	collection = schema.UppercaseClassesNames(collection)[0]
+	if collection == "" {
+		collection = "*"
+	}
+	if shard == "" {
+		shard = "*"
+	}
+	collection = strings.ReplaceAll(collection, "*", ".*")
+	shard = strings.ReplaceAll(shard, "*", ".*")
+	return fmt.Sprintf("%s/collections/%s/shards/%s", authorization.ReplicateDomain, collection, shard)
+}
+
+func CasbinAliases(collection, alias string) string {
+	if collection == "" {
+		collection = "*"
+	}
+	if alias == "" {
+		alias = "*"
+	}
+	collection = strings.ReplaceAll(collection, "*", ".*")
+	alias = strings.ReplaceAll(alias, "*", ".*")
+	return fmt.Sprintf("%s/collections/%s/aliases/%s", authorization.AliasesDomain, collection, alias)
+}
+
+func CasbinData(collection, shard, object string) string {
+	collection = schema.UppercaseClassesNames(collection)[0]
+	if collection == "" {
+		collection = "*"
+	}
+	if shard == "" {
+		shard = "*"
+	}
+	if object == "" {
+		object = "*"
+	}
+	collection = strings.ReplaceAll(collection, "*", ".*")
+	shard = strings.ReplaceAll(shard, "*", ".*")
+	object = strings.ReplaceAll(object, "*", ".*")
+	return fmt.Sprintf("%s/collections/%s/shards/%s/objects/%s", authorization.DataDomain, collection, shard, object)
+}
+
+func extractFromExtAction(inputAction string) (string, string, error) {
+	splits := strings.Split(inputAction, "_")
+	if len(splits) < 2 {
+		return "", "", fmt.Errorf("invalid action: %s", inputAction)
+	}
+	domain := splits[len(splits)-1]
+	verb := strings.ToUpper(splits[0][:1])
+	if verb == "M" {
+		verb = CRUD
+	}
+
+	if !validVerb(verb) {
+		return "", "", fmt.Errorf("invalid verb: %s", verb)
+	}
+
+	return verb, domain, nil
+}
+
+// casbinPolicyDomains decouples the endpoints domains
+// from the casbin internal domains.
+// e.g.
+// [create_collections, create_tenants] -> schema domain
+func casbinPolicyDomains(domain string) string {
+	switch domain {
+	case authorization.CollectionsDomain, authorization.TenantsDomain:
+		return authorization.SchemaDomain
+	default:
+		return domain
+	}
+}
+
+func policy(permission *models.Permission) (*authorization.Policy, error) {
+	if permission.Action == nil {
+		return &authorization.Policy{Resource: InternalPlaceHolder}, nil
+	}
+
+	verb, domain, err := extractFromExtAction(*permission.Action)
+	if err != nil {
+		return nil, err
+	}
+
+	var resource string
+	switch domain {
+	case authorization.GroupsDomain:
+		group := "*"
+		if permission.Groups != nil {
+			if permission.Groups.Group != nil {
+				group = *permission.Groups.Group
+			}
+			if permission.Groups.GroupType != models.GroupTypeOidc {
+				return nil, fmt.Errorf("invalid groups type: %v", permission.Groups.GroupType)
+			}
+		} else {
+			return nil, fmt.Errorf("invalid permission: %v", permission)
+		}
+		resource = CasbinGroups(group, string(models.GroupTypeOidc))
+	case authorization.UsersDomain:
+		user := "*"
+		if permission.Users != nil && permission.Users.Users != nil {
+			user = *permission.Users.Users
+		}
+		resource = CasbinUsers(user)
+	case authorization.RolesDomain:
+		role := "*"
+		// default verb for role to handle cases where role is nil
+		origVerb := verb
+		verb = authorization.VerbWithScope(verb, authorization.ROLE_SCOPE_MATCH)
+		if permission.Roles != nil && permission.Roles.Role != nil {
+			role = *permission.Roles.Role
+			if permission.Roles.Scope != nil {
+				verb = authorization.VerbWithScope(origVerb, strings.ToUpper(*permission.Roles.Scope))
+			}
+		}
+		resource = CasbinRoles(role)
+	case authorization.ClusterDomain:
+		resource = CasbinClusters()
+	case authorization.CollectionsDomain:
+		collection := "*"
+		tenant := "#"
+		if permission.Collections != nil && permission.Collections.Collection != nil {
+			collection = schema.UppercaseClassName(*permission.Collections.Collection)
+		}
+		resource = CasbinSchema(collection, tenant)
+
+	case authorization.TenantsDomain:
+		collection := "*"
+		tenant := "*"
+		if permission.Tenants != nil {
+			if permission.Tenants.Collection != nil {
+				collection = schema.UppercaseClassName(*permission.Tenants.Collection)
+			}
+
+			if permission.Tenants.Tenant != nil {
+				tenant = *permission.Tenants.Tenant
+			}
+		}
+		resource = CasbinSchema(collection, tenant)
+	case authorization.DataDomain:
+		collection := "*"
+		tenant := "*"
+		object := "*"
+		if permission.Data != nil && permission.Data.Collection != nil {
+			collection = schema.UppercaseClassName(*permission.Data.Collection)
+		}
+		if permission.Data != nil && permission.Data.Tenant != nil {
+			tenant = *permission.Data.Tenant
+		}
+		if permission.Data != nil && permission.Data.Object != nil {
+			object = *permission.Data.Object
+		}
+		resource = CasbinData(collection, tenant, object)
+	case authorization.BackupsDomain:
+		collection := "*"
+		if permission.Backups != nil {
+			if permission.Backups.Collection != nil {
+				collection = schema.UppercaseClassName(*permission.Backups.Collection)
+			}
+		}
+		resource = CasbinBackups(collection)
+	case authorization.NodesDomain:
+		collection := "*"
+		verbosity := "minimal"
+		if permission.Nodes != nil {
+			if permission.Nodes.Collection != nil {
+				collection = schema.UppercaseClassName(*permission.Nodes.Collection)
+			}
+			if permission.Nodes.Verbosity != nil {
+				verbosity = *permission.Nodes.Verbosity
+			}
+		}
+		resource = CasbinNodes(verbosity, collection)
+	case authorization.ReplicateDomain:
+		collection := "*"
+		shard := "*"
+		if permission.Replicate != nil {
+			if permission.Replicate.Collection != nil {
+				collection = schema.UppercaseClassName(*permission.Replicate.Collection)
+			}
+			if permission.Replicate.Shard != nil {
+				shard = *permission.Replicate.Shard
+			}
+		}
+		resource = CasbinReplicate(collection, shard)
+	case authorization.AliasesDomain:
+		collection := "*"
+		alias := "*"
+		if permission.Aliases != nil {
+			if permission.Aliases.Collection != nil {
+				collection = schema.UppercaseClassName(*permission.Aliases.Collection)
+			}
+			if permission.Aliases.Alias != nil {
+				alias = schema.UppercaseClassName(*permission.Aliases.Alias)
+			}
+		}
+		resource = CasbinAliases(collection, alias)
+	default:
+		return nil, fmt.Errorf("invalid domain: %s", domain)
+
+	}
+	if !validResource(resource) {
+		return nil, fmt.Errorf("invalid resource: %s", resource)
+	}
+
+	return &authorization.Policy{
+		Resource: resource,
+		Verb:     verb,
+		Domain:   casbinPolicyDomains(domain),
+	}, nil
+}
+
+func weaviatePermissionAction(pathLastPart, verb, domain string) string {
+	action := fmt.Sprintf("%s_%s", weaviate_actions_prefixes[verb], domain)
+	action = strings.ReplaceAll(action, "_*", "")
+	switch domain {
+	case authorization.SchemaDomain:
+		if pathLastPart == "#" {
+			// e.g
+			// schema/collections/ABC/shards/#    collection permission
+			// schema/collections/ABC/shards/*    tenant permission
+			action = fmt.Sprintf("%s_%s", weaviate_actions_prefixes[verb], authorization.CollectionsDomain)
+		} else {
+			action = fmt.Sprintf("%s_%s", weaviate_actions_prefixes[verb], authorization.TenantsDomain)
+		}
+		return action
+	default:
+		return action
+	}
+}
+
+func permission(policy []string, validatePath bool) (*models.Permission, error) {
+	mapped := newPolicy(policy)
+
+	if mapped.Resource == InternalPlaceHolder {
+		return &models.Permission{}, nil
+	}
+
+	if !validVerb(mapped.Verb) {
+		return nil, fmt.Errorf("invalid verb: %s", mapped.Verb)
+	}
+
+	permission := &models.Permission{}
+
+	splits := strings.Split(mapped.Resource, "/")
+
+	// validating the resource can be expensive (regexp!)
+	if validatePath && !validResource(mapped.Resource) {
+		return nil, fmt.Errorf("invalid resource: %s", mapped.Resource)
+	}
+
+	switch mapped.Domain {
+	case authorization.SchemaDomain:
+		if splits[4] == "#" {
+			permission.Collections = &models.PermissionCollections{
+				Collection: &splits[2],
+			}
+		} else {
+			permission.Tenants = &models.PermissionTenants{
+				Collection: &splits[2],
+				Tenant:     &splits[4],
+			}
+		}
+	case authorization.DataDomain:
+		permission.Data = &models.PermissionData{
+			Collection: &splits[2],
+			Tenant:     &splits[4],
+			Object:     &splits[6],
+		}
+	case authorization.RolesDomain:
+		permission.Roles = &models.PermissionRoles{
+			Role: &splits[1],
+		}
+
+		verbSplits := strings.Split(mapped.Verb, "_")
+		mapped.Verb = verbSplits[0]
+		scope := strings.ToLower(verbSplits[1])
+		permission.Roles.Scope = &scope
+
+	case authorization.NodesDomain:
+		verbosity := splits[2]
+		var collection *string
+		if verbosity == "minimal" {
+			collection = nil
+		} else {
+			collection = &splits[4]
+		}
+		permission.Nodes = &models.PermissionNodes{
+			Collection: collection,
+			Verbosity:  &verbosity,
+		}
+	case authorization.BackupsDomain:
+		permission.Backups = &models.PermissionBackups{
+			Collection: &splits[2],
+		}
+	case authorization.UsersDomain:
+		permission.Users = &models.PermissionUsers{
+			Users: &splits[1],
+		}
+	case authorization.ReplicateDomain:
+		permission.Replicate = &models.PermissionReplicate{
+			Collection: &splits[2],
+			Shard:      &splits[4],
+		}
+	case authorization.AliasesDomain:
+		permission.Aliases = &models.PermissionAliases{
+			Collection: &splits[2],
+			Alias:      &splits[4],
+		}
+	case authorization.GroupsDomain:
+		permission.Groups = &models.PermissionGroups{
+			Group:     &splits[2],
+			GroupType: models.GroupType(splits[1]),
+		}
+	case *authorization.All:
+		permission.Backups = authorization.AllBackups
+		permission.Data = authorization.AllData
+		permission.Nodes = authorization.AllNodes
+		permission.Roles = authorization.AllRoles
+		permission.Collections = authorization.AllCollections
+		permission.Tenants = authorization.AllTenants
+		permission.Users = authorization.AllUsers
+		permission.Replicate = authorization.AllReplicate
+		permission.Aliases = authorization.AllAliases
+		permission.Groups = authorization.AllOIDCGroups
+	case authorization.ClusterDomain:
+		// do nothing
+	default:
+		return nil, fmt.Errorf("invalid domain: %s", mapped.Domain)
+	}
+
+	permission.Action = authorization.String(weaviatePermissionAction(splits[len(splits)-1], mapped.Verb, mapped.Domain))
+	return permission, nil
+}
+
+func validResource(input string) bool {
+	for _, pattern := range resourcePatterns {
+		matched, err := regexp.MatchString(pattern, input)
+		if err != nil {
+			return false
+		}
+		if matched {
+			return true
+		}
+	}
+	return false
+}
+
+func validVerb(input string) bool {
+	return regexp.MustCompile(VALID_VERBS).MatchString(input)
+}
+
+func PrefixRoleName(name string) string {
+	if strings.HasPrefix(name, ROLE_NAME_PREFIX) {
+		return name
+	}
+	return fmt.Sprintf("%s%s", ROLE_NAME_PREFIX, name)
+}
+
+func PrefixGroupName(name string) string {
+	if strings.HasPrefix(name, OIDC_GROUP_NAME_PREFIX) {
+		return name
+	}
+	return fmt.Sprintf("%s%s", OIDC_GROUP_NAME_PREFIX, name)
+}
+
+func NameHasPrefix(name string) bool {
+	return strings.Contains(name, PREFIX_SEPARATOR)
+}
+
+func UserNameWithTypeFromPrincipal(principal *models.Principal) string {
+	return fmt.Sprintf("%s:%s", principal.UserType, principal.Username)
+}
+
+func UserNameWithTypeFromId(username string, authType authentication.AuthType) string {
+	return fmt.Sprintf("%s:%s", authType, username)
+}
+
+func TrimRoleNamePrefix(name string) string {
+	return strings.TrimPrefix(name, ROLE_NAME_PREFIX)
+}
+
+func GetUserAndPrefix(name string) (string, string) {
+	splits := strings.Split(name, PREFIX_SEPARATOR)
+	return splits[1], splits[0]
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/conv/casbin_types_test.go

@@ -0,0 +1,1160 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package conv
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/weaviate/weaviate/usecases/auth/authentication"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+)
+
+type innerTest struct {
+	permissionAction string
+	testDescription  string
+	policyVerb       string
+}
+
+var (
+	foo = authorization.String("Foo")
+	bar = authorization.String("bar")
+	baz = authorization.String("baz")
+
+	createDesc = "create"
+	readDesc   = "read"
+	updateDesc = "update"
+	deleteDesc = "delete"
+	manageDesc = "manage"
+
+	createVerb          = authorization.CREATE
+	readVerb            = authorization.READ
+	updateVerb          = authorization.UPDATE
+	deleteVerb          = authorization.DELETE
+	assignAndRevokeVerb = authorization.USER_AND_GROUP_ASSIGN_AND_REVOKE
+	manageVerb          = CRUD
+
+	rolesTestsR = []innerTest{
+		{permissionAction: authorization.ReadRoles, testDescription: readDesc, policyVerb: authorization.VerbWithScope(readVerb, authorization.ROLE_SCOPE_MATCH)},
+	}
+	rolesTestsCUD = []innerTest{
+		{permissionAction: authorization.CreateRoles, testDescription: createVerb, policyVerb: authorization.VerbWithScope(createVerb, authorization.ROLE_SCOPE_ALL)},
+		{permissionAction: authorization.UpdateRoles, testDescription: updateDesc, policyVerb: authorization.VerbWithScope(updateVerb, authorization.ROLE_SCOPE_ALL)},
+		{permissionAction: authorization.DeleteRoles, testDescription: deleteDesc, policyVerb: authorization.VerbWithScope(deleteVerb, authorization.ROLE_SCOPE_ALL)},
+	}
+	clusterTests = []innerTest{
+		{permissionAction: authorization.ReadCluster, testDescription: readDesc, policyVerb: readVerb},
+	}
+	nodesTests = []innerTest{
+		{permissionAction: authorization.ReadNodes, testDescription: readDesc, policyVerb: readVerb},
+	}
+	backupsTests = []innerTest{
+		{permissionAction: authorization.ManageBackups, testDescription: manageDesc, policyVerb: manageVerb},
+	}
+	collectionsTests = []innerTest{
+		{permissionAction: authorization.CreateCollections, testDescription: createDesc, policyVerb: createVerb},
+		{permissionAction: authorization.ReadCollections, testDescription: readDesc, policyVerb: readVerb},
+		{permissionAction: authorization.UpdateCollections, testDescription: updateDesc, policyVerb: updateVerb},
+		{permissionAction: authorization.DeleteCollections, testDescription: deleteDesc, policyVerb: deleteVerb},
+	}
+	objectsDataTests = []innerTest{
+		{permissionAction: authorization.CreateData, testDescription: createDesc, policyVerb: createVerb},
+		{permissionAction: authorization.ReadData, testDescription: readDesc, policyVerb: readVerb},
+		{permissionAction: authorization.UpdateData, testDescription: updateDesc, policyVerb: updateVerb},
+		{permissionAction: authorization.DeleteData, testDescription: deleteDesc, policyVerb: deleteVerb},
+	}
+	tenantsActionTests = []innerTest{
+		{permissionAction: authorization.CreateTenants, testDescription: createDesc, policyVerb: createVerb},
+		{permissionAction: authorization.ReadTenants, testDescription: readDesc, policyVerb: readVerb},
+		{permissionAction: authorization.UpdateTenants, testDescription: updateDesc, policyVerb: updateVerb},
+		{permissionAction: authorization.DeleteTenants, testDescription: deleteDesc, policyVerb: deleteVerb},
+	}
+	userTests = []innerTest{
+		{permissionAction: authorization.AssignAndRevokeUsers, testDescription: manageDesc, policyVerb: assignAndRevokeVerb},
+		{permissionAction: authorization.CreateUsers, testDescription: createDesc, policyVerb: createVerb},
+		{permissionAction: authorization.ReadUsers, testDescription: readDesc, policyVerb: readVerb},
+		{permissionAction: authorization.UpdateUsers, testDescription: updateDesc, policyVerb: updateVerb},
+		{permissionAction: authorization.DeleteUsers, testDescription: deleteDesc, policyVerb: deleteVerb},
+	}
+	groupTests = []innerTest{
+		{permissionAction: authorization.ReadGroups, testDescription: readDesc, policyVerb: readVerb},
+		{permissionAction: authorization.AssignAndRevokeGroups, testDescription: manageDesc, policyVerb: assignAndRevokeVerb},
+	}
+)
+
+func Test_policy(t *testing.T) {
+	tests := []struct {
+		name       string
+		permission *models.Permission
+		policy     *authorization.Policy
+		tests      []innerTest
+	}{
+		{
+			name: "all roles",
+			permission: &models.Permission{
+				Roles: &models.PermissionRoles{Role: authorization.All, Scope: authorization.String(models.PermissionRolesScopeMatch)},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinRoles("*"),
+				Domain:   authorization.RolesDomain,
+				Verb:     authorization.VerbWithScope(authorization.READ, authorization.ROLE_SCOPE_MATCH),
+			},
+			tests: rolesTestsR,
+		},
+		{
+			name: "a role",
+			permission: &models.Permission{
+				Roles: &models.PermissionRoles{Role: authorization.String("admin"), Scope: authorization.String(models.PermissionRolesScopeMatch)},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinRoles("admin"),
+				Domain:   authorization.RolesDomain,
+				Verb:     authorization.VerbWithScope(authorization.READ, authorization.ROLE_SCOPE_MATCH),
+			},
+			tests: rolesTestsR,
+		},
+		{
+			name: "a role with scope all",
+			permission: &models.Permission{
+				Roles: &models.PermissionRoles{Role: authorization.String("admin"), Scope: authorization.String(models.PermissionRolesScopeAll)},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinRoles("admin"),
+				Domain:   authorization.RolesDomain,
+				Verb:     authorization.VerbWithScope(authorization.READ, authorization.ROLE_SCOPE_ALL),
+			},
+			tests: rolesTestsCUD,
+		},
+		{
+			name:       "cluster",
+			permission: &models.Permission{},
+			policy: &authorization.Policy{
+				Resource: CasbinClusters(),
+				Domain:   authorization.ClusterDomain,
+			},
+			tests: clusterTests,
+		},
+		{
+			name: "minimal nodes",
+			permission: &models.Permission{
+				Nodes: &models.PermissionNodes{
+					Verbosity: authorization.String("minimal"),
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinNodes("minimal", "doesntmatter"),
+				Domain:   authorization.NodesDomain,
+			},
+			tests: nodesTests,
+		},
+		{
+			name: "verbose nodes for all collections",
+			permission: &models.Permission{
+				Nodes: &models.PermissionNodes{
+					Verbosity:  authorization.String("verbose"),
+					Collection: authorization.All,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinNodes("verbose", "*"),
+				Domain:   authorization.NodesDomain,
+			},
+			tests: nodesTests,
+		},
+		{
+			name: "verbose nodes for one collections",
+			permission: &models.Permission{
+				Nodes: &models.PermissionNodes{
+					Verbosity:  authorization.String("verbose"),
+					Collection: foo,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinNodes("verbose", "Foo"),
+				Domain:   authorization.NodesDomain,
+			},
+			tests: nodesTests,
+		},
+		{
+			name: "all backends",
+			permission: &models.Permission{
+				Backups: &models.PermissionBackups{},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinBackups("*"),
+				Domain:   authorization.BackupsDomain,
+			},
+			tests: backupsTests,
+		},
+		{
+			name: "a backend",
+			permission: &models.Permission{
+				Backups: &models.PermissionBackups{
+					Collection: authorization.String("ABC"),
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinBackups("ABC"),
+				Domain:   authorization.BackupsDomain,
+			},
+			tests: backupsTests,
+		},
+		{
+			name: "all collections",
+			permission: &models.Permission{
+				Collections: &models.PermissionCollections{},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinSchema("*", "#"),
+				Domain:   authorization.SchemaDomain,
+			},
+			tests: collectionsTests,
+		},
+		{
+			name: "a collection",
+			permission: &models.Permission{
+				Collections: &models.PermissionCollections{
+					Collection: foo,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinSchema("Foo", "#"),
+				Domain:   authorization.SchemaDomain,
+			},
+			tests: collectionsTests,
+		},
+		{
+			name: "all tenants in all collections",
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinSchema("*", "*"),
+				Domain:   authorization.SchemaDomain,
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name: "all tenants in a collection",
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{
+					Collection: foo,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinSchema("Foo", "*"),
+				Domain:   authorization.SchemaDomain,
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name: "a tenant in all collections",
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{
+					Tenant: bar,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinSchema("*", "bar"),
+				Domain:   authorization.SchemaDomain,
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name: "a tenant in a collection",
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{
+					Collection: foo,
+					Tenant:     bar,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinSchema("Foo", "bar"),
+				Domain:   authorization.SchemaDomain,
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name: "all objects in all collections ST",
+			permission: &models.Permission{
+				Data: &models.PermissionData{},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinData("*", "*", "*"),
+				Domain:   authorization.DataDomain,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name: "all objects in a collection ST",
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinData("Foo", "*", "*"),
+				Domain:   authorization.DataDomain,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name: "an object in all collections ST",
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Object: baz,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinData("*", "*", "baz"),
+				Domain:   authorization.DataDomain,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name: "an object in a collection ST",
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+					Object:     baz,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinData("Foo", "*", "baz"),
+				Domain:   authorization.DataDomain,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name: "all objects in all tenants in a collection MT",
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinData("Foo", "*", "*"),
+				Domain:   authorization.DataDomain,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name: "all objects in a tenant in all collections MT",
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Tenant: bar,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinData("*", "bar", "*"),
+				Domain:   authorization.DataDomain,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name: "all objects in a tenant in a collection MT",
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+					Tenant:     bar,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinData("Foo", "bar", "*"),
+				Domain:   authorization.DataDomain,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name: "an object in all tenants in all collections MT",
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Object: baz,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinData("*", "*", "baz"),
+				Domain:   authorization.DataDomain,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name: "an object in all tenants in a collection MT",
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+					Object:     baz,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinData("Foo", "*", "baz"),
+				Domain:   authorization.DataDomain,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name: "an object in a tenant in all collections MT",
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Tenant: bar,
+					Object: baz,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinData("*", "bar", "baz"),
+				Domain:   authorization.DataDomain,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name: "an object in a tenant in a collection MT",
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+					Tenant:     bar,
+					Object:     baz,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinData("Foo", "bar", "baz"),
+				Domain:   authorization.DataDomain,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name: "a tenant",
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{
+					Collection: foo,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinSchema("Foo", ""),
+				Domain:   authorization.SchemaDomain,
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name: "all tenants in all collections",
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinSchema("*", "*"),
+				Domain:   authorization.SchemaDomain,
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name: "all tenants in a collection",
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{
+					Collection: foo,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinSchema("Foo", "*"),
+				Domain:   authorization.SchemaDomain,
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name: "a tenant in all collections",
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{
+					Tenant: bar,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinSchema("*", "bar"),
+				Domain:   authorization.SchemaDomain,
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name: "a tenant in a collection",
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{
+					Collection: foo,
+					Tenant:     bar,
+				},
+			},
+			policy: &authorization.Policy{
+				Resource: CasbinSchema("Foo", "bar"),
+				Domain:   authorization.SchemaDomain,
+			},
+			tests: tenantsActionTests,
+		},
+	}
+	for _, tt := range tests {
+		for _, ttt := range tt.tests {
+			t.Run(fmt.Sprintf("%s %s", ttt.testDescription, tt.name), func(t *testing.T) {
+				tt.permission.Action = authorization.String(ttt.permissionAction)
+				tt.policy.Verb = ttt.policyVerb
+
+				policy, err := policy(tt.permission)
+				require.Nil(t, err)
+				require.Equal(t, tt.policy, policy)
+			})
+		}
+	}
+}
+
+func Test_permission(t *testing.T) {
+	tests := []struct {
+		name       string
+		policy     []string
+		permission *models.Permission
+		tests      []innerTest
+	}{
+		{
+			name:   "all roles",
+			policy: []string{"p", "/*", "", authorization.RolesDomain},
+			permission: &models.Permission{
+				Roles: &models.PermissionRoles{Role: authorization.String("*"), Scope: authorization.String(models.PermissionRolesScopeMatch)},
+			},
+			tests: rolesTestsR,
+		},
+		{
+			name:   "all roles",
+			policy: []string{"p", "/*", authorization.ROLE_SCOPE_MATCH, authorization.RolesDomain},
+			permission: &models.Permission{
+				Roles: authorization.AllRoles,
+			},
+			tests: rolesTestsCUD,
+		},
+		{
+			name:   "a role",
+			policy: []string{"p", "/custom", authorization.ROLE_SCOPE_MATCH, authorization.RolesDomain},
+			permission: &models.Permission{
+				Roles: &models.PermissionRoles{Role: authorization.String("custom"), Scope: authorization.String(models.PermissionRolesScopeMatch)},
+			},
+			tests: rolesTestsR,
+		},
+		{
+			name:   "a role",
+			policy: []string{"p", "/custom", authorization.ROLE_SCOPE_MATCH, authorization.RolesDomain},
+			permission: &models.Permission{
+				Roles: &models.PermissionRoles{Role: authorization.String("custom"), Scope: authorization.String(models.PermissionRolesScopeAll)},
+			},
+			tests: rolesTestsCUD,
+		},
+		{
+			name:   "all users",
+			policy: []string{"p", "/*", "", authorization.UsersDomain},
+			permission: &models.Permission{
+				Users: authorization.AllUsers,
+			},
+			tests: userTests,
+		},
+		{
+			name:       "cluster",
+			policy:     []string{"p", "/*", "", authorization.ClusterDomain},
+			permission: &models.Permission{},
+			tests:      clusterTests,
+		},
+		{
+			name:   "minimal nodes",
+			policy: []string{"p", "/verbosity/minimal", "", authorization.NodesDomain},
+			permission: &models.Permission{
+				Nodes: &models.PermissionNodes{
+					Verbosity: authorization.String("minimal"),
+				},
+			},
+			tests: nodesTests,
+		},
+		{
+			name:   "verbose nodes over all collections",
+			policy: []string{"p", "/verbosity/verbose/collections/*", "", authorization.NodesDomain},
+			permission: &models.Permission{
+				Nodes: &models.PermissionNodes{
+					Collection: authorization.All,
+					Verbosity:  authorization.String("verbose"),
+				},
+			},
+			tests: nodesTests,
+		},
+		{
+			name:   "verbose nodes over one collection",
+			policy: []string{"p", "/verbosity/verbose/collections/Foo", "", authorization.NodesDomain},
+			permission: &models.Permission{
+				Nodes: &models.PermissionNodes{
+					Collection: authorization.String("Foo"),
+					Verbosity:  authorization.String("verbose"),
+				},
+			},
+			tests: nodesTests,
+		},
+		{
+			name:   "all tenants",
+			policy: []string{"p", "/collections/*/shards/*", "", authorization.SchemaDomain},
+			permission: &models.Permission{
+				Tenants: authorization.AllTenants,
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name:   "a tenant",
+			policy: []string{"p", "/collections/Foo/shards/*", "", authorization.SchemaDomain},
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{
+					Collection: foo,
+					Tenant:     authorization.All,
+				},
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name:   "backup all collections",
+			policy: []string{"p", "/collections/*", "", "backups"},
+			permission: &models.Permission{
+				Backups: authorization.AllBackups,
+			},
+			tests: backupsTests,
+		},
+		{
+			name:   "a collection ABC",
+			policy: []string{"p", "/collections/ABC", "", "backups"},
+			permission: &models.Permission{
+				Backups: &models.PermissionBackups{
+					Collection: authorization.String("ABC"),
+				},
+			},
+			tests: backupsTests,
+		},
+		{
+			name:   "all collections",
+			policy: []string{"p", "/collections/*/shards/#", "", authorization.SchemaDomain},
+			permission: &models.Permission{
+				Collections: authorization.AllCollections,
+			},
+			tests: collectionsTests,
+		},
+		{
+			name:   "a collection",
+			policy: []string{"p", "/collections/Foo/shards/#", "", authorization.SchemaDomain},
+			permission: &models.Permission{
+				Collections: &models.PermissionCollections{
+					Collection: foo,
+				},
+			},
+			tests: collectionsTests,
+		},
+		{
+			name:   "all tenants in all collections",
+			policy: []string{"p", "/collections/*/shards/*", "", authorization.SchemaDomain},
+			permission: &models.Permission{
+				Tenants: authorization.AllTenants,
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name:   "all tenants in a collection",
+			policy: []string{"p", "/collections/Foo/shards/*", "", authorization.SchemaDomain},
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{
+					Collection: foo,
+					Tenant:     authorization.All,
+				},
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name:   "a tenant in all collections",
+			policy: []string{"p", "/collections/*/shards/bar", "", authorization.SchemaDomain},
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{
+					Collection: authorization.All,
+					Tenant:     bar,
+				},
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name:   "a tenant in a collection",
+			policy: []string{"p", "/collections/Foo/shards/bar", "", authorization.SchemaDomain},
+			permission: &models.Permission{
+				Tenants: &models.PermissionTenants{
+					Collection: foo,
+					Tenant:     bar,
+				},
+			},
+			tests: tenantsActionTests,
+		},
+		{
+			name:   "all objects in all collections ST",
+			policy: []string{"p", "/collections/*/shards/*/objects/*", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: authorization.All,
+					Tenant:     authorization.All,
+					Object:     authorization.All,
+				},
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name:   "all objects in a collection ST",
+			policy: []string{"p", "/collections/Foo/shards/*/objects/*", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+					Tenant:     authorization.All,
+					Object:     authorization.All,
+				},
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name:   "an object in all collections ST",
+			policy: []string{"p", "/collections/*/shards/*/objects/baz", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: authorization.All,
+					Tenant:     authorization.All,
+					Object:     baz,
+				},
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name:   "an object in a collection ST",
+			policy: []string{"p", "/collections/Foo/shards/*/objects/baz", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+					Tenant:     authorization.All,
+					Object:     baz,
+				},
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name:   "all objects in all tenants in all collections MT",
+			policy: []string{"p", "/collections/*/shards/*/objects/*", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: authorization.AllData,
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name:   "all objects in all tenants in a collection MT",
+			policy: []string{"p", "/collections/Foo/shards/*/objects/*", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+					Tenant:     authorization.All,
+					Object:     authorization.All,
+				},
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name:   "all objects in a tenant in all collections MT",
+			policy: []string{"p", "/collections/*/shards/bar/objects/*", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: authorization.All,
+					Tenant:     bar,
+					Object:     authorization.All,
+				},
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name:   "all objects in a tenant in a collection MT",
+			policy: []string{"p", "/collections/Foo/shards/bar/objects/*", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+					Tenant:     bar,
+					Object:     authorization.All,
+				},
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name:   "an object in all tenants in all collections MT",
+			policy: []string{"p", "/collections/*/shards/*/objects/baz", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: authorization.All,
+					Tenant:     authorization.All,
+					Object:     baz,
+				},
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name:   "an object in all tenants in a collection MT",
+			policy: []string{"p", "/collections/Foo/shards/*/objects/baz", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+					Tenant:     authorization.All,
+					Object:     baz,
+				},
+			},
+		},
+		{
+			name:   "an object in a tenant in all collections MT",
+			policy: []string{"p", "/collections/*/shards/bar/objects/baz", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: authorization.All,
+					Tenant:     bar,
+					Object:     baz,
+				},
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name:   "an object in a tenant in a collection MT",
+			policy: []string{"p", "/collections/Foo/shards/bar/objects/baz", "", authorization.DataDomain},
+			permission: &models.Permission{
+				Data: &models.PermissionData{
+					Collection: foo,
+					Tenant:     bar,
+					Object:     baz,
+				},
+			},
+			tests: objectsDataTests,
+		},
+		{
+			name:   "a user",
+			policy: []string{"p", "/baz", "", authorization.UsersDomain},
+			permission: &models.Permission{
+				Users: &models.PermissionUsers{
+					Users: baz,
+				},
+			},
+			tests: userTests,
+		},
+		{
+			name:   "all users",
+			policy: []string{"p", "/*", "", authorization.UsersDomain},
+			permission: &models.Permission{
+				Users: &models.PermissionUsers{
+					Users: authorization.All,
+				},
+			},
+			tests: userTests,
+		},
+		{
+			name:   "a group",
+			policy: []string{"p", "/oidc/baz", "", authorization.GroupsDomain},
+			permission: &models.Permission{
+				Groups: &models.PermissionGroups{
+					Group:     baz,
+					GroupType: models.GroupTypeOidc,
+				},
+			},
+			tests: groupTests,
+		},
+		{
+			name:   "all groups",
+			policy: []string{"p", "/oidc/*", "", authorization.GroupsDomain},
+			permission: &models.Permission{
+				Groups: &models.PermissionGroups{
+					Group:     authorization.All,
+					GroupType: models.GroupTypeOidc,
+				},
+			},
+			tests: groupTests,
+		},
+	}
+	for _, tt := range tests {
+		tt.policy[1] = fmt.Sprintf("%s%s", tt.policy[3], tt.policy[1])
+		for _, ttt := range tt.tests {
+			t.Run(fmt.Sprintf("%s %s", ttt.testDescription, tt.name), func(t *testing.T) {
+				policyForTest := make([]string, len(tt.policy))
+				copy(policyForTest, tt.policy)
+				tt.permission.Action = authorization.String(ttt.permissionAction)
+				// TODO-RBAC : this test has to be rewritten and consider scopes
+				if policyForTest[2] == authorization.ROLE_SCOPE_MATCH {
+					policyForTest[2] = ttt.policyVerb + "_" + authorization.ROLE_SCOPE_MATCH
+				} else {
+					policyForTest[2] = ttt.policyVerb
+				}
+				permission, err := permission(policyForTest, true)
+				require.Nil(t, err)
+				require.Equal(t, tt.permission, permission)
+			})
+		}
+	}
+}
+
+func Test_pUsers(t *testing.T) {
+	tests := []struct {
+		user     string
+		expected string
+	}{
+		{user: "", expected: fmt.Sprintf("%s/.*", authorization.UsersDomain)},
+		{user: "*", expected: fmt.Sprintf("%s/.*", authorization.UsersDomain)},
+		{user: "foo", expected: fmt.Sprintf("%s/foo", authorization.UsersDomain)},
+	}
+	for _, tt := range tests {
+		name := fmt.Sprintf("user: %s", tt.user)
+		t.Run(name, func(t *testing.T) {
+			p := CasbinUsers(tt.user)
+			require.Equal(t, tt.expected, p)
+		})
+	}
+}
+
+func Test_pGroups(t *testing.T) {
+	tests := []struct {
+		group    string
+		expected string
+	}{
+		{group: "", expected: fmt.Sprintf("%s/%s/.*", authorization.GroupsDomain, authentication.AuthTypeOIDC)},
+		{group: "*", expected: fmt.Sprintf("%s/%s/.*", authorization.GroupsDomain, authentication.AuthTypeOIDC)},
+		{group: "foo", expected: fmt.Sprintf("%s/%s/foo", authorization.GroupsDomain, authentication.AuthTypeOIDC)},
+	}
+	for _, tt := range tests {
+		name := fmt.Sprintf("group: %s", tt.group)
+		t.Run(name, func(t *testing.T) {
+			p := CasbinGroups(tt.group, string(authentication.AuthTypeOIDC))
+			require.Equal(t, tt.expected, p)
+		})
+	}
+}
+
+func Test_pRoles(t *testing.T) {
+	tests := []struct {
+		role     string
+		expected string
+	}{
+		{role: "", expected: fmt.Sprintf("%s/.*", authorization.RolesDomain)},
+		{role: "*", expected: fmt.Sprintf("%s/.*", authorization.RolesDomain)},
+		{role: "foo", expected: fmt.Sprintf("%s/foo", authorization.RolesDomain)},
+	}
+	for _, tt := range tests {
+		name := fmt.Sprintf("role: %s", tt.role)
+		t.Run(name, func(t *testing.T) {
+			p := CasbinRoles(tt.role)
+			require.Equal(t, tt.expected, p)
+		})
+	}
+}
+
+func Test_pCollections(t *testing.T) {
+	tests := []struct {
+		collection string
+		expected   string
+	}{
+		{collection: "", expected: fmt.Sprintf("%s/collections/.*/shards/.*", authorization.SchemaDomain)},
+		{collection: "*", expected: fmt.Sprintf("%s/collections/.*/shards/.*", authorization.SchemaDomain)},
+		{collection: "foo", expected: fmt.Sprintf("%s/collections/Foo/shards/.*", authorization.SchemaDomain)},
+	}
+	for _, tt := range tests {
+		name := fmt.Sprintf("collection: %s", tt.collection)
+		t.Run(name, func(t *testing.T) {
+			p := CasbinSchema(tt.collection, "")
+			require.Equal(t, tt.expected, p)
+		})
+	}
+}
+
+func Test_CasbinShards(t *testing.T) {
+	tests := []struct {
+		collection string
+		shard      string
+		expected   string
+	}{
+		{collection: "", shard: "", expected: fmt.Sprintf("%s/collections/.*/shards/.*", authorization.SchemaDomain)},
+		{collection: "*", shard: "*", expected: fmt.Sprintf("%s/collections/.*/shards/.*", authorization.SchemaDomain)},
+		{collection: "foo", shard: "", expected: fmt.Sprintf("%s/collections/Foo/shards/.*", authorization.SchemaDomain)},
+		{collection: "foo", shard: "*", expected: fmt.Sprintf("%s/collections/Foo/shards/.*", authorization.SchemaDomain)},
+		{collection: "", shard: "bar", expected: fmt.Sprintf("%s/collections/.*/shards/bar", authorization.SchemaDomain)},
+		{collection: "*", shard: "bar", expected: fmt.Sprintf("%s/collections/.*/shards/bar", authorization.SchemaDomain)},
+		{collection: "foo", shard: "bar", expected: fmt.Sprintf("%s/collections/Foo/shards/bar", authorization.SchemaDomain)},
+	}
+	for _, tt := range tests {
+		name := fmt.Sprintf("collection: %s; shard: %s", tt.collection, tt.shard)
+		t.Run(name, func(t *testing.T) {
+			p := CasbinSchema(tt.collection, tt.shard)
+			require.Equal(t, tt.expected, p)
+		})
+	}
+}
+
+func Test_pObjects(t *testing.T) {
+	tests := []struct {
+		collection string
+		shard      string
+		object     string
+		expected   string
+	}{
+		{collection: "", shard: "", object: "", expected: fmt.Sprintf("%s/collections/.*/shards/.*/objects/.*", authorization.DataDomain)},
+		{collection: "*", shard: "*", object: "*", expected: fmt.Sprintf("%s/collections/.*/shards/.*/objects/.*", authorization.DataDomain)},
+		{collection: "foo", shard: "", object: "", expected: fmt.Sprintf("%s/collections/Foo/shards/.*/objects/.*", authorization.DataDomain)},
+		{collection: "foo", shard: "*", object: "*", expected: fmt.Sprintf("%s/collections/Foo/shards/.*/objects/.*", authorization.DataDomain)},
+		{collection: "", shard: "bar", object: "", expected: fmt.Sprintf("%s/collections/.*/shards/bar/objects/.*", authorization.DataDomain)},
+		{collection: "*", shard: "bar", object: "*", expected: fmt.Sprintf("%s/collections/.*/shards/bar/objects/.*", authorization.DataDomain)},
+		{collection: "", shard: "", object: "baz", expected: fmt.Sprintf("%s/collections/.*/shards/.*/objects/baz", authorization.DataDomain)},
+		{collection: "*", shard: "*", object: "baz", expected: fmt.Sprintf("%s/collections/.*/shards/.*/objects/baz", authorization.DataDomain)},
+		{collection: "foo", shard: "bar", object: "", expected: fmt.Sprintf("%s/collections/Foo/shards/bar/objects/.*", authorization.DataDomain)},
+		{collection: "foo", shard: "bar", object: "*", expected: fmt.Sprintf("%s/collections/Foo/shards/bar/objects/.*", authorization.DataDomain)},
+		{collection: "foo", shard: "", object: "baz", expected: fmt.Sprintf("%s/collections/Foo/shards/.*/objects/baz", authorization.DataDomain)},
+		{collection: "foo", shard: "*", object: "baz", expected: fmt.Sprintf("%s/collections/Foo/shards/.*/objects/baz", authorization.DataDomain)},
+		{collection: "", shard: "bar", object: "baz", expected: fmt.Sprintf("%s/collections/.*/shards/bar/objects/baz", authorization.DataDomain)},
+		{collection: "*", shard: "bar", object: "baz", expected: fmt.Sprintf("%s/collections/.*/shards/bar/objects/baz", authorization.DataDomain)},
+		{collection: "foo", shard: "bar", object: "baz", expected: fmt.Sprintf("%s/collections/Foo/shards/bar/objects/baz", authorization.DataDomain)},
+	}
+	for _, tt := range tests {
+		name := fmt.Sprintf("collection: %s; shard: %s; object: %s", tt.collection, tt.shard, tt.object)
+		t.Run(name, func(t *testing.T) {
+			p := CasbinData(tt.collection, tt.shard, tt.object)
+			require.Equal(t, tt.expected, p)
+		})
+	}
+}
+
+func Test_CasbinBackups(t *testing.T) {
+	tests := []struct {
+		backend  string
+		expected string
+	}{
+		{backend: "", expected: fmt.Sprintf("%s/collections/.*", authorization.BackupsDomain)},
+		{backend: "*", expected: fmt.Sprintf("%s/collections/.*", authorization.BackupsDomain)},
+		{backend: "foo", expected: fmt.Sprintf("%s/collections/Foo", authorization.BackupsDomain)},
+		{backend: "foo", expected: fmt.Sprintf("%s/collections/Foo", authorization.BackupsDomain)},
+		{backend: "", expected: fmt.Sprintf("%s/collections/.*", authorization.BackupsDomain)},
+		{backend: "*", expected: fmt.Sprintf("%s/collections/.*", authorization.BackupsDomain)},
+		{backend: "foo", expected: fmt.Sprintf("%s/collections/Foo", authorization.BackupsDomain)},
+	}
+	for _, tt := range tests {
+		name := fmt.Sprintf("backend: %s", tt.backend)
+		t.Run(name, func(t *testing.T) {
+			p := CasbinBackups(tt.backend)
+			require.Equal(t, tt.expected, p)
+		})
+	}
+}
+
+func Test_fromCasbinResource(t *testing.T) {
+	tests := []struct {
+		resource string
+		expected string
+	}{
+		{resource: "collections/.*/shards/.*/objects/.*", expected: "collections/*/shards/*/objects/*"},
+	}
+	for _, tt := range tests {
+		name := fmt.Sprintf("Resource: %s", tt.resource)
+		t.Run(name, func(t *testing.T) {
+			p := fromCasbinResource(tt.resource)
+			require.Equal(t, tt.expected, p)
+		})
+	}
+}
+
+func TestValidResource(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected bool
+	}{
+		{
+			name:     "valid resource - users",
+			input:    fmt.Sprintf("%s/testUser", authorization.UsersDomain),
+			expected: true,
+		},
+		{
+			name:     "valid resource - groups",
+			input:    fmt.Sprintf("%s/testGroups", authorization.GroupsDomain),
+			expected: true,
+		},
+		{
+			name:     "valid resource - roles",
+			input:    fmt.Sprintf("%s/testRole", authorization.RolesDomain),
+			expected: true,
+		},
+		{
+			name:     "valid resource - collections",
+			input:    fmt.Sprintf("%s/collections/testCollection", authorization.SchemaDomain),
+			expected: true,
+		},
+		{
+			name:     "valid resource - objects",
+			input:    fmt.Sprintf("%s/collections/testCollection/shards/testShard/objects/testObject", authorization.DataDomain),
+			expected: true,
+		},
+		{
+			name:     "invalid resource",
+			input:    "invalid/resource",
+			expected: false,
+		},
+		{
+			name:     "invalid resource",
+			input:    "some resource",
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := validResource(tt.input)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestValidVerb(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected bool
+	}{
+		{
+			name:     "valid verb - create",
+			input:    "C",
+			expected: true,
+		},
+		{
+			name:     "valid verb - read",
+			input:    "R",
+			expected: true,
+		},
+		{
+			name:     "valid verb - update",
+			input:    "U",
+			expected: true,
+		},
+		{
+			name:     "valid verb - delete",
+			input:    "D",
+			expected: true,
+		},
+		{
+			name:     "All",
+			input:    "CRUD",
+			expected: true,
+		},
+		{
+			name:     "invalid verb",
+			input:    "X",
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := validVerb(tt.input)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/docs/auth_calls.md

@@ -0,0 +1,80 @@
+# Authorization Calls
+This document lists all authorization calls in the codebase.
+## Usage
+To regenerate this documentation, run the following commands from the repository root:
+```bash
+cd usecases/auth/authorization/docs
+go run generator.go
+```
+## Statistics
+- Total files found: 23162
+- Files processed: 1937
+- Total Authorize calls found: 79
+
+| Function | File | Verb → Resources |
+|----------|------|-----------------|
+| resolveAggregate | adapters/handlers/graphql/local/aggregate/resolver.go | READ → ShardsData |
+| authorizePath | adapters/handlers/graphql/local/common_filters/authz.go | READ → CollectionsData |
+| AuthorizeProperty | adapters/handlers/graphql/local/common_filters/authz.go | READ → CollectionsData |
+| resolveExplore | adapters/handlers/graphql/local/explore/concepts_resolver.go | READ → CollectionsData |
+| resolveGet | adapters/handlers/graphql/local/get/class_builder_fields.go | READ → ShardsData |
+| batchDelete | adapters/handlers/grpc/v1/service.go | DELETE → ShardsData |
+| batchObjects | adapters/handlers/grpc/v1/service.go | UPDATE → ShardsData<br>CREATE → ShardsData |
+| classGetterWithAuthzFunc | adapters/handlers/grpc/v1/service.go | READ → Collections |
+| createRole | adapters/handlers/rest/authz/handlers_authz.go | CREATE → Roles |
+| addPermissions | adapters/handlers/rest/authz/handlers_authz.go | UPDATE → Roles |
+| removePermissions | adapters/handlers/rest/authz/handlers_authz.go | UPDATE → Roles |
+| hasPermission | adapters/handlers/rest/authz/handlers_authz.go | READ → Roles |
+| getRoles | adapters/handlers/rest/authz/handlers_authz.go | READ → Roles |
+| getRole | adapters/handlers/rest/authz/handlers_authz.go | READ → Roles |
+| deleteRole | adapters/handlers/rest/authz/handlers_authz.go | DELETE → Roles |
+| assignRole | adapters/handlers/rest/authz/handlers_authz.go | UPDATE → Roles |
+| getRolesForUser | adapters/handlers/rest/authz/handlers_authz.go | READ → Roles |
+| getUsersForRole | adapters/handlers/rest/authz/handlers_authz.go | READ → Roles |
+| revokeRole | adapters/handlers/rest/authz/handlers_authz.go | UPDATE → Roles |
+| setupGraphQLHandlers | adapters/handlers/rest/handlers_graphql.go | READ → CollectionsMetadata, Collections |
+| Backup | usecases/backup/scheduler.go | CREATE → Backups |
+| Restore | usecases/backup/scheduler.go | CREATE → Backups |
+| Cancel | usecases/backup/scheduler.go | DELETE → Backups |
+| Schedule | usecases/classification/classifier.go | UPDATE → CollectionsMetadata |
+| validateFilter | usecases/classification/classifier.go | READ → CollectionsMetadata |
+| Get | usecases/classification/classifier.go | READ → CollectionsMetadata |
+| GetNodeStatus | usecases/nodes/handler.go | READ → Nodes |
+| GetNodeStatistics | usecases/nodes/handler.go | READ → Cluster |
+| AddObject | usecases/objects/add.go | CREATE → ShardsData<br>READ → CollectionsMetadata |
+| autoSchema | usecases/objects/auto_schema.go | CREATE → CollectionsMetadata<br>UPDATE → CollectionsMetadata |
+| AddObjects | usecases/objects/batch_add.go | UPDATE → ShardsData<br>CREATE → ShardsData |
+| DeleteObjects | usecases/objects/batch_delete.go | DELETE → ShardsData |
+| classGetterFunc | usecases/objects/batch_delete.go | READ → Collections |
+| AddReferences | usecases/objects/batch_references_add.go | UPDATE → pathsData<br>READ → pathsMetadata |
+| addReferences | usecases/objects/batch_references_add.go | READ → shardsDataPaths |
+| DeleteObject | usecases/objects/delete.go | READ → CollectionsMetadata<br>DELETE → Objects |
+| GetObject | usecases/objects/get.go | READ → Objects |
+| GetObjects | usecases/objects/get.go | READ → Objects |
+| GetObjectsClass | usecases/objects/get.go | READ → Objects |
+| HeadObject | usecases/objects/head.go | READ → Objects, CollectionsMetadata |
+| MergeObject | usecases/objects/merge.go | UPDATE → Objects<br>READ → CollectionsMetadata |
+| Query | usecases/objects/query.go | READ → CollectionsMetadata |
+| AddObjectReference | usecases/objects/references_add.go | UPDATE → ShardsData<br>READ → CollectionsMetadata, Collections |
+| DeleteObjectReference | usecases/objects/references_delete.go | UPDATE → ShardsData<br>READ → CollectionsMetadata, CollectionsData |
+| UpdateObjectReferences | usecases/objects/references_update.go | UPDATE → ShardsData<br>READ → CollectionsMetadata, Collections |
+| UpdateObject | usecases/objects/update.go | UPDATE → Objects<br>READ → CollectionsMetadata |
+| ValidateObject | usecases/objects/validate.go | READ → Objects |
+| GetClass | usecases/schema/class.go | READ → CollectionsMetadata |
+| GetConsistentClass | usecases/schema/class.go | READ → CollectionsMetadata |
+| GetCachedClass | usecases/schema/class.go | READ → CollectionsMetadata |
+| AddClass | usecases/schema/class.go | CREATE → CollectionsMetadata<br>READ → CollectionsMetadata |
+| DeleteClass | usecases/schema/class.go | DELETE → CollectionsMetadata<br>READ → CollectionsMetadata |
+| UpdateClass | usecases/schema/class.go | UPDATE → CollectionsMetadata |
+| GetSchema | usecases/schema/handler.go | READ → CollectionsMetadata |
+| GetConsistentSchema | usecases/schema/handler.go | READ → CollectionsMetadata |
+| UpdateShardStatus | usecases/schema/handler.go | UPDATE → ShardsMetadata |
+| ShardsStatus | usecases/schema/handler.go | READ → ShardsMetadata |
+| AddClassProperty | usecases/schema/property.go | UPDATE → CollectionsMetadata<br>READ → CollectionsMetadata |
+| DeleteClassProperty | usecases/schema/property.go | UPDATE → CollectionsMetadata |
+| AddTenants | usecases/schema/tenant.go | CREATE → ShardsMetadata |
+| UpdateTenants | usecases/schema/tenant.go | UPDATE → ShardsMetadata |
+| DeleteTenants | usecases/schema/tenant.go | DELETE → ShardsMetadata |
+| GetConsistentTenants | usecases/schema/tenant.go | READ → ShardsMetadata |
+| ConsistentTenantExists | usecases/schema/tenant.go | READ → ShardsMetadata |
+| validateFilters | usecases/traverser/traverser_get.go | READ → CollectionsMetadata |

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/docs/generator.go

@@ -0,0 +1,257 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+//go:build ignore
+// +build ignore
+
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type authCall struct {
+	Function string
+	// Map verbs to their resources
+	VerbResourceMap map[string][]string // key: verb, value: slice of resources
+	FilePath        string
+}
+
+const mainDirPath = "../../../../"
+
+func main() {
+	var calls []authCall
+	var totalFiles, skippedFiles, processedFiles int
+
+	err := filepath.Walk(mainDirPath, func(path string, info os.FileInfo, err error) error {
+		totalFiles++
+
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error accessing path %s: %v\n", path, err)
+			return nil
+		}
+
+		// Skip directories
+		if info.IsDir() {
+			if shouldSkipDir(path) {
+				fmt.Fprintf(os.Stderr, "Skipping directory: %s\n", path)
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		// Skip non-go files, vendor, and test files
+		if !strings.HasSuffix(path, ".go") ||
+			strings.Contains(path, "/vendor/") ||
+			strings.HasSuffix(path, "_test.go") {
+			skippedFiles++
+			return nil
+		}
+
+		fmt.Fprintf(os.Stderr, "Processing file: %s\n", path)
+		processedFiles++
+
+		// Read and parse the file
+		fset := token.NewFileSet()
+		content, err := os.ReadFile(path)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error reading %s: %v\n", path, err)
+			return nil
+		}
+
+		node, err := parser.ParseFile(fset, path, content, 0)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error parsing %s: %v\n", path, err)
+			return nil
+		}
+
+		// Visit all nodes in the AST
+		ast.Inspect(node, func(n ast.Node) bool {
+			if call, ok := n.(*ast.CallExpr); ok {
+				if sel, ok := call.Fun.(*ast.SelectorExpr); ok {
+					if sel.Sel.Name == "Authorize" {
+						// Find the containing function
+						var funcName string
+						ast.Inspect(node, func(parent ast.Node) bool {
+							if fn, ok := parent.(*ast.FuncDecl); ok {
+								if fn.Pos() <= call.Pos() && call.End() <= fn.End() {
+									// Skip test functions
+									if !strings.HasPrefix(fn.Name.Name, "Test") {
+										funcName = fn.Name.Name
+									}
+									return false
+								}
+							}
+							return true
+						})
+
+						// Skip if no valid function name (e.g., test function)
+						if funcName == "" {
+							return true
+						}
+
+						if len(call.Args) >= 3 {
+							verb := formatArg(call.Args[1])
+							resource := formatArg(call.Args[2])
+
+							verb = strings.TrimPrefix(verb, "&")
+							verb = strings.TrimPrefix(verb, "authorization.")
+							resource = strings.TrimPrefix(resource, "authorization.")
+
+							// Check if we already have an entry for this function+file
+							if idx, found := findOrCreateCall(calls, funcName, path); found {
+								// Initialize map if needed
+								if calls[idx].VerbResourceMap == nil {
+									calls[idx].VerbResourceMap = make(map[string][]string)
+								}
+								// Add resource to verb's resource list if not already present
+								if !contains(calls[idx].VerbResourceMap[verb], resource) {
+									calls[idx].VerbResourceMap[verb] = append(calls[idx].VerbResourceMap[verb], resource)
+								}
+							} else {
+								verbMap := make(map[string][]string)
+								verbMap[verb] = []string{resource}
+								calls = append(calls, authCall{
+									Function:        funcName,
+									VerbResourceMap: verbMap,
+									FilePath:        path,
+								})
+							}
+						}
+					}
+				}
+			}
+			return true
+		})
+		return nil
+	})
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error walking directory: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Print statistics
+	fmt.Fprintf(os.Stderr, "\nStatistics:\n")
+	fmt.Fprintf(os.Stderr, "Total files found: %d\n", totalFiles)
+	fmt.Fprintf(os.Stderr, "Files skipped: %d\n", skippedFiles)
+	fmt.Fprintf(os.Stderr, "Files processed: %d\n", processedFiles)
+
+	// Count total auth calls by summing the length of VerbResourceMap for each function
+	totalCalls := 0
+	for _, call := range calls {
+		totalCalls += len(call.VerbResourceMap)
+	}
+	fmt.Fprintf(os.Stderr, "Total Authorize calls found: %d\n", totalCalls)
+
+	// Create and write to the markdown file
+	f, err := os.Create("auth_calls.md")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error creating file: %v\n", err)
+		os.Exit(1)
+	}
+	defer f.Close()
+
+	// Write the table header
+	fmt.Fprintln(f, "# Authorization Calls")
+	fmt.Fprintln(f, "This document lists all authorization calls in the codebase.")
+
+	// Add usage section
+	fmt.Fprintln(f, "## Usage")
+	fmt.Fprintln(f, "To regenerate this documentation, run the following commands from the repository root:")
+	fmt.Fprintln(f, "```bash")
+	fmt.Fprintln(f, "cd usecases/auth/authorization/docs")
+	fmt.Fprintln(f, "go run generator.go")
+	fmt.Fprintln(f, "```")
+
+	// Continue with statistics section
+	fmt.Fprintln(f, "## Statistics")
+	fmt.Fprintf(f, "- Total files found: %d\n", totalFiles)
+	fmt.Fprintf(f, "- Files processed: %d\n", processedFiles)
+	fmt.Fprintf(f, "- Total Authorize calls found: %d\n\n", totalCalls)
+
+	fmt.Fprintln(f, "| Function | File | Verb → Resources |")
+	fmt.Fprintln(f, "|----------|------|-----------------|")
+
+	// Write each call in table format
+	for _, call := range calls {
+		var mappings []string
+		for verb, resources := range call.VerbResourceMap {
+			mappings = append(mappings, fmt.Sprintf("%s → %s", verb, strings.Join(resources, ", ")))
+		}
+		fmt.Fprintf(f, "| %s | %s | %s |\n",
+			call.Function,
+			strings.TrimPrefix(call.FilePath, mainDirPath),
+			strings.Join(mappings, "<br>"),
+		)
+	}
+
+	fmt.Fprintf(os.Stderr, "Results written to auth_calls.md\n")
+}
+
+func shouldSkipDir(path string) bool {
+	skippedDirs := []string{
+		".git",
+		"vendor",
+		"node_modules",
+		"dist",
+		"build",
+	}
+
+	base := filepath.Base(path)
+	for _, skip := range skippedDirs {
+		if base == skip {
+			return true
+		}
+	}
+	return false
+}
+
+func formatArg(expr ast.Expr) string {
+	switch v := expr.(type) {
+	case *ast.SelectorExpr:
+		if ident, ok := v.X.(*ast.Ident); ok {
+			return fmt.Sprintf("%s.%s", ident.Name, v.Sel.Name)
+		}
+	case *ast.Ident:
+		return v.Name
+	case *ast.CallExpr:
+		if sel, ok := v.Fun.(*ast.SelectorExpr); ok {
+			if ident, ok := sel.X.(*ast.Ident); ok {
+				return fmt.Sprintf("%s.%s", ident.Name, sel.Sel.Name)
+			}
+		}
+	}
+	return fmt.Sprintf("%v", expr)
+}
+
+func findOrCreateCall(calls []authCall, function, filePath string) (int, bool) {
+	for i, call := range calls {
+		if call.Function == function && call.FilePath == filePath {
+			return i, true
+		}
+	}
+	return 0, false
+}
+
+func contains(slice []string, item string) bool {
+	for _, s := range slice {
+		if s == item {
+			return true
+		}
+	}
+	return false
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/errors/errors.go

@@ -0,0 +1,69 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package errors
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+// Forbidden indicates a failed authorization
+type Forbidden struct {
+	principal *models.Principal
+	verb      string
+	resources []string
+}
+
+type Unauthenticated struct{}
+
+func (u Unauthenticated) Error() string {
+	return "user is not authenticated"
+}
+
+// NewUnauthenticated creates an explicit Unauthenticated error
+func NewUnauthenticated() Unauthenticated {
+	return Unauthenticated{}
+}
+
+// NewForbidden creates an explicit Forbidden error with details about the
+// principal and the attempted access on a specific resource
+func NewForbidden(principal *models.Principal, verb string, resources ...string) Forbidden {
+	return Forbidden{
+		principal: principal,
+		verb:      verb,
+		resources: resources,
+	}
+}
+
+func (f Forbidden) Error() string {
+	optionalGroups := ""
+	if len(f.principal.Groups) == 1 {
+		optionalGroups = fmt.Sprintf(" (of group '%s')", f.principal.Groups[0])
+	} else if len(f.principal.Groups) > 1 {
+		groups := wrapInSingleQuotes(f.principal.Groups)
+		groupsList := strings.Join(groups, ", ")
+		optionalGroups = fmt.Sprintf(" (of groups %s)", groupsList)
+	}
+
+	return fmt.Sprintf("authorization, forbidden action: user '%s'%s has insufficient permissions to %s %s",
+		f.principal.Username, optionalGroups, f.verb, f.resources)
+}
+
+func wrapInSingleQuotes(input []string) []string {
+	for i, s := range input {
+		input[i] = fmt.Sprintf("'%s'", s)
+	}
+
+	return input
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/errors/errors_test.go

@@ -0,0 +1,52 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package errors
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func Test_ForbiddenError_NoGroups(t *testing.T) {
+	principal := &models.Principal{
+		Username: "john",
+	}
+
+	err := NewForbidden(principal, "delete", "schema/things")
+	expectedErrMsg := "authorization, forbidden action: user 'john' has insufficient permissions to delete [schema/things]"
+	assert.Equal(t, expectedErrMsg, err.Error())
+}
+
+func Test_ForbiddenError_SingleGroup(t *testing.T) {
+	principal := &models.Principal{
+		Username: "john",
+		Groups:   []string{"worstusers"},
+	}
+
+	err := NewForbidden(principal, "delete", "schema/things")
+	expectedErrMsg := "authorization, forbidden action: user 'john' (of group 'worstusers') has insufficient permissions to delete [schema/things]"
+	assert.Equal(t, expectedErrMsg, err.Error())
+}
+
+func Test_ForbiddenError_MultipleGroups(t *testing.T) {
+	principal := &models.Principal{
+		Username: "john",
+		Groups:   []string{"worstusers", "fraudsters", "evilpeople"},
+	}
+
+	err := NewForbidden(principal, "delete", "schema/things")
+	expectedErrMsg := "authorization, forbidden action: user 'john' (of groups 'worstusers', 'fraudsters', 'evilpeople') " +
+		"has insufficient permissions to delete [schema/things]"
+	assert.Equal(t, expectedErrMsg, err.Error())
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/filter/filter.go

@@ -0,0 +1,122 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package filter
+
+import (
+	"context"
+	"slices"
+
+	"github.com/weaviate/weaviate/usecases/auth/authorization/rbac/rbacconf"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+)
+
+// ResourceFilter handles filtering resources based on authorization
+type ResourceFilter[T any] struct {
+	authorizer authorization.Authorizer
+	config     rbacconf.Config
+}
+
+func New[T any](authorizer authorization.Authorizer, config rbacconf.Config) *ResourceFilter[T] {
+	return &ResourceFilter[T]{
+		authorizer: authorizer,
+		config:     config,
+	}
+}
+
+// FilterFn defines a function that generates authorization resources for an item
+type FilterFn[T any] func(item T) string
+
+// Filter filters a slice of items based on authorization
+func (f *ResourceFilter[T]) Filter(
+	ctx context.Context,
+	logger logrus.FieldLogger,
+	principal *models.Principal,
+	items []T,
+	verb string,
+	resourceFn FilterFn[T],
+) []T {
+	if len(items) == 0 {
+		return items
+	}
+	if !f.config.Enabled {
+		// here it's either you have the permissions or not so 1 check is enough
+		if err := f.authorizer.Authorize(ctx, principal, verb, resourceFn(items[0])); err != nil {
+			logger.WithFields(logrus.Fields{
+				"username":  principal.Username,
+				"verb":      verb,
+				"resources": items,
+			}).Error(err)
+			return nil
+		}
+		return items
+	}
+
+	// For RBAC, first check if all items have the same parent resource
+	firstResource := resourceFn(items[0])
+	allSameParent := true
+
+	for i := 1; i < len(items); i++ {
+		if authorization.WildcardPath(resourceFn(items[i])) != authorization.WildcardPath(firstResource) {
+			allSameParent = false
+		}
+	}
+
+	// If all items have the same parent, we can do a single authorization check
+	if allSameParent {
+		err := f.authorizer.Authorize(ctx, principal, verb, authorization.WildcardPath(firstResource))
+		if err != nil {
+			logger.WithFields(logrus.Fields{
+				"username": principal.Username,
+				"verb":     verb,
+				"resource": authorization.WildcardPath(firstResource),
+			}).Error(err)
+		}
+
+		if err == nil {
+			// user is authorized
+			return items
+		}
+	}
+
+	// For RBAC, filter based on per-item authorization
+	filtered := make([]T, 0, len(items))
+	resources := make([]string, 0, len(items))
+	for _, item := range items {
+		resources = append(resources, resourceFn(item))
+	}
+
+	allowedList, err := f.authorizer.FilterAuthorizedResources(ctx, principal, verb, resources...)
+	if err != nil {
+		logger.WithFields(logrus.Fields{
+			"username":  principal.Username,
+			"verb":      verb,
+			"resources": resources,
+		}).Error(err)
+	}
+
+	if len(allowedList) == len(resources) {
+		// has permissions to all
+		return items
+	}
+
+	for _, item := range items {
+		if slices.Contains(allowedList, resourceFn(item)) {
+			filtered = append(filtered, item)
+		}
+	}
+
+	return filtered
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/filter/filter_test.go

@@ -0,0 +1,64 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package filter
+
+import (
+	"context"
+	"testing"
+
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/mocks"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/rbac/rbacconf"
+)
+
+func TestFilter(t *testing.T) {
+	tests := []struct {
+		Name   string
+		Config rbacconf.Config
+		Items  []*models.Object
+	}{
+		{
+			Name:   "rbac enabled, no objects",
+			Items:  []*models.Object{},
+			Config: rbacconf.Config{Enabled: true},
+		},
+		{
+			Name:   "rbac disenabled, no objects",
+			Items:  []*models.Object{},
+			Config: rbacconf.Config{Enabled: false},
+		},
+	}
+
+	l, _ := test.NewNullLogger()
+
+	authorizer := mocks.NewMockAuthorizer()
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			resourceFilter := New[*models.Object](authorizer, tt.Config)
+			filteredObjects := resourceFilter.Filter(
+				context.Background(),
+				l,
+				&models.Principal{Username: "user"},
+				tt.Items,
+				authorization.READ,
+				func(obj *models.Object) string {
+					return ""
+				},
+			)
+
+			require.Equal(t, len(tt.Items), len(filteredObjects))
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/mocks/authorizer.go

@@ -0,0 +1,61 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package mocks
+
+import (
+	"context"
+
+	models "github.com/weaviate/weaviate/entities/models"
+)
+
+type AuthZReq struct {
+	Principal *models.Principal
+	Verb      string
+	Resources []string
+}
+
+type FakeAuthorizer struct {
+	err      error
+	requests []AuthZReq
+}
+
+func NewMockAuthorizer() *FakeAuthorizer {
+	return &FakeAuthorizer{}
+}
+
+func (a *FakeAuthorizer) SetErr(err error) {
+	a.err = err
+}
+
+// Authorize provides a mock function with given fields: principal, verb, resource
+func (a *FakeAuthorizer) Authorize(ctx context.Context, principal *models.Principal, verb string, resources ...string) error {
+	a.requests = append(a.requests, AuthZReq{principal, verb, resources})
+	if a.err != nil {
+		return a.err
+	}
+	return nil
+}
+
+func (a *FakeAuthorizer) AuthorizeSilent(ctx context.Context, principal *models.Principal, verb string, resources ...string) error {
+	return a.Authorize(ctx, principal, verb, resources...)
+}
+
+func (a *FakeAuthorizer) FilterAuthorizedResources(ctx context.Context, principal *models.Principal, verb string, resources ...string) ([]string, error) {
+	if err := a.Authorize(ctx, principal, verb, resources...); err != nil {
+		return nil, err
+	}
+	return resources, nil
+}
+
+func (a *FakeAuthorizer) Calls() []AuthZReq {
+	return a.requests
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/rbac/authorizer.go

@@ -0,0 +1,171 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package rbac
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/conv"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/errors"
+)
+
+const AuditLogVersion = 2
+
+func (m *Manager) authorize(ctx context.Context, principal *models.Principal, verb string, skipAudit bool, resources ...string) error {
+	if principal == nil {
+		return fmt.Errorf("rbac: %w", errors.NewUnauthenticated())
+	}
+
+	if len(resources) == 0 {
+		return fmt.Errorf("at least 1 resource is required")
+	}
+
+	logger := m.logger.WithFields(logrus.Fields{
+		"action":           "authorize",
+		"user":             principal.Username,
+		"component":        authorization.ComponentName,
+		"request_action":   verb,
+		"rbac_log_version": AuditLogVersion,
+	})
+	if !m.rbacConf.IpInAuditDisabled {
+		sourceIp := ctx.Value("sourceIp")
+		logger = logger.WithField("source_ip", sourceIp)
+	}
+
+	if len(principal.Groups) > 0 {
+		logger = logger.WithField("groups", principal.Groups)
+	}
+
+	// Create a map to aggregate resources and their counts while preserving order
+	resourceCounts := make(map[string]int)
+	var uniqueResources []string
+	for _, resource := range resources {
+		if _, exists := resourceCounts[resource]; !exists {
+			uniqueResources = append(uniqueResources, resource)
+		}
+		resourceCounts[resource]++
+	}
+	permResults := make([]logrus.Fields, 0, len(uniqueResources))
+
+	for _, resource := range uniqueResources {
+		allowed, err := m.checkPermissions(principal, resource, verb)
+		if err != nil {
+			logger.WithFields(logrus.Fields{
+				"resource": resource,
+			}).WithError(err).Error("failed to enforce policy")
+			return err
+		}
+
+		perm, err := conv.PathToPermission(verb, resource)
+		if err != nil {
+			return fmt.Errorf("rbac: %w", err)
+		}
+
+		if allowed {
+			permResults = append(permResults, logrus.Fields{
+				"resource": prettyPermissionsResources(perm),
+				"results":  prettyStatus(allowed),
+			})
+		}
+
+		if !allowed {
+			if !skipAudit {
+				logger.WithField("permissions", permResults).Error("authorization denied")
+			}
+			return fmt.Errorf("rbac: %w", errors.NewForbidden(principal, prettyPermissionsActions(perm), prettyPermissionsResources(perm)))
+		}
+	}
+
+	// Log all results at once if audit is enabled
+	if !skipAudit {
+		logger.WithField("permissions", permResults).Info()
+	}
+
+	return nil
+}
+
+// Authorize verify if the user has access to a resource to do specific action
+func (m *Manager) Authorize(ctx context.Context, principal *models.Principal, verb string, resources ...string) error {
+	return m.authorize(ctx, principal, verb, false, resources...)
+}
+
+// AuthorizeSilent verify if the user has access to a resource to do specific action without audit logs
+// to be used internally
+func (m *Manager) AuthorizeSilent(ctx context.Context, principal *models.Principal, verb string, resources ...string) error {
+	return m.authorize(ctx, principal, verb, true, resources...)
+}
+
+// FilterAuthorizedResources authorize the passed resources with best effort approach, it will return
+// list of allowed resources, if none, it will return an empty slice
+func (m *Manager) FilterAuthorizedResources(ctx context.Context, principal *models.Principal, verb string, resources ...string) ([]string, error) {
+	if principal == nil {
+		return nil, errors.NewUnauthenticated()
+	}
+
+	if len(resources) == 0 {
+		return nil, fmt.Errorf("at least 1 resource is required")
+	}
+
+	logger := m.logger.WithFields(logrus.Fields{
+		"action":         "authorize",
+		"user":           principal.Username,
+		"component":      authorization.ComponentName,
+		"request_action": verb,
+	})
+
+	if len(principal.Groups) > 0 {
+		logger = logger.WithField("groups", principal.Groups)
+	}
+
+	allowedResources := make([]string, 0, len(resources))
+
+	// Create a map to aggregate resources and their counts while preserving order
+	resourceCounts := make(map[string]int)
+	var uniqueResources []string
+	for _, resource := range resources {
+		if _, exists := resourceCounts[resource]; !exists {
+			uniqueResources = append(uniqueResources, resource)
+		}
+		resourceCounts[resource]++
+	}
+
+	permResults := make([]logrus.Fields, 0, len(uniqueResources))
+
+	for _, resource := range uniqueResources {
+		allowed, err := m.checkPermissions(principal, resource, verb)
+		if err != nil {
+			logger.WithError(err).WithField("resource", resource).Error("failed to enforce policy")
+			return nil, err
+		}
+
+		if allowed {
+			perm, err := conv.PathToPermission(verb, resource)
+			if err != nil {
+				return nil, err
+			}
+
+			permResults = append(permResults, logrus.Fields{
+				"resource": prettyPermissionsResources(perm),
+				"results":  prettyStatus(allowed),
+			})
+			allowedResources = append(allowedResources, resource)
+		}
+	}
+
+	logger.WithField("permissions", permResults).Info()
+	return allowedResources, nil
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/rbac/authorizer_test.go

@@ -0,0 +1,640 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package rbac
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/weaviate/weaviate/usecases/auth/authentication"
+
+	"github.com/sirupsen/logrus"
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/conv"
+	authzErrors "github.com/weaviate/weaviate/usecases/auth/authorization/errors"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/rbac/rbacconf"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+func TestAuthorize(t *testing.T) {
+	tests := []struct {
+		name          string
+		principal     *models.Principal
+		verb          string
+		resources     []string
+		skipAudit     bool
+		setupPolicies func(*Manager) error
+		wantErr       bool
+		errContains   string
+	}{
+		{
+			name:      "nil principal returns unauthenticated error",
+			principal: nil,
+			verb:      authorization.READ,
+			resources: authorization.CollectionsMetadata("Test"),
+			wantErr:   true,
+		},
+		{
+			name: "empty resources returns error",
+			principal: &models.Principal{
+				Username: "test-user",
+				Groups:   []string{},
+			},
+			verb:        authorization.READ,
+			resources:   []string{},
+			wantErr:     true,
+			errContains: "at least 1 resource is required",
+		},
+		{
+			name: "authorized user with correct permissions",
+			principal: &models.Principal{
+				Username: "admin-user",
+				Groups:   []string{"admin-group"},
+				UserType: models.UserTypeInputDb,
+			},
+			verb:      authorization.READ,
+			resources: authorization.CollectionsMetadata("Test1", "Test2"),
+			setupPolicies: func(m *Manager) error {
+				_, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("admin"), "*", authorization.SchemaDomain, authorization.READ)
+				if err != nil {
+					return err
+				}
+				ok, err := m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("admin-user", authentication.AuthTypeDb),
+					conv.PrefixRoleName("admin"))
+				if err != nil {
+					return err
+				}
+				if !ok {
+					return fmt.Errorf("failed to add role for user")
+				}
+				return nil
+			},
+		},
+		{
+			name: "unauthorized user returns forbidden error",
+			principal: &models.Principal{
+				Username: "regular-user",
+				Groups:   []string{},
+			},
+			verb:        authorization.UPDATE,
+			resources:   authorization.CollectionsMetadata("Test1"),
+			wantErr:     true,
+			errContains: "forbidden",
+		},
+		{
+			name: "partial authorization fails completely",
+			principal: &models.Principal{
+				Username: "partial-user",
+				Groups:   []string{},
+				UserType: models.UserTypeInputDb,
+			},
+			verb:      authorization.READ,
+			resources: authorization.CollectionsMetadata("Test1", "Test2"),
+			setupPolicies: func(m *Manager) error {
+				_, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("partial"), authorization.CollectionsMetadata("Test1")[0], authorization.READ, authorization.SchemaDomain)
+				if err != nil {
+					return err
+				}
+				ok, err := m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("partial-user", authentication.AuthTypeDb),
+					conv.PrefixRoleName("partial"))
+				if err != nil {
+					return err
+				}
+				if !ok {
+					return fmt.Errorf("failed to add role for user")
+				}
+				return nil
+			},
+			wantErr:     true,
+			errContains: "Test2",
+		},
+		{
+			name: "group-based authorization",
+			principal: &models.Principal{
+				Username: "group-user",
+				Groups:   []string{"authorized-group"},
+			},
+			verb:      authorization.READ,
+			resources: authorization.CollectionsMetadata("Test1"),
+			setupPolicies: func(m *Manager) error {
+				_, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("group-role"), authorization.CollectionsMetadata("Test1")[0], authorization.READ, authorization.SchemaDomain)
+				if err != nil {
+					return err
+				}
+				ok, err := m.casbin.AddRoleForUser(conv.PrefixGroupName("authorized-group"),
+					conv.PrefixRoleName("group-role"))
+				if err != nil {
+					return err
+				}
+				if !ok {
+					return fmt.Errorf("failed to add role for group")
+				}
+				return nil
+			},
+		},
+		{
+			name: "audit logging can be skipped",
+			principal: &models.Principal{
+				Username: "audit-test-user",
+				Groups:   []string{},
+				UserType: models.UserTypeInputDb,
+			},
+			verb:      authorization.READ,
+			resources: authorization.CollectionsMetadata("Test1"),
+			skipAudit: true,
+			setupPolicies: func(m *Manager) error {
+				_, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("audit-role"), authorization.CollectionsMetadata("Test1")[0], authorization.READ, authorization.SchemaDomain)
+				if err != nil {
+					return err
+				}
+				ok, err := m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("audit-test-user", authentication.AuthTypeDb),
+					conv.PrefixRoleName("audit-role"))
+				if err != nil {
+					return err
+				}
+				if !ok {
+					return fmt.Errorf("failed to add role for user")
+				}
+				return nil
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Setup logger with hook for testing
+			logger, hook := test.NewNullLogger()
+			m, err := setupTestManager(t, logger)
+			require.NoError(t, err)
+
+			// Setup policies if needed
+			if tt.setupPolicies != nil {
+				err := tt.setupPolicies(m)
+				require.NoError(t, err)
+			}
+
+			// Execute
+			err = m.authorize(context.Background(), tt.principal, tt.verb, tt.skipAudit, tt.resources...)
+
+			// Assert error conditions
+			if tt.wantErr {
+				require.Error(t, err)
+				if tt.errContains != "" {
+					assert.Contains(t, err.Error(), tt.errContains)
+				}
+				return
+			}
+
+			require.NoError(t, err)
+
+			// Verify logging behavior
+			if !tt.skipAudit {
+				require.NotEmpty(t, hook.AllEntries())
+				lastEntry := hook.LastEntry()
+				require.NotNil(t, lastEntry)
+
+				// Verify log fields
+				assert.Equal(t, "authorize", lastEntry.Data["action"])
+				assert.Equal(t, tt.principal.Username, lastEntry.Data["user"])
+				assert.Equal(t, authorization.ComponentName, lastEntry.Data["component"])
+				assert.Equal(t, tt.verb, lastEntry.Data["request_action"])
+
+				if len(tt.principal.Groups) > 0 {
+					assert.Contains(t, lastEntry.Data, "groups")
+					assert.ElementsMatch(t, tt.principal.Groups, lastEntry.Data["groups"])
+				}
+			} else {
+				// Verify no info logs when audit is skipped
+				for _, entry := range hook.AllEntries() {
+					assert.NotEqual(t, logrus.InfoLevel, entry.Level)
+				}
+			}
+		})
+	}
+}
+
+func TestFilterAuthorizedResources(t *testing.T) {
+	tests := []struct {
+		name          string
+		principal     *models.Principal
+		verb          string
+		resources     []string
+		setupPolicies func(*Manager) error
+		wantResources []string
+		wantErr       bool
+		errType       error
+	}{
+		{
+			name:      "nil principal returns unauthenticated error",
+			principal: nil,
+			verb:      authorization.READ,
+			resources: authorization.CollectionsMetadata("Test"),
+			wantErr:   true,
+			errType:   authzErrors.Unauthenticated{},
+		},
+		{
+			name: "wildcard permission allows all resources",
+			principal: &models.Principal{
+				Username: "admin-user",
+				UserType: models.UserTypeInputDb,
+			},
+			verb:      authorization.READ,
+			resources: authorization.CollectionsMetadata("Test1", "Test2"),
+			setupPolicies: func(m *Manager) error {
+				_, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("admin"),
+					"*", authorization.READ, authorization.SchemaDomain)
+				if err != nil {
+					return err
+				}
+				ok, err := m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("admin-user", authentication.AuthTypeDb),
+					conv.PrefixRoleName("admin"))
+				if err != nil {
+					return err
+				}
+				if !ok {
+					return fmt.Errorf("failed to add role for user")
+				}
+				return nil
+			},
+			wantResources: authorization.CollectionsMetadata("Test1", "Test2"),
+		},
+		{
+			name: "specific permission allows only matching resource",
+			principal: &models.Principal{
+				Username: "limited-user",
+				UserType: models.UserTypeInputDb,
+			},
+			verb:      authorization.READ,
+			resources: authorization.CollectionsMetadata("Test1", "Test2"),
+			setupPolicies: func(m *Manager) error {
+				_, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("limited"),
+					authorization.CollectionsMetadata("Test1")[0], authorization.READ, authorization.SchemaDomain)
+				if err != nil {
+					return err
+				}
+				ok, err := m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("limited-user", authentication.AuthTypeDb),
+					conv.PrefixRoleName("limited"))
+				if err != nil {
+					return err
+				}
+				if !ok {
+					return fmt.Errorf("failed to add role for user")
+				}
+				return nil
+			},
+			wantResources: authorization.CollectionsMetadata("Test1"),
+		},
+		{
+			name: "no permissions returns empty list",
+			principal: &models.Principal{
+				Username: "no-perm-user",
+			},
+			verb:          authorization.READ,
+			resources:     authorization.CollectionsMetadata("Test1", "Test2"),
+			wantResources: []string{},
+		},
+		{
+			name: "wildcard collection permission allows all collections",
+			principal: &models.Principal{
+				Username: "collections-admin",
+				UserType: models.UserTypeInputDb,
+			},
+			verb:      authorization.READ,
+			resources: authorization.CollectionsMetadata("Test1", "Test2"),
+			setupPolicies: func(m *Manager) error {
+				_, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("collections-admin"),
+					authorization.CollectionsMetadata()[0], authorization.READ, authorization.SchemaDomain)
+				if err != nil {
+					return err
+				}
+				ok, err := m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("collections-admin", authentication.AuthTypeDb),
+					conv.PrefixRoleName("collections-admin"))
+				if err != nil {
+					return err
+				}
+				if !ok {
+					return fmt.Errorf("failed to add role for user")
+				}
+				return nil
+			},
+			wantResources: authorization.CollectionsMetadata("Test1", "Test2"),
+		},
+		{
+			name: "empty resources list returns empty result",
+			principal: &models.Principal{
+				Username: "test-user",
+			},
+			verb:          authorization.READ,
+			resources:     []string{},
+			wantResources: []string{},
+			wantErr:       true,
+			errType:       fmt.Errorf("at least 1 resource is required"),
+		},
+		{
+			name: "user with multiple roles",
+			principal: &models.Principal{
+				Username: "multi-role-user",
+				UserType: models.UserTypeInputDb,
+			},
+			verb:      authorization.READ,
+			resources: authorization.CollectionsMetadata("Test1", "Test2", "Test3"),
+			setupPolicies: func(m *Manager) error {
+				if _, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("role1"), authorization.CollectionsMetadata("Test1")[0], authorization.READ, authorization.SchemaDomain); err != nil {
+					return err
+				}
+				if _, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("role2"), authorization.CollectionsMetadata("Test2")[0], authorization.READ, authorization.SchemaDomain); err != nil {
+					return err
+				}
+				if ok, err := m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("multi-role-user", authentication.AuthTypeDb), conv.PrefixRoleName("role1")); err != nil {
+					return err
+				} else if !ok {
+					return fmt.Errorf("failed to add role for user")
+				}
+				if ok, err := m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("multi-role-user", authentication.AuthTypeDb), conv.PrefixRoleName("role2")); err != nil {
+					return err
+				} else if !ok {
+					return fmt.Errorf("failed to add role for user")
+				}
+				return nil
+			},
+			wantResources: authorization.CollectionsMetadata("Test1", "Test2"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Setup
+			logger, _ := test.NewNullLogger()
+			m, err := setupTestManager(t, logger)
+			require.NoError(t, err)
+
+			// Setup policies if needed
+			if tt.setupPolicies != nil {
+				err := tt.setupPolicies(m)
+				require.NoError(t, err)
+			}
+
+			// Execute
+			got, err := m.FilterAuthorizedResources(context.Background(), tt.principal, tt.verb, tt.resources...)
+
+			// Assert
+			if tt.wantErr {
+				require.Error(t, err)
+				if tt.errType != nil {
+					assert.Contains(t, err.Error(), tt.errType.Error())
+				}
+				return
+			}
+
+			require.NoError(t, err)
+			assert.ElementsMatch(t, tt.wantResources, got)
+		})
+	}
+}
+
+func TestFilterAuthorizedResourcesLogging(t *testing.T) {
+	logger, hook := test.NewNullLogger()
+	m, err := setupTestManager(t, logger)
+	require.NoError(t, err)
+
+	principal := &models.Principal{
+		Username: "test-user",
+		Groups:   []string{"group1"},
+		UserType: models.UserTypeInputDb,
+	}
+
+	testResources := authorization.CollectionsMetadata("Test1", "Test2")
+
+	// Setup a policy
+	_, err = m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("admin"), "*", "*", authorization.RolesDomain)
+	require.NoError(t, err)
+	_, err = m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("test-user", authentication.AuthTypeDb), conv.PrefixRoleName("admin"))
+	require.NoError(t, err)
+
+	// Call the function
+	allowedResources, err := m.FilterAuthorizedResources(context.Background(), principal, authorization.READ, testResources...)
+	require.NoError(t, err)
+
+	// Verify logging
+	require.NotEmpty(t, hook.AllEntries())
+	entry := hook.LastEntry()
+	require.NotNil(t, entry)
+
+	// Check the permissions array exists and has the correct structure
+	permissions, ok := entry.Data["permissions"].([]logrus.Fields)
+	require.True(t, ok, "permissions should be []logrus.Fields")
+	require.NotEmpty(t, permissions, "permissions should not be empty")
+
+	// Check that we have entries for both resources
+	require.Len(t, permissions, 2, "Should have permissions entries for both resources")
+
+	// Check the first permission entry
+	firstPerm := permissions[0]
+	assert.Contains(t, firstPerm, "resource", "First permission entry should contain resource field")
+	assert.Contains(t, firstPerm, "results", "First permission entry should contain results field")
+	assert.Equal(t, "[Domain: collections, Collection: Test1]", firstPerm["resource"])
+	assert.Equal(t, "success", firstPerm["results"])
+
+	// Check the second permission entry
+	secondPerm := permissions[1]
+	assert.Contains(t, secondPerm, "resource", "Second permission entry should contain resource field")
+	assert.Contains(t, secondPerm, "results", "Second permission entry should contain results field")
+	assert.Equal(t, "[Domain: collections, Collection: Test2]", secondPerm["resource"])
+	assert.Equal(t, "success", secondPerm["results"])
+
+	// Check other required fields
+	assert.Equal(t, "authorize", entry.Data["action"])
+	assert.Equal(t, principal.Username, entry.Data["user"])
+	assert.Equal(t, principal.Groups, entry.Data["groups"])
+	assert.Equal(t, authorization.ComponentName, entry.Data["component"])
+	assert.Equal(t, authorization.READ, entry.Data["request_action"])
+
+	// Verify the final result matches the logged permissions
+	assert.ElementsMatch(t, testResources, allowedResources,
+		"Allowed resources should match input resources")
+}
+
+func TestAuthorizeResourceAggregation(t *testing.T) {
+	// Setup proper logger with hook for testing
+	logger := logrus.New()
+	logger.SetLevel(logrus.InfoLevel)
+
+	// Create a hook to capture log entries
+	hook := &test.Hook{}
+	logger.AddHook(hook)
+
+	m, err := setupTestManager(t, logger)
+	require.NoError(t, err)
+
+	// Setup admin policy
+	_, err = m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("admin"), "*", authorization.READ, authorization.DataDomain)
+	require.NoError(t, err)
+	ok, err := m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("admin-user", authentication.AuthTypeDb),
+		conv.PrefixRoleName("admin"))
+	require.NoError(t, err)
+	require.True(t, ok)
+
+	principal := &models.Principal{
+		Username: "admin-user",
+		Groups:   []string{"admin-group"},
+		UserType: models.UserTypeInputDb,
+	}
+
+	// Test with 1000 duplicate resources (simulating the original issue)
+	resources := make([]string, 1000)
+	for i := 0; i < 1000; i++ {
+		resources[i] = "data/collections/ContactRecommendations/shards/*/objects/*"
+	}
+
+	// Execute authorization
+	err = m.authorize(context.Background(), principal, authorization.READ, false, resources...)
+	require.NoError(t, err)
+
+	// Verify logging behavior
+	require.NotEmpty(t, hook.AllEntries())
+	lastEntry := hook.LastEntry()
+	require.NotNil(t, lastEntry)
+
+	// Verify log fields
+	assert.Equal(t, "authorize", lastEntry.Data["action"])
+	assert.Equal(t, "admin-user", lastEntry.Data["user"])
+	assert.Equal(t, authorization.ComponentName, lastEntry.Data["component"])
+	assert.Equal(t, authorization.READ, lastEntry.Data["request_action"])
+
+	// Verify permissions field exists
+	permissions, ok := lastEntry.Data["permissions"].([]logrus.Fields)
+	require.True(t, ok, "permissions field should be present")
+
+	// Verify aggregation - should only have 1 entry instead of 1000
+	assert.Len(t, permissions, 1, "should aggregate 1000 duplicate resources into 1 entry")
+
+	// Verify the single entry has the correct resource and count
+	require.Len(t, permissions, 1)
+	perm := permissions[0]
+
+	resource, ok := perm["resource"].(string)
+	require.True(t, ok, "resource should be a string")
+	assert.Equal(t, "[Domain: data, Collection: ContactRecommendations, Tenant: *, Object: *]", resource)
+
+	// Verify aggregation by checking that we have fewer log entries than resources
+	// This proves that 1000 identical resources were aggregated into 1 log entry
+	assert.Len(t, permissions, 1, "should aggregate 1000 duplicate resources into 1 log entry")
+
+	results, ok := perm["results"].(string)
+	require.True(t, ok, "results should be a string")
+	assert.Equal(t, "success", results)
+}
+
+func TestFilterAuthorizedResourcesAggregation(t *testing.T) {
+	// Setup proper logger with hook for testing
+	logger := logrus.New()
+	logger.SetLevel(logrus.InfoLevel)
+
+	// Create a hook to capture log entries
+	hook := &test.Hook{}
+	logger.AddHook(hook)
+
+	m, err := setupTestManager(t, logger)
+	require.NoError(t, err)
+
+	// Setup admin policy
+	_, err = m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("admin"), "*", authorization.READ, authorization.DataDomain)
+	require.NoError(t, err)
+	ok, err := m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("admin-user", authentication.AuthTypeDb),
+		conv.PrefixRoleName("admin"))
+	require.NoError(t, err)
+	require.True(t, ok)
+
+	principal := &models.Principal{
+		Username: "admin-user",
+		Groups:   []string{"admin-group"},
+		UserType: models.UserTypeInputDb,
+	}
+
+	// Test with 1000 duplicate resources (simulating the original issue)
+	resources := make([]string, 1000)
+	for i := 0; i < 1000; i++ {
+		resources[i] = "data/collections/ContactRecommendations/shards/*/objects/*"
+	}
+
+	// Execute FilterAuthorizedResources
+	allowedResources, err := m.FilterAuthorizedResources(context.Background(), principal, authorization.READ, resources...)
+	require.NoError(t, err)
+
+	// Verify logging behavior
+	require.NotEmpty(t, hook.AllEntries())
+	lastEntry := hook.LastEntry()
+	require.NotNil(t, lastEntry)
+
+	// Verify log fields
+	assert.Equal(t, "authorize", lastEntry.Data["action"])
+	assert.Equal(t, "admin-user", lastEntry.Data["user"])
+	assert.Equal(t, authorization.ComponentName, lastEntry.Data["component"])
+	assert.Equal(t, authorization.READ, lastEntry.Data["request_action"])
+
+	// Verify permissions field exists
+	permissions, ok := lastEntry.Data["permissions"].([]logrus.Fields)
+	require.True(t, ok, "permissions field should be present")
+
+	// Verify aggregation - should only have 1 entry instead of 1000
+	assert.Len(t, permissions, 1, "should aggregate 1000 duplicate resources into 1 entry")
+
+	// Verify the single entry has the correct resource and count
+	require.Len(t, permissions, 1)
+	perm := permissions[0]
+
+	resource, ok := perm["resource"].(string)
+	require.True(t, ok, "resource should be a string")
+	assert.Equal(t, "[Domain: data, Collection: ContactRecommendations, Tenant: *, Object: *]", resource)
+
+	results, ok := perm["results"].(string)
+	require.True(t, ok, "results should be a string")
+	assert.Equal(t, "success", results)
+
+	// Verify that all 1000 resources are returned in allowedResources
+	assert.Len(t, allowedResources, 1, "should return 1 unique resource (duplicates are aggregated)")
+
+	// Verify the returned resource is correct
+	assert.Equal(t, "data/collections/ContactRecommendations/shards/*/objects/*", allowedResources[0], "returned resource should be the same as input")
+}
+
+func setupTestManager(t *testing.T, logger *logrus.Logger) (*Manager, error) {
+	tmpDir, err := os.MkdirTemp("", "rbac-test-*")
+	if err != nil {
+		return nil, err
+	}
+
+	t.Cleanup(func() {
+		os.RemoveAll(tmpDir)
+	})
+
+	rbacDir := filepath.Join(tmpDir, "rbac")
+	if err := os.MkdirAll(rbacDir, 0o755); err != nil {
+		return nil, err
+	}
+
+	policyPath := filepath.Join(rbacDir, "policy.csv")
+
+	conf := rbacconf.Config{
+		Enabled: true,
+	}
+
+	return New(policyPath, conf, config.Authentication{OIDC: config.OIDC{Enabled: true}, APIKey: config.StaticAPIKey{Enabled: true, Users: []string{"test-user"}}}, logger)
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/rbac/manager.go

@@ -0,0 +1,595 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package rbac
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"slices"
+	"strings"
+	"sync"
+
+	"github.com/weaviate/weaviate/usecases/auth/authentication"
+
+	"github.com/casbin/casbin/v2"
+	"github.com/sirupsen/logrus"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/conv"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/rbac/rbacconf"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+const (
+	SnapshotVersionV0 = iota
+	SnapshotVersionLatest
+)
+
+type Manager struct {
+	casbin     *casbin.SyncedCachedEnforcer
+	logger     logrus.FieldLogger
+	authNconf  config.Authentication
+	rbacConf   rbacconf.Config
+	backupLock sync.RWMutex
+}
+
+func New(rbacStoragePath string, rbacConf rbacconf.Config, authNconf config.Authentication, logger logrus.FieldLogger) (*Manager, error) {
+	csbin, err := Init(rbacConf, rbacStoragePath, authNconf)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Manager{csbin, logger, authNconf, rbacConf, sync.RWMutex{}}, nil
+}
+
+// there is no different between UpdateRolesPermissions and CreateRolesPermissions, purely to satisfy an interface
+func (m *Manager) UpdateRolesPermissions(roles map[string][]authorization.Policy) error {
+	m.backupLock.RLock()
+	defer m.backupLock.RUnlock()
+
+	return m.upsertRolesPermissions(roles)
+}
+
+func (m *Manager) CreateRolesPermissions(roles map[string][]authorization.Policy) error {
+	m.backupLock.RLock()
+	defer m.backupLock.RUnlock()
+
+	return m.upsertRolesPermissions(roles)
+}
+
+func (m *Manager) GetUsersOrGroupsWithRoles(isGroup bool, authType authentication.AuthType) ([]string, error) {
+	roles, err := m.casbin.GetAllSubjects()
+	if err != nil {
+		return nil, err
+	}
+	usersOrGroups := map[string]struct{}{}
+	for _, role := range roles {
+		users, err := m.casbin.GetUsersForRole(role)
+		if err != nil {
+			return nil, err
+		}
+		for _, userOrGroup := range users {
+			name, _ := conv.GetUserAndPrefix(userOrGroup)
+			if isGroup {
+				// groups are only supported for OIDC
+				if authType == authentication.AuthTypeOIDC && strings.HasPrefix(userOrGroup, conv.OIDC_GROUP_NAME_PREFIX) {
+					usersOrGroups[name] = struct{}{}
+				}
+			} else {
+				// groups are only supported for OIDC
+				if authType == authentication.AuthTypeOIDC && strings.HasPrefix(userOrGroup, string(authentication.AuthTypeOIDC)) {
+					usersOrGroups[name] = struct{}{}
+				}
+
+				if authType == authentication.AuthTypeDb && strings.HasPrefix(userOrGroup, string(authentication.AuthTypeDb)) {
+					usersOrGroups[name] = struct{}{}
+				}
+
+			}
+		}
+	}
+
+	usersOrGroupsList := make([]string, 0, len(usersOrGroups))
+	for user := range usersOrGroups {
+		usersOrGroupsList = append(usersOrGroupsList, user)
+	}
+
+	return usersOrGroupsList, nil
+}
+
+func (m *Manager) upsertRolesPermissions(roles map[string][]authorization.Policy) error {
+	for roleName, policies := range roles {
+		// assign role to internal user to make sure to catch empty roles
+		// e.g. : g, user:wv_internal_empty, role:roleName
+		if _, err := m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId(conv.InternalPlaceHolder, authentication.AuthTypeDb), conv.PrefixRoleName(roleName)); err != nil {
+			return fmt.Errorf("AddRoleForUser: %w", err)
+		}
+		for _, policy := range policies {
+			if _, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName(roleName), policy.Resource, policy.Verb, policy.Domain); err != nil {
+				return fmt.Errorf("AddNamedPolicy: %w", err)
+			}
+		}
+	}
+	if err := m.casbin.SavePolicy(); err != nil {
+		return fmt.Errorf("SavePolicy: %w", err)
+	}
+	if err := m.casbin.InvalidateCache(); err != nil {
+		return fmt.Errorf("InvalidateCache: %w", err)
+	}
+	return nil
+}
+
+func (m *Manager) GetRoles(names ...string) (map[string][]authorization.Policy, error) {
+	m.backupLock.RLock()
+	defer m.backupLock.RUnlock()
+
+	var (
+		casbinStoragePolicies    [][][]string
+		casbinStoragePoliciesMap = make(map[string]struct{})
+	)
+
+	if len(names) == 0 {
+		// get all roles
+		polices, err := m.casbin.GetNamedPolicy("p")
+		if err != nil {
+			return nil, fmt.Errorf("GetNamedPolicy: %w", err)
+		}
+		casbinStoragePolicies = append(casbinStoragePolicies, polices)
+
+		for _, p := range polices {
+			// e.g. policy line in casbin -> role:roleName resource verb domain, that's why p[0]
+			casbinStoragePoliciesMap[p[0]] = struct{}{}
+		}
+
+		polices, err = m.casbin.GetNamedGroupingPolicy("g")
+		if err != nil {
+			return nil, fmt.Errorf("GetNamedGroupingPolicy: %w", err)
+		}
+		casbinStoragePolicies = collectStaleRoles(polices, casbinStoragePoliciesMap, casbinStoragePolicies)
+	} else {
+		for _, name := range names {
+			polices, err := m.casbin.GetFilteredNamedPolicy("p", 0, conv.PrefixRoleName(name))
+			if err != nil {
+				return nil, fmt.Errorf("GetFilteredNamedPolicy: %w", err)
+			}
+			casbinStoragePolicies = append(casbinStoragePolicies, polices)
+
+			for _, p := range polices {
+				// e.g. policy line in casbin -> role:roleName resource verb domain, that's why p[0]
+				casbinStoragePoliciesMap[p[0]] = struct{}{}
+			}
+
+			polices, err = m.casbin.GetFilteredNamedGroupingPolicy("g", 1, conv.PrefixRoleName(name))
+			if err != nil {
+				return nil, fmt.Errorf("GetFilteredNamedGroupingPolicy: %w", err)
+			}
+			casbinStoragePolicies = collectStaleRoles(polices, casbinStoragePoliciesMap, casbinStoragePolicies)
+		}
+	}
+	policies, err := conv.CasbinPolicies(casbinStoragePolicies...)
+	if err != nil {
+		return nil, fmt.Errorf("CasbinPolicies: %w", err)
+	}
+	return policies, nil
+}
+
+func (m *Manager) RemovePermissions(roleName string, permissions []*authorization.Policy) error {
+	m.backupLock.RLock()
+	defer m.backupLock.RUnlock()
+
+	for _, permission := range permissions {
+		ok, err := m.casbin.RemoveNamedPolicy("p", conv.PrefixRoleName(roleName), permission.Resource, permission.Verb, permission.Domain)
+		if err != nil {
+			return fmt.Errorf("RemoveNamedPolicy: %w", err)
+		}
+		if !ok {
+			return nil // deletes are idempotent
+		}
+	}
+	if err := m.casbin.SavePolicy(); err != nil {
+		return fmt.Errorf("SavePolicy: %w", err)
+	}
+	if err := m.casbin.InvalidateCache(); err != nil {
+		return fmt.Errorf("InvalidateCache: %w", err)
+	}
+	return nil
+}
+
+func (m *Manager) HasPermission(roleName string, permission *authorization.Policy) (bool, error) {
+	m.backupLock.RLock()
+	defer m.backupLock.RUnlock()
+
+	policy, err := m.casbin.HasNamedPolicy("p", conv.PrefixRoleName(roleName), permission.Resource, permission.Verb, permission.Domain)
+	if err != nil {
+		return false, fmt.Errorf("HasNamedPolicy: %w", err)
+	}
+	return policy, nil
+}
+
+func (m *Manager) DeleteRoles(roles ...string) error {
+	m.backupLock.RLock()
+	defer m.backupLock.RUnlock()
+
+	for _, roleName := range roles {
+		// remove role
+		roleRemoved, err := m.casbin.RemoveFilteredNamedPolicy("p", 0, conv.PrefixRoleName(roleName))
+		if err != nil {
+			return fmt.Errorf("RemoveFilteredNamedPolicy: %w", err)
+		}
+		// remove role assignment
+		roleAssignmentsRemoved, err := m.casbin.RemoveFilteredGroupingPolicy(1, conv.PrefixRoleName(roleName))
+		if err != nil {
+			return fmt.Errorf("RemoveFilteredGroupingPolicy: %w", err)
+		}
+
+		if !roleRemoved && !roleAssignmentsRemoved {
+			return nil // deletes are idempotent
+		}
+	}
+	if err := m.casbin.SavePolicy(); err != nil {
+		return fmt.Errorf("SavePolicy: %w", err)
+	}
+	if err := m.casbin.InvalidateCache(); err != nil {
+		return fmt.Errorf("InvalidateCache: %w", err)
+	}
+	return nil
+}
+
+// AddRolesFroUser NOTE: user has to be prefixed by user:, group:, key: etc.
+// see func PrefixUserName(user) it will prefix username and nop-op if already prefixed
+func (m *Manager) AddRolesForUser(user string, roles []string) error {
+	m.backupLock.RLock()
+	defer m.backupLock.RUnlock()
+
+	if !conv.NameHasPrefix(user) {
+		return errors.New("user does not contain a prefix")
+	}
+
+	for _, role := range roles {
+		if _, err := m.casbin.AddRoleForUser(user, conv.PrefixRoleName(role)); err != nil {
+			return fmt.Errorf("AddRoleForUser: %w", err)
+		}
+	}
+	if err := m.casbin.SavePolicy(); err != nil {
+		return fmt.Errorf("SavePolicy: %w", err)
+	}
+	if err := m.casbin.InvalidateCache(); err != nil {
+		return fmt.Errorf("InvalidateCache: %w", err)
+	}
+	return nil
+}
+
+func (m *Manager) GetRolesForUserOrGroup(userName string, authType authentication.AuthType, isGroup bool) (map[string][]authorization.Policy, error) {
+	m.backupLock.RLock()
+	defer m.backupLock.RUnlock()
+
+	var rolesNames []string
+	var err error
+	if isGroup {
+		rolesNames, err = m.casbin.GetRolesForUser(conv.PrefixGroupName(userName))
+		if err != nil {
+			return nil, fmt.Errorf("GetRolesForUserOrGroup: %w", err)
+		}
+	} else {
+		rolesNames, err = m.casbin.GetRolesForUser(conv.UserNameWithTypeFromId(userName, authType))
+		if err != nil {
+			return nil, fmt.Errorf("GetRolesForUserOrGroup: %w", err)
+		}
+	}
+	if len(rolesNames) == 0 {
+		return map[string][]authorization.Policy{}, err
+	}
+	roles, err := m.GetRoles(rolesNames...)
+	if err != nil {
+		return nil, fmt.Errorf("GetRoles: %w", err)
+	}
+	return roles, err
+}
+
+func (m *Manager) GetUsersOrGroupForRole(roleName string, authType authentication.AuthType, isGroup bool) ([]string, error) {
+	m.backupLock.RLock()
+	defer m.backupLock.RUnlock()
+
+	pusers, err := m.casbin.GetUsersForRole(conv.PrefixRoleName(roleName))
+	if err != nil {
+		return nil, fmt.Errorf("GetUsersOrGroupForRole: %w", err)
+	}
+	users := make([]string, 0, len(pusers))
+	for idx := range pusers {
+		userOrGroup, prefix := conv.GetUserAndPrefix(pusers[idx])
+		if userOrGroup == conv.InternalPlaceHolder {
+			continue
+		}
+		if isGroup {
+			if authType == authentication.AuthTypeOIDC && strings.HasPrefix(conv.OIDC_GROUP_NAME_PREFIX, prefix) {
+				users = append(users, userOrGroup)
+			}
+		} else {
+			if prefix == string(authType) {
+				users = append(users, userOrGroup)
+			}
+		}
+	}
+	return users, nil
+}
+
+func (m *Manager) RevokeRolesForUser(userName string, roles ...string) error {
+	m.backupLock.RLock()
+	defer m.backupLock.RUnlock()
+
+	if !conv.NameHasPrefix(userName) {
+		return errors.New("user does not contain a prefix")
+	}
+
+	for _, roleName := range roles {
+		if _, err := m.casbin.DeleteRoleForUser(userName, conv.PrefixRoleName(roleName)); err != nil {
+			return fmt.Errorf("DeleteRoleForUser: %w", err)
+		}
+	}
+	if err := m.casbin.SavePolicy(); err != nil {
+		return fmt.Errorf("SavePolicy: %w", err)
+	}
+	if err := m.casbin.InvalidateCache(); err != nil {
+		return fmt.Errorf("InvalidateCache: %w", err)
+	}
+	return nil
+}
+
+// Snapshot is the RBAC state to be used for RAFT snapshots
+type snapshot struct {
+	Policy         [][]string `json:"roles_policies"`
+	GroupingPolicy [][]string `json:"grouping_policies"`
+	Version        int        `json:"version"`
+}
+
+func (m *Manager) Snapshot() ([]byte, error) {
+	// snapshot isn't always initialized, e.g. when RBAC is disabled
+	if m == nil {
+		return []byte{}, nil
+	}
+	if m.casbin == nil {
+		return nil, nil
+	}
+
+	policy, err := m.casbin.GetPolicy()
+	if err != nil {
+		return nil, err
+	}
+	groupingPolicy, err := m.casbin.GetGroupingPolicy()
+	if err != nil {
+		return nil, err
+	}
+
+	// Use a buffer to stream the JSON encoding
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(snapshot{Policy: policy, GroupingPolicy: groupingPolicy, Version: SnapshotVersionLatest}); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func (m *Manager) Restore(b []byte) error {
+	// don't overwrite with empty snapshot to avoid overwriting recovery from file
+	// with a non-existent RBAC snapshot when coming from old versions
+	if m == nil || len(b) == 0 {
+		return nil
+	}
+	if m.casbin == nil {
+		return nil
+	}
+
+	snapshot := snapshot{}
+	if err := json.Unmarshal(b, &snapshot); err != nil {
+		return fmt.Errorf("restore snapshot: decode json: %w", err)
+	}
+
+	// we need to clear the policies before adding the new ones
+	m.casbin.ClearPolicy()
+
+	_, err := m.casbin.AddPolicies(snapshot.Policy)
+	if err != nil {
+		return fmt.Errorf("add policies: %w", err)
+	}
+
+	_, err = m.casbin.AddGroupingPolicies(snapshot.GroupingPolicy)
+	if err != nil {
+		return fmt.Errorf("add grouping policies: %w", err)
+	}
+
+	if snapshot.Version == SnapshotVersionV0 {
+		if err := upgradePoliciesFrom129(m.casbin, true); err != nil {
+			return fmt.Errorf("upgrade policies: %w", err)
+		}
+
+		if err := upgradeGroupingsFrom129(m.casbin, m.authNconf); err != nil {
+			return fmt.Errorf("upgrade groupings: %w", err)
+		}
+	}
+
+	// environment config needs to be applied again in case there were changes since the last snapshot
+	if err := applyPredefinedRoles(m.casbin, m.rbacConf, m.authNconf); err != nil {
+		return fmt.Errorf("apply env config: %w", err)
+	}
+
+	// Load the policies to ensure they are in memory
+	if err := m.casbin.LoadPolicy(); err != nil {
+		return fmt.Errorf("load policies: %w", err)
+	}
+
+	return nil
+}
+
+// BatchEnforcers is not needed after some digging they just loop over requests,
+// w.r.t.
+// source code https://github.com/casbin/casbin/blob/master/enforcer.go#L872
+// issue https://github.com/casbin/casbin/issues/710
+func (m *Manager) checkPermissions(principal *models.Principal, resource, verb string) (bool, error) {
+	// first check group permissions
+	for _, group := range principal.Groups {
+		allowed, err := m.casbin.Enforce(conv.PrefixGroupName(group), resource, verb)
+		if err != nil {
+			return false, err
+		}
+		if allowed {
+			return true, nil
+		}
+	}
+
+	// If no group permissions, check user permissions
+	return m.casbin.Enforce(conv.UserNameWithTypeFromPrincipal(principal), resource, verb)
+}
+
+func prettyPermissionsActions(perm *models.Permission) string {
+	if perm == nil || perm.Action == nil {
+		return ""
+	}
+	return *perm.Action
+}
+
+func prettyPermissionsResources(perm *models.Permission) string {
+	res := ""
+	if perm == nil {
+		return ""
+	}
+
+	if perm.Backups != nil {
+		s := fmt.Sprintf("Domain: %s,", authorization.BackupsDomain)
+		if perm.Backups.Collection != nil && *perm.Backups.Collection != "" {
+			s += fmt.Sprintf("Collection: %s", *perm.Backups.Collection)
+		}
+		s = strings.TrimSuffix(s, ",")
+		res += fmt.Sprintf("[%s]", s)
+	}
+
+	if perm.Data != nil {
+		s := fmt.Sprintf("Domain: %s,", authorization.DataDomain)
+		if perm.Data.Collection != nil && *perm.Data.Collection != "" {
+			s += fmt.Sprintf(" Collection: %s,", *perm.Data.Collection)
+		}
+		if perm.Data.Tenant != nil && *perm.Data.Tenant != "" {
+			s += fmt.Sprintf(" Tenant: %s,", *perm.Data.Tenant)
+		}
+		if perm.Data.Object != nil && *perm.Data.Object != "" {
+			s += fmt.Sprintf(" Object: %s", *perm.Data.Object)
+		}
+		s = strings.TrimSuffix(s, ",")
+		res += fmt.Sprintf("[%s]", s)
+	}
+
+	if perm.Nodes != nil {
+		s := fmt.Sprintf("Domain: %s,", authorization.NodesDomain)
+
+		if perm.Nodes.Verbosity != nil && *perm.Nodes.Verbosity != "" {
+			s += fmt.Sprintf(" Verbosity: %s,", *perm.Nodes.Verbosity)
+		}
+		if perm.Nodes.Collection != nil && *perm.Nodes.Collection != "" {
+			s += fmt.Sprintf(" Collection: %s", *perm.Nodes.Collection)
+		}
+		s = strings.TrimSuffix(s, ",")
+		res += fmt.Sprintf("[%s]", s)
+	}
+
+	if perm.Roles != nil {
+		s := fmt.Sprintf("Domain: %s,", authorization.RolesDomain)
+		if perm.Roles.Role != nil && *perm.Roles.Role != "" {
+			s += fmt.Sprintf(" Role: %s,", *perm.Roles.Role)
+		}
+		s = strings.TrimSuffix(s, ",")
+		res += fmt.Sprintf("[%s]", s)
+	}
+
+	if perm.Collections != nil {
+		s := fmt.Sprintf("Domain: %s,", authorization.CollectionsDomain)
+
+		if perm.Collections.Collection != nil && *perm.Collections.Collection != "" {
+			s += fmt.Sprintf(" Collection: %s,", *perm.Collections.Collection)
+		}
+		s = strings.TrimSuffix(s, ",")
+		res += fmt.Sprintf("[%s]", s)
+	}
+
+	if perm.Tenants != nil {
+		s := fmt.Sprintf("Domain: %s,", authorization.TenantsDomain)
+
+		if perm.Tenants.Tenant != nil && *perm.Tenants.Tenant != "" {
+			s += fmt.Sprintf(" Collection: %s,", *perm.Tenants.Collection)
+			s += fmt.Sprintf(" Tenant: %s", *perm.Tenants.Tenant)
+		}
+		s = strings.TrimSuffix(s, ",")
+		res += fmt.Sprintf("[%s]", s)
+	}
+
+	if perm.Users != nil {
+		s := fmt.Sprintf("Domain: %s,", authorization.UsersDomain)
+
+		if perm.Users.Users != nil {
+			s += fmt.Sprintf(" User: %s,", *perm.Users.Users)
+		}
+		s = strings.TrimSuffix(s, ",")
+		res += fmt.Sprintf("[%s]", s)
+	}
+
+	if perm.Replicate != nil {
+		s := fmt.Sprintf("Domain: %s,", authorization.ReplicateDomain)
+
+		if perm.Replicate.Collection != nil && *perm.Replicate.Collection != "" {
+			s += fmt.Sprintf(" Collection: %s,", *perm.Replicate.Collection)
+		}
+		if perm.Replicate.Shard != nil && *perm.Replicate.Shard != "" {
+			s += fmt.Sprintf(" Shard: %s,", *perm.Replicate.Shard)
+		}
+		s = strings.TrimSuffix(s, ",")
+		res += fmt.Sprintf("[%s]", s)
+	}
+
+	if perm.Aliases != nil {
+		s := fmt.Sprintf("Domain: %s,", authorization.AliasesDomain)
+
+		if perm.Aliases.Collection != nil && *perm.Aliases.Collection != "" {
+			s += fmt.Sprintf(" Collection: %s,", *perm.Aliases.Collection)
+		}
+		if perm.Aliases.Alias != nil && *perm.Aliases.Alias != "" {
+			s += fmt.Sprintf(" Alias: %s,", *perm.Aliases.Alias)
+		}
+		s = strings.TrimSuffix(s, ",")
+		res += fmt.Sprintf("[%s]", s)
+	}
+
+	return res
+}
+
+func prettyStatus(value bool) string {
+	if value {
+		return "success"
+	}
+	return "failed"
+}
+
+func collectStaleRoles(polices [][]string, casbinStoragePoliciesMap map[string]struct{}, casbinStoragePolicies [][][]string) [][][]string {
+	for _, p := range polices {
+		// ignore builtin roles
+		if slices.Contains(authorization.BuiltInRoles, conv.TrimRoleNamePrefix(p[1])) {
+			continue
+		}
+		// collect stale or empty roles
+		if _, ok := casbinStoragePoliciesMap[p[1]]; !ok {
+			// e.g. policy line in casbin -> g, user:wv_internal_empty, role:roleName, that's why p[1]
+			casbinStoragePolicies = append(casbinStoragePolicies, [][]string{{
+				p[1], conv.InternalPlaceHolder, conv.InternalPlaceHolder, "*",
+			}})
+		}
+	}
+	return casbinStoragePolicies
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/rbac/manager_test.go

@@ -0,0 +1,306 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package rbac
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/weaviate/weaviate/usecases/auth/authentication"
+
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/conv"
+)
+
+func TestSnapshotAndRestore(t *testing.T) {
+	tests := []struct {
+		name          string
+		setupPolicies func(*Manager) error
+		wantErr       bool
+	}{
+		{
+			name: "empty policies",
+			setupPolicies: func(m *Manager) error {
+				return nil
+			},
+		},
+		{
+			name: "with role and policy",
+			setupPolicies: func(m *Manager) error {
+				// Add a role and policy
+				_, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("admin"), "*", authorization.READ, authorization.SchemaDomain)
+				if err != nil {
+					return err
+				}
+				_, err = m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("test-user", authentication.AuthTypeDb), conv.PrefixRoleName("admin"))
+				return err
+			},
+		},
+		{
+			name: "multiple roles and policies",
+			setupPolicies: func(m *Manager) error {
+				// Add multiple roles and policies
+				_, err := m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("admin"), "*", authorization.READ, authorization.SchemaDomain)
+				if err != nil {
+					return err
+				}
+				_, err = m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("editor"), "collections/*", authorization.UPDATE, authorization.SchemaDomain)
+				if err != nil {
+					return err
+				}
+				_, err = m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("test-user", authentication.AuthTypeDb), conv.PrefixRoleName("admin"))
+				if err != nil {
+					return err
+				}
+				_, err = m.casbin.AddRoleForUser(conv.UserNameWithTypeFromId("test-user", authentication.AuthTypeDb), conv.PrefixRoleName("editor"))
+				return err
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Setup logger with hook for testing
+			logger, _ := test.NewNullLogger()
+			m, err := setupTestManager(t, logger)
+			require.NoError(t, err)
+
+			// Get initial policies before our test setup
+			initialPolicies, err := m.casbin.GetPolicy()
+			require.NoError(t, err)
+			initialGroupingPolicies, err := m.casbin.GetGroupingPolicy()
+			require.NoError(t, err)
+
+			// Setup policies if needed
+			if tt.setupPolicies != nil {
+				err := tt.setupPolicies(m)
+				require.NoError(t, err)
+			}
+
+			// Take snapshot
+			snapshotData, err := m.Snapshot()
+			require.NoError(t, err)
+			require.NotNil(t, snapshotData)
+
+			// Create a new manager for restore
+			m2, err := setupTestManager(t, logger)
+			require.NoError(t, err)
+
+			// Restore from snapshot
+			err = m2.Restore(snapshotData)
+			if tt.wantErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			// Get final policies after our test setup
+			finalPolicies, err := m.casbin.GetPolicy()
+			require.NoError(t, err)
+			finalGroupingPolicies, err := m.casbin.GetGroupingPolicy()
+			require.NoError(t, err)
+
+			// Get restored policies
+			restoredPolicies, err := m2.casbin.GetPolicy()
+			require.NoError(t, err)
+			restoredGroupingPolicies, err := m2.casbin.GetGroupingPolicy()
+			require.NoError(t, err)
+
+			// Compare only the delta of policies we added
+			addedPolicies := getPolicyDelta(initialPolicies, finalPolicies)
+			restoredAddedPolicies := getPolicyDelta(initialPolicies, restoredPolicies)
+			assert.ElementsMatch(t, addedPolicies, restoredAddedPolicies)
+
+			// Compare only the delta of grouping policies we added
+			addedGroupingPolicies := getPolicyDelta(initialGroupingPolicies, finalGroupingPolicies)
+			restoredAddedGroupingPolicies := getPolicyDelta(initialGroupingPolicies, restoredGroupingPolicies)
+			assert.ElementsMatch(t, addedGroupingPolicies, restoredAddedGroupingPolicies)
+		})
+	}
+}
+
+// getPolicyDelta returns the policies that are in b but not in a
+func getPolicyDelta(a, b [][]string) [][]string {
+	delta := make([][]string, 0)
+	for _, policyB := range b {
+		found := false
+		for _, policyA := range a {
+			if equalPolicies(policyA, policyB) {
+				found = true
+				break
+			}
+		}
+		if !found {
+			delta = append(delta, policyB)
+		}
+	}
+	return delta
+}
+
+// equalPolicies compares two policies for equality
+func equalPolicies(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func TestSnapshotNilCasbin(t *testing.T) {
+	logger, _ := test.NewNullLogger()
+	m := &Manager{
+		casbin: nil,
+		logger: logger,
+	}
+
+	snapshotData, err := m.Snapshot()
+	require.NoError(t, err)
+	assert.Nil(t, snapshotData)
+}
+
+func TestRestoreNilCasbin(t *testing.T) {
+	logger, _ := test.NewNullLogger()
+	m := &Manager{
+		casbin: nil,
+		logger: logger,
+	}
+
+	err := m.Restore([]byte("{}"))
+	require.NoError(t, err)
+}
+
+func TestRestoreInvalidData(t *testing.T) {
+	logger, _ := test.NewNullLogger()
+	m, err := setupTestManager(t, logger)
+	require.NoError(t, err)
+
+	// Test with invalid JSON
+	err = m.Restore([]byte("invalid json"))
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "decode json")
+
+	// Test with empty data
+	err = m.Restore([]byte("{}"))
+	require.NoError(t, err)
+}
+
+func TestRestoreEmptyData(t *testing.T) {
+	logger, _ := test.NewNullLogger()
+	m, err := setupTestManager(t, logger)
+	require.NoError(t, err)
+
+	_, err = m.casbin.AddNamedPolicy("p", conv.PrefixRoleName("admin"), "*", authorization.READ, authorization.SchemaDomain)
+	require.NoError(t, err)
+
+	policies, err := m.casbin.GetPolicy()
+	require.NoError(t, err)
+	require.Len(t, policies, 5)
+
+	err = m.Restore([]byte{})
+	require.NoError(t, err)
+
+	// nothing overwritten
+	policies, err = m.casbin.GetPolicy()
+	require.NoError(t, err)
+	require.Len(t, policies, 5)
+}
+
+func TestSnapshotAndRestoreUpgrade(t *testing.T) {
+	tests := []struct {
+		name              string
+		policiesInput     [][]string
+		policiesExpected  [][]string
+		groupingsInput    [][]string
+		groupingsExpected [][]string
+	}{
+		{
+			name: "assign users",
+			policiesInput: [][]string{
+				{"role:some_role", "users/.*", "U", "users"},
+			},
+			policiesExpected: [][]string{
+				{"role:some_role", "users/.*", "A", "users"},
+				// build-in roles are added after restore
+				{"role:viewer", "*", authorization.READ, "*"},
+				{"role:read-only", "*", authorization.READ, "*"},
+				{"role:admin", "*", conv.VALID_VERBS, "*"},
+				{"role:root", "*", conv.VALID_VERBS, "*"},
+			},
+		},
+		{
+			name: "build-in",
+			policiesInput: [][]string{
+				{"role:viewer", "*", "R", "*"},
+				{"role:admin", "*", "(C)|(R)|(U)|(D)", "*"},
+			},
+			policiesExpected: [][]string{
+				{"role:viewer", "*", "R", "*"},
+				{"role:read-only", "*", "R", "*"},
+				{"role:admin", "*", conv.VALID_VERBS, "*"},
+				// build-in roles are added after restore
+				{"role:root", "*", conv.VALID_VERBS, "*"},
+			},
+		},
+		{
+			name: "users",
+			policiesInput: [][]string{
+				{"role:admin", "*", "(C)|(R)|(U)|(D)", "*"}, // present to iterate over all roles in downgrade
+			},
+			policiesExpected: [][]string{
+				{"role:admin", "*", "(C)|(R)|(U)|(D)|(A)", "*"},
+				// build-in roles are added after restore
+				{"role:viewer", "*", authorization.READ, "*"},
+				{"role:read-only", "*", authorization.READ, "*"},
+				{"role:root", "*", conv.VALID_VERBS, "*"},
+			},
+			groupingsInput: [][]string{
+				{"user:test-user", "role:admin"},
+			},
+			groupingsExpected: [][]string{
+				{"db:test-user", "role:admin"},
+				{"oidc:test-user", "role:admin"},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			logger, _ := test.NewNullLogger()
+			m, err := setupTestManager(t, logger)
+			require.NoError(t, err)
+
+			sh := snapshot{Version: 0, GroupingPolicy: tt.groupingsInput, Policy: tt.policiesInput}
+
+			bytes, err := json.Marshal(sh)
+			require.NoError(t, err)
+
+			err = m.Restore(bytes)
+			require.NoError(t, err)
+
+			finalPolicies, err := m.casbin.GetPolicy()
+			require.NoError(t, err)
+			assert.ElementsMatch(t, finalPolicies, tt.policiesExpected)
+
+			finalGroupingPolicies, err := m.casbin.GetGroupingPolicy()
+			require.NoError(t, err)
+			assert.Equal(t, finalGroupingPolicies, tt.groupingsExpected)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/rbac/model.go

@@ -0,0 +1,320 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package rbac
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/weaviate/weaviate/usecases/auth/authentication"
+
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/conv"
+
+	"github.com/casbin/casbin/v2"
+	"github.com/casbin/casbin/v2/model"
+	fileadapter "github.com/casbin/casbin/v2/persist/file-adapter"
+	casbinutil "github.com/casbin/casbin/v2/util"
+	"github.com/pkg/errors"
+
+	"github.com/weaviate/weaviate/usecases/auth/authorization/rbac/rbacconf"
+	"github.com/weaviate/weaviate/usecases/build"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+const DEFAULT_POLICY_VERSION = "1.29.0"
+
+const (
+	// MODEL is the used model for casbin to store roles, permissions, users and comparisons patterns
+	// docs: https://casbin.org/docs/syntax-for-models
+	MODEL = `
+	[request_definition]
+	r = sub, obj, act
+
+	[policy_definition]
+	p = sub, obj, act, dom
+
+	[role_definition]
+	g = _, _
+
+	[policy_effect]
+	e = some(where (p.eft == allow))
+
+	[matchers]
+	m = g(r.sub, p.sub) && weaviateMatcher(r.obj, p.obj) && regexMatch(r.act, p.act)
+`
+)
+
+func createStorage(filePath string) error {
+	if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil {
+		return fmt.Errorf("failed to create directories: %w", err)
+	}
+
+	_, err := os.Stat(filePath)
+	if err == nil { // file exists
+		return nil
+	}
+
+	if os.IsNotExist(err) {
+		file, err := os.Create(filePath)
+		if err != nil {
+			return fmt.Errorf("failed to create file: %w", err)
+		}
+		defer file.Close()
+		return nil
+	}
+
+	return err
+}
+
+func Init(conf rbacconf.Config, policyPath string, authNconf config.Authentication) (*casbin.SyncedCachedEnforcer, error) {
+	if !conf.Enabled {
+		return nil, nil
+	}
+
+	m, err := model.NewModelFromString(MODEL)
+	if err != nil {
+		return nil, fmt.Errorf("load rbac model: %w", err)
+	}
+
+	enforcer, err := casbin.NewSyncedCachedEnforcer(m)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create enforcer: %w", err)
+	}
+	enforcer.EnableCache(true)
+
+	rbacStoragePath := fmt.Sprintf("%s/rbac", policyPath)
+	rbacStorageFilePath := fmt.Sprintf("%s/rbac/policy.csv", policyPath)
+
+	if err := createStorage(rbacStorageFilePath); err != nil {
+		return nil, errors.Wrapf(err, "create storage path: %v", rbacStorageFilePath)
+	}
+
+	enforcer.SetAdapter(fileadapter.NewAdapter(rbacStorageFilePath))
+
+	if err := enforcer.LoadPolicy(); err != nil {
+		return nil, err
+	}
+	// parse version string to check if upgrade is needed
+	policyVersion, err := getVersion(rbacStoragePath)
+	if err != nil {
+		return nil, err
+	}
+	versionParts := strings.Split(policyVersion, ".")
+	minorVersion, err := strconv.Atoi(versionParts[1])
+	if err != nil {
+		return nil, err
+	}
+
+	if versionParts[0] == "1" && minorVersion < 30 {
+		if err := upgradePoliciesFrom129(enforcer, false); err != nil {
+			return nil, err
+		}
+
+		if err := upgradeGroupingsFrom129(enforcer, authNconf); err != nil {
+			return nil, err
+		}
+	}
+	// docs: https://casbin.org/docs/function/
+	enforcer.AddFunction("weaviateMatcher", WeaviateMatcherFunc)
+
+	if err := applyPredefinedRoles(enforcer, conf, authNconf); err != nil {
+		return nil, errors.Wrapf(err, "apply env config")
+	}
+
+	// update version after casbin policy has been written
+	if err := writeVersion(rbacStoragePath, build.Version); err != nil {
+		return nil, err
+	}
+
+	return enforcer, nil
+}
+
+// applyPredefinedRoles adds pre-defined roles (admin/viewer/root) and assigns them to the users provided in the
+// local config
+func applyPredefinedRoles(enforcer *casbin.SyncedCachedEnforcer, conf rbacconf.Config, authNconf config.Authentication) error {
+	// remove preexisting root role including assignments
+	_, err := enforcer.RemoveFilteredNamedPolicy("p", 0, conv.PrefixRoleName(authorization.Root))
+	if err != nil {
+		return err
+	}
+	_, err = enforcer.RemoveFilteredGroupingPolicy(1, conv.PrefixRoleName(authorization.Root))
+	if err != nil {
+		return err
+	}
+
+	_, err = enforcer.RemoveFilteredNamedPolicy("p", 0, conv.PrefixRoleName(authorization.ReadOnly))
+	if err != nil {
+		return err
+	}
+	_, err = enforcer.RemoveFilteredGroupingPolicy(1, conv.PrefixRoleName(authorization.ReadOnly))
+	if err != nil {
+		return err
+	}
+
+	// add pre existing roles
+	for name, verb := range conv.BuiltInPolicies {
+		if verb == "" {
+			continue
+		}
+		if _, err := enforcer.AddNamedPolicy("p", conv.PrefixRoleName(name), "*", verb, "*"); err != nil {
+			return fmt.Errorf("add policy: %w", err)
+		}
+	}
+
+	for i := range conf.RootUsers {
+		if strings.TrimSpace(conf.RootUsers[i]) == "" {
+			continue
+		}
+
+		if authNconf.APIKey.Enabled && slices.Contains(authNconf.APIKey.Users, conf.RootUsers[i]) {
+			if _, err := enforcer.AddRoleForUser(conv.UserNameWithTypeFromId(conf.RootUsers[i], authentication.AuthTypeDb), conv.PrefixRoleName(authorization.Root)); err != nil {
+				return fmt.Errorf("add role for user: %w", err)
+			}
+		}
+
+		if authNconf.OIDC.Enabled {
+			if _, err := enforcer.AddRoleForUser(conv.UserNameWithTypeFromId(conf.RootUsers[i], authentication.AuthTypeOIDC), conv.PrefixRoleName(authorization.Root)); err != nil {
+				return fmt.Errorf("add role for user: %w", err)
+			}
+		}
+	}
+
+	// temporary to enable import of existing keys to WCD (Admin + readonly)
+	for i := range conf.AdminUsers {
+		if strings.TrimSpace(conf.AdminUsers[i]) == "" {
+			continue
+		}
+
+		if authNconf.APIKey.Enabled && slices.Contains(authNconf.APIKey.Users, conf.AdminUsers[i]) {
+			if _, err := enforcer.AddRoleForUser(conv.UserNameWithTypeFromId(conf.AdminUsers[i], authentication.AuthTypeDb), conv.PrefixRoleName(authorization.Admin)); err != nil {
+				return fmt.Errorf("add role for user: %w", err)
+			}
+		}
+
+		if authNconf.OIDC.Enabled {
+			if _, err := enforcer.AddRoleForUser(conv.UserNameWithTypeFromId(conf.AdminUsers[i], authentication.AuthTypeOIDC), conv.PrefixRoleName(authorization.Admin)); err != nil {
+				return fmt.Errorf("add role for user: %w", err)
+			}
+		}
+	}
+
+	for i := range conf.ViewerUsers {
+		if strings.TrimSpace(conf.ViewerUsers[i]) == "" {
+			continue
+		}
+
+		if authNconf.APIKey.Enabled && slices.Contains(authNconf.APIKey.Users, conf.ViewerUsers[i]) {
+			if _, err := enforcer.AddRoleForUser(conv.UserNameWithTypeFromId(conf.ViewerUsers[i], authentication.AuthTypeDb), conv.PrefixRoleName(authorization.Viewer)); err != nil {
+				return fmt.Errorf("add role for user: %w", err)
+			}
+		}
+
+		if authNconf.OIDC.Enabled {
+			if _, err := enforcer.AddRoleForUser(conv.UserNameWithTypeFromId(conf.ViewerUsers[i], authentication.AuthTypeOIDC), conv.PrefixRoleName(authorization.Viewer)); err != nil {
+				return fmt.Errorf("add role for user: %w", err)
+			}
+		}
+	}
+
+	for _, group := range conf.RootGroups {
+		if strings.TrimSpace(group) == "" {
+			continue
+		}
+		if _, err := enforcer.AddRoleForUser(conv.PrefixGroupName(group), conv.PrefixRoleName(authorization.Root)); err != nil {
+			return fmt.Errorf("add role for group %s: %w", group, err)
+		}
+	}
+
+	for _, viewerGroup := range conf.ReadOnlyGroups {
+		if strings.TrimSpace(viewerGroup) == "" {
+			continue
+		}
+		if _, err := enforcer.AddRoleForUser(conv.PrefixGroupName(viewerGroup), conv.PrefixRoleName(authorization.ReadOnly)); err != nil {
+			return fmt.Errorf("add viewer role for group %s: %w", viewerGroup, err)
+		}
+	}
+
+	if err := enforcer.SavePolicy(); err != nil {
+		return errors.Wrapf(err, "save policy")
+	}
+
+	return nil
+}
+
+func WeaviateMatcher(key1 string, key2 string) bool {
+	// If we're dealing with a tenant-specific path (matches /shards/#$)
+	if strings.HasSuffix(key1, "/shards/#") {
+		// Don't allow matching with wildcard patterns
+		if strings.HasSuffix(key2, "/shards/.*") {
+			return false
+		}
+	}
+	// For all other cases, use standard KeyMatch5
+	return casbinutil.KeyMatch5(key1, key2)
+}
+
+func WeaviateMatcherFunc(args ...interface{}) (interface{}, error) {
+	name1 := args[0].(string)
+	name2 := args[1].(string)
+
+	return (bool)(WeaviateMatcher(name1, name2)), nil
+}
+
+func getVersion(path string) (string, error) {
+	filePath := path + "/version"
+	_, err := os.Stat(filePath)
+	if err != nil { // file exists
+		return DEFAULT_POLICY_VERSION, nil
+	}
+	b, err := os.ReadFile(filePath)
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
+
+func writeVersion(path, version string) error {
+	tmpFile, err := os.CreateTemp(path, "policy-temp-*.tmp")
+	if err != nil {
+		return err
+	}
+	tempFilename := tmpFile.Name()
+
+	defer func() {
+		tmpFile.Close()
+		os.Remove(tempFilename) // Remove temp file if it still exists
+	}()
+
+	writer := bufio.NewWriter(tmpFile)
+	if _, err := fmt.Fprint(writer, version); err != nil {
+		return err
+	}
+
+	// Flush the writer to ensure all data is written, then sync and flush tmpfile and atomically rename afterwards
+	if err := writer.Flush(); err != nil {
+		return err
+	}
+	if err := tmpFile.Sync(); err != nil {
+		return err
+	}
+	if err := tmpFile.Close(); err != nil {
+		return err
+	}
+
+	return os.Rename(tempFilename, path+"/version")
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/rbac/model_test.go

@@ -0,0 +1,170 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package rbac
+
+import (
+	"testing"
+
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/conv"
+)
+
+func testKeyMatch5(t *testing.T, key1, key2 string, expected bool) {
+	t.Helper()
+	if result := WeaviateMatcher(key1, key2); result != expected {
+		t.Errorf("WeaviateMatcher(%q, %q) = %v; want %v", key1, key2, result, expected)
+	}
+}
+
+func TestKeyMatch5AuthZ(t *testing.T) {
+	tests := []struct {
+		name     string
+		key1     string
+		key2     string
+		expected bool
+	}{
+		// Allow all
+		{"Allow all roles", authorization.Roles()[0], "*", true},
+		{"Allow all collections", authorization.CollectionsMetadata()[0], "*", true},
+		{"Allow all collections with ABC", authorization.CollectionsMetadata("ABC")[0], "*", true},
+		{"Allow all shards", authorization.ShardsMetadata("")[0], "*", true},
+		{"Allow all shards with ABC", authorization.ShardsMetadata("ABC", "ABC")[0], "*", true},
+		{"Allow all objects", authorization.Objects("", "", ""), "*", true},
+		{"Allow all objects with Tenant1", authorization.Objects("", "Tenant1", ""), "*", true},
+		{"Allow all tenants", authorization.ShardsMetadata("")[0], "*", true},
+		{"Allow all tenants with ABC", authorization.ShardsMetadata("ABC", "ABC")[0], "*", true},
+
+		// Class level
+		{"Class level collections ABC", authorization.CollectionsMetadata("ABC")[0], conv.CasbinSchema("*", "#"), true},
+		{"Class level shards ABC", authorization.ShardsMetadata("ABC")[0], conv.CasbinSchema("*", "*"), true},
+		{"Class level collections ABC exact", authorization.CollectionsMetadata("ABC")[0], conv.CasbinSchema("ABC", "#"), true},
+		{"Class level collections Class1 exact", authorization.CollectionsMetadata("Class1")[0], conv.CasbinSchema("Class1", "#"), true},
+		{"Class level collections Class2 mismatch", authorization.CollectionsMetadata("Class2")[0], conv.CasbinSchema("Class1", "#"), false},
+		{"Class level shards ABC TenantX", authorization.ShardsMetadata("ABC", "TenantX")[0], conv.CasbinSchema("ABC", ""), true},
+		{"Class level objects ABC TenantX objectY", authorization.Objects("ABC", "TenantX", "objectY"), conv.CasbinData("ABC", "*", "*"), true},
+		{"Class level tenant ABC TenantX", authorization.ShardsMetadata("ABC", "TenantX")[0], conv.CasbinSchema("ABC", ""), true},
+
+		// Tenants level
+		{"Tenants level shards", authorization.ShardsMetadata("")[0], conv.CasbinSchema("*", "*"), true},
+		{"Tenants level shards ABC Tenant1", authorization.ShardsMetadata("ABC", "Tenant1")[0], conv.CasbinSchema("*", "*"), true},
+		{"Tenants level shards Class1 Tenant1", authorization.ShardsMetadata("Class1", "Tenant1")[0], conv.CasbinSchema("*", "Tenant1"), true},
+		{"Tenants level objects Class1 Tenant1 ObjectY", authorization.Objects("Class1", "Tenant1", "ObjectY"), conv.CasbinData("*", "Tenant1", ""), true},
+		{"Tenants level shards Class1 Tenant2 mismatch", authorization.ShardsMetadata("Class1", "Tenant2")[0], conv.CasbinSchema("*", "Tenant1"), false},
+		{"Tenants level shards Class1 Tenant2 mismatch 2", authorization.ShardsMetadata("Class1", "Tenant2")[0], conv.CasbinSchema("Class2", "Tenant1"), false},
+		{"Tenants level shards mismatch", authorization.ShardsMetadata("")[0], conv.CasbinSchema("Class1", ""), false},
+		{"Tenants level collections Class1", authorization.CollectionsMetadata("Class1")[0], conv.CasbinSchema("Class1", "#"), true},
+		{"Tenants level shards Class1 tenant1", authorization.ShardsMetadata("Class1", "tenant1")[0], conv.CasbinSchema("Class1", ""), true},
+
+		// Objects level
+		{"Objects level all", authorization.Objects("", "", ""), conv.CasbinData(".*", ".*", ".*"), true},
+		{"Objects level ABC Tenant1", authorization.Objects("ABC", "Tenant1", ""), conv.CasbinData("*", "*", "*"), true},
+		{"Objects level ABC Tenant1 exact", authorization.Objects("ABC", "Tenant1", ""), conv.CasbinData("*", "Tenant1", "*"), true},
+		{"Objects level ABC Tenant1 abc", authorization.Objects("ABC", "Tenant1", "abc"), conv.CasbinData("*", "Tenant1", "*"), true},
+		{"Objects level ABC Tenant1 abc exact", authorization.Objects("ABC", "Tenant1", "abc"), conv.CasbinData("*", "Tenant1", "*"), true},
+		{"Objects level ABC Tenant1 abc exact 2", authorization.Objects("ABC", "Tenant1", "abc"), conv.CasbinData("*", "*", "abc"), true},
+		{"Objects level ABC Tenant1 abc exact 3", authorization.Objects("ABC", "Tenant1", "abc"), conv.CasbinData("ABC", "Tenant1", "abc"), true},
+		{"Objects level ABCD Tenant1 abc mismatch", authorization.Objects("ABCD", "Tenant1", "abc"), conv.CasbinData("ABC", "Tenant1", "abc"), false},
+		{"Objects level ABC Tenant1 abcd mismatch", authorization.Objects("ABC", "Tenant1", "abcd"), conv.CasbinData("ABC", "Tenant1", "abc"), false},
+		{"Objects level ABC bar abcd", authorization.Objects("ABC", "bar", "abcd"), conv.CasbinData("*", "bar", ""), true},
+
+		// Tenants
+		{"Tenants level tenant", authorization.ShardsMetadata("")[0], conv.CasbinSchema("*", "*"), true},
+		{"Tenants level tenant ABC Tenant1", authorization.ShardsMetadata("ABC", "Tenant1")[0], conv.CasbinSchema("*", "*"), true},
+		{"Tenants level tenant Class1 Tenant1", authorization.ShardsMetadata("Class1", "Tenant1")[0], conv.CasbinSchema("*", "Tenant1"), true},
+		{"Tenants level objects Class1 Tenant1 ObjectY", authorization.Objects("Class1", "Tenant1", "ObjectY"), conv.CasbinData("*", "Tenant1", ""), true},
+		{"Tenants level tenant Class1 Tenant2 mismatch", authorization.ShardsMetadata("Class1", "Tenant2")[0], conv.CasbinSchema("*", "Tenant1"), false},
+		{"Tenants level tenant Class1 Tenant2 mismatch 2", authorization.ShardsMetadata("Class1", "Tenant2")[0], conv.CasbinSchema("Class2", "Tenant1"), false},
+		{"Tenants level tenant mismatch", authorization.ShardsMetadata("")[0], conv.CasbinSchema("Class1", ""), false},
+		{"Tenants level collections Class1", authorization.ShardsMetadata("Class1")[0], conv.CasbinSchema("Class1", ""), true},
+		{"Tenants level tenant Class1 tenant1", authorization.ShardsMetadata("Class1", "tenant1")[0], conv.CasbinSchema("Class1", ""), true},
+
+		// Regex
+		{"Regex collections ABCD", authorization.CollectionsMetadata("ABCD")[0], conv.CasbinSchema("ABC", "#"), false},
+		{"Regex shards ABC", authorization.ShardsMetadata("ABC", "")[0], conv.CasbinSchema("ABC", ""), true},
+		{"Regex objects ABC", authorization.Objects("ABC", "", ""), conv.CasbinData("ABC", "*", "*"), true},
+		{"Regex objects ABCD mismatch", authorization.Objects("ABCD", "", ""), conv.CasbinData("ABC", "*", "*"), false},
+		{"Regex objects ABCD wildcard", authorization.Objects("ABCD", "", ""), conv.CasbinData("ABC.*", "*", "*"), true},
+		{"Regex objects BCD mismatch", authorization.Objects("BCD", "", ""), conv.CasbinData("ABC", "*", "*"), false},
+		{"Regex tenant ABC", authorization.ShardsMetadata("ABC", "")[0], conv.CasbinSchema("ABC", ""), true},
+
+		{"Regex collections ABC wildcard", authorization.CollectionsMetadata("ABC")[0], conv.CasbinSchema("ABC*", "#"), true},
+		{"Regex collections ABC wildcard 2", authorization.CollectionsMetadata("ABC")[0], conv.CasbinSchema("ABC*", "#"), true},
+		{"Regex collections ABCD wildcard", authorization.CollectionsMetadata("ABCD")[0], conv.CasbinSchema("ABC*", "#"), true},
+
+		// ShardsMetadata read on collections level permissions
+		{"ShardsMetadata read on collections level ABC", authorization.ShardsMetadata("ABC")[0], conv.CasbinSchema("ABC", ""), true},
+
+		// some other cases
+		{"Mismatched collection", authorization.CollectionsMetadata("Class1")[0], conv.CasbinSchema("Class2", "#"), false},
+		{"Mismatched shard", authorization.ShardsMetadata("Class1", "Shard1")[0], conv.CasbinSchema("Class1", "Shard2"), false},
+		{"Partial match role", authorization.Roles("anotherRole")[0], conv.CasbinRoles("ro*"), false},
+		{"Partial match role", authorization.Roles("role")[0], conv.CasbinRoles("ro*"), true},
+		{"Partial match collection", authorization.CollectionsMetadata("Class1")[0], conv.CasbinSchema("Cla*", "#"), true},
+		{"Partial match shard", authorization.ShardsMetadata("Class1", "Shard1")[0], conv.CasbinSchema("Class1", "Sha*"), true},
+		{"Partial match object", authorization.Objects("Class1", "Shard1", "Object1"), conv.CasbinData("Class1", "Shard1", "Obj*"), true},
+		{"Special character mismatch", authorization.Objects("Class1", "Shard1", "Object1"), "data/collections/Class1/shards/Shard1/objects/Object1!", false},
+		{"Mismatched object", authorization.Objects("Class1", "Shard1", "Object1"), conv.CasbinData("Class1", "Shard1", "Object2"), false},
+		{"Mismatched tenant", authorization.ShardsMetadata("Class1", "Tenant1")[0], conv.CasbinSchema("Class1", "Tenant2"), false},
+
+		{"Collection check vs all shards", authorization.CollectionsMetadata("Class1")[0], conv.CasbinSchema("Class1", "*"), false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			testKeyMatch5(t, tt.key1, tt.key2, tt.expected)
+		})
+	}
+}
+
+func TestKeyMatchTenant(t *testing.T) {
+	tests := []struct {
+		name     string
+		key1     string
+		key2     string
+		expected bool
+	}{
+		// Tenant specific patterns
+		{
+			"Tenant specific path should not match wildcard",
+			"schema/collections/Class1/shards/#",
+			"schema/collections/Class1/shards/.*",
+			false,
+		},
+		{
+			"Tenant specific path should match exact #",
+			"schema/collections/Class1/shards/#",
+			"schema/collections/Class1/shards/#",
+			true,
+		},
+		{
+			"Regular shard should match wildcard",
+			"schema/collections/Class1/shards/shard-1",
+			"schema/collections/Class1/shards/.*",
+			true,
+		},
+		{
+			"Regular shard should not match tenant specific",
+			"schema/collections/Class1/shards/shard-1",
+			"schema/collections/Class1/shards/#",
+			false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := WeaviateMatcher(tt.key1, tt.key2)
+			if result != tt.expected {
+				t.Errorf("WeaviateMatcher(%s, %s) = %v; want %v", tt.key1, tt.key2, result, tt.expected)
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/rbac/rbacconf/config.go

@@ -0,0 +1,30 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package rbacconf
+
+// Config makes every subject on the list an admin, whereas everyone else
+// has no rights whatsoever
+type Config struct {
+	Enabled           bool     `json:"enabled" yaml:"enabled"`
+	RootUsers         []string `json:"root_users" yaml:"root_users"`
+	RootGroups        []string `json:"root_groups" yaml:"root_groups"`
+	ReadOnlyGroups    []string `json:"readonly_groups" yaml:"readonly_groups"`
+	ViewerUsers       []string `json:"viewer_users" yaml:"viewer_users"`
+	AdminUsers        []string `json:"admin_users" yaml:"admin_users"`
+	IpInAuditDisabled bool     `json:"ip_in_audit" yaml:"ip_in_audit"`
+}
+
+// Validate admin list config for viability, can be called from the central
+// config package
+func (c Config) Validate() error {
+	return nil
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/rbac/up_down_grades.go

@@ -0,0 +1,105 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package rbac
+
+import (
+	"fmt"
+	"slices"
+	"strings"
+
+	"github.com/weaviate/weaviate/usecases/auth/authentication"
+
+	"github.com/casbin/casbin/v2"
+	"github.com/weaviate/weaviate/usecases/auth/authorization"
+	"github.com/weaviate/weaviate/usecases/auth/authorization/conv"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+func upgradeGroupingsFrom129(enforcer *casbin.SyncedCachedEnforcer, authNconf config.Authentication) error {
+	// clear out assignments without namespaces and re-add them with namespaces
+	roles, _ := enforcer.GetAllSubjects()
+	for _, role := range roles {
+		users, err := enforcer.GetUsersForRole(role)
+		if err != nil {
+			return err
+		}
+
+		for _, user := range users {
+			// internal user assignments (for empty roles) need to be converted from namespaced assignment to db-user only
+			// other assignments need to be converted to both namespaces
+			if strings.Contains(user, conv.InternalPlaceHolder) {
+				if _, err := enforcer.DeleteRoleForUser(user, role); err != nil {
+					return err
+				}
+
+				if _, err := enforcer.AddRoleForUser(conv.UserNameWithTypeFromId(conv.InternalPlaceHolder, authentication.AuthTypeDb), role); err != nil {
+					return err
+				}
+			} else if strings.HasPrefix(user, "user:") {
+				userNoPrefix := strings.TrimPrefix(user, "user:")
+				if _, err := enforcer.DeleteRoleForUser(user, role); err != nil {
+					return err
+				}
+				if authNconf.APIKey.Enabled && slices.Contains(authNconf.APIKey.Users, userNoPrefix) {
+					if _, err := enforcer.AddRoleForUser(conv.UserNameWithTypeFromId(userNoPrefix, authentication.AuthTypeDb), role); err != nil {
+						return err
+					}
+				}
+				if authNconf.OIDC.Enabled {
+					if _, err := enforcer.AddRoleForUser(conv.UserNameWithTypeFromId(userNoPrefix, authentication.AuthTypeOIDC), role); err != nil {
+						return err
+					}
+				}
+			}
+		}
+
+	}
+	return nil
+}
+
+func upgradePoliciesFrom129(enforcer *casbin.SyncedCachedEnforcer, keepBuildInRoles bool) error {
+	policies, err := enforcer.GetPolicy()
+	if err != nil {
+		return err
+	}
+
+	// a role can have multiple policies, so first all old role need to be removed and then re-added
+	policiesToAdd := make([][]string, 0, len(policies))
+	for _, policy := range policies {
+		if _, err := enforcer.RemoveFilteredNamedPolicy("p", 0, policy[0]); err != nil {
+			return err
+		}
+
+		if policy[3] == authorization.UsersDomain && policy[2] == authorization.UPDATE {
+			policy[2] = authorization.USER_AND_GROUP_ASSIGN_AND_REVOKE
+		}
+
+		policiesToAdd = append(policiesToAdd, policy)
+	}
+
+	for _, policy := range policiesToAdd {
+		roleName := conv.TrimRoleNamePrefix(policy[0])
+		if _, ok := conv.BuiltInPolicies[roleName]; ok {
+			if !keepBuildInRoles {
+				continue
+			} else if policy[2] == conv.CRUD {
+				policy[2] = conv.VALID_VERBS
+			}
+		}
+
+		if _, err := enforcer.AddNamedPolicy("p", policy[0], policy[1], policy[2], policy[3]); err != nil {
+			return fmt.Errorf("readd policy: %w", err)
+		}
+	}
+
+	return nil
+}

platform/dbops/binaries/weaviate-src/usecases/auth/authorization/rbac/up_down_grades_test.go

@@ -0,0 +1,176 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package rbac
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"slices"
+	"testing"
+
+	"github.com/casbin/casbin/v2"
+	"github.com/casbin/casbin/v2/model"
+	fileadapter "github.com/casbin/casbin/v2/persist/file-adapter"
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/usecases/auth/authorization/conv"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+func TestUpdateGroupings(t *testing.T) {
+	tests := []struct {
+		name               string
+		rolesToAdd         []string
+		assignments        map[string]string
+		expectedAfterWards map[string]string
+		authNconf          config.Authentication
+	}{
+		{
+			name:               "only internal - will only be added as db",
+			rolesToAdd:         []string{"role:test"},
+			assignments:        map[string]string{"user:" + conv.InternalPlaceHolder: "role:test"},
+			expectedAfterWards: map[string]string{"db:" + conv.InternalPlaceHolder: "role:test"},
+			authNconf:          config.Authentication{OIDC: config.OIDC{Enabled: true}},
+		},
+		{
+			name:               "only oidc enabled - normal user will only be added as oidc",
+			rolesToAdd:         []string{"role:test"},
+			assignments:        map[string]string{"user:something": "role:test"},
+			expectedAfterWards: map[string]string{"oidc:something": "role:test"},
+			authNconf:          config.Authentication{OIDC: config.OIDC{Enabled: true}},
+		},
+		{
+			name:               "only db enabled - normal user will only be added as db",
+			rolesToAdd:         []string{"role:test"},
+			assignments:        map[string]string{"user:something": "role:test"},
+			expectedAfterWards: map[string]string{"db:something": "role:test"},
+			authNconf:          config.Authentication{APIKey: config.StaticAPIKey{Enabled: true, Users: []string{"something"}}},
+		},
+		{
+			name:               "both enabled - normal user will be added for both",
+			rolesToAdd:         []string{"role:test"},
+			assignments:        map[string]string{"user:something": "role:test"},
+			expectedAfterWards: map[string]string{"db:something": "role:test", "oidc:something": "role:test"},
+			authNconf:          config.Authentication{APIKey: config.StaticAPIKey{Enabled: true, Users: []string{"something"}}, OIDC: config.OIDC{Enabled: true}},
+		},
+		{
+			name:               "both enabled but user is not added to api key list- normal user will be added for both",
+			rolesToAdd:         []string{"role:test"},
+			assignments:        map[string]string{"user:something": "role:test"},
+			expectedAfterWards: map[string]string{"oidc:something": "role:test"},
+			authNconf:          config.Authentication{APIKey: config.StaticAPIKey{Enabled: true}, OIDC: config.OIDC{Enabled: true}},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m, err := model.NewModelFromString(MODEL)
+			require.NoError(t, err)
+
+			enforcer, err := casbin.NewSyncedCachedEnforcer(m)
+			require.NoError(t, err)
+
+			for _, role := range tt.rolesToAdd {
+				_, err := enforcer.AddNamedPolicy("p", role, "*", "R", "*")
+				require.NoError(t, err)
+
+			}
+
+			for user, role := range tt.assignments {
+				_, err := enforcer.AddRoleForUser(user, role)
+				require.NoError(t, err)
+			}
+
+			require.NoError(t, upgradeGroupingsFrom129(enforcer, tt.authNconf))
+			roles, _ := enforcer.GetAllSubjects()
+			require.Len(t, roles, len(tt.rolesToAdd))
+			for user, role := range tt.expectedAfterWards {
+				users, err := enforcer.GetUsersForRole(role)
+				require.NoError(t, err)
+				require.True(t, slices.Contains(users, user))
+			}
+		})
+	}
+}
+
+func TestUpgradeRoles(t *testing.T) {
+	tests := []struct {
+		name             string
+		lines            []string
+		expectedPolicies [][]string
+		version          string
+	}{
+		{
+			name: "skip build in roles",
+			lines: []string{
+				"p, role:other_role, data/collections/.*/shards/.*/objects/.*, R, data",
+				"p, role:viewer, *, R, *",
+			},
+			expectedPolicies: [][]string{
+				{"role:other_role", "data/collections/.*/shards/.*/objects/.*", " R", "data"},
+			},
+		},
+		{
+			name: "upgrade update user if coming from old version",
+			lines: []string{
+				"p, role:some_role, users/.*, U, users",
+			},
+			expectedPolicies: [][]string{
+				{"p, role:some_role, users/.*, A, users"},
+			},
+		},
+		{
+			name: "mixed upgrade and not upgrade and skip",
+			lines: []string{
+				"p, role:some_role, users/.*, U, users",
+				"p, role:other_role, data/collections/.*/shards/.*/objects/.*, R, data",
+				"p, role:viewer, *, R, *",
+			},
+			expectedPolicies: [][]string{
+				{"p, role:some_role, users/.*, A, users, "},
+				{"role:other_role", "data/collections/.*/shards/.*/objects/.*", " R", "data"},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			path := t.TempDir()
+			tmpFile, err := os.CreateTemp(path, "upgrade-temp-*.tmp")
+			require.NoError(t, err)
+
+			writer := bufio.NewWriter(tmpFile)
+			for _, line := range tt.lines {
+				_, err := fmt.Fprintln(writer, line)
+				require.NoError(t, err)
+			}
+			require.NoError(t, writer.Flush())
+			require.NoError(t, tmpFile.Sync())
+			require.NoError(t, tmpFile.Close())
+
+			m, err := model.NewModelFromString(MODEL)
+			require.NoError(t, err)
+
+			enforcer, err := casbin.NewSyncedCachedEnforcer(m)
+			require.NoError(t, err)
+			enforcer.SetAdapter(fileadapter.NewAdapter(tmpFile.Name()))
+			require.NoError(t, enforcer.LoadPolicy())
+
+			require.NoError(t, upgradePoliciesFrom129(enforcer, false))
+			policies, _ := enforcer.GetPolicy()
+			require.Len(t, policies, len(tt.expectedPolicies))
+			for i, policy := range tt.expectedPolicies {
+				require.Equal(t, tt.expectedPolicies[i], policy)
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/usecases/backup/test_data/chunk-1.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c9c7916275093514a2ff0552f86b7bf975ad8e5a13ad27aece239a28dcc7fac
+size 404

platform/dbops/binaries/weaviate-src/usecases/backup/test_data/node1/article_cT9eTErXgmTX.proplengths

@@ -0,0 +1 @@
+{"BucketedData":{"title":{"7":2},"title2":{"7":2}},"SumData":{"title":16,"title2":16},"CountData":{"title":2,"title2":2}}

platform/dbops/binaries/weaviate-src/usecases/backup/test_data/node1/article_uq5WKfRlq2mO.proplengths

@@ -0,0 +1 @@
+{"BucketedData":{"title":{"7":1},"title2":{"7":1}},"SumData":{"title":8,"title2":8},"CountData":{"title":1,"title2":1}}