Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

28.7 KB
Raw Blame
//
// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package permission

import (
	"context"
	"errors"
	"fmt"
	"strings"

	"ragflow/internal/entity"

	"gorm.io/gorm"
)

type communityPolicy struct {
	source Source
}

type membershipResult struct {
	membership *Membership
	err        error
}

type evaluation struct {
	source      Source
	memberships map[string]membershipResult
	resources   map[ResourceRef]Resource
	resourceErr map[ResourceRef]error
}

func newPolicy(source Source) policy {
	if activePolicy, handled := newPolicyEE(source); handled {
		return activePolicy
	}
	return &communityPolicy{source: source}
}

func (p *communityPolicy) CheckFeature(ctx context.Context, feature Feature, action Action) error {
	if strings.TrimSpace(UserIDFromContext(ctx)) == "" {
		return ErrUnauthenticated
	}
	if strings.TrimSpace(string(feature)) == "" || !validAction(action) {
		return ErrInvalidPermission
	}
	// Community edition has no role-based feature restrictions.
	return nil
}

func (p *communityPolicy) CheckTenant(ctx context.Context, tenantID string, requirement TenantRequirement) error {
	return newEvaluation(p.source).checkTenant(ctx, tenantID, requirement)
}

func (p *communityPolicy) CheckResource(ctx context.Context, ref ResourceRef, operation Operation) error {
	if strings.TrimSpace(UserIDFromContext(ctx)) == "" {
		return ErrUnauthenticated
	}
	return newEvaluation(p.source).checkResource(ctx, ref, operation)
}

func (p *communityPolicy) CheckDependency(ctx context.Context, entryRef, dependencyRef ResourceRef, entryOperation, dependencyOperation Operation) error {
	if strings.TrimSpace(UserIDFromContext(ctx)) == "" {
		return ErrUnauthenticated
	}
	if !validOperation(entryOperation) || !validOperation(dependencyOperation) {
		return ErrInvalidPermission
	}
	evaluation := newEvaluation(p.source)
	return evaluation.checkDependency(ctx, entryRef, dependencyRef, entryOperation, dependencyOperation)
}

func (p *communityPolicy) ResolveAccess(ctx context.Context, ref ResourceRef) (Access, error) {
	return newEvaluation(p.source).resolveAccess(ctx, ref)
}

func (p *communityPolicy) Scope(ctx context.Context, query ScopeQuery) (Scope, error) {
	userID := strings.TrimSpace(UserIDFromContext(ctx))
	if userID == "" {
		return Scope{}, ErrUnauthenticated
	}
	if strings.TrimSpace(string(query.Kind)) == "" || !validOperation(query.Operation) {
		return Scope{}, ErrInvalidPermission
	}
	if (query.Parent.ID == "") != (query.Parent.Kind == "") {
		return Scope{}, ErrInvalidPermission
	}
	if query.Entry != nil && (!validResourceRef(*query.Entry) || !validOperation(query.EntryOp)) {
		return Scope{}, ErrInvalidPermission
	}

	evaluation := newEvaluation(p.source)
	candidateRefs, err := p.source.ListResourceRefs(ctx, query.Kind, query.Parent)
	if err != nil {
		return Scope{}, fmt.Errorf("permission: list resource candidates: %w", err)
	}
	candidateRefs = uniqueRefs(candidateRefs)
	resourcesToLoad := append([]ResourceRef(nil), candidateRefs...)
	if query.Parent.ID != "" {
		resourcesToLoad = append(resourcesToLoad, query.Parent)
	}
	if query.Entry != nil {
		resourcesToLoad = append(resourcesToLoad, *query.Entry)
	}
	if err := evaluation.loadResources(ctx, resourcesToLoad); err != nil {
		return Scope{}, err
	}

	var entryRef ResourceRef
	if query.Entry != nil {
		entryRef = *query.Entry
	}
	accessible := make([]ResourceRef, 0, len(candidateRefs))
	for _, ref := range candidateRefs {
		var checkErr error
		if query.Entry == nil {
			checkErr = evaluation.checkResource(ctx, ref, query.Operation)
		} else {
			checkErr = evaluation.checkDependency(ctx, entryRef, ref, query.EntryOp, query.Operation)
		}
		if checkErr == nil {
			accessible = append(accessible, ref)
			continue
		}
		if errorsIsPermissionDenial(checkErr) || errors.Is(checkErr, ErrResourceNotFound) {
			continue
		}
		return Scope{}, checkErr
	}

	// In the community edition the effective tenant comes from the persisted
	// resource boundary, not from a caller-selected tenant. Scopes without a
	// single parent or entry can contain resources from multiple tenants, so
	// their explicit authorized IDs are the boundary and TenantID stays empty.
	var tenantID string
	if query.Parent.ID != "" {
		if parent, parentErr := evaluation.getResource(query.Parent); parentErr == nil {
			tenantID = parent.TenantID
		}
	}
	if query.Entry != nil {
		if entry, entryErr := evaluation.getResource(*query.Entry); entryErr == nil {
			tenantID = entry.TenantID
		}
	}
	scope := Scope{TenantID: tenantID, Kind: query.Kind, Parent: query.Parent, Operation: query.Operation}
	if len(accessible) == 0 {
		scope.Mode = ScopeNone
		return scope, nil
	}
	scope.Mode = ScopeIDs
	scope.ResourceIDs = make([]string, 0, len(accessible))
	for _, ref := range accessible {
		scope.ResourceIDs = append(scope.ResourceIDs, ref.ID)
	}
	return scope, nil
}

