commands

type BranchNode struct {
	Kind     ExpandNodeKind          `json:"kind"`
	Target   tuple.EntityAndRelation `json:"target"`
	Children []IExpandNode           `json:"children"`
	Err      error                   `json:"-"`
}

type BuildCombiner func(ctx context.Context, functions []BuildFunction) IBuilderNode

type BuildFunction func(ctx context.Context, resultChan chan<- IBuilderNode)

type BuilderNodeKind string

type CheckCombiner func(ctx context.Context, functions []CheckFunction) CheckDecision

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

type CheckDecision struct {
	Prefix string       `json:"prefix"`
	Can    bool         `json:"can"`
	Err    errors.Error `json:"-"`
}

type CheckFunction func(ctx context.Context, decisionChan chan<- CheckDecision)

type CheckQuery struct {
	Entity  tuple.Entity
	Subject tuple.Subject
	// contains filtered or unexported fields
}

type CheckResponse struct {
	Can            bool
	Visits         map[string]interface{}
	RemainingDepth int32
}

type ExpandCombiner func(ctx context.Context, requests []ExpandFunction) IExpandNode

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

type ExpandFunction func(ctx context.Context, expandChan chan<- IExpandNode)

type ExpandNode struct {
	Kind      ExpandNodeKind `json:"kind"`
	Operation schema.OPType  `json:"operation"`
	Children  []IExpandNode  `json:"children"`
	Err       error          `json:"-"`
}

type ExpandNodeKind string

type ExpandQuery struct {
	Entity tuple.Entity
}

type ExpandResponse struct {
	Tree IExpandNode
}

type IBuilderNode interface {
	GetKind() BuilderNodeKind
	Error() error
}

type ICheckCommand interface {
	Execute(ctx context.Context, q *CheckQuery, child schema.Child) (response CheckResponse, err errors.Error)
}

type IExpandCommand interface {
	Execute(ctx context.Context, q *ExpandQuery, child schema.Child) (response ExpandResponse, err errors.Error)
}

type IExpandNode interface {
	GetKind() ExpandNodeKind
	Error() error
}

type ILookupQueryCommand interface {
	Execute(ctx context.Context, q *LookupQueryQuery, child schema.Child) (response LookupQueryResponse, err errors.Error)
}

type ISchemaLookupCommand interface {
	Execute(ctx context.Context, q *SchemaLookupQuery, actions []schema.Action) (response SchemaLookupResponse, err errors.Error)
}

type LeafNode struct {
	Kind    ExpandNodeKind `json:"kind"`
	Subject tuple.Subject  `json:"subject"`
	Err     error          `json:"-"`
}

type LogicNode struct {
	Operation schema.OPType  `json:"operation"`
	Children  []IBuilderNode `json:"children"`
	Err       error          `json:"-"`
}

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

type LookupQueryQuery struct {
	EntityType string
	Action     string
	Subject    tuple.Subject
	// contains filtered or unexported fields
}

type LookupQueryResponse struct {
	Node  IBuilderNode
	Query string
	Args  []interface{}
}

type QueryNode struct {
	Key       string          `json:"condition"`
	Join      map[string]join `json:"join"`
	Args      []string        `json:"vars"`
	Exclusion bool            `json:"exclusion"`
	Err       error           `json:"-"`
	// contains filtered or unexported fields
}

type ResolverFunction func() ([]string, errors.Error)

type SchemaLookupCombiner func(ctx context.Context, functions []SchemaLookupFunction) SchemaLookupDecision

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

type SchemaLookupDecision struct {
	Prefix string       `json:"prefix"`
	Can    bool         `json:"can"`
	Err    errors.Error `json:"-"`
}

type SchemaLookupFunction func(ctx context.Context, lookupChan chan<- SchemaLookupDecision)

type SchemaLookupQuery struct {
	Relations []string
}

type SchemaLookupResponse struct {
	ActionNames []string
}

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