schema

type AuthContainer struct {
	Password *RuleNode
	Query    *RuleNode
	Add      *RuleNode
	Update   *RuleNode
	Delete   *RuleNode
}

type EntityRepresentations struct {
	TypeDefn Type            // the type corresponding to __typename in the representations argument
	KeyField FieldDefinition // the definition of the @key field
	KeyVals  []interface{}   // the list of values corresponding to the key field
	// a map of key field value to the input representation for that value. The keys in this map
	// are the string formatted version of the key field value.
	KeyValToRepresentation map[string]map[string]interface{}
}

type ExecutionTrace struct {
	Resolvers []*ResolverTrace `json:"resolvers"`
}

type Extensions struct {
	TouchedUids uint64 `json:"touched_uids,omitempty"`
	Tracing     *Trace `json:"tracing,omitempty"`
	DQLQuery    string `json:"dql_query,omitempty"`
}

type Field interface {
	Name() string
	Alias() string
	// DgraphAlias is used as an alias in DQL while rewriting the GraphQL field.
	DgraphAlias() string
	ResponseName() string
	RemoteResponseName() string
	Arguments() map[string]interface{}
	ArgValue(name string) interface{}
	IsArgListType(name string) bool
	IDArgValue() (map[string]string, uint64, error)
	XIDArgs() map[string]string
	SetArgTo(arg string, val interface{})
	Skip() bool
	Include() bool
	// SkipField tells whether to skip this field during completion or not based on:
	//  * @skip
	//  * @include
	//  * __typename: used for skipping fields in abstract types
	//  * seenField: used for skipping when the field has already been seen at the current level
	SkipField(dgraphTypes []string, seenField map[string]bool) bool
	Cascade() []string
	// ApolloRequiredFields returns the fields names which were specified in @requires.
	ApolloRequiredFields() []string
	// CustomRequiredFields returns a map from DgraphAlias to the field definition of the fields
	// which are required to resolve this custom field.
	CustomRequiredFields() map[string]FieldDefinition
	// IsCustomHTTP tells whether this field has @custom(http: {...}) directive on it.
	IsCustomHTTP() bool
	// HasCustomHTTPChild tells whether any descendent of this field has @custom(http: {...}) on it.
	HasCustomHTTPChild() bool
	HasLambdaDirective() bool
	Type() Type
	IsExternal() bool
	SelectionSet() []Field
	Location() x.Location
	DgraphPredicate() string
	Operation() Operation
	// AbstractType tells us whether this field represents a GraphQL Interface/Union.
	AbstractType() bool
	IncludeAbstractField(types []string) bool
	TypeName(dgraphTypes []string) string
	GetObjectName() string
	IsAuthQuery() bool
	CustomHTTPConfig() (*FieldHTTPConfig, error)
	EnumValues() []string
	ConstructedFor() Type
	ConstructedForDgraphPredicate() string
	DgraphPredicateForAggregateField() string
	IsAggregateField() bool
	GqlErrorf(path []interface{}, message string, args ...interface{}) *x.GqlError
	// MaxPathLength finds the max length (including list indexes) of any path in the 'query' f.
	MaxPathLength() int
	// PreAllocatePathSlice is used to pre-allocate a path buffer of the correct size before running
	// CompleteObject on the top level query - means that we aren't reallocating slices multiple
	// times during the complete* functions.
	PreAllocatePathSlice() []interface{}
	// NullValue returns the appropriate null bytes to be written as value in the JSON response for
	// this field.
	//  * If this field is a list field then it returns []byte("[]").
	//  * If it is nullable, it returns []byte("null").
	//  * Otherwise, this field is non-nullable and so it will return a nil slice to indicate that.
	NullValue() []byte
	// NullResponse returns the bytes representing a JSON object to be used for setting the Data
	// field of a Resolved, when this field resolves to a NullValue.
	//  * If this field is a list field then it returns []byte(`{"fieldAlias":[]}`).
	//  * If it is nullable, it returns []byte(`{"fieldAlias":null}`).
	//  * Otherwise, this field is non-nullable and so it will return a nil slice to indicate that.
	// This is useful only for top-level fields like a query or mutation.
	NullResponse() []byte
	// CompleteAlias applies GraphQL alias completion for field to the input buffer buf.
	CompleteAlias(buf *bytes.Buffer)
	// GetAuthMeta returns the Dgraph.Authorization meta information stored in schema
	GetAuthMeta() *authorization.AuthMeta
}

type FieldDefinition interface {
	Name() string
	DgraphAlias() string
	DgraphPredicate() string
	Type() Type
	ParentType() Type
	IsID() bool
	IsExternal() bool
	HasIDDirective() bool
	HasEmbeddingDirective() bool
	EmbeddingSearchMetric() string
	HasInterfaceArg() bool
	GetDefaultValue(action string) interface{}
	Inverse() FieldDefinition
	WithMemberType(string) FieldDefinition
	// TODO - It might be possible to get rid of ForwardEdge and just use Inverse() always.
	ForwardEdge() FieldDefinition
	// GetAuthMeta returns the Dgraph.Authorization meta information stored in schema
	GetAuthMeta() *authorization.AuthMeta
}