func (p *communityPolicy) QueryScope(ctx context.Context, query ScopeQuery) (QueryScope, bool, error) {
	if query.Kind == ResourceKindModelProvider || query.Kind == ResourceKindModelInstance || query.Kind == ResourceKindModel {
		return p.modelQueryScope(ctx, query)
	}
	if query.Kind == ResourceKindMCPServer && query.Operation == OperationRead && query.Parent.ID == "" && query.Parent.Kind == "" && query.Entry == nil {
		return p.mcpServerReadQueryScope(ctx, query.TenantID)
	}
	if query.Kind == ResourceKindFile || query.Kind == ResourceKindFolder {
		return p.fileReadQueryScope(ctx, query)
	}
	if query.Kind != ResourceKindDataset || query.Operation != OperationRead || query.Parent.ID != "" || query.Parent.Kind != "" || query.Entry != nil {
		return QueryScope{}, false, nil
	}
	userID := strings.TrimSpace(UserIDFromContext(ctx))
	if userID == "" {
		return QueryScope{}, true, ErrUnauthenticated
	}
	source, ok := p.source.(*databaseSource)
	if !ok || source.db == nil {
		return QueryScope{}, false, nil
	}
	if err := source.validateDatasetTenants(ctx, userID); err != nil {
		return QueryScope{}, true, err
	}
	// Enterprise tenant roles are stored as numeric IDs. The generic SQL fast
	// path cannot resolve those IDs safely, so let the normal resource checks
	// evaluate candidate IDs through databaseSource.GetMembership instead.
	if tenantRoleMembershipEnabled(source.db) {
		return QueryScope{}, false, nil
	}

	return QueryScope{apply: func(query *gorm.DB) *gorm.DB {
		db := source.db.WithContext(ctx)
		activeOwner := db.Model(&entity.UserTenant{}).
			Select("1").
			Where("user_tenant.tenant_id = knowledgebase.tenant_id AND user_tenant.role = ? AND user_tenant.status = ?", string(RoleOwner), string(entity.StatusValid))
		callerIsOwner := db.Model(&entity.UserTenant{}).
			Select("1").
			Where("user_tenant.tenant_id = knowledgebase.tenant_id AND user_tenant.user_id = ? AND user_tenant.role = ? AND user_tenant.status = ?", userID, string(RoleOwner), string(entity.StatusValid))
		callerIsMember := db.Model(&entity.UserTenant{}).
			Select("1").
			Where("user_tenant.tenant_id = knowledgebase.tenant_id AND user_tenant.user_id = ? AND user_tenant.role = ? AND user_tenant.status = ?", userID, string(RoleNormal), string(entity.StatusValid))
		accessibleDatasets := db.Model(&entity.Knowledgebase{}).
			Select("knowledgebase.id").
			Where("knowledgebase.status = ?", string(entity.StatusValid)).
			Where("EXISTS (?)", activeOwner).
			Where("(EXISTS (?) OR (knowledgebase.permission = ? AND EXISTS (?)))", callerIsOwner, string(entity.TenantPermissionTeam), callerIsMember)
		return query.Where("knowledgebase.id IN (?)", accessibleDatasets)
	}}, true, nil
}

