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 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 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