expressions

Documentation

Index

• func TryResolveExpressionEarly(ctx context.Context, schema *proto.Schema, model *proto.Model, ...) (canResolveInMemory bool, resolvedValue bool)
• type OperandResolver
  • func NewOperandResolver(ctx context.Context, schema *proto.Schema, model *proto.Model, ...) *OperandResolver
  • func (resolver *OperandResolver) GetOperandType() (proto.Type, bool, error)
  • func (resolver *OperandResolver) IsContext() bool
  • func (resolver *OperandResolver) IsContextDbColumn() bool
  • func (resolver *OperandResolver) IsContextField() bool
  • func (resolver *OperandResolver) IsExplicitInput() bool
  • func (resolver *OperandResolver) IsImplicitInput() bool
  • func (resolver *OperandResolver) IsLiteral() bool
  • func (resolver *OperandResolver) IsModelDbColumn() bool
  • func (resolver *OperandResolver) NormalisedFragments() ([]string, error)
  • func (resolver *OperandResolver) ResolveValue(args map[string]any) (any, error)

Functions

func TryResolveExpressionEarly

func TryResolveExpressionEarly(ctx context.Context, schema *proto.Schema, model *proto.Model, action *proto.Action, expression *parser.Expression, args map[string]any) (canResolveInMemory bool, resolvedValue bool)

TryResolveExpressionEarly attempts to evaluate the expression in the runtime process without generating a row-based query against the database.

Types

type OperandResolver

type OperandResolver struct {
	Context context.Context
	Schema  *proto.Schema
	Model   *proto.Model
	Action  *proto.Action
	// contains filtered or unexported fields
}

OperandResolver hides some of the complexity of expression parsing so that the runtime action code can reason about and execute expression logic without stepping through the AST.

func NewOperandResolver

func NewOperandResolver(ctx context.Context, schema *proto.Schema, model *proto.Model, action *proto.Action, operand *parser.Operand) *OperandResolver

func (*OperandResolver) GetOperandType

func (resolver *OperandResolver) GetOperandType() (proto.Type, bool, error)

GetOperandType returns the equivalent protobuf type for the expression operand and whether it is an array or not

func (*OperandResolver) IsContext

func (resolver *OperandResolver) IsContext() bool

func (*OperandResolver) IsContextDbColumn

func (resolver *OperandResolver) IsContextDbColumn() bool

IsContextDbColumn returns true if the expression refers to a value on the context which will require database access (such as with identity backlinks), such as: @permission(expression: ctx.identity.user.isActive)

func (*OperandResolver) IsContextField

func (resolver *OperandResolver) IsContextField() bool

IsContextField returns true if the expression operand refers to a value on the context which does not require to be read from the database. For example, a permission condition may check against the current identity, such as: @permission(thing.identity == ctx.identity)

However if the expression traverses onwards from identity (using an Identity-backlink) like this: "ctx.identity.user" then it returns false, because that can no longer be resolved solely from the in memory context data.

func (*OperandResolver) IsExplicitInput

func (resolver *OperandResolver) IsExplicitInput() bool

IsExplicitInput returns true if the expression operand refers to an explicit input on an action. For example, a where condition might use an explicit input, such as: list listThings(isActive: Boolean) @where(thing.isActive == isActive)

func (*OperandResolver) IsImplicitInput

func (resolver *OperandResolver) IsImplicitInput() bool

IsImplicitInput returns true if the expression operand refers to an implicit input on an action. For example, an input value provided in a create action might require validation, such as: create createThing() with (name) @validation(name != "")

func (*OperandResolver) IsLiteral

func (resolver *OperandResolver) IsLiteral() bool

IsLiteral returns true if the expression operand is a literal type. For example, a number or string literal written straight into the Keel schema, such as the right-hand side operand in @where(person.age > 21).

func (*OperandResolver) IsModelDbColumn

func (resolver *OperandResolver) IsModelDbColumn() bool

IsModelDbColumn returns true if the expression operand refers to a field value residing in the database. For example, a where condition might filter on reading data, such as: @where(post.author.isActive)

func (*OperandResolver) NormalisedFragments

func (resolver *OperandResolver) NormalisedFragments() ([]string, error)

NormalisedFragments will return the expression fragments "in full" so that they can be processed for query building For example, note the two expressions in the condition @where(account in ctx.identity.primaryAccount.following.followee) NormalisedFragments will transform each of these operands as follows:

account.id
ctx.identity.primaryAccount.following.followeeId

func (*OperandResolver) ResolveValue

func (resolver *OperandResolver) ResolveValue(args map[string]any) (any, error)

ResolveValue returns the actual value of the operand, provided a database read is not required.