func (p *communityPolicy) modelQueryScope(ctx context.Context, query ScopeQuery) (QueryScope, bool, error) {
	parent := query.Parent
	if query.Entry != nil || (parent.ID == "") != (parent.Kind == "") {
		return QueryScope{}, false, nil
	}
	userID := strings.TrimSpace(UserIDFromContext(ctx))
	if userID == "" {
		return QueryScope{}, true, ErrUnauthenticated
	}
	source, ok := p.source.(*databaseSource)
	if !ok || source.db == nil || tenantRoleMembershipEnabled(source.db) {
		return QueryScope{}, false, nil
	}
	if query.Kind == ResourceKindModelInstance && parent.ID != "" && parent.Kind != ResourceKindModelProvider {
		return QueryScope{}, false, nil
	}
	if query.Kind == ResourceKindModel && parent.ID != "" && parent.Kind != ResourceKindModelProvider && parent.Kind != ResourceKindModelInstance {
		return QueryScope{}, false, nil
	}

	providerAccess := func(providerIDColumn, parentID string, ownerOnly bool) *gorm.DB {
		provider := source.db.WithContext(ctx).Model(&entity.TenantModelProvider{}).
			Select("1").
			Where("tenant_model_provider.id = " + providerIDColumn)
		if parentID != "" {
			provider = provider.Where("tenant_model_provider.id = ?", parentID)
		}
		owner := source.db.WithContext(ctx).Model(&entity.UserTenant{}).
			Select("user_tenant.user_id").
			Where("user_tenant.tenant_id = tenant_model_provider.tenant_id AND user_tenant.role = ? AND user_tenant.status = ?", string(RoleOwner), string(entity.StatusValid)).
			Limit(1)
		provider = provider.Where("tenant_model_provider.user_id = COALESCE((?), tenant_model_provider.tenant_id)", owner)
		if ownerOnly {
			return provider.Where("tenant_model_provider.user_id = ?", userID)
		}
		membership := source.db.WithContext(ctx).Model(&entity.UserTenant{}).
			Select("1").
			Where("user_tenant.tenant_id = tenant_model_provider.tenant_id AND user_tenant.user_id = ? AND user_tenant.status = ? AND user_tenant.role IN ?",
				userID, string(entity.StatusValid), []string{string(RoleOwner), string(RoleAdmin), string(RoleNormal)})
		return provider.Where("(tenant_model_provider.user_id = ? OR EXISTS (?))", userID, membership)
	}

	switch query.Kind {
	case ResourceKindModelProvider:
		if parent.ID != "" || query.Operation != OperationRead {
			return QueryScope{}, false, nil
		}
		return QueryScope{apply: func(query *gorm.DB) *gorm.DB {
			db := source.db.WithContext(ctx)
			owner := db.Model(&entity.UserTenant{}).
				Select("user_tenant.user_id").
				Where("user_tenant.tenant_id = tenant_model_provider.tenant_id AND user_tenant.role = ? AND user_tenant.status = ?", string(RoleOwner), string(entity.StatusValid)).
				Limit(1)
			membership := db.Model(&entity.UserTenant{}).
				Select("1").
				Where("user_tenant.tenant_id = tenant_model_provider.tenant_id AND user_tenant.user_id = ? AND user_tenant.status = ? AND user_tenant.role IN ?",
					userID, string(entity.StatusValid), []string{string(RoleOwner), string(RoleAdmin), string(RoleNormal)})
			return query.
				Where("tenant_model_provider.user_id = COALESCE((?), tenant_model_provider.tenant_id)", owner).
				Where("(tenant_model_provider.user_id = ? OR EXISTS (?))", userID, membership)
		}}, true, nil
	case ResourceKindModelInstance:
		if query.Operation != OperationRead && query.Operation != OperationUse {
			return QueryScope{}, false, nil
		}
		ownerOnly := query.Operation == OperationRead
		return QueryScope{apply: func(query *gorm.DB) *gorm.DB {
			return query.Where("EXISTS (?)", providerAccess("tenant_model_instance.provider_id", parent.ID, ownerOnly))
		}}, true, nil
	case ResourceKindModel:
		if query.Operation != OperationRead && query.Operation != OperationUse {
			return QueryScope{}, false, nil
		}
		return QueryScope{apply: func(query *gorm.DB) *gorm.DB {
			modelQuery := query.Where("EXISTS (?)", providerAccess("tenant_model.provider_id", "", false))
			switch parent.Kind {
			case ResourceKindModelProvider:
				modelQuery = modelQuery.Where("tenant_model.provider_id = ?", parent.ID)
			case ResourceKindModelInstance:
				modelQuery = modelQuery.Where("tenant_model.instance_id = ?", parent.ID)
			}
			return modelQuery
		}}, true, nil
	default:
		return QueryScope{}, false, nil
	}
}

