relay connection working with gqlgen

1 files changed, 313 insertions, 0 deletions

diff --git a/vendor/github.com/vektah/gqlgen/neelance/introspection/introspection.go b/vendor/github.com/vektah/gqlgen/neelance/introspection/introspection.go
new file mode 100644
index 00000000..5e354c9a
--- /dev/null
+++ b/vendor/github.com/vektah/gqlgen/neelance/introspection/introspection.go
@@ -0,0 +1,313 @@
+package introspection
+
+import (
+	"sort"
+
+	"github.com/vektah/gqlgen/neelance/common"
+	"github.com/vektah/gqlgen/neelance/schema"
+)
+
+type Schema struct {
+	schema *schema.Schema
+}
+
+// WrapSchema is only used internally.
+func WrapSchema(schema *schema.Schema) *Schema {
+	return &Schema{schema}
+}
+
+func (r *Schema) Types() []Type {
+	var names []string
+	for name := range r.schema.Types {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	l := make([]Type, len(names))
+	for i, name := range names {
+		l[i] = Type{r.schema.Types[name]}
+	}
+	return l
+}
+
+func (r *Schema) Directives() []Directive {
+	var names []string
+	for name := range r.schema.Directives {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	l := make([]Directive, len(names))
+	for i, name := range names {
+		l[i] = Directive{r.schema.Directives[name]}
+	}
+	return l
+}
+
+func (r *Schema) QueryType() Type {
+	t, ok := r.schema.EntryPoints["query"]
+	if !ok {
+		return Type{}
+	}
+	return Type{t}
+}
+
+func (r *Schema) MutationType() *Type {
+	t, ok := r.schema.EntryPoints["mutation"]
+	if !ok {
+		return nil
+	}
+	return &Type{t}
+}
+
+func (r *Schema) SubscriptionType() *Type {
+	t, ok := r.schema.EntryPoints["subscription"]
+	if !ok {
+		return nil
+	}
+	return &Type{t}
+}
+
+type Type struct {
+	typ common.Type
+}
+
+// WrapType is only used internally.
+func WrapType(typ common.Type) *Type {
+	return &Type{typ}
+}
+
+func (r *Type) Kind() string {
+	return r.typ.Kind()
+}
+
+func (r *Type) Name() *string {
+	if named, ok := r.typ.(schema.NamedType); ok {
+		name := named.TypeName()
+		return &name
+	}
+	return nil
+}
+
+func (r *Type) Description() *string {
+	if named, ok := r.typ.(schema.NamedType); ok {
+		desc := named.Description()
+		if desc == "" {
+			return nil
+		}
+		return &desc
+	}
+	return nil
+}
+
+func (r *Type) Fields(includeDeprecated bool) []Field {
+	var fields schema.FieldList
+	switch t := r.typ.(type) {
+	case *schema.Object:
+		fields = t.Fields
+	case *schema.Interface:
+		fields = t.Fields
+	default:
+		return nil
+	}
+
+	var l []Field
+	for _, f := range fields {
+		if d := f.Directives.Get("deprecated"); d == nil || includeDeprecated {
+			l = append(l, Field{f})
+		}
+	}
+	return l
+}
+
+func (r *Type) Interfaces() []Type {
+	t, ok := r.typ.(*schema.Object)
+	if !ok {
+		return nil
+	}
+
+	l := make([]Type, len(t.Interfaces))
+	for i, intf := range t.Interfaces {
+		l[i] = Type{intf}
+	}
+	return l
+}
+
+func (r *Type) PossibleTypes() []Type {
+	var possibleTypes []*schema.Object
+	switch t := r.typ.(type) {
+	case *schema.Interface:
+		possibleTypes = t.PossibleTypes
+	case *schema.Union:
+		possibleTypes = t.PossibleTypes
+	default:
+		return nil
+	}
+
+	l := make([]Type, len(possibleTypes))
+	for i, intf := range possibleTypes {
+		l[i] = Type{intf}
+	}
+	return l
+}
+
+func (r *Type) EnumValues(includeDeprecated bool) []EnumValue {
+	t, ok := r.typ.(*schema.Enum)
+	if !ok {
+		return nil
+	}
+
+	var l []EnumValue
+	for _, v := range t.Values {
+		if d := v.Directives.Get("deprecated"); d == nil || includeDeprecated {
+			l = append(l, EnumValue{v})
+		}
+	}
+	return l
+}
+
+func (r *Type) InputFields() []InputValue {
+	t, ok := r.typ.(*schema.InputObject)
+	if !ok {
+		return nil
+	}
+
+	l := make([]InputValue, len(t.Values))
+	for i, v := range t.Values {
+		l[i] = InputValue{v}
+	}
+	return l
+}
+
+func (r *Type) OfType() *Type {
+	switch t := r.typ.(type) {
+	case *common.List:
+		return &Type{t.OfType}
+	case *common.NonNull:
+		return &Type{t.OfType}
+	default:
+		return nil
+	}
+}
+
+type Field struct {
+	field *schema.Field
+}
+
+func (r *Field) Name() string {
+	return r.field.Name
+}
+
+func (r *Field) Description() *string {
+	if r.field.Desc == "" {
+		return nil
+	}
+	return &r.field.Desc
+}
+
+func (r *Field) Args() []InputValue {
+	l := make([]InputValue, len(r.field.Args))
+	for i, v := range r.field.Args {
+		l[i] = InputValue{v}
+	}
+	return l
+}
+
+func (r *Field) Type() Type {
+	return Type{r.field.Type}
+}
+
+func (r *Field) IsDeprecated() bool {
+	return r.field.Directives.Get("deprecated") != nil
+}
+
+func (r *Field) DeprecationReason() *string {
+	d := r.field.Directives.Get("deprecated")
+	if d == nil {
+		return nil
+	}
+	reason := d.Args.MustGet("reason").Value(nil).(string)
+	return &reason
+}
+
+type InputValue struct {
+	value *common.InputValue
+}
+
+func (r *InputValue) Name() string {
+	return r.value.Name.Name
+}
+
+func (r *InputValue) Description() *string {
+	if r.value.Desc == "" {
+		return nil
+	}
+	return &r.value.Desc
+}
+
+func (r *InputValue) Type() Type {
+	return Type{r.value.Type}
+}
+
+func (r *InputValue) DefaultValue() *string {
+	if r.value.Default == nil {
+		return nil
+	}
+	s := r.value.Default.String()
+	return &s
+}
+
+type EnumValue struct {
+	value *schema.EnumValue
+}
+
+func (r *EnumValue) Name() string {
+	return r.value.Name
+}
+
+func (r *EnumValue) Description() *string {
+	if r.value.Desc == "" {
+		return nil
+	}
+	return &r.value.Desc
+}
+
+func (r *EnumValue) IsDeprecated() bool {
+	return r.value.Directives.Get("deprecated") != nil
+}
+
+func (r *EnumValue) DeprecationReason() *string {
+	d := r.value.Directives.Get("deprecated")
+	if d == nil {
+		return nil
+	}
+	reason := d.Args.MustGet("reason").Value(nil).(string)
+	return &reason
+}
+
+type Directive struct {
+	directive *schema.DirectiveDecl
+}
+
+func (r *Directive) Name() string {
+	return r.directive.Name
+}
+
+func (r *Directive) Description() *string {
+	if r.directive.Desc == "" {
+		return nil
+	}
+	return &r.directive.Desc
+}
+
+func (r *Directive) Locations() []string {
+	return r.directive.Locs
+}
+
+func (r *Directive) Args() []InputValue {
+	l := make([]InputValue, len(r.directive.Args))
+	for i, v := range r.directive.Args {
+		l[i] = InputValue{v}
+	}
+	return l
+}