graphql

var (
	// ErrCoroutineStopped is returned from PauseCoroutine when a coroutine is stopped. The caller
	// should propagate the error up as quickly as possible.
	ErrCoroutineStopped = errors.New("graphql: coroutine stopped")
	// ErrNoCoroutine is returned from PauseCoroutine when there's no coroutine in the context.
	ErrNoCoroutine = errors.New("graphql: no coroutine")
)

var Boolean = NewScalar(ScalarConfig{
	Name:        "Boolean",
	Description: "The `Boolean` scalar type represents `true` or `false`.",
	Serialize:   coerceBool,
	ParseValue:  coerceBool,
	ParseLiteral: func(valueAST ast.Value) any {
		switch valueAST := valueAST.(type) {
		case *ast.BooleanValue:
			return valueAST.Value
		}
		return nil
	},
})

var DeprecatedDirective = NewDirective(DirectiveConfig{
	Name:        "deprecated",
	Description: "Marks an element of a GraphQL schema as no longer supported.",
	Args: FieldConfigArgument{
		"reason": &ArgumentConfig{
			Type: String,
			Description: "Explains why this element was deprecated, usually also including a " +
				"suggestion for how to access supported similar data. Formatted" +
				"in [Markdown](https://daringfireball.net/projects/markdown/).",
			DefaultValue: DefaultDeprecationReason,
		},
	},
	Locations: []string{
		DirectiveLocationFieldDefinition,
		DirectiveLocationEnumValue,
	},
})

var DirectiveLocationEnumType = NewEnum(EnumConfig{
	Name: "__DirectiveLocation",
	Description: "A Directive can be adjacent to many parts of the GraphQL language, a " +
		"__DirectiveLocation describes one such possible adjacencies.",
	Values: EnumValueConfigMap{
		"QUERY": &EnumValueConfig{
			Value:       DirectiveLocationQuery,
			Description: "Location adjacent to a query operation.",
		},
		"MUTATION": &EnumValueConfig{
			Value:       DirectiveLocationMutation,
			Description: "Location adjacent to a mutation operation.",
		},
		"SUBSCRIPTION": &EnumValueConfig{
			Value:       DirectiveLocationSubscription,
			Description: "Location adjacent to a subscription operation.",
		},
		"FIELD": &EnumValueConfig{
			Value:       DirectiveLocationField,
			Description: "Location adjacent to a field.",
		},
		"FRAGMENT_DEFINITION": &EnumValueConfig{
			Value:       DirectiveLocationFragmentDefinition,
			Description: "Location adjacent to a fragment definition.",
		},
		"FRAGMENT_SPREAD": &EnumValueConfig{
			Value:       DirectiveLocationFragmentSpread,
			Description: "Location adjacent to a fragment spread.",
		},
		"INLINE_FRAGMENT": &EnumValueConfig{
			Value:       DirectiveLocationInlineFragment,
			Description: "Location adjacent to an inline fragment.",
		},
		"SCHEMA": &EnumValueConfig{
			Value:       DirectiveLocationSchema,
			Description: "Location adjacent to a schema definition.",
		},
		"SCALAR": &EnumValueConfig{
			Value:       DirectiveLocationScalar,
			Description: "Location adjacent to a scalar definition.",
		},
		"OBJECT": &EnumValueConfig{
			Value:       DirectiveLocationObject,
			Description: "Location adjacent to a object definition.",
		},
		"FIELD_DEFINITION": &EnumValueConfig{
			Value:       DirectiveLocationFieldDefinition,
			Description: "Location adjacent to a field definition.",
		},
		"ARGUMENT_DEFINITION": &EnumValueConfig{
			Value:       DirectiveLocationArgumentDefinition,
			Description: "Location adjacent to an argument definition.",
		},
		"INTERFACE": &EnumValueConfig{
			Value:       DirectiveLocationInterface,
			Description: "Location adjacent to an interface definition.",
		},
		"UNION": &EnumValueConfig{
			Value:       DirectiveLocationUnion,
			Description: "Location adjacent to a union definition.",
		},
		"ENUM": &EnumValueConfig{
			Value:       DirectiveLocationEnum,
			Description: "Location adjacent to an enum definition.",
		},
		"ENUM_VALUE": &EnumValueConfig{
			Value:       DirectiveLocationEnumValue,
			Description: "Location adjacent to an enum value definition.",
		},
		"INPUT_OBJECT": &EnumValueConfig{
			Value:       DirectiveLocationInputObject,
			Description: "Location adjacent to an input object type definition.",
		},
		"INPUT_FIELD_DEFINITION": &EnumValueConfig{
			Value:       DirectiveLocationInputFieldDefinition,
			Description: "Location adjacent to an input object field definition.",
		},
	},
})