func (p *communityPolicy) mcpServerReadQueryScope(ctx context.Context, targetTenantID string) (QueryScope, bool, error) {
	userID := strings.TrimSpace(UserIDFromContext(ctx))
	if userID == "" {
		return QueryScope{}, true, ErrUnauthenticated
	}
	tenantID := strings.TrimSpace(targetTenantID)
	if tenantID == "" {
		tenantID = strings.TrimSpace(TenantIDFromContext(ctx))
	}
	if tenantID == "" {
		return QueryScope{}, true, ErrInvalidPermission
	}
	source, ok := p.source.(*databaseSource)
	if !ok || source.db == nil {
		return QueryScope{}, false, nil
	}
	return QueryScope{apply: func(query *gorm.DB) *gorm.DB {
		activeOwner := source.db.WithContext(ctx).Model(&entity.UserTenant{}).
			Select("1").
			Where("user_tenant.tenant_id = mcp_server.tenant_id AND user_tenant.user_id = ? AND user_tenant.role = ? AND user_tenant.status = ?",
				userID, string(RoleOwner), string(entity.StatusValid))
		return query.Where("mcp_server.tenant_id = ?", tenantID).Where("EXISTS (?)", activeOwner)
	}}, true, nil
}

func (p *communityPolicy) fileReadQueryScope(ctx context.Context, query ScopeQuery) (QueryScope, bool, error) {
	if query.Operation != OperationRead || query.Parent.Kind != ResourceKindFolder || strings.TrimSpace(query.Parent.ID) == "" || query.Entry != nil {
		return QueryScope{}, false, nil
	}
	userID := strings.TrimSpace(UserIDFromContext(ctx))
	if userID == "" {
		return QueryScope{}, true, ErrUnauthenticated
	}
	source, ok := p.source.(*databaseSource)
	if !ok || source.db == nil {
		return QueryScope{}, false, nil
	}
	// Tenant role IDs are resolved by the enterprise policy. Keep its existing
	// policy-driven scope until that policy supplies its own SQL predicate.
	if tenantRoleMembershipEnabled(source.db) {
		return QueryScope{}, false, nil
	}

	parentID := query.Parent.ID
	return QueryScope{apply: func(query *gorm.DB) *gorm.DB {
		db := source.db.WithContext(ctx)
		parent := db.Model(&entity.File{}).
			Select("tenant_id").
			Where("id = ? AND type = ?", parentID, "folder")

		fileOwner := db.Model(&entity.UserTenant{}).
			Select("1").
			Where("user_tenant.tenant_id = file.tenant_id AND user_tenant.user_id = ? AND user_tenant.role = ? AND user_tenant.status = ?", userID, string(RoleOwner), string(entity.StatusValid))
		anyFileOwner := db.Model(&entity.UserTenant{}).
			Select("1").
			Where("user_tenant.tenant_id = file.tenant_id AND user_tenant.role = ? AND user_tenant.status = ?", string(RoleOwner), string(entity.StatusValid))

		rootMember := db.Model(&entity.UserTenant{}).
			Select("1").
			Where("user_tenant.tenant_id = file.tenant_id AND user_tenant.user_id = ? AND user_tenant.role IN ? AND user_tenant.status = ?", userID, []string{string(RoleOwner), string(RoleAdmin), string(RoleNormal)}, string(entity.StatusValid))
		datasetOwner := db.Model(&entity.UserTenant{}).
			Select("1").
			Where("user_tenant.tenant_id = knowledgebase.tenant_id AND user_tenant.user_id = ? AND user_tenant.role = ? AND user_tenant.status = ?", userID, string(RoleOwner), string(entity.StatusValid))
		datasetMember := db.Model(&entity.UserTenant{}).
			Select("1").
			Where("user_tenant.tenant_id = knowledgebase.tenant_id AND user_tenant.user_id = ? AND user_tenant.role = ? AND user_tenant.status = ?", userID, string(RoleNormal), string(entity.StatusValid))
		sharedDataset := db.Table("file2document AS f2d").
			Select("1").
			Joins("JOIN document ON document.id = f2d.document_id").
			Joins("JOIN knowledgebase ON knowledgebase.id = document.kb_id").
			Where("f2d.file_id = file.id AND knowledgebase.status = ?", string(entity.StatusValid)).
			Where("(EXISTS (?) OR (knowledgebase.permission = ? AND EXISTS (?)))", datasetOwner, string(entity.TenantPermissionTeam), datasetMember)

		return query.
			Where("file.tenant_id = (?)", parent).
			Where("(file.parent_id = file.id AND ((TRIM(file.created_by) = ?) OR (NULLIF(TRIM(file.created_by), '') IS NULL AND (EXISTS (?) OR (file.tenant_id = ? AND NOT EXISTS (?)))) OR EXISTS (?))) OR (file.parent_id <> file.id AND ((TRIM(file.created_by) = ?) OR (NULLIF(TRIM(file.created_by), '') IS NULL AND (EXISTS (?) OR (file.tenant_id = ? AND NOT EXISTS (?)))) OR EXISTS (?)))",
				userID, fileOwner, userID, anyFileOwner, rootMember,
				userID, fileOwner, userID, anyFileOwner, sharedDataset)
	}}, true, nil
}

