Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	// Allow may be returned by rules to indicate that the policy
	// evaluation should terminate with an allow decision.
	Allow = privacy.Allow

	// Deny may be returned by rules to indicate that the policy
	// evaluation should terminate with an deny decision.
	Deny = privacy.Deny

	// Skip may be returned by rules to indicate that the policy
	// evaluation should continue to the next rule.
	Skip = privacy.Skip
)

Functions

func Allowf

func Allowf(format string, a ...interface{}) error

    Allowf returns an formatted wrapped Allow decision.

    func DecisionContext

    func DecisionContext(parent context.Context, decision error) context.Context

      DecisionContext creates a new context from the given parent context with a policy decision attach to it.

      func DecisionFromContext

      func DecisionFromContext(ctx context.Context) (error, bool)

        DecisionFromContext retrieves the policy decision from the context.

        func Denyf

        func Denyf(format string, a ...interface{}) error

          Denyf returns an formatted wrapped Deny decision.

          func Skipf

          func Skipf(format string, a ...interface{}) error

            Skipf returns an formatted wrapped Skip decision.

            Types

            type Filter

            type Filter interface {
            	// Where applies a filter on the executed query/mutation.
            	Where(entql.P)
            }

              Filter is the interface that wraps the Where function for filtering nodes in queries and mutations.

              type FilterFunc

              type FilterFunc func(context.Context, Filter) error

                The FilterFunc type is an adapter that allows the use of ordinary functions as filters for query and mutation types.

                func (FilterFunc) EvalMutation

                func (f FilterFunc) EvalMutation(ctx context.Context, m ent.Mutation) error

                  EvalMutation calls f(ctx, q) if the mutation implements the Filter interface, otherwise it is denied.

                  func (FilterFunc) EvalQuery

                  func (f FilterFunc) EvalQuery(ctx context.Context, q ent.Query) error

                    EvalQuery calls f(ctx, q) if the query implements the Filter interface, otherwise it is denied.

                    type MutationPolicy

                    type MutationPolicy = privacy.MutationPolicy

                      MutationPolicy combines multiple mutation rules into a single policy.

                      type MutationRule

                      type MutationRule = privacy.MutationRule

                        MutationRule defines the interface which decides whether a mutation is allowed and optionally modifies it.

                        func DenyMutationOperationRule

                        func DenyMutationOperationRule(op ent.Op) MutationRule

                          DenyMutationOperationRule returns a rule denying specified mutation operation.

                          func OnMutationOperation

                          func OnMutationOperation(rule MutationRule, op ent.Op) MutationRule

                            OnMutationOperation evaluates the given rule only on a given mutation operation.

                            type MutationRuleFunc

                            type MutationRuleFunc func(context.Context, ent.Mutation) error

                              MutationRuleFunc type is an adapter which allows the use of ordinary functions as mutation rules.

                              func (MutationRuleFunc) EvalMutation

                              func (f MutationRuleFunc) EvalMutation(ctx context.Context, m ent.Mutation) error

                                EvalMutation returns f(ctx, m).

                                type Policy

                                type Policy struct {
                                	Query    QueryPolicy
                                	Mutation MutationPolicy
                                }

                                  Policy groups query and mutation policies.

                                  func (Policy) EvalMutation

                                  func (policy Policy) EvalMutation(ctx context.Context, m ent.Mutation) error

                                    EvalMutation forwards evaluation to mutate a policy.

                                    func (Policy) EvalQuery

                                    func (policy Policy) EvalQuery(ctx context.Context, q ent.Query) error

                                      EvalQuery forwards evaluation to query a policy.

                                      type QueryMutationRule

                                      type QueryMutationRule interface {
                                      	QueryRule
                                      	MutationRule
                                      }

                                        QueryMutationRule is an interface which groups query and mutation rules.

                                        func AlwaysAllowRule

                                        func AlwaysAllowRule() QueryMutationRule

                                          AlwaysAllowRule returns a rule that returns an allow decision.

                                          func AlwaysDenyRule

                                          func AlwaysDenyRule() QueryMutationRule

                                            AlwaysDenyRule returns a rule that returns a deny decision.

                                            func ContextQueryMutationRule

                                            func ContextQueryMutationRule(eval func(context.Context) error) QueryMutationRule

                                              ContextQueryMutationRule creates a query/mutation rule from a context eval func.

                                              type QueryPolicy

                                              type QueryPolicy = privacy.QueryPolicy

                                                QueryPolicy combines multiple query rules into a single policy.

                                                type QueryRule

                                                type QueryRule = privacy.QueryRule

                                                  QueryRule defines the interface deciding whether a query is allowed and optionally modify it.

                                                  type QueryRuleFunc

                                                  type QueryRuleFunc func(context.Context, ent.Query) error

                                                    QueryRuleFunc type is an adapter to allow the use of ordinary functions as query rules.

                                                    func (QueryRuleFunc) EvalQuery

                                                    func (f QueryRuleFunc) EvalQuery(ctx context.Context, q ent.Query) error

                                                      Eval returns f(ctx, q).

                                                      type TaskMutationRuleFunc

                                                      type TaskMutationRuleFunc func(context.Context, *ent.TaskMutation) error

                                                        The TaskMutationRuleFunc type is an adapter to allow the use of ordinary functions as a mutation rule.

                                                        func (TaskMutationRuleFunc) EvalMutation

                                                        func (f TaskMutationRuleFunc) EvalMutation(ctx context.Context, m ent.Mutation) error

                                                          EvalMutation calls f(ctx, m).

                                                          type TaskQueryRuleFunc

                                                          type TaskQueryRuleFunc func(context.Context, *ent.TaskQuery) error

                                                            The TaskQueryRuleFunc type is an adapter to allow the use of ordinary functions as a query rule.

                                                            func (TaskQueryRuleFunc) EvalQuery

                                                            func (f TaskQueryRuleFunc) EvalQuery(ctx context.Context, q ent.Query) error

                                                              EvalQuery return f(ctx, q).

                                                              type TeamMutationRuleFunc

                                                              type TeamMutationRuleFunc func(context.Context, *ent.TeamMutation) error

                                                                The TeamMutationRuleFunc type is an adapter to allow the use of ordinary functions as a mutation rule.

                                                                func (TeamMutationRuleFunc) EvalMutation

                                                                func (f TeamMutationRuleFunc) EvalMutation(ctx context.Context, m ent.Mutation) error

                                                                  EvalMutation calls f(ctx, m).

                                                                  type TeamQueryRuleFunc

                                                                  type TeamQueryRuleFunc func(context.Context, *ent.TeamQuery) error

                                                                    The TeamQueryRuleFunc type is an adapter to allow the use of ordinary functions as a query rule.

                                                                    func (TeamQueryRuleFunc) EvalQuery

                                                                    func (f TeamQueryRuleFunc) EvalQuery(ctx context.Context, q ent.Query) error

                                                                      EvalQuery return f(ctx, q).

                                                                      type UserMutationRuleFunc

                                                                      type UserMutationRuleFunc func(context.Context, *ent.UserMutation) error

                                                                        The UserMutationRuleFunc type is an adapter to allow the use of ordinary functions as a mutation rule.

                                                                        func (UserMutationRuleFunc) EvalMutation

                                                                        func (f UserMutationRuleFunc) EvalMutation(ctx context.Context, m ent.Mutation) error

                                                                          EvalMutation calls f(ctx, m).

                                                                          type UserQueryRuleFunc

                                                                          type UserQueryRuleFunc func(context.Context, *ent.UserQuery) error

                                                                            The UserQueryRuleFunc type is an adapter to allow the use of ordinary functions as a query rule.

                                                                            func (UserQueryRuleFunc) EvalQuery

                                                                            func (f UserQueryRuleFunc) EvalQuery(ctx context.Context, q ent.Query) error

                                                                              EvalQuery return f(ctx, q).

                                                                              Source Files