engines

type BulkChecker ¶

type BulkChecker struct {
	// contains filtered or unexported fields
}

BulkChecker handles concurrent permission checks with ordered result processing. This struct implements a high-performance bulk permission checking system that: - Collects permission check requests asynchronously - Processes them concurrently with controlled parallelism - Maintains strict ordering of results based on request sorting - Provides efficient resource management and error handling

func NewBulkChecker(ctx context.Context, checker invoke.Check, typ BulkCheckerType, callback func(entityID, ct string), config BulkCheckerConfig) (*BulkChecker, error)

func (bc *BulkChecker) Close() error

func (bc *BulkChecker) ExecuteRequests(size uint32) error

func (bc *BulkChecker) StopCollectingRequests()

type BulkCheckerConfig ¶ added in v1.4.1

type BulkCheckerConfig struct {
	// ConcurrencyLimit defines the maximum number of concurrent permission checks
	// that can be processed simultaneously. Higher values increase throughput
	// but may consume more system resources.
	ConcurrencyLimit int
	// BufferSize defines the size of the internal request buffer.
	// This should be set based on expected request volume to avoid blocking.
	BufferSize int
}

BulkCheckerConfig holds configuration parameters for the BulkChecker. This struct allows for fine-tuning the behavior and performance characteristics of the bulk permission checking system.

func DefaultBulkCheckerConfig() BulkCheckerConfig

type BulkCheckerRequest ¶

type BulkCheckerRequest struct {
	// Request contains the actual permission check request
	Request *base.PermissionCheckRequest
	// Result holds a pre-computed result if available, otherwise CHECK_RESULT_UNSPECIFIED
	Result base.CheckResult
}

BulkCheckerRequest represents a permission check request with optional pre-computed result. This struct encapsulates both the permission check request and an optional pre-determined result, allowing for optimization when results are already known (e.g., from caching).

type BulkCheckerType ¶ added in v0.5.0

type BulkCheckerType string

BulkCheckerType defines the type of bulk checking operation. This enum determines how requests are sorted and processed.

const (
	// BulkCheckerTypeSubject indicates that requests should be sorted and processed by subject ID
	BulkCheckerTypeSubject BulkCheckerType = "subject"
	// BulkCheckerTypeEntity indicates that requests should be sorted and processed by entity ID
	BulkCheckerTypeEntity BulkCheckerType = "entity"
)

type BulkEntityPublisher ¶ added in v0.5.0

type BulkEntityPublisher struct {
	// contains filtered or unexported fields
}

BulkEntityPublisher handles entity-based permission check publishing. This struct provides a convenient interface for publishing entity permission check requests to a BulkChecker instance.

func NewBulkEntityPublisher(ctx context.Context, request *base.PermissionLookupEntityRequest, bulkChecker *BulkChecker) *BulkEntityPublisher

func (p *BulkEntityPublisher) Publish(entity *base.Entity, metadata *base.PermissionCheckRequestMetadata, context *base.Context, result base.CheckResult)

type BulkSubjectPublisher ¶ added in v0.5.0

type BulkSubjectPublisher struct {
	// contains filtered or unexported fields
}

BulkSubjectPublisher handles subject-based permission check publishing. This struct provides a convenient interface for publishing subject permission check requests to a BulkChecker instance.

func NewBulkSubjectPublisher(ctx context.Context, request *base.PermissionLookupSubjectRequest, bulkChecker *BulkChecker) *BulkSubjectPublisher

func (p *BulkSubjectPublisher) Publish(subject *base.Subject, metadata *base.PermissionCheckRequestMetadata, context *base.Context, result base.CheckResult)

type CheckCombiner ¶

type CheckCombiner func(ctx context.Context, functions []CheckFunction, limit int) (*base.PermissionCheckResponse, error)

CheckCombiner is a type that represents a function which takes a context, a slice of CheckFunctions, and a limit. It combines the results of multiple CheckFunctions according to a specific strategy and returns a PermissionCheckResponse along with an error.

type CheckEngine ¶

type CheckEngine struct {
	// contains filtered or unexported fields
}

CheckEngine is a core component responsible for performing permission checks. It reads schema and relationship information, and uses the engine key manager to validate permission requests.

func NewCheckEngine(sr storage.SchemaReader, rr storage.DataReader, opts ...CheckOption) *CheckEngine

func (engine *CheckEngine) Check(ctx context.Context, request *base.PermissionCheckRequest) (response *base.PermissionCheckResponse, err error)

func (engine *CheckEngine) SetInvoker(invoker invoke.Check)

type CheckFunction ¶

type CheckFunction func(ctx context.Context) (*base.PermissionCheckResponse, error)

CheckFunction is a type that represents a function that takes a context and returns a PermissionCheckResponse along with an error. It is used to perform individual permission checks within the CheckEngine.

type CheckOption ¶

type CheckOption func(engine *CheckEngine)

CheckOption - a functional option type for configuring the CheckEngine.

func CheckConcurrencyLimit(limit int) CheckOption

type CheckResponse ¶

type CheckResponse struct {
	// contains filtered or unexported fields
}

CheckResponse - a struct that holds a PermissionCheckResponse and an error for a single check function.

type EntityFilter ¶ added in v1.1.0

type EntityFilter struct {
	// contains filtered or unexported fields
}

EntityFilter is a struct that performs permission checks on a set of entities

func NewEntityFilter(dataReader storage.DataReader, sch *base.SchemaDefinition) *EntityFilter

func (engine *EntityFilter) EntityFilter(
	ctx context.Context,
	request *base.PermissionEntityFilterRequest,
	visits *VisitsMap,
	publisher *BulkEntityPublisher,
) (err error)