func (s *databaseSource) validateDatasetTenants(ctx context.Context, userID string) error {
	var tenantIDs []string
	err := s.db.WithContext(ctx).Model(&entity.Knowledgebase{}).
		Joins("JOIN user_tenant member ON member.tenant_id = knowledgebase.tenant_id").
		Where("knowledgebase.status = ? AND member.user_id = ? AND member.status = ?", string(entity.StatusValid), userID, string(entity.StatusValid)).
		Distinct("knowledgebase.tenant_id").
		Pluck("knowledgebase.tenant_id", &tenantIDs).Error
	if err != nil {
		return err
	}
	_, err = s.loadTenantOwnerIDs(ctx, tenantIDs)
	return err
}

func (p *communityPolicy) FilterResources(ctx context.Context, refs []ResourceRef, operation Operation) ([]ResourceRef, error) {
	accesses, err := p.FilterAccesses(ctx, refs, operation)
	if err != nil {
		return nil, err
	}
	accessible := make([]ResourceRef, 0, len(accesses))
	for _, ref := range uniqueRefs(refs) {
		if _, ok := accesses[ref]; ok {
			accessible = append(accessible, ref)
		}
	}
	return accessible, nil
}

func (p *communityPolicy) ResolveAccesses(ctx context.Context, refs []ResourceRef) (map[ResourceRef]Access, error) {
	if strings.TrimSpace(UserIDFromContext(ctx)) == "" {
		return nil, ErrUnauthenticated
	}
	evaluation := newEvaluation(p.source)
	refs = uniqueRefs(refs)
	if err := evaluation.loadResources(ctx, refs); err != nil {
		return nil, err
	}
	accesses := make(map[ResourceRef]Access, len(refs))
	for _, ref := range refs {
		access, err := evaluation.resolveAccess(ctx, ref)
		if err == nil {
			accesses[ref] = access
			continue
		}
		if errorsIsPermissionDenial(err) || errors.Is(err, ErrResourceNotFound) {
			continue
		}
		return nil, err
	}
	return accesses, nil
}