var DirectiveType = NewObject(ObjectConfig{
	Name: "__Directive",
	Description: "A Directive provides a way to describe alternate runtime execution and " +
		"type validation behavior in a GraphQL document. " +
		"\n\nIn some cases, you need to provide options to alter GraphQL's " +
		"execution behavior in ways field arguments will not suffice, such as " +
		"conditionally including or skipping a field. Directives provide this by " +
		"describing additional information to the executor.",
	Fields: Fields{
		"name": &Field{
			Type: NewNonNull(String),
		},
		"description": &Field{
			Type: String,
		},
		"locations": &Field{
			Type: NewNonNull(NewList(
				NewNonNull(DirectiveLocationEnumType),
			)),
		},
		"args": &Field{
			Type: NewNonNull(NewList(
				NewNonNull(InputValueType),
			)),
		},

		"onOperation": &Field{
			DeprecationReason: "Use `locations`.",
			Type:              NewNonNull(Boolean),
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if dir, ok := p.Source.(*Directive); ok {
					res := false
					for _, loc := range dir.Locations {
						if loc == DirectiveLocationQuery ||
							loc == DirectiveLocationMutation ||
							loc == DirectiveLocationSubscription {
							res = true
							break
						}
					}
					return res, nil
				}
				return false, nil
			},
		},
		"onFragment": &Field{
			DeprecationReason: "Use `locations`.",
			Type:              NewNonNull(Boolean),
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if dir, ok := p.Source.(*Directive); ok {
					res := false
					for _, loc := range dir.Locations {
						if loc == DirectiveLocationFragmentSpread ||
							loc == DirectiveLocationInlineFragment ||
							loc == DirectiveLocationFragmentDefinition {
							res = true
							break
						}
					}
					return res, nil
				}
				return false, nil
			},
		},
		"onField": &Field{
			DeprecationReason: "Use `locations`.",
			Type:              NewNonNull(Boolean),
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if dir, ok := p.Source.(*Directive); ok {
					res := false
					for _, loc := range dir.Locations {
						if loc == DirectiveLocationField {
							res = true
							break
						}
					}
					return res, nil
				}
				return false, nil
			},
		},
	},
})

var EnumValueType = NewObject(ObjectConfig{
	Name: "__EnumValue",
	Description: "One possible value for a given Enum. Enum values are unique values, not " +
		"a placeholder for a string or numeric value. However an Enum value is " +
		"returned in a JSON response as a string.",
	Fields: Fields{
		"name": &Field{
			Type: NewNonNull(String),
		},
		"description": &Field{
			Type: String,
		},
		"isDeprecated": &Field{
			Type: NewNonNull(Boolean),
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if field, ok := p.Source.(*EnumValueDefinition); ok {
					return field.DeprecationReason != "", nil
				}
				return false, nil
			},
		},
		"deprecationReason": &Field{
			Type: String,
		},
	},
})

var FieldType = NewObject(ObjectConfig{
	Name: "__Field",
	Description: "Object and Interface types are described by a list of Fields, each of " +
		"which has a name, potentially a list of arguments, and a return type.",
	Fields: Fields{
		"name": &Field{
			Type: NewNonNull(String),
		},
		"description": &Field{
			Type: String,
		},
		"args": &Field{
			Type: NewNonNull(NewList(NewNonNull(InputValueType))),
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if field, ok := p.Source.(*FieldDefinition); ok {
					args := append([]*Argument(nil), field.Args...)
					sort.Slice(args, func(i, j int) bool {
						return args[i].Name() < args[j].Name()
					})
					return args, nil
				}
				return []any{}, nil
			},
		},
		"type": &Field{
			Type: NewNonNull(TypeType),
		},
		"isDeprecated": &Field{
			Type: NewNonNull(Boolean),
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if field, ok := p.Source.(*FieldDefinition); ok {
					return field.DeprecationReason != "", nil
				}
				return false, nil
			},
		},
		"deprecationReason": &Field{
			Type: String,
		},
	},
})

