scope.go

package warden

import (
	"context"

	"github.com/xraph/forge"
)

type tenantScope struct {
	appID         string
	tenantID      string
	namespacePath string

	// namespaces is AncestorNamespaces(namespacePath), computed once by
	// Check after every scope override (context, CheckRequest, CallOption)
	// has been applied, and reused by evaluateRBAC/evaluateReBAC/evaluateABAC
	// instead of each recomputing it.
	namespaces []string
}

// scopeFromContext extracts tenant scope from context. Explicit WithTenant
// values take priority over forge.Scope so that callers (e.g.
// ensureWardenScope) can override the tenant derived from forge scope when
// OrgID is empty (app-scoped sessions where roles are stored under appID).
func scopeFromContext(ctx context.Context) tenantScope {
	// 1. Check for explicit WithTenant values first, since these take priority.
	if tid := tenantIDFromContext(ctx); tid != "" {
		return tenantScope{
			appID:         appIDFromContext(ctx),
			tenantID:      tid,
			namespacePath: namespacePathFromContext(ctx),
		}
	}

	// 2. Fall back to forge.Scope.
	if s, ok := forge.ScopeFrom(ctx); ok {
		return tenantScope{
			appID:         s.AppID(),
			tenantID:      s.OrgID(),
			namespacePath: namespacePathFromContext(ctx),
		}
	}

	// 3. Standalone mode with no tenant set.
	return tenantScope{
		appID:         appIDFromContext(ctx),
		tenantID:      tenantIDFromContext(ctx),
		namespacePath: namespacePathFromContext(ctx),
	}
}

// ScopeFromContext extracts the tenant scope from the given context.
// Returns appID and tenantID using the standard resolution chain:
// explicit WithTenant > forge.Scope > empty.
func ScopeFromContext(ctx context.Context) (appID, tenantID string) {
	s := scopeFromContext(ctx)
	return s.appID, s.tenantID
}

// NamespaceFromContext extracts the namespace path from the given context.
// Returns the empty string (tenant root) if not set.
func NamespaceFromContext(ctx context.Context) string {
	return scopeFromContext(ctx).namespacePath
}