compiler

type CompiledExpression ¶

type CompiledExpression struct {
	Path string
}

CompiledExpression is an InputExpression which loads a CheckedExpr from a file.

func (c *CompiledExpression) CreateAST(_ Compiler) (*cel.Ast, map[string]any, error)

type Compiler ¶

type Compiler interface {
	// CreateEnv creates a singleton CEL environment with the configured environment options.
	CreateEnv() (*cel.Env, error)
	// CreatePolicyParser creates a policy parser using the optionally configured parser options.
	CreatePolicyParser() (*policy.Parser, error)
	// PolicyCompilerOptions returns the policy compiler options.
	PolicyCompilerOptions() []policy.CompilerOption
	// PolicyMetadataEnvOptions returns the policy metadata environment options.
	PolicyMetadataEnvOptions() []PolicyMetadataEnvOption
}

Compiler interface is used to set up a compiler with the following capabilities: - create a CEL environment - create a policy parser - fetch policy compiler options - fetch policy environment options

Note: This compiler is not the same as the CEL expression compiler, rather it provides an abstraction layer which can create the different components needed for parsing and compiling CEL expressions and policies.

func NewCompiler(opts ...any) (Compiler, error)

type ExpressionType ¶

type ExpressionType int

ExpressionType is an enum for the type of input expression.

const (
	// ExpressionTypeUnspecified is used when the expression type is not specified.
	ExpressionTypeUnspecified ExpressionType = iota
	// CompiledExpressionFile is file containing a checked expression.
	CompiledExpressionFile
	// PolicyFile is a file containing a CEL policy.
	PolicyFile
	// ExpressionFile is a file containing a CEL expression.
	ExpressionFile
	// RawExpressionString is a raw CEL expression string.
	RawExpressionString
)

type FileExpression ¶

type FileExpression struct {
	Path string
}

FileExpression is an InputExpression which loads a CEL expression or policy from a file.

func (f *FileExpression) CreateAST(compiler Compiler) (*cel.Ast, map[string]any, error)

type FileFormat ¶

type FileFormat int

FileFormat represents the format of the file being loaded.

const (
	// Unspecified is used when the file format is not determined.
	Unspecified FileFormat = iota + 1
	// BinaryProto is used for a binary proto file.
	BinaryProto
	// TextProto is used for a text proto file.
	TextProto
	// TextYAML is used for a YAML file.
	TextYAML
	// CELString is used for a CEL string expression defined in a file with .cel extension.
	CELString
	// CELPolicy is used for a CEL policy file with .celpolicy extension.
	CELPolicy
)

func InferFileFormat(path string) FileFormat

type InputExpression ¶

type InputExpression interface {
	// CreateAST creates a CEL AST from the input expression using the provided compiler.
	CreateAST(Compiler) (*cel.Ast, map[string]any, error)
}

InputExpression is an interface for an expression which can be compiled into a CEL AST and return an optional policy metadata map.

type PolicyMetadataEnvOption ¶

type PolicyMetadataEnvOption func(map[string]any) cel.EnvOption

PolicyMetadataEnvOption represents a function which accepts a policy metadata map and returns an environment option used to extend the CEL environment.

The policy metadata map is generally produced as a byproduct of parsing the policy and it can be optionally customised by providing a custom policy parser.

type RawExpression ¶

type RawExpression struct {
	Value string
}

RawExpression is an InputExpression which loads a CEL expression from a string.

func (r *RawExpression) CreateAST(compiler Compiler) (*cel.Ast, map[string]any, error)