type ExpandCombiner ¶

type ExpandCombiner func(ctx context.Context, entity *base.Entity, permission string, arguments []*base.Argument, functions []ExpandFunction) ExpandResponse

ExpandCombiner represents a function that combines the results of multiple ExpandFunction calls into a single ExpandResponse.

type ExpandEngine ¶

type ExpandEngine struct {
	// contains filtered or unexported fields
}

ExpandEngine - This comment is describing a type called ExpandEngine. The ExpandEngine type contains two fields: schemaReader, which is a storage.SchemaReader object, and relationshipReader, which is a storage.RelationshipReader object. The ExpandEngine type is used to expand permission scopes based on a given user ID and a set of permission requirements.

func NewExpandEngine(sr storage.SchemaReader, rr storage.DataReader) *ExpandEngine

func (engine *ExpandEngine) Expand(ctx context.Context, request *base.PermissionExpandRequest) (response *base.PermissionExpandResponse, err error)

type ExpandFunction ¶

type ExpandFunction func(ctx context.Context, expandChain chan<- ExpandResponse)

ExpandFunction represents a function that expands the schema and relationships of a request and sends the response through the provided channel.

type ExpandResponse ¶

type ExpandResponse struct {
	Response *base.PermissionExpandResponse
	Err      error
}

ExpandResponse is a struct that contains the response and error returned from the expand function in the ExpandEngine. It is used to return the response and error together as a single object.

type LookupEngine ¶ added in v0.5.0

type LookupEngine struct {
	// contains filtered or unexported fields
}

func NewLookupEngine(
	check invoke.Check,
	schemaReader storage.SchemaReader,
	dataReader storage.DataReader,
	opts ...LookupOption,
) *LookupEngine

func (engine *LookupEngine) LookupEntity(ctx context.Context, request *base.PermissionLookupEntityRequest) (response *base.PermissionLookupEntityResponse, err error)

func (engine *LookupEngine) LookupEntityStream(ctx context.Context, request *base.PermissionLookupEntityRequest, server base.Permission_LookupEntityStreamServer) (err error)

func (engine *LookupEngine) LookupSubject(ctx context.Context, request *base.PermissionLookupSubjectRequest) (response *base.PermissionLookupSubjectResponse, err error)

type LookupOption ¶ added in v0.5.0

type LookupOption func(engine *LookupEngine)

func LookupConcurrencyLimit(limit int) LookupOption

type SubjectFilter ¶ added in v1.1.4

type SubjectFilter struct {
	// contains filtered or unexported fields
}

func NewSubjectFilter(schemaReader storage.SchemaReader, dataReader storage.DataReader, opts ...SubjectFilterOption) *SubjectFilter

func (engine *SubjectFilter) SubjectFilter(ctx context.Context, request *base.PermissionLookupSubjectRequest) (response []string, err error)

type SubjectFilterCombiner ¶ added in v0.5.0

type SubjectFilterCombiner func(ctx context.Context, functions []SubjectFilterFunction, limit int) ([]string, error)

SubjectFilterCombiner defines the type for a function that takes a context, a slice of SubjectFilterFunctions, an integer as a limit and returns a pointer to a PermissionSubjectFilterResponse and an error. This type is useful when you want to define a function that can execute multiple SubjectFilterFunctions in a specific way (like concurrently with a limit or sequentially) and combine their results into a single PermissionSubjectFilterResponse.

type SubjectFilterFunction ¶ added in v0.5.0

type SubjectFilterFunction func(ctx context.Context) ([]string, error)

SubjectFilterFunction defines the type for a function that takes a context and returns a pointer to a PermissionSubjectFilterResponse and an error. This type is often used when you want to pass around functions with this specific signature.

type SubjectFilterOption ¶ added in v1.1.4

type SubjectFilterOption func(engine *SubjectFilter)

SubjectFilterOption - a functional option type for configuring the LookupSubjectEngine.

func SubjectFilterConcurrencyLimit(limit int) SubjectFilterOption

type SubjectFilterResponse ¶ added in v0.5.0

type SubjectFilterResponse struct {
	// contains filtered or unexported fields
}

SubjectFilterResponse -

type SubjectPermissionEngine ¶ added in v0.4.7

type SubjectPermissionEngine struct {
	// contains filtered or unexported fields
}

func NewSubjectPermission(checker invoke.Check, sr storage.SchemaReader, opts ...SubjectPermissionOption) *SubjectPermissionEngine

func (engine *SubjectPermissionEngine) SubjectPermission(ctx context.Context, request *base.PermissionSubjectPermissionRequest) (*base.PermissionSubjectPermissionResponse, error)

type SubjectPermissionOption ¶ added in v0.4.7

type SubjectPermissionOption func(engine *SubjectPermissionEngine)

SubjectPermissionOption - a functional option type for configuring the SubjectPermissionEngine.

func SubjectPermissionConcurrencyLimit(limit int) SubjectPermissionOption

type SubjectPermissionResponse ¶ added in v0.4.7

type SubjectPermissionResponse struct {
	// contains filtered or unexported fields
}

SubjectPermissionResponse - a struct that holds a SubjectPermissionResponse and an error for a single subject permission check result.

type VisitsMap ¶ added in v1.1.0

type VisitsMap struct {
	// contains filtered or unexported fields
}

VisitsMap - a thread-safe map of ENR records.

func (s *VisitsMap) AddEA(entityType, attribute string) bool

func (s *VisitsMap) AddER(entity *base.Entity, relation string) bool

func (s *VisitsMap) AddPublished(entity *base.Entity) bool