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
}
