aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/github.com/graphql-go/graphql/definition.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/graphql-go/graphql/definition.go')
-rw-r--r--vendor/github.com/graphql-go/graphql/definition.go1340
1 files changed, 0 insertions, 1340 deletions
diff --git a/vendor/github.com/graphql-go/graphql/definition.go b/vendor/github.com/graphql-go/graphql/definition.go
deleted file mode 100644
index dffea080..00000000
--- a/vendor/github.com/graphql-go/graphql/definition.go
+++ /dev/null
@@ -1,1340 +0,0 @@
-package graphql
-
-import (
- "context"
- "fmt"
- "reflect"
- "regexp"
-
- "github.com/graphql-go/graphql/language/ast"
-)
-
-// Type interface for all of the possible kinds of GraphQL types
-type Type interface {
- Name() string
- Description() string
- String() string
- Error() error
-}
-
-var _ Type = (*Scalar)(nil)
-var _ Type = (*Object)(nil)
-var _ Type = (*Interface)(nil)
-var _ Type = (*Union)(nil)
-var _ Type = (*Enum)(nil)
-var _ Type = (*InputObject)(nil)
-var _ Type = (*List)(nil)
-var _ Type = (*NonNull)(nil)
-var _ Type = (*Argument)(nil)
-
-// Input interface for types that may be used as input types for arguments and directives.
-type Input interface {
- Name() string
- Description() string
- String() string
- Error() error
-}
-
-var _ Input = (*Scalar)(nil)
-var _ Input = (*Enum)(nil)
-var _ Input = (*InputObject)(nil)
-var _ Input = (*List)(nil)
-var _ Input = (*NonNull)(nil)
-
-// IsInputType determines if given type is a GraphQLInputType
-func IsInputType(ttype Type) bool {
- named := GetNamed(ttype)
- if _, ok := named.(*Scalar); ok {
- return true
- }
- if _, ok := named.(*Enum); ok {
- return true
- }
- if _, ok := named.(*InputObject); ok {
- return true
- }
- return false
-}
-
-// IsOutputType determines if given type is a GraphQLOutputType
-func IsOutputType(ttype Type) bool {
- name := GetNamed(ttype)
- if _, ok := name.(*Scalar); ok {
- return true
- }
- if _, ok := name.(*Object); ok {
- return true
- }
- if _, ok := name.(*Interface); ok {
- return true
- }
- if _, ok := name.(*Union); ok {
- return true
- }
- if _, ok := name.(*Enum); ok {
- return true
- }
- return false
-}
-
-// Leaf interface for types that may be leaf values
-type Leaf interface {
- Name() string
- Description() string
- String() string
- Error() error
- Serialize(value interface{}) interface{}
-}
-
-var _ Leaf = (*Scalar)(nil)
-var _ Leaf = (*Enum)(nil)
-
-// IsLeafType determines if given type is a leaf value
-func IsLeafType(ttype Type) bool {
- named := GetNamed(ttype)
- if _, ok := named.(*Scalar); ok {
- return true
- }
- if _, ok := named.(*Enum); ok {
- return true
- }
- return false
-}
-
-// Output interface for types that may be used as output types as the result of fields.
-type Output interface {
- Name() string
- Description() string
- String() string
- Error() error
-}
-
-var _ Output = (*Scalar)(nil)
-var _ Output = (*Object)(nil)
-var _ Output = (*Interface)(nil)
-var _ Output = (*Union)(nil)
-var _ Output = (*Enum)(nil)
-var _ Output = (*List)(nil)
-var _ Output = (*NonNull)(nil)
-
-// Composite interface for types that may describe the parent context of a selection set.
-type Composite interface {
- Name() string
- Description() string
- String() string
- Error() error
-}
-
-var _ Composite = (*Object)(nil)
-var _ Composite = (*Interface)(nil)
-var _ Composite = (*Union)(nil)
-
-// IsCompositeType determines if given type is a GraphQLComposite type
-func IsCompositeType(ttype interface{}) bool {
- if _, ok := ttype.(*Object); ok {
- return true
- }
- if _, ok := ttype.(*Interface); ok {
- return true
- }
- if _, ok := ttype.(*Union); ok {
- return true
- }
- return false
-}
-
-// Abstract interface for types that may describe the parent context of a selection set.
-type Abstract interface {
- Name() string
-}
-
-var _ Abstract = (*Interface)(nil)
-var _ Abstract = (*Union)(nil)
-
-func IsAbstractType(ttype interface{}) bool {
- if _, ok := ttype.(*Interface); ok {
- return true
- }
- if _, ok := ttype.(*Union); ok {
- return true
- }
- return false
-}
-
-// Nullable interface for types that can accept null as a value.
-type Nullable interface {
-}
-
-var _ Nullable = (*Scalar)(nil)
-var _ Nullable = (*Object)(nil)
-var _ Nullable = (*Interface)(nil)
-var _ Nullable = (*Union)(nil)
-var _ Nullable = (*Enum)(nil)
-var _ Nullable = (*InputObject)(nil)
-var _ Nullable = (*List)(nil)
-
-// GetNullable returns the Nullable type of the given GraphQL type
-func GetNullable(ttype Type) Nullable {
- if ttype, ok := ttype.(*NonNull); ok {
- return ttype.OfType
- }
- return ttype
-}
-
-// Named interface for types that do not include modifiers like List or NonNull.
-type Named interface {
- String() string
-}
-
-var _ Named = (*Scalar)(nil)
-var _ Named = (*Object)(nil)
-var _ Named = (*Interface)(nil)
-var _ Named = (*Union)(nil)
-var _ Named = (*Enum)(nil)
-var _ Named = (*InputObject)(nil)
-
-// GetNamed returns the Named type of the given GraphQL type
-func GetNamed(ttype Type) Named {
- unmodifiedType := ttype
- for {
- if ttype, ok := unmodifiedType.(*List); ok {
- unmodifiedType = ttype.OfType
- continue
- }
- if ttype, ok := unmodifiedType.(*NonNull); ok {
- unmodifiedType = ttype.OfType
- continue
- }
- break
- }
- return unmodifiedType
-}
-
-// Scalar Type Definition
-//
-// The leaf values of any request and input values to arguments are
-// Scalars (or Enums) and are defined with a name and a series of functions
-// used to parse input from ast or variables and to ensure validity.
-//
-// Example:
-//
-// var OddType = new Scalar({
-// name: 'Odd',
-// serialize(value) {
-// return value % 2 === 1 ? value : null;
-// }
-// });
-//
-type Scalar struct {
- PrivateName string `json:"name"`
- PrivateDescription string `json:"description"`
-
- scalarConfig ScalarConfig
- err error
-}
-
-// SerializeFn is a function type for serializing a GraphQLScalar type value
-type SerializeFn func(value interface{}) interface{}
-
-// ParseValueFn is a function type for parsing the value of a GraphQLScalar type
-type ParseValueFn func(value interface{}) interface{}
-
-// ParseLiteralFn is a function type for parsing the literal value of a GraphQLScalar type
-type ParseLiteralFn func(valueAST ast.Value) interface{}
-
-// ScalarConfig options for creating a new GraphQLScalar
-type ScalarConfig struct {
- Name string `json:"name"`
- Description string `json:"description"`
- Serialize SerializeFn
- ParseValue ParseValueFn
- ParseLiteral ParseLiteralFn
-}
-
-// NewScalar creates a new GraphQLScalar
-func NewScalar(config ScalarConfig) *Scalar {
- st := &Scalar{}
- err := invariant(config.Name != "", "Type must be named.")
- if err != nil {
- st.err = err
- return st
- }
-
- err = assertValidName(config.Name)
- if err != nil {
- st.err = err
- return st
- }
-
- st.PrivateName = config.Name
- st.PrivateDescription = config.Description
-
- err = invariantf(
- config.Serialize != nil,
- `%v must provide "serialize" function. If this custom Scalar is `+
- `also used as an input type, ensure "parseValue" and "parseLiteral" `+
- `functions are also provided.`, st,
- )
- if err != nil {
- st.err = err
- return st
- }
- if config.ParseValue != nil || config.ParseLiteral != nil {
- err = invariantf(
- config.ParseValue != nil && config.ParseLiteral != nil,
- `%v must provide both "parseValue" and "parseLiteral" functions.`, st,
- )
- if err != nil {
- st.err = err
- return st
- }
- }
-
- st.scalarConfig = config
- return st
-}
-func (st *Scalar) Serialize(value interface{}) interface{} {
- if st.scalarConfig.Serialize == nil {
- return value
- }
- return st.scalarConfig.Serialize(value)
-}
-func (st *Scalar) ParseValue(value interface{}) interface{} {
- if st.scalarConfig.ParseValue == nil {
- return value
- }
- return st.scalarConfig.ParseValue(value)
-}
-func (st *Scalar) ParseLiteral(valueAST ast.Value) interface{} {
- if st.scalarConfig.ParseLiteral == nil {
- return nil
- }
- return st.scalarConfig.ParseLiteral(valueAST)
-}
-func (st *Scalar) Name() string {
- return st.PrivateName
-}
-func (st *Scalar) Description() string {
- return st.PrivateDescription
-
-}
-func (st *Scalar) String() string {
- return st.PrivateName
-}
-func (st *Scalar) Error() error {
- return st.err
-}
-
-// Object Type Definition
-//
-// Almost all of the GraphQL types you define will be object Object types
-// have a name, but most importantly describe their fields.
-// Example:
-//
-// var AddressType = new Object({
-// name: 'Address',
-// fields: {
-// street: { type: String },
-// number: { type: Int },
-// formatted: {
-// type: String,
-// resolve(obj) {
-// return obj.number + ' ' + obj.street
-// }
-// }
-// }
-// });
-//
-// When two types need to refer to each other, or a type needs to refer to
-// itself in a field, you can use a function expression (aka a closure or a
-// thunk) to supply the fields lazily.
-//
-// Example:
-//
-// var PersonType = new Object({
-// name: 'Person',
-// fields: () => ({
-// name: { type: String },
-// bestFriend: { type: PersonType },
-// })
-// });
-//
-// /
-type Object struct {
- PrivateName string `json:"name"`
- PrivateDescription string `json:"description"`
- IsTypeOf IsTypeOfFn
-
- typeConfig ObjectConfig
- initialisedFields bool
- fields FieldDefinitionMap
- initialisedInterfaces bool
- interfaces []*Interface
- // Interim alternative to throwing an error during schema definition at run-time
- err error
-}
-
-// IsTypeOfParams Params for IsTypeOfFn()
-type IsTypeOfParams struct {
- // Value that needs to be resolve.
- // Use this to decide which GraphQLObject this value maps to.
- Value interface{}
-
- // Info is a collection of information about the current execution state.
- Info ResolveInfo
-
- // Context argument is a context value that is provided to every resolve function within an execution.
- // It is commonly
- // used to represent an authenticated user, or request-specific caches.
- Context context.Context
-}
-
-type IsTypeOfFn func(p IsTypeOfParams) bool
-
-type InterfacesThunk func() []*Interface
-
-type ObjectConfig struct {
- Name string `json:"name"`
- Interfaces interface{} `json:"interfaces"`
- Fields interface{} `json:"fields"`
- IsTypeOf IsTypeOfFn `json:"isTypeOf"`
- Description string `json:"description"`
-}
-
-type FieldsThunk func() Fields
-
-func NewObject(config ObjectConfig) *Object {
- objectType := &Object{}
-
- err := invariant(config.Name != "", "Type must be named.")
- if err != nil {
- objectType.err = err
- return objectType
- }
- err = assertValidName(config.Name)
- if err != nil {
- objectType.err = err
- return objectType
- }
-
- objectType.PrivateName = config.Name
- objectType.PrivateDescription = config.Description
- objectType.IsTypeOf = config.IsTypeOf
- objectType.typeConfig = config
-
- return objectType
-}
-func (gt *Object) AddFieldConfig(fieldName string, fieldConfig *Field) {
- if fieldName == "" || fieldConfig == nil {
- return
- }
- switch gt.typeConfig.Fields.(type) {
- case Fields:
- gt.typeConfig.Fields.(Fields)[fieldName] = fieldConfig
- gt.initialisedFields = false
- }
-}
-func (gt *Object) Name() string {
- return gt.PrivateName
-}
-func (gt *Object) Description() string {
- return ""
-}
-func (gt *Object) String() string {
- return gt.PrivateName
-}
-func (gt *Object) Fields() FieldDefinitionMap {
- if gt.initialisedFields {
- return gt.fields
- }
-
- var configureFields Fields
- switch gt.typeConfig.Fields.(type) {
- case Fields:
- configureFields = gt.typeConfig.Fields.(Fields)
- case FieldsThunk:
- configureFields = gt.typeConfig.Fields.(FieldsThunk)()
- }
-
- fields, err := defineFieldMap(gt, configureFields)
- gt.err = err
- gt.fields = fields
- gt.initialisedFields = true
- return gt.fields
-}
-
-func (gt *Object) Interfaces() []*Interface {
- if gt.initialisedInterfaces {
- return gt.interfaces
- }
-
- var configInterfaces []*Interface
- switch gt.typeConfig.Interfaces.(type) {
- case InterfacesThunk:
- configInterfaces = gt.typeConfig.Interfaces.(InterfacesThunk)()
- case []*Interface:
- configInterfaces = gt.typeConfig.Interfaces.([]*Interface)
- case nil:
- default:
- gt.err = fmt.Errorf("Unknown Object.Interfaces type: %T", gt.typeConfig.Interfaces)
- gt.initialisedInterfaces = true
- return nil
- }
-
- interfaces, err := defineInterfaces(gt, configInterfaces)
- gt.err = err
- gt.interfaces = interfaces
- gt.initialisedInterfaces = true
- return gt.interfaces
-}
-
-func (gt *Object) Error() error {
- return gt.err
-}
-
-func defineInterfaces(ttype *Object, interfaces []*Interface) ([]*Interface, error) {
- ifaces := []*Interface{}
-
- if len(interfaces) == 0 {
- return ifaces, nil
- }
- for _, iface := range interfaces {
- err := invariantf(
- iface != nil,
- `%v may only implement Interface types, it cannot implement: %v.`, ttype, iface,
- )
- if err != nil {
- return ifaces, err
- }
- if iface.ResolveType != nil {
- err = invariantf(
- iface.ResolveType != nil,
- `Interface Type %v does not provide a "resolveType" function `+
- `and implementing Type %v does not provide a "isTypeOf" `+
- `function. There is no way to resolve this implementing type `+
- `during execution.`, iface, ttype,
- )
- if err != nil {
- return ifaces, err
- }
- }
- ifaces = append(ifaces, iface)
- }
-
- return ifaces, nil
-}
-
-func defineFieldMap(ttype Named, fieldMap Fields) (FieldDefinitionMap, error) {
- resultFieldMap := FieldDefinitionMap{}
-
- err := invariantf(
- len(fieldMap) > 0,
- `%v fields must be an object with field names as keys or a function which return such an object.`, ttype,
- )
- if err != nil {
- return resultFieldMap, err
- }
-
- for fieldName, field := range fieldMap {
- if field == nil {
- continue
- }
- err = invariantf(
- field.Type != nil,
- `%v.%v field type must be Output Type but got: %v.`, ttype, fieldName, field.Type,
- )
- if err != nil {
- return resultFieldMap, err
- }
- if field.Type.Error() != nil {
- return resultFieldMap, field.Type.Error()
- }
- err = assertValidName(fieldName)
- if err != nil {
- return resultFieldMap, err
- }
- fieldDef := &FieldDefinition{
- Name: fieldName,
- Description: field.Description,
- Type: field.Type,
- Resolve: field.Resolve,
- DeprecationReason: field.DeprecationReason,
- }
-
- fieldDef.Args = []*Argument{}
- for argName, arg := range field.Args {
- err := assertValidName(argName)
- if err != nil {
- return resultFieldMap, err
- }
- err = invariantf(
- arg != nil,
- `%v.%v args must be an object with argument names as keys.`, ttype, fieldName,
- )
- if err != nil {
- return resultFieldMap, err
- }
- err = invariantf(
- arg.Type != nil,
- `%v.%v(%v:) argument type must be Input Type but got: %v.`, ttype, fieldName, argName, arg.Type,
- )
- if err != nil {
- return resultFieldMap, err
- }
- fieldArg := &Argument{
- PrivateName: argName,
- PrivateDescription: arg.Description,
- Type: arg.Type,
- DefaultValue: arg.DefaultValue,
- }
- fieldDef.Args = append(fieldDef.Args, fieldArg)
- }
- resultFieldMap[fieldName] = fieldDef
- }
- return resultFieldMap, nil
-}
-
-// ResolveParams Params for FieldResolveFn()
-type ResolveParams struct {
- // Source is the source value
- Source interface{}
-
- // Args is a map of arguments for current GraphQL request
- Args map[string]interface{}
-
- // Info is a collection of information about the current execution state.
- Info ResolveInfo
-
- // Context argument is a context value that is provided to every resolve function within an execution.
- // It is commonly
- // used to represent an authenticated user, or request-specific caches.
- Context context.Context
-}
-
-type FieldResolveFn func(p ResolveParams) (interface{}, error)
-
-type ResolveInfo struct {
- FieldName string
- FieldASTs []*ast.Field
- ReturnType Output
- ParentType Composite
- Schema Schema
- Fragments map[string]ast.Definition
- RootValue interface{}
- Operation ast.Definition
- VariableValues map[string]interface{}
-}
-
-type Fields map[string]*Field
-
-type Field struct {
- Name string `json:"name"` // used by graphlql-relay
- Type Output `json:"type"`
- Args FieldConfigArgument `json:"args"`
- Resolve FieldResolveFn `json:"-"`
- DeprecationReason string `json:"deprecationReason"`
- Description string `json:"description"`
-}
-
-type FieldConfigArgument map[string]*ArgumentConfig
-
-type ArgumentConfig struct {
- Type Input `json:"type"`
- DefaultValue interface{} `json:"defaultValue"`
- Description string `json:"description"`
-}
-
-type FieldDefinitionMap map[string]*FieldDefinition
-type FieldDefinition struct {
- Name string `json:"name"`
- Description string `json:"description"`
- Type Output `json:"type"`
- Args []*Argument `json:"args"`
- Resolve FieldResolveFn `json:"-"`
- DeprecationReason string `json:"deprecationReason"`
-}
-
-type FieldArgument struct {
- Name string `json:"name"`
- Type Type `json:"type"`
- DefaultValue interface{} `json:"defaultValue"`
- Description string `json:"description"`
-}
-
-type Argument struct {
- PrivateName string `json:"name"`
- Type Input `json:"type"`
- DefaultValue interface{} `json:"defaultValue"`
- PrivateDescription string `json:"description"`
-}
-
-func (st *Argument) Name() string {
- return st.PrivateName
-}
-func (st *Argument) Description() string {
- return st.PrivateDescription
-
-}
-func (st *Argument) String() string {
- return st.PrivateName
-}
-func (st *Argument) Error() error {
- return nil
-}
-
-// Interface Type Definition
-//
-// When a field can return one of a heterogeneous set of types, a Interface type
-// is used to describe what types are possible, what fields are in common across
-// all types, as well as a function to determine which type is actually used
-// when the field is resolved.
-//
-// Example:
-//
-// var EntityType = new Interface({
-// name: 'Entity',
-// fields: {
-// name: { type: String }
-// }
-// });
-//
-//
-type Interface struct {
- PrivateName string `json:"name"`
- PrivateDescription string `json:"description"`
- ResolveType ResolveTypeFn
-
- typeConfig InterfaceConfig
- initialisedFields bool
- fields FieldDefinitionMap
- err error
-}
-type InterfaceConfig struct {
- Name string `json:"name"`
- Fields interface{} `json:"fields"`
- ResolveType ResolveTypeFn
- Description string `json:"description"`
-}
-
-// ResolveTypeParams Params for ResolveTypeFn()
-type ResolveTypeParams struct {
- // Value that needs to be resolve.
- // Use this to decide which GraphQLObject this value maps to.
- Value interface{}
-
- // Info is a collection of information about the current execution state.
- Info ResolveInfo
-
- // Context argument is a context value that is provided to every resolve function within an execution.
- // It is commonly
- // used to represent an authenticated user, or request-specific caches.
- Context context.Context
-}
-
-type ResolveTypeFn func(p ResolveTypeParams) *Object
-
-func NewInterface(config InterfaceConfig) *Interface {
- it := &Interface{}
-
- err := invariant(config.Name != "", "Type must be named.")
- if err != nil {
- it.err = err
- return it
- }
- err = assertValidName(config.Name)
- if err != nil {
- it.err = err
- return it
- }
- it.PrivateName = config.Name
- it.PrivateDescription = config.Description
- it.ResolveType = config.ResolveType
- it.typeConfig = config
-
- return it
-}
-
-func (it *Interface) AddFieldConfig(fieldName string, fieldConfig *Field) {
- if fieldName == "" || fieldConfig == nil {
- return
- }
- switch it.typeConfig.Fields.(type) {
- case Fields:
- it.typeConfig.Fields.(Fields)[fieldName] = fieldConfig
- it.initialisedFields = false
- }
-}
-
-func (it *Interface) Name() string {
- return it.PrivateName
-}
-
-func (it *Interface) Description() string {
- return it.PrivateDescription
-}
-
-func (it *Interface) Fields() (fields FieldDefinitionMap) {
- if it.initialisedFields {
- return it.fields
- }
-
- var configureFields Fields
- switch it.typeConfig.Fields.(type) {
- case Fields:
- configureFields = it.typeConfig.Fields.(Fields)
- case FieldsThunk:
- configureFields = it.typeConfig.Fields.(FieldsThunk)()
- }
-
- fields, err := defineFieldMap(it, configureFields)
- it.err = err
- it.fields = fields
- it.initialisedFields = true
- return it.fields
-}
-
-func (it *Interface) String() string {
- return it.PrivateName
-}
-
-func (it *Interface) Error() error {
- return it.err
-}
-
-// Union Type Definition
-//
-// When a field can return one of a heterogeneous set of types, a Union type
-// is used to describe what types are possible as well as providing a function
-// to determine which type is actually used when the field is resolved.
-//
-// Example:
-//
-// var PetType = new Union({
-// name: 'Pet',
-// types: [ DogType, CatType ],
-// resolveType(value) {
-// if (value instanceof Dog) {
-// return DogType;
-// }
-// if (value instanceof Cat) {
-// return CatType;
-// }
-// }
-// });
-type Union struct {
- PrivateName string `json:"name"`
- PrivateDescription string `json:"description"`
- ResolveType ResolveTypeFn
-
- typeConfig UnionConfig
- types []*Object
- possibleTypes map[string]bool
-
- err error
-}
-type UnionConfig struct {
- Name string `json:"name"`
- Types []*Object `json:"types"`
- ResolveType ResolveTypeFn
- Description string `json:"description"`
-}
-
-func NewUnion(config UnionConfig) *Union {
- objectType := &Union{}
-
- err := invariant(config.Name != "", "Type must be named.")
- if err != nil {
- objectType.err = err
- return objectType
- }
- err = assertValidName(config.Name)
- if err != nil {
- objectType.err = err
- return objectType
- }
- objectType.PrivateName = config.Name
- objectType.PrivateDescription = config.Description
- objectType.ResolveType = config.ResolveType
-
- err = invariantf(
- len(config.Types) > 0,
- `Must provide Array of types for Union %v.`, config.Name,
- )
- if err != nil {
- objectType.err = err
- return objectType
- }
- for _, ttype := range config.Types {
- err := invariantf(
- ttype != nil,
- `%v may only contain Object types, it cannot contain: %v.`, objectType, ttype,
- )
- if err != nil {
- objectType.err = err
- return objectType
- }
- if objectType.ResolveType == nil {
- err = invariantf(
- ttype.IsTypeOf != nil,
- `Union Type %v does not provide a "resolveType" function `+
- `and possible Type %v does not provide a "isTypeOf" `+
- `function. There is no way to resolve this possible type `+
- `during execution.`, objectType, ttype,
- )
- if err != nil {
- objectType.err = err
- return objectType
- }
- }
- }
- objectType.types = config.Types
- objectType.typeConfig = config
-
- return objectType
-}
-func (ut *Union) Types() []*Object {
- return ut.types
-}
-func (ut *Union) String() string {
- return ut.PrivateName
-}
-func (ut *Union) Name() string {
- return ut.PrivateName
-}
-func (ut *Union) Description() string {
- return ut.PrivateDescription
-}
-func (ut *Union) Error() error {
- return ut.err
-}
-
-// Enum Type Definition
-//
-// Some leaf values of requests and input values are Enums. GraphQL serializes
-// Enum values as strings, however internally Enums can be represented by any
-// kind of type, often integers.
-//
-// Example:
-//
-// var RGBType = new Enum({
-// name: 'RGB',
-// values: {
-// RED: { value: 0 },
-// GREEN: { value: 1 },
-// BLUE: { value: 2 }
-// }
-// });
-//
-// Note: If a value is not provided in a definition, the name of the enum value
-// will be used as its internal value.
-
-type Enum struct {
- PrivateName string `json:"name"`
- PrivateDescription string `json:"description"`
-
- enumConfig EnumConfig
- values []*EnumValueDefinition
- valuesLookup map[interface{}]*EnumValueDefinition
- nameLookup map[string]*EnumValueDefinition
-
- err error
-}
-type EnumValueConfigMap map[string]*EnumValueConfig
-type EnumValueConfig struct {
- Value interface{} `json:"value"`
- DeprecationReason string `json:"deprecationReason"`
- Description string `json:"description"`
-}
-type EnumConfig struct {
- Name string `json:"name"`
- Values EnumValueConfigMap `json:"values"`
- Description string `json:"description"`
-}
-type EnumValueDefinition struct {
- Name string `json:"name"`
- Value interface{} `json:"value"`
- DeprecationReason string `json:"deprecationReason"`
- Description string `json:"description"`
-}
-
-func NewEnum(config EnumConfig) *Enum {
- gt := &Enum{}
- gt.enumConfig = config
-
- err := assertValidName(config.Name)
- if err != nil {
- gt.err = err
- return gt
- }
-
- gt.PrivateName = config.Name
- gt.PrivateDescription = config.Description
- gt.values, err = gt.defineEnumValues(config.Values)
- if err != nil {
- gt.err = err
- return gt
- }
-
- return gt
-}
-func (gt *Enum) defineEnumValues(valueMap EnumValueConfigMap) ([]*EnumValueDefinition, error) {
- values := []*EnumValueDefinition{}
-
- err := invariantf(
- len(valueMap) > 0,
- `%v values must be an object with value names as keys.`, gt,
- )
- if err != nil {
- return values, err
- }
-
- for valueName, valueConfig := range valueMap {
- err := invariantf(
- valueConfig != nil,
- `%v.%v must refer to an object with a "value" key `+
- `representing an internal value but got: %v.`, gt, valueName, valueConfig,
- )
- if err != nil {
- return values, err
- }
- err = assertValidName(valueName)
- if err != nil {
- return values, err
- }
- value := &EnumValueDefinition{
- Name: valueName,
- Value: valueConfig.Value,
- DeprecationReason: valueConfig.DeprecationReason,
- Description: valueConfig.Description,
- }
- if value.Value == nil {
- value.Value = valueName
- }
- values = append(values, value)
- }
- return values, nil
-}
-func (gt *Enum) Values() []*EnumValueDefinition {
- return gt.values
-}
-func (gt *Enum) Serialize(value interface{}) interface{} {
- v := value
- if reflect.ValueOf(v).Kind() == reflect.Ptr {
- v = reflect.Indirect(reflect.ValueOf(v)).Interface()
- }
- if enumValue, ok := gt.getValueLookup()[v]; ok {
- return enumValue.Name
- }
- return nil
-}
-func (gt *Enum) ParseValue(value interface{}) interface{} {
- var v string
-
- switch value := value.(type) {
- case string:
- v = value
- case *string:
- v = *value
- default:
- return nil
- }
- if enumValue, ok := gt.getNameLookup()[v]; ok {
- return enumValue.Value
- }
- return nil
-}
-func (gt *Enum) ParseLiteral(valueAST ast.Value) interface{} {
- if valueAST, ok := valueAST.(*ast.EnumValue); ok {
- if enumValue, ok := gt.getNameLookup()[valueAST.Value]; ok {
- return enumValue.Value
- }
- }
- return nil
-}
-func (gt *Enum) Name() string {
- return gt.PrivateName
-}
-func (gt *Enum) Description() string {
- return gt.PrivateDescription
-}
-func (gt *Enum) String() string {
- return gt.PrivateName
-}
-func (gt *Enum) Error() error {
- return gt.err
-}
-func (gt *Enum) getValueLookup() map[interface{}]*EnumValueDefinition {
- if len(gt.valuesLookup) > 0 {
- return gt.valuesLookup
- }
- valuesLookup := map[interface{}]*EnumValueDefinition{}
- for _, value := range gt.Values() {
- valuesLookup[value.Value] = value
- }
- gt.valuesLookup = valuesLookup
- return gt.valuesLookup
-}
-
-func (gt *Enum) getNameLookup() map[string]*EnumValueDefinition {
- if len(gt.nameLookup) > 0 {
- return gt.nameLookup
- }
- nameLookup := map[string]*EnumValueDefinition{}
- for _, value := range gt.Values() {
- nameLookup[value.Name] = value
- }
- gt.nameLookup = nameLookup
- return gt.nameLookup
-}
-
-// InputObject Type Definition
-//
-// An input object defines a structured collection of fields which may be
-// supplied to a field argument.
-//
-// Using `NonNull` will ensure that a value must be provided by the query
-//
-// Example:
-//
-// var GeoPoint = new InputObject({
-// name: 'GeoPoint',
-// fields: {
-// lat: { type: new NonNull(Float) },
-// lon: { type: new NonNull(Float) },
-// alt: { type: Float, defaultValue: 0 },
-// }
-// });
-type InputObject struct {
- PrivateName string `json:"name"`
- PrivateDescription string `json:"description"`
-
- typeConfig InputObjectConfig
- fields InputObjectFieldMap
- init bool
- err error
-}
-type InputObjectFieldConfig struct {
- Type Input `json:"type"`
- DefaultValue interface{} `json:"defaultValue"`
- Description string `json:"description"`
-}
-type InputObjectField struct {
- PrivateName string `json:"name"`
- Type Input `json:"type"`
- DefaultValue interface{} `json:"defaultValue"`
- PrivateDescription string `json:"description"`
-}
-
-func (st *InputObjectField) Name() string {
- return st.PrivateName
-}
-func (st *InputObjectField) Description() string {
- return st.PrivateDescription
-
-}
-func (st *InputObjectField) String() string {
- return st.PrivateName
-}
-func (st *InputObjectField) Error() error {
- return nil
-}
-
-type InputObjectConfigFieldMap map[string]*InputObjectFieldConfig
-type InputObjectFieldMap map[string]*InputObjectField
-type InputObjectConfigFieldMapThunk func() InputObjectConfigFieldMap
-type InputObjectConfig struct {
- Name string `json:"name"`
- Fields interface{} `json:"fields"`
- Description string `json:"description"`
-}
-
-func NewInputObject(config InputObjectConfig) *InputObject {
- gt := &InputObject{}
- err := invariant(config.Name != "", "Type must be named.")
- if err != nil {
- gt.err = err
- return gt
- }
-
- gt.PrivateName = config.Name
- gt.PrivateDescription = config.Description
- gt.typeConfig = config
- //gt.fields = gt.defineFieldMap()
- return gt
-}
-
-func (gt *InputObject) defineFieldMap() InputObjectFieldMap {
- var fieldMap InputObjectConfigFieldMap
- switch gt.typeConfig.Fields.(type) {
- case InputObjectConfigFieldMap:
- fieldMap = gt.typeConfig.Fields.(InputObjectConfigFieldMap)
- case InputObjectConfigFieldMapThunk:
- fieldMap = gt.typeConfig.Fields.(InputObjectConfigFieldMapThunk)()
- }
- resultFieldMap := InputObjectFieldMap{}
-
- err := invariantf(
- len(fieldMap) > 0,
- `%v fields must be an object with field names as keys or a function which return such an object.`, gt,
- )
- if err != nil {
- gt.err = err
- return resultFieldMap
- }
-
- for fieldName, fieldConfig := range fieldMap {
- if fieldConfig == nil {
- continue
- }
- err := assertValidName(fieldName)
- if err != nil {
- continue
- }
- err = invariantf(
- fieldConfig.Type != nil,
- `%v.%v field type must be Input Type but got: %v.`, gt, fieldName, fieldConfig.Type,
- )
- if err != nil {
- gt.err = err
- return resultFieldMap
- }
- field := &InputObjectField{}
- field.PrivateName = fieldName
- field.Type = fieldConfig.Type
- field.PrivateDescription = fieldConfig.Description
- field.DefaultValue = fieldConfig.DefaultValue
- resultFieldMap[fieldName] = field
- }
- gt.init = true
- return resultFieldMap
-}
-
-func (gt *InputObject) Fields() InputObjectFieldMap {
- if !gt.init {
- gt.fields = gt.defineFieldMap()
- }
- return gt.fields
-}
-func (gt *InputObject) Name() string {
- return gt.PrivateName
-}
-func (gt *InputObject) Description() string {
- return gt.PrivateDescription
-}
-func (gt *InputObject) String() string {
- return gt.PrivateName
-}
-func (gt *InputObject) Error() error {
- return gt.err
-}
-
-// List Modifier
-//
-// A list is a kind of type marker, a wrapping type which points to another
-// type. Lists are often created within the context of defining the fields of
-// an object type.
-//
-// Example:
-//
-// var PersonType = new Object({
-// name: 'Person',
-// fields: () => ({
-// parents: { type: new List(Person) },
-// children: { type: new List(Person) },
-// })
-// })
-//
-type List struct {
- OfType Type `json:"ofType"`
-
- err error
-}
-
-func NewList(ofType Type) *List {
- gl := &List{}
-
- err := invariantf(ofType != nil, `Can only create List of a Type but got: %v.`, ofType)
- if err != nil {
- gl.err = err
- return gl
- }
-
- gl.OfType = ofType
- return gl
-}
-func (gl *List) Name() string {
- return fmt.Sprintf("%v", gl.OfType)
-}
-func (gl *List) Description() string {
- return ""
-}
-func (gl *List) String() string {
- if gl.OfType != nil {
- return fmt.Sprintf("[%v]", gl.OfType)
- }
- return ""
-}
-func (gl *List) Error() error {
- return gl.err
-}
-
-// NonNull Modifier
-//
-// A non-null is a kind of type marker, a wrapping type which points to another
-// type. Non-null types enforce that their values are never null and can ensure
-// an error is raised if this ever occurs during a request. It is useful for
-// fields which you can make a strong guarantee on non-nullability, for example
-// usually the id field of a database row will never be null.
-//
-// Example:
-//
-// var RowType = new Object({
-// name: 'Row',
-// fields: () => ({
-// id: { type: new NonNull(String) },
-// })
-// })
-//
-// Note: the enforcement of non-nullability occurs within the executor.
-type NonNull struct {
- OfType Type `json:"ofType"`
-
- err error
-}
-
-func NewNonNull(ofType Type) *NonNull {
- gl := &NonNull{}
-
- _, isOfTypeNonNull := ofType.(*NonNull)
- err := invariantf(ofType != nil && !isOfTypeNonNull, `Can only create NonNull of a Nullable Type but got: %v.`, ofType)
- if err != nil {
- gl.err = err
- return gl
- }
- gl.OfType = ofType
- return gl
-}
-func (gl *NonNull) Name() string {
- return fmt.Sprintf("%v!", gl.OfType)
-}
-func (gl *NonNull) Description() string {
- return ""
-}
-func (gl *NonNull) String() string {
- if gl.OfType != nil {
- return gl.Name()
- }
- return ""
-}
-func (gl *NonNull) Error() error {
- return gl.err
-}
-
-var NameRegExp, _ = regexp.Compile("^[_a-zA-Z][_a-zA-Z0-9]*$")
-
-func assertValidName(name string) error {
- return invariantf(
- NameRegExp.MatchString(name),
- `Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "%v" does not.`, name)
-
-}
generated by cgit (git 2.34.1) at 2024-09-20 13:25:30 +0000