domain

Documentation

Index

• Constants
• Variables
• type AsBody
  • func (ab AsBody) Map(fn func(target interface{}) interface{}) Function
  • func (ab AsBody) Target() interface{}
• type Base64
  • func (b Base64) Map(fn func(target interface{}) interface{}) Function
  • func (b Base64) Target() interface{}
• type CacheControl
• type Chain
• type Debugging
• type Details
• type EnvSource
• type Flatten
  • func (f Flatten) Map(fn func(target interface{}) interface{}) Function
  • func (f Flatten) Target() interface{}
• type Function
• type HTTPClient
• type JSON
  • func (j JSON) Map(fn func(target interface{}) interface{}) Function
  • func (j JSON) Target() interface{}
• type Match
  • func (m Match) Map(fn func(target interface{}) interface{}) Function
  • func (m Match) Target() interface{}
• type Modifiers
• type NoExplode
  • func (f NoExplode) Map(fn func(target interface{}) interface{}) Function
  • func (f NoExplode) Target() interface{}
• type NoMultiplex
  • func (nm NoMultiplex) Map(fn func(target interface{}) interface{}) Function
  • func (nm NoMultiplex) Target() interface{}
• type Params
• type Query
• type ResourceID
  • func NewResourceID(statement Statement) ResourceID
• type Resources
  • func NewResources(statements []Statement) Resources
• type Statement
• type Variable

Constants

const (
	FromMethod   string = "from"
	ToMethod            = "to"
	IntoMethod          = "into"
	UpdateMethod        = "update"
	DeleteMethod        = "delete"
)

Methods available to be used in query statements.

Variables

var ErrRequestTimeout = errors.New("request timed out")

ErrRequestTimeout is the error returned by HTTPClient when a HTTP call fails due to the request exceeding the timeout defined in HTTPRequest.

Types

type AsBody

type AsBody struct {
	Value interface{}
}

AsBody is a Function that define a `with` parameter as the request body for statements using to, into or patch methods.

func (AsBody) Map

func (ab AsBody) Map(fn func(target interface{}) interface{}) Function

Map apply the given function to the Target value preserving the AsBody as a wrapper.

func (AsBody) Target

func (ab AsBody) Target() interface{}

Target return the value upon which AsBody will be applied.

type Base64

type Base64 struct {
	Value interface{}
}

Base64 is a Function that encode the target value as base64.

func (Base64) Map

func (b Base64) Map(fn func(target interface{}) interface{}) Function

Map apply the given function to the Target value preserving the Base64 as a wrapper.

func (Base64) Target

func (b Base64) Target() interface{}

Target return the value upon which Base64 will be applied.

type CacheControl

type CacheControl struct {
	MaxAge  interface{}
	SMaxAge interface{}
}

CacheControl is the internal representation of the `max-age` and `s-max-age` clauses.

type Chain

type Chain []interface{}

Chain is the internal representation of a chain parameter value.

type Debugging

type Debugging struct {
	Method          string
	Url             string
	RequestHeaders  map[string]string
	ResponseHeaders map[string]string
	Params          map[string]interface{}
	RequestBody     interface{}
	ResponseTime    int64
}

Debugging represents the collection of information about the statement result. This is only used when the client enable it during query execution.

type Details

type Details struct {
	Status       int
	Success      bool
	IgnoreErrors bool
	CacheControl restql.ResourceCacheControl
	Debug        *Debugging
}

Details represents metadata about the statement result.

type EnvSource

type EnvSource interface {
	GetString(key string) string
	GetAll() map[string]string
}

EnvSource expose access to environment variables.

type Flatten

type Flatten struct {
	Value interface{}
}

Flatten is a Function that encode the target value as a plain list of value.

func (Flatten) Map

func (f Flatten) Map(fn func(target interface{}) interface{}) Function

Map apply the given function to the Target value preserving the Flatten as a wrapper.

func (Flatten) Target

func (f Flatten) Target() interface{}

Target return the value upon which Flatten will be applied.

type Function

type Function interface {
	Target() interface{}
	Map(fn func(target interface{}) interface{}) Function
}

Function is the interface implemented by types that provide encoding, filters and special behaviour through the apply operator.

Target returns the value upon which the function will be applied. Map uses a function to transform the target value preserving the current Function type wrapping it.

type HTTPClient

type HTTPClient interface {
	Do(ctx context.Context, request restql.HTTPRequest) (restql.HTTPResponse, error)
}

HTTPClient is the interface that wrap the method Do

Do takes an HTTPRequest and execute it respecting the cancellation signal from the given Context.

type JSON

type JSON struct {
	Value interface{}
}

JSON is a Function that encode the target value as json.

func (JSON) Map

func (j JSON) Map(fn func(target interface{}) interface{}) Function

Map apply the given function to the Target value preserving the JSON as a wrapper.

func (JSON) Target

func (j JSON) Target() interface{}

Target return the value upon which JSON will be applied.

type Match

type Match struct {
	Value interface{}
	Arg   interface{}
}

Match is a Function that select values from the statement result based on the given Arg.

func (Match) Map

func (m Match) Map(fn func(target interface{}) interface{}) Function

Map apply the given function to the Target value preserving the Match as a wrapper.

func (Match) Target

func (m Match) Target() interface{}

Target return the value upon which Match will be applied.

type Modifiers

type Modifiers map[string]interface{}

Modifiers is the internal representation of the `use` clause.

type NoExplode

type NoExplode struct {
	Value interface{}
}

NoExplode is a Function that disable object explosion when resolving with values.

func (NoExplode) Map

func (f NoExplode) Map(fn func(target interface{}) interface{}) Function

Map apply the given function to the Target value preserving the NoExplode as a wrapper.

func (NoExplode) Target

func (f NoExplode) Target() interface{}

Target return the value upon which NoExplode will be applied.

type NoMultiplex

type NoMultiplex struct {
	Value interface{}
}

NoMultiplex is a Function that disable request multiplexing of statements with list parameters.

func (NoMultiplex) Map

func (nm NoMultiplex) Map(fn func(target interface{}) interface{}) Function

Map apply the given function to the Target value preserving the NoMultiplex as a wrapper.

func (NoMultiplex) Target

func (nm NoMultiplex) Target() interface{}

Target return the value upon which NoMultiplex will be applied.

type Params

type Params struct {
	Body   interface{}
	Values map[string]interface{}
}

Params is the internal representation of the `with` clause.

type Query

type Query struct {
	Use        Modifiers
	Statements []Statement
}

Query is the internal representation of the restQL language.

type ResourceID

type ResourceID string

ResourceID is an unique identifier used by a statement. If an alias is present, it is used. Otherwise, the resource name.

func NewResourceID

func NewResourceID(statement Statement) ResourceID

NewResourceID make a ResourceID from a Statement.

type Resources

type Resources map[ResourceID]interface{}

Resources represents the index of statements already resolved or to be resolved.

func NewResources

func NewResources(statements []Statement) Resources

NewResources constructs a Resources collection from a slice of statements.

type Statement

type Statement struct {
	Method       string
	Resource     string
	Alias        string
	In           []string
	Headers      map[string]interface{}
	Timeout      interface{}
	With         Params
	Only         []interface{}
	Hidden       bool
	CacheControl CacheControl
	IgnoreErrors bool
}

Statement is the internal representation of a query statement.

type Variable

type Variable struct {
	Target string
}

Variable is the internal representation of a variable parameter value.