mirror of
https://github.com/stashapp/stash.git
synced 2025-12-18 12:54:38 +03:00
45f700d6ea
* Upgrade gqlgen to v0.17.2 This enables builds on Go 1.18. github.com/vektah/gqlparser is upgraded to the newest version too. Getting this to work is a bit of a hazzle. I had to first remove vendoring from the repository, perform the upgrade and then re-introduce the vendor directory. I think gqlgens analysis went wrong for some reason on the upgrade. It would seem a clean-room installation fixed it. * Bump project to 1.18 * Update all packages, address gqlgenc breaking changes * Let `go mod tidy` handle the go.mod file * Upgrade linter to 1.45.2 * Introduce v1.45.2 of the linter The linter now correctly warns on `strings.Title` because it isn't unicode-aware. Fix this by using the suggested fix from x/text/cases to produce unicode-aware strings. The mapping isn't entirely 1-1 as this new approach has a larger iface: it spans all of unicode rather than just ASCII. It coincides for ASCII however, so things should be largely the same. * Ready ourselves for errchkjson and contextcheck. * Revert dockerfile golang version changes for now Co-authored-by: Kermie <kermie@isinthe.house> Co-authored-by: WithoutPants <53250216+WithoutPants@users.noreply.github.com>
94 lines
2.0 KiB
Go
94 lines
2.0 KiB
Go
package introspection
|
|
|
|
import (
|
|
"sort"
|
|
"strings"
|
|
|
|
"github.com/vektah/gqlparser/v2/ast"
|
|
)
|
|
|
|
type Schema struct {
|
|
schema *ast.Schema
|
|
}
|
|
|
|
func (s *Schema) Description() *string {
|
|
if s.schema.Description == "" {
|
|
return nil
|
|
}
|
|
return &s.schema.Description
|
|
}
|
|
|
|
func (s *Schema) Types() []Type {
|
|
typeIndex := map[string]Type{}
|
|
typeNames := make([]string, 0, len(s.schema.Types))
|
|
for _, typ := range s.schema.Types {
|
|
if strings.HasPrefix(typ.Name, "__") {
|
|
continue
|
|
}
|
|
typeNames = append(typeNames, typ.Name)
|
|
typeIndex[typ.Name] = *WrapTypeFromDef(s.schema, typ)
|
|
}
|
|
sort.Strings(typeNames)
|
|
|
|
types := make([]Type, len(typeNames))
|
|
for i, t := range typeNames {
|
|
types[i] = typeIndex[t]
|
|
}
|
|
return types
|
|
}
|
|
|
|
func (s *Schema) QueryType() *Type {
|
|
return WrapTypeFromDef(s.schema, s.schema.Query)
|
|
}
|
|
|
|
func (s *Schema) MutationType() *Type {
|
|
return WrapTypeFromDef(s.schema, s.schema.Mutation)
|
|
}
|
|
|
|
func (s *Schema) SubscriptionType() *Type {
|
|
return WrapTypeFromDef(s.schema, s.schema.Subscription)
|
|
}
|
|
|
|
func (s *Schema) Directives() []Directive {
|
|
dIndex := map[string]Directive{}
|
|
dNames := make([]string, 0, len(s.schema.Directives))
|
|
|
|
for _, d := range s.schema.Directives {
|
|
dNames = append(dNames, d.Name)
|
|
dIndex[d.Name] = s.directiveFromDef(d)
|
|
}
|
|
sort.Strings(dNames)
|
|
|
|
res := make([]Directive, len(dNames))
|
|
for i, d := range dNames {
|
|
res[i] = dIndex[d]
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
func (s *Schema) directiveFromDef(d *ast.DirectiveDefinition) Directive {
|
|
locs := make([]string, len(d.Locations))
|
|
for i, loc := range d.Locations {
|
|
locs[i] = string(loc)
|
|
}
|
|
|
|
args := make([]InputValue, len(d.Arguments))
|
|
for i, arg := range d.Arguments {
|
|
args[i] = InputValue{
|
|
Name: arg.Name,
|
|
description: arg.Description,
|
|
DefaultValue: defaultValue(arg.DefaultValue),
|
|
Type: WrapTypeFromType(s.schema, arg.Type),
|
|
}
|
|
}
|
|
|
|
return Directive{
|
|
Name: d.Name,
|
|
description: d.Description,
|
|
Locations: locs,
|
|
Args: args,
|
|
IsRepeatable: d.IsRepeatable,
|
|
}
|
|
}
|