type FieldHTTPConfig struct {
	URL    string
	Method string
	// would be nil if there is no body
	Template       interface{}
	Mode           string
	ForwardHeaders http.Header
	// would be empty for non-GraphQL requests
	RemoteGqlQueryName string
	RemoteGqlQuery     string

	// For the following request
	// graphql: "query($sinput: [SchoolInput]) { schoolNames(schools: $sinput) }"
	// the GraphqlBatchModeArgument would be sinput, we use it to know the GraphQL variable that
	// we should send the data in.
	GraphqlBatchModeArgument string
}

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

type Handler interface {
	MetaInfo() *metaInfo
	DGSchema() string
	GQLSchema() string
	GQLSchemaWithoutApolloExtras() string
}

type IntrospectionRequest struct {
	Query string `json:"query"`
}

type LabeledOffsetDuration struct {
	Label string `json:"label"`
	OffsetDuration
}

type Mutation interface {
	Field
	MutationType() MutationType
	MutatedType() Type
	QueryField() Field
	NumUidsField() Field
	HasLambdaOnMutate() bool
}

type MutationType string

type OffsetDuration struct {

	// Offset in nanoseconds, relative to the request start, as an integer
	StartOffset int64 `json:"startOffset"`

	// Duration in nanoseconds, relative to start of operation, as an integer.
	Duration int64 `json:"duration"`
}

type OffsetTimer interface {
	Start()
	Stop()
}

type Operation interface {
	Queries() []Query
	Mutations() []Mutation
	Schema() Schema
	IsQuery() bool
	IsMutation() bool
	IsSubscription() bool
	CacheControl() string
}

type PersistedQuery struct {
	Sha256Hash string
}

type Query interface {
	Field
	QueryType() QueryType
	DQLQuery() string
	Rename(newName string)
	// RepresentationsArg returns a parsed version of the `representations` argument for `_entities`
	// query
	RepresentationsArg() (*EntityRepresentations, error)
	AuthFor(jwtVars map[string]interface{}) Query
}

type QueryType string

type RBACQuery struct {
	Variable string
	Operator string
	Operand  interface{}
	// contains filtered or unexported fields
}

type Request struct {
	Query         string                 `json:"query"`
	OperationName string                 `json:"operationName"`
	Variables     map[string]interface{} `json:"variables"`
	Extensions    RequestExtensions
	Header        http.Header `json:"-"` // no need to marshal headers while generating poll hash
}

type RequestExtensions struct {
	PersistedQuery PersistedQuery
}

type ResolverTrace struct {

	// the response path of the current resolver - same format as path in error
	// result format specified in the GraphQL specification
	Path       []interface{} `json:"path"`
	ParentType string        `json:"parentType"`
	FieldName  string        `json:"fieldName"`
	ReturnType string        `json:"returnType"`

	// Offset relative to request start and total duration or resolving
	OffsetDuration

	// Dgraph isn't in Apollo tracing.  It records the offsets and times
	// of Dgraph operations for the query/mutation (including network latency)
	// in nanoseconds.
	Dgraph []*LabeledOffsetDuration `json:"dgraph"`
}

type Response struct {
	Errors     x.GqlErrorList
	Data       bytes.Buffer
	Extensions *Extensions
	Header     http.Header
	// contains filtered or unexported fields
}

type RuleNode struct {
	Or        []*RuleNode
	And       []*RuleNode
	Not       *RuleNode
	Rule      Query
	DQLRule   *dql.GraphQuery
	RBACRule  *RBACQuery
	Variables ast.VariableDefinitionList
}

type RuleResult int

type Schema interface {
	Operation(r *Request) (Operation, error)
	Queries(t QueryType) []string
	Mutations(t MutationType) []string
	IsFederated() bool
	SetMeta(meta *metaInfo)
	Meta() *metaInfo
}

type TimerFactory interface {
	NewOffsetTimer(storeTo *OffsetDuration) OffsetTimer
}

type Trace struct {

	// Apollo Tracing Spec version
	Version int `json:"version"`

	// Timestamps in RFC 3339 nano format.
	StartTime string `json:"startTime,"`
	EndTime   string `json:"endTime"`

	// Duration in nanoseconds, relative to the request start, as an integer.
	Duration int64 `json:"duration"`

	// Parsing and Validation not required at the moment.
	//Parsing    *OffsetDuration `json:"parsing,omitempty"`
	//Validation *OffsetDuration `json:"validation,omitempty"`
	Execution *ExecutionTrace `json:"execution,omitempty"`
}

type Type interface {
	Field(name string) FieldDefinition
	Fields() []FieldDefinition
	IDField() FieldDefinition
	XIDFields() []FieldDefinition
	InterfaceImplHasAuthRules() bool
	PasswordField() FieldDefinition
	Name() string
	DgraphName() string
	DgraphPredicate(fld string) string
	Nullable() bool
	// true if this is a union type
	IsUnion() bool
	IsInterface() bool
	// returns a list of member types for this union
	UnionMembers([]interface{}) []Type
	ListType() Type
	Interfaces() []string
	ImplementingTypes() []Type
	EnsureNonNulls(map[string]interface{}, string) error
	FieldOriginatedFrom(fieldName string) (Type, bool)
	AuthRules() *TypeAuth
	IsGeo() bool
	IsAggregateResult() bool
	IsInbuiltOrEnumType() bool
	fmt.Stringer
}

type TypeAuth struct {
	Rules  *AuthContainer
	Fields map[string]*AuthContainer
}