func (p *communityPolicy) FilterAccesses(ctx context.Context, refs []ResourceRef, operation Operation) (map[ResourceRef]Access, error) {
	if !validOperation(operation) {
		return nil, ErrInvalidPermission
	}
	accesses, err := p.ResolveAccesses(ctx, refs)
	if err != nil {
		return nil, err
	}
	for ref, access := range accesses {
		if !access.Allows(operation) {
			delete(accesses, ref)
		}
	}
	return accesses, nil
}

func newEvaluation(source Source) *evaluation {
	return &evaluation{
		source:      source,
		memberships: make(map[string]membershipResult),
		resources:   make(map[ResourceRef]Resource),
		resourceErr: make(map[ResourceRef]error),
	}
}

func (e *evaluation) checkTenant(ctx context.Context, tenantID string, requirement TenantRequirement) error {
	return e.checkTenantForUser(ctx, UserIDFromContext(ctx), tenantID, requirement)
}

func (e *evaluation) checkTenantForUser(ctx context.Context, userID, tenantID string, requirement TenantRequirement) error {
	if strings.TrimSpace(userID) == "" {
		return ErrUnauthenticated
	}
	if strings.TrimSpace(tenantID) == "" || !validTenantRequirement(requirement) {
		return ErrInvalidPermission
	}
	membership, err := e.getMembership(ctx, userID, tenantID)
	if err != nil {
		return err
	}
	if !membershipSatisfies(membership, requirement) {
		return ErrMembershipNotFound
	}
	return nil
}

func (e *evaluation) checkResource(ctx context.Context, ref ResourceRef, operation Operation) error {
	if !validOperation(operation) {
		return ErrInvalidPermission
	}
	access, err := e.resolveAccess(ctx, ref)
	if err != nil {
		return err
	}
	if !accessAllows(access, operation) {
		return ErrPermissionDenied
	}
	return nil
}

func (e *evaluation) checkDependency(ctx context.Context, entryRef, dependencyRef ResourceRef, entryOperation, dependencyOperation Operation) error {
	userID := strings.TrimSpace(UserIDFromContext(ctx))
	if strings.TrimSpace(userID) == "" {
		return ErrUnauthenticated
	}
	if !validOperation(entryOperation) || !validOperation(dependencyOperation) {
		return ErrInvalidPermission
	}
	if err := e.loadResources(ctx, []ResourceRef{entryRef, dependencyRef}); err != nil {
		return err
	}
	entry, err := e.getResource(entryRef)
	if err != nil {
		return err
	}
	entryAccess, err := e.resolveResource(ctx, entry)
	if err != nil {
		return err
	}
	if !accessAllows(entryAccess, entryOperation) {
		return ErrPermissionDenied
	}
	dependency, err := e.getResource(dependencyRef)
	if err != nil {
		return err
	}
	userAccess, err := e.resolveResource(ctx, dependency)
	if err != nil {
		return err
	}
	if !accessAllows(userAccess, dependencyOperation) {
		return ErrPermissionDenied
	}
	ownerAccess, err := e.resolveResourceForUser(ctx, entry.OwnerUserID, dependency)
	if err != nil {
		if errorsIsPermissionDenial(err) {
			return ErrPermissionDenied
		}
		return err
	}
	if !accessAllows(ownerAccess, dependencyOperation) {
		return ErrPermissionDenied
	}
	return nil
}

func (e *evaluation) resolveAccess(ctx context.Context, ref ResourceRef) (Access, error) {
	userID := strings.TrimSpace(UserIDFromContext(ctx))
	if strings.TrimSpace(userID) == "" {
		return Access{}, ErrUnauthenticated
	}
	if err := e.loadResources(ctx, []ResourceRef{ref}); err != nil {
		return Access{}, err
	}
	resource, err := e.getResource(ref)
	if err != nil {
		return Access{}, err
	}
	return e.resolveResource(ctx, resource)
}