var Float = NewScalar(ScalarConfig{
	Name: "Float",
	Description: "The `Float` scalar type represents signed double-precision fractional " +
		"values as specified by " +
		"[IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point). ",
	Serialize:  coerceFloat64,
	ParseValue: coerceFloat64,
	ParseLiteral: func(valueAST ast.Value) any {
		switch valueAST := valueAST.(type) {
		case *ast.FloatValue:
			if floatValue, err := strconv.ParseFloat(valueAST.Value, 64); err == nil {
				return floatValue
			}
		case *ast.IntValue:
			if floatValue, err := strconv.ParseFloat(valueAST.Value, 64); err == nil {
				return floatValue
			}
		}
		return nil
	},
})

var ID = NewScalar(ScalarConfig{
	Name: "ID",
	Description: "The `ID` scalar type represents a unique identifier, often used to " +
		"refetch an object or as key for a cache. The ID type appears in a JSON " +
		"response as a String; however, it is not intended to be human-readable. " +
		"When expected as an input type, any string (such as `\"4\"`) or integer " +
		"(such as `4`) input value will be accepted as an ID.",
	Serialize:  coerceString,
	ParseValue: coerceString,
	ParseLiteral: func(valueAST ast.Value) any {
		switch valueAST := valueAST.(type) {
		case *ast.IntValue:
			return valueAST.Value
		case *ast.StringValue:
			return valueAST.Value
		}
		return nil
	},
})

var IncludeDirective = NewDirective(DirectiveConfig{
	Name: "include",
	Description: "Directs the executor to include this field or fragment only when " +
		"the `if` argument is true.",
	Locations: []string{
		DirectiveLocationField,
		DirectiveLocationFragmentSpread,
		DirectiveLocationInlineFragment,
	},
	Args: FieldConfigArgument{
		"if": &ArgumentConfig{
			Type:        NewNonNull(Boolean),
			Description: "Included when true.",
		},
	},
})

var InputValueType = NewObject(ObjectConfig{
	Name: "__InputValue",
	Description: "Arguments provided to Fields or Directives and the input fields of an " +
		"InputObject are represented as Input Values which describe their type " +
		"and optionally a default value.",
	Fields: Fields{
		"name": &Field{
			Type: NewNonNull(String),
		},
		"description": &Field{
			Type: String,
		},
		"type": &Field{
			Type: NewNonNull(TypeType),
		},
		"defaultValue": &Field{
			Type: String,
			Description: "A GraphQL-formatted string representing the default value for this " +
				"input value.",
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if inputVal, ok := p.Source.(*Argument); ok {
					if inputVal.DefaultValue == nil {
						return nil, nil
					}
					if isNullish(inputVal.DefaultValue) {
						return nil, nil
					}
					astVal := astFromValue(inputVal.DefaultValue, inputVal)
					return printer.Print(astVal), nil
				}
				if inputVal, ok := p.Source.(*InputObjectField); ok {
					if inputVal.DefaultValue == nil {
						return nil, nil
					}
					astVal := astFromValue(inputVal.DefaultValue, inputVal)
					return printer.Print(astVal), nil
				}
				return nil, nil
			},
		},
	},
})

var Int = NewScalar(ScalarConfig{
	Name: "Int",
	Description: "The `Int` scalar type represents non-fractional signed whole numeric " +
		"values. Int can represent values between -(2^31) and 2^31 - 1. ",
	Serialize:  coerceInt,
	ParseValue: coerceInt,
	ParseLiteral: func(valueAST ast.Value) any {
		switch valueAST := valueAST.(type) {
		case *ast.IntValue:
			if intValue, err := strconv.Atoi(valueAST.Value); err == nil {
				return intValue
			}
		}
		return nil
	},
})

var NameRegExp = regexp.MustCompile("^[_a-zA-Z][_a-zA-Z0-9]*$")

