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 }