func (e *evaluation) resolveResource(ctx context.Context, resource Resource) (Access, error) {
	userID := strings.TrimSpace(UserIDFromContext(ctx))
	if userID == "" {
		return Access{}, ErrUnauthenticated
	}
	return e.resolveResourceForUser(ctx, userID, resource)
}

func (e *evaluation) resolveResourceForUser(ctx context.Context, userID string, resource Resource) (Access, error) {
	if resource.TenantID == "" || resource.OwnerUserID == "" || !validResourceRef(resource.Ref) {
		return Access{}, fmt.Errorf("%w: incomplete resource authorization facts", ErrInvalidPermission)
	}
	if !resource.Active {
		return Access{}, ErrResourceNotFound
	}
	if !validOperations(resource.OwnerOperations) {
		return Access{}, fmt.Errorf("%w: invalid owner operations", ErrInvalidPermission)
	}
	if !validOperations(resource.TenantOperations) || !validOperations(resource.CreatorOperations) {
		return Access{}, fmt.Errorf("%w: invalid delegated operations", ErrInvalidPermission)
	}
	switch resource.Visibility {
	case VisibilityPrivate, VisibilityTenant, VisibilityShared:
	default:
		return Access{}, fmt.Errorf("%w: unknown resource visibility %q", ErrInvalidPermission, resource.Visibility)
	}
	if userID == resource.OwnerUserID {
		return resourceAccess(resource, AccessSourceOwner), nil
	}

	switch resource.Visibility {
	case VisibilityPrivate:
		return Access{}, ErrPermissionDenied
	case VisibilityTenant:
		requirement := resource.TenantRequirement
		if requirement == "" {
			requirement = TenantNormalMember
		}
		if err := e.checkTenantForUser(ctx, userID, resource.TenantID, requirement); err != nil {
			if errors.Is(err, ErrMembershipNotFound) {
				return Access{}, ErrPermissionDenied
			}
			return Access{}, err
		}
		if userID == resource.CreatedBy && resource.CreatorOperations != nil {
			return resourceAccessWithOperations(resource, AccessSourceCreator, resource.CreatorOperations), nil
		}
		operations := resource.TenantOperations
		if operations == nil {
			operations = resource.OwnerOperations
		}
		return resourceAccessWithOperations(resource, AccessSourceTenant, operations), nil
	case VisibilityShared:
		if contains(resource.SharedWithUserIDs, userID) {
			return resourceAccess(resource, AccessSourceShared), nil
		}
		for _, tenantID := range resource.SharedWithTenantIDs {
			if err := e.checkTenantForUser(ctx, userID, tenantID, TenantNormalMember); err != nil {
				if errors.Is(err, ErrMembershipNotFound) {
					continue
				}
				return Access{}, err
			}
			return resourceAccess(resource, AccessSourceShared), nil
		}
		return Access{}, ErrPermissionDenied
	default:
		return Access{}, fmt.Errorf("%w: unknown resource visibility %q", ErrInvalidPermission, resource.Visibility)
	}
}

func (e *evaluation) loadResources(ctx context.Context, refs []ResourceRef) error {
	if e.source == nil {
		return ErrSourceUnavailable
	}
	var missing []ResourceRef
	for _, ref := range uniqueRefs(refs) {
		if _, ok := e.resources[ref]; ok {
			continue
		}
		if _, ok := e.resourceErr[ref]; ok {
			continue
		}
		if !validResourceRef(ref) {
			return ErrInvalidPermission
		}
		missing = append(missing, ref)
	}
	if len(missing) == 0 {
		return nil
	}
	resources, err := e.source.GetResources(ctx, missing)
	if err != nil {
		return fmt.Errorf("permission: load resources: %w", err)
	}
	for _, ref := range missing {
		e.resourceErr[ref] = ErrResourceNotFound
	}
	for _, resource := range resources {
		if _, requested := e.resourceErr[resource.Ref]; requested {
			e.resources[resource.Ref] = resource
			delete(e.resourceErr, resource.Ref)
		}
	}
	return nil
}

func (e *evaluation) getResource(ref ResourceRef) (Resource, error) {
	if !validResourceRef(ref) {
		return Resource{}, ErrInvalidPermission
	}
	if resource, ok := e.resources[ref]; ok {
		return resource, nil
	}
	if err, ok := e.resourceErr[ref]; ok {
		return Resource{}, err
	}
	return Resource{}, ErrResourceNotFound
}

func (e *evaluation) getMembership(ctx context.Context, userID, tenantID string) (*Membership, error) {
	if e.source == nil {
		return nil, ErrSourceUnavailable
	}
	key := userID + "\x00" + tenantID
	if result, ok := e.memberships[key]; ok {
		return result.membership, result.err
	}
	membership, err := e.source.GetMembership(ctx, userID, tenantID)
	if err != nil {
		err = fmt.Errorf("permission: load tenant membership: %w", err)
	} else if membership == nil || !membership.Active || membership.UserID != userID || membership.TenantID != tenantID {
		membership = nil
		err = ErrMembershipNotFound
	}
	e.memberships[key] = membershipResult{membership: membership, err: err}
	return membership, err
}

func errorsIsPermissionDenial(err error) bool {
	return errors.Is(err, ErrPermissionDenied) || errors.Is(err, ErrMembershipNotFound)
}

func validResourceRef(ref ResourceRef) bool {
	return strings.TrimSpace(string(ref.Kind)) != "" && strings.TrimSpace(ref.ID) != ""
}

func validAction(action Action) bool {
	switch action {
	case ActionEnable, ActionRead, ActionWrite, ActionShare:
		return true
	default:
		return false
	}
}

func validOperation(operation Operation) bool {
	switch operation {
	case OperationRead, OperationCreate, OperationUpdate, OperationDelete, OperationDeleteContent, OperationShare, OperationRun, OperationUse:
		return true
	default:
		return false
	}
}

func validTenantRequirement(requirement TenantRequirement) bool {
	switch requirement {
	case TenantMember, TenantNormalMember, TenantAdmin, TenantOwner:
		return true
	default:
		return false
	}
}

func membershipSatisfies(membership *Membership, requirement TenantRequirement) bool {
	if membership == nil || !membership.Active {
		return false
	}
	switch requirement {
	case TenantMember:
		return membership.Role == RoleOwner || membership.Role == RoleAdmin || membership.Role == RoleNormal
	case TenantNormalMember:
		return membership.Role == RoleNormal
	case TenantAdmin:
		return membership.Role == RoleOwner || membership.Role == RoleAdmin
	case TenantOwner:
		return membership.Role == RoleOwner
	default:
		return false
	}
}

func validOperations(operations []Operation) bool {
	for _, operation := range operations {
		if !validOperation(operation) {
			return false
		}
	}
	return true
}

func resourceAccess(resource Resource, source AccessSource) Access {
	return resourceAccessWithOperations(resource, source, resource.OwnerOperations)
}

func resourceAccessWithOperations(resource Resource, source AccessSource, operations []Operation) Access {
	permissionMask := int32(0)
	for _, operation := range operations {
		switch operation {
		case OperationRead, OperationRun, OperationUse:
			permissionMask |= ResourcePermissionRead
		case OperationCreate, OperationUpdate, OperationDeleteContent:
			permissionMask |= ResourcePermissionWrite
		case OperationDelete, OperationShare:
			permissionMask |= ResourcePermissionManage
		}
	}
	if source == AccessSourceOwner {
		permissionMask = ResourcePermissionOwner
	}
	return Access{
		Resource:       resource.Ref,
		TenantID:       resource.TenantID,
		Source:         source,
		PermissionMask: permissionMask,
		Operations:     append([]Operation(nil), operations...),
	}
}

func accessAllows(access Access, operation Operation) bool {
	return access.Allows(operation)
}

func contains(values []string, target string) bool {
	for _, value := range values {
		if value == target {
			return true
		}
	}
	return false
}

func uniqueRefs(refs []ResourceRef) []ResourceRef {
	seen := make(map[ResourceRef]struct{}, len(refs))
	unique := make([]ResourceRef, 0, len(refs))
	for _, ref := range refs {
		if !validResourceRef(ref) {
			continue
		}
		if _, ok := seen[ref]; ok {
			continue
		}
		seen[ref] = struct{}{}
		unique = append(unique, ref)
	}
	return unique
}