var SchemaMetaFieldDef = &FieldDefinition{
	Name:        "__schema",
	Type:        NewNonNull(SchemaType),
	Description: "Access the current type schema of this server.",
	Args:        []*Argument{},
	Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
		return p.Info.Schema, nil
	},
}

var SchemaType = NewObject(ObjectConfig{
	Name: "__Schema",
	Description: `A GraphQL Schema defines the capabilities of a GraphQL server. ` +
		`It exposes all available types and directives on the server, as well as ` +
		`the entry points for query, mutation, and subscription operations.`,
	Fields: Fields{
		"types": &Field{
			Description: "A list of all types supported by this server.",
			Type: NewNonNull(NewList(
				NewNonNull(TypeType),
			)),
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if schema, ok := p.Source.(Schema); ok {
					var results []Type
					for _, ttype := range schema.TypeMap() {
						results = append(results, ttype)
					}
					sort.Slice(results, func(i, j int) bool {
						return results[i].Name() < results[j].Name()
					})
					return results, nil
				}
				return []Type{}, nil
			},
		},
		"queryType": &Field{
			Description: "The type that query operations will be rooted at.",
			Type:        NewNonNull(TypeType),
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if schema, ok := p.Source.(Schema); ok {
					return schema.QueryType(), nil
				}
				return nil, nil
			},
		},
		"mutationType": &Field{
			Description: `If this server supports mutation, the type that ` +
				`mutation operations will be rooted at.`,
			Type: TypeType,
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if schema, ok := p.Source.(Schema); ok {
					if schema.MutationType() != nil {
						return schema.MutationType(), nil
					}
				}
				return nil, nil
			},
		},
		"subscriptionType": &Field{
			Description: `If this server supports subscription, the type that ` +
				`subscription operations will be rooted at.`,
			Type: TypeType,
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if schema, ok := p.Source.(Schema); ok {
					if schema.SubscriptionType() != nil {
						return schema.SubscriptionType(), nil
					}
				}
				return nil, nil
			},
		},
		"directives": &Field{
			Description: `A list of all directives supported by this server.`,
			Type: NewNonNull(NewList(
				NewNonNull(DirectiveType),
			)),
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				if schema, ok := p.Source.(Schema); ok {
					return schema.Directives(), nil
				}
				return nil, nil
			},
		},
	},
})

var SkipDirective = NewDirective(DirectiveConfig{
	Name: "skip",
	Description: "Directs the executor to skip this field or fragment when the `if` " +
		"argument is true.",
	Args: FieldConfigArgument{
		"if": &ArgumentConfig{
			Type:        NewNonNull(Boolean),
			Description: "Skipped when true.",
		},
	},
	Locations: []string{
		DirectiveLocationField,
		DirectiveLocationFragmentSpread,
		DirectiveLocationInlineFragment,
	},
})

var SpecifiedDirectives = []*Directive{
	IncludeDirective,
	SkipDirective,
	DeprecatedDirective,
}

var SpecifiedRules = []ValidationRuleFn{
	ArgumentsOfCorrectTypeRule,
	DefaultValuesOfCorrectTypeRule,
	FieldsOnCorrectTypeRule,
	FragmentsOnCompositeTypesRule,
	KnownArgumentNamesRule,
	KnownDirectivesRule,
	KnownFragmentNamesRule,
	KnownTypeNamesRule,
	LoneAnonymousOperationRule,
	NoFragmentCyclesRule,
	NoUndefinedVariablesRule,
	NoUnusedFragmentsRule,
	NoUnusedVariablesRule,

	PossibleFragmentSpreadsRule,
	ProvidedNonNullArgumentsRule,
	ScalarLeafsRule,
	UniqueArgumentNamesRule,
	UniqueFragmentNamesRule,
	UniqueInputFieldNamesRule,
	UniqueOperationNamesRule,
	UniqueVariableNamesRule,
	VariablesAreInputTypesRule,
	VariablesInAllowedPositionRule,
}

var String = NewScalar(ScalarConfig{
	Name: "String",
	Description: "The `String` scalar type represents textual data, represented as UTF-8 " +
		"character sequences. The String type is most often used by GraphQL to " +
		"represent free-form human-readable text.",
	Serialize:  coerceString,
	ParseValue: coerceString,
	ParseLiteral: func(valueAST ast.Value) any {
		switch valueAST := valueAST.(type) {
		case *ast.StringValue:
			return valueAST.Value
		}
		return nil
	},
})

var TypeKindEnumType = NewEnum(EnumConfig{
	Name:        "__TypeKind",
	Description: "An enum describing what kind of type a given `__Type` is",
	Values: EnumValueConfigMap{
		"SCALAR": &EnumValueConfig{
			Value:       TypeKindScalar,
			Description: "Indicates this type is a scalar.",
		},
		"OBJECT": &EnumValueConfig{
			Value: TypeKindObject,
			Description: "Indicates this type is an object. " +
				"`fields` and `interfaces` are valid fields.",
		},
		"INTERFACE": &EnumValueConfig{
			Value: TypeKindInterface,
			Description: "Indicates this type is an interface. " +
				"`fields` and `possibleTypes` are valid fields.",
		},
		"UNION": &EnumValueConfig{
			Value: TypeKindUnion,
			Description: "Indicates this type is a union. " +
				"`possibleTypes` is a valid field.",
		},
		"ENUM": &EnumValueConfig{
			Value: TypeKindEnum,
			Description: "Indicates this type is an enum. " +
				"`enumValues` is a valid field.",
		},
		"INPUT_OBJECT": &EnumValueConfig{
			Value: TypeKindInputObject,
			Description: "Indicates this type is an input object. " +
				"`inputFields` is a valid field.",
		},
		"LIST": &EnumValueConfig{
			Value: TypeKindList,
			Description: "Indicates this type is a list. " +
				"`ofType` is a valid field.",
		},
		"NON_NULL": &EnumValueConfig{
			Value: TypeKindNonNull,
			Description: "Indicates this type is a non-null. " +
				"`ofType` is a valid field.",
		},
	},
})

var TypeMetaFieldDef = &FieldDefinition{
	Name:        "__type",
	Type:        TypeType,
	Description: "Request the type information of a single type.",
	Args: []*Argument{
		{
			PrivateName: "name",
			Type:        NewNonNull(String),
		},
	},
	Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
		name, ok := p.Args["name"].(string)
		if !ok {
			return nil, nil
		}
		return p.Info.Schema.Type(name), nil
	},
}

var TypeNameMetaFieldDef = &FieldDefinition{
	Name:        "__typename",
	Type:        NewNonNull(String),
	Description: "The name of the current Object type at runtime.",
	Args:        []*Argument{},
	Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
		return p.Info.ParentType.Name(), nil
	},
}

var TypeType = NewObject(ObjectConfig{
	Name: "__Type",
	Description: "The fundamental unit of any GraphQL Schema is the type. There are " +
		"many kinds of types in GraphQL as represented by the `__TypeKind` enum." +
		"\n\nDepending on the kind of a type, certain fields describe " +
		"information about that type. Scalar types provide no information " +
		"beyond a name and description, while Enum types provide their values. " +
		"Object and Interface types provide the fields they describe. Abstract " +
		"types, Union and Interface, provide the Object types possible " +
		"at runtime. List and NonNull types compose other types.",

	Fields: Fields{
		"kind": &Field{
			Type: NewNonNull(TypeKindEnumType),
			Resolve: func(ctx context.Context, p ResolveParams) (any, error) {
				switch p.Source.(type) {
				case *Scalar:
					return TypeKindScalar, nil
				case *Object:
					return TypeKindObject, nil
				case *Interface:
					return TypeKindInterface, nil
				case *Union:
					return TypeKindUnion, nil
				case *Enum:
					return TypeKindEnum, nil
				case *InputObject:
					return TypeKindInputObject, nil
				case *List:
					return TypeKindList, nil
				case *NonNull:
					return TypeKindNonNull, nil
				}
				return nil, fmt.Errorf("graphql: unknown kind of type: %v", p.Source)
			},
		},
		"name": &Field{
			Type: String,
		},
		"description": &Field{
			Type: String,
		},
		"fields":        &Field{},
		"interfaces":    &Field{},
		"possibleTypes": &Field{},
		"enumValues":    &Field{},
		"inputFields":   &Field{},
		"ofType":        &Field{},
	},
})