Class: GraphQL::Schema::Directive

Inherits:
Member
  • Object
show all
Extended by:
Member::HasArguments, Member::HasArguments::HasDirectiveArguments, Member::HasValidators
Defined in:
lib/graphql/schema/directive.rb,
lib/graphql/schema/directive/skip.rb,
lib/graphql/schema/directive/one_of.rb,
lib/graphql/schema/directive/feature.rb,
lib/graphql/schema/directive/flagged.rb,
lib/graphql/schema/directive/include.rb,
lib/graphql/schema/directive/transform.rb,
lib/graphql/schema/directive/deprecated.rb,
lib/graphql/schema/directive/specified_by.rb

Overview

Subclasses of this can influence how Execution::Interpreter runs queries.

  • Directive.include?: if it returns false, the field or fragment will be skipped altogether, as if it were absent
  • Directive.resolve: Wraps field resolution (so it should call yield to continue)

Direct Known Subclasses

Deprecated, Feature, Flagged, Include, OneOf, Skip, SpecifiedBy, Transform

Defined Under Namespace

Classes: Deprecated, Feature, Flagged, Include, InvalidArgumentError, OneOf, Skip, SpecifiedBy, Transform

Constant Summary collapse

LOCATIONS = 
[
  QUERY =                  :QUERY,
  MUTATION =               :MUTATION,
  SUBSCRIPTION =           :SUBSCRIPTION,
  FIELD =                  :FIELD,
  FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
  FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
  INLINE_FRAGMENT =        :INLINE_FRAGMENT,
  SCHEMA =                 :SCHEMA,
  SCALAR =                 :SCALAR,
  OBJECT =                 :OBJECT,
  FIELD_DEFINITION =       :FIELD_DEFINITION,
  ARGUMENT_DEFINITION =    :ARGUMENT_DEFINITION,
  INTERFACE =              :INTERFACE,
  UNION =                  :UNION,
  ENUM =                   :ENUM,
  ENUM_VALUE =             :ENUM_VALUE,
  INPUT_OBJECT =           :INPUT_OBJECT,
  INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
  VARIABLE_DEFINITION =    :VARIABLE_DEFINITION,
]
DEFAULT_DEPRECATION_REASON = 
'No longer supported'
LOCATION_DESCRIPTIONS = 
{
  QUERY:                    'Location adjacent to a query operation.',
  MUTATION:                 'Location adjacent to a mutation operation.',
  SUBSCRIPTION:             'Location adjacent to a subscription operation.',
  FIELD:                    'Location adjacent to a field.',
  FRAGMENT_DEFINITION:      'Location adjacent to a fragment definition.',
  FRAGMENT_SPREAD:          'Location adjacent to a fragment spread.',
  INLINE_FRAGMENT:          'Location adjacent to an inline fragment.',
  SCHEMA:                   'Location adjacent to a schema definition.',
  SCALAR:                   'Location adjacent to a scalar definition.',
  OBJECT:                   'Location adjacent to an object type definition.',
  FIELD_DEFINITION:         'Location adjacent to a field definition.',
  ARGUMENT_DEFINITION:      'Location adjacent to an argument definition.',
  INTERFACE:                'Location adjacent to an interface definition.',
  UNION:                    'Location adjacent to a union definition.',
  ENUM:                     'Location adjacent to an enum definition.',
  ENUM_VALUE:               'Location adjacent to an enum value definition.',
  INPUT_OBJECT:             'Location adjacent to an input object type definition.',
  INPUT_FIELD_DEFINITION:   'Location adjacent to an input object field definition.',
  VARIABLE_DEFINITION:      'Location adjacent to a variable definition.',
}

Constants included from Member::HasArguments

Member::HasArguments::NO_ARGUMENTS

Constants included from EmptyObjects

EmptyObjects::EMPTY_ARRAY, EmptyObjects::EMPTY_HASH

Constants included from Member::GraphQLTypeNames

Member::GraphQLTypeNames::Boolean, Member::GraphQLTypeNames::ID, Member::GraphQLTypeNames::Int

Instance Attribute Summary collapse

Attributes included from Member::BaseDSLMethods

#default_graphql_name

Attributes included from Member::RelayShortcuts

#connection_type, #connection_type_class, #edge_type, #edge_type_class

Attributes included from Member::HasAstNode

#ast_node

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Member::HasArguments

add_argument, all_argument_definitions, any_arguments?, argument, argument_class, arguments_statically_coercible?, coerce_arguments, get_argument, own_arguments, remove_argument, validate_directive_argument

Methods included from Member::HasArguments::HasDirectiveArguments

validate_directive_argument

Methods included from Member::HasValidators

validates, validators

Methods included from Member::BaseDSLMethods

#authorized?, #comment, #default_relay, #description, #introspection, #introspection?, #mutation, #name, #visible?

Methods included from Member::BaseDSLMethods::ConfigurationExtension

#inherited

Methods included from Member::TypeSystemHelpers

#kind, #list?, #non_null?, #to_list_type, #to_non_null_type, #to_type_signature

Methods included from Member::Scoped

#inherited, #reauthorize_scoped_objects, #scope_items

Methods included from Member::HasPath

#path

Methods included from Member::HasAstNode

#inherited

Methods included from Member::HasDirectives

add_directive, #directive, #directives, get_directives, #inherited, #remove_directive, remove_directive

Constructor Details

#initialize(owner, **arguments) ⇒ Directive

Returns a new instance of Directive.



122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/graphql/schema/directive.rb', line 122

def initialize(owner, **arguments)
  @owner = owner
  assert_valid_owner
  # It's be nice if we had the real context here, but we don't. What we _would_ get is:
  # - error handling
  # - lazy resolution
  # Probably, those won't be needed here, since these are configuration arguments,
  # not runtime arguments.
  context = Query::NullContext.instance
  self.class.all_argument_definitions.each do |arg_defn|
    if arguments.key?(arg_defn.keyword)
      value = arguments[arg_defn.keyword]
      # This is a Ruby-land value; convert it to graphql for validation
      graphql_value = begin
        arg_defn.type.unwrap.coerce_isolated_result(value)
      rescue GraphQL::Schema::Enum::UnresolvedValueError
        # Let validation handle this
        value
      end
    else
      value = graphql_value = nil
    end

    result = arg_defn.type.validate_input(graphql_value, context)
    if !result.valid?
      raise InvalidArgumentError, "@#{graphql_name}.#{arg_defn.graphql_name} on #{owner.path} is invalid (#{value.inspect}): #{result.problems.first["explanation"]}"
    end
  end
  self.class.validate!(arguments, context)
  @arguments = self.class.coerce_arguments(nil, arguments, context)
  if @arguments.is_a?(GraphQL::ExecutionError)
    raise @arguments
  end
end

Instance Attribute Details

#arguments ⇒ GraphQL::Interpreter::Arguments (readonly)

Returns:

  • (GraphQL::Interpreter::Arguments) 


117
118
119
 
# File 'lib/graphql/schema/directive.rb', line 117

def arguments
  @arguments
end

#owner ⇒ GraphQL::Schema::Field, ... (readonly)

Returns:



114
115
116
 
# File 'lib/graphql/schema/directive.rb', line 114

def owner
  @owner
end

Class Method Details

.default_directive(new_default_directive = nil) ⇒ Object 



45
46
47
48
49
50
51
52
53
 
# File 'lib/graphql/schema/directive.rb', line 45

def default_directive(new_default_directive = nil)
  if new_default_directive != nil
    @default_directive = new_default_directive
  elsif @default_directive.nil?
    @default_directive = (superclass.respond_to?(:default_directive) ? superclass.default_directive : false)
  else
    !!@default_directive
  end
end

.default_directive? ⇒ Boolean

Returns:



55
56
57
 
# File 'lib/graphql/schema/directive.rb', line 55

def default_directive?
  default_directive
end

.default_graphql_name ⇒ Object

Return a name based on the class name, but downcase the first letter.



24
25
26
27
28
29
30
 
# File 'lib/graphql/schema/directive.rb', line 24

def default_graphql_name
  @default_graphql_name ||= begin
    camelized_name = super.dup
    camelized_name[0] = camelized_name[0].downcase
    -camelized_name
  end
end

.include?(_object, arguments, context) ⇒ Boolean

If false, this part of the query won’t be evaluated

Returns:



60
61
62
 
# File 'lib/graphql/schema/directive.rb', line 60

def include?(_object, arguments, context)
  static_include?(arguments, context)
end

.locations(*new_locations) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/graphql/schema/directive.rb', line 32

def locations(*new_locations)
  if !new_locations.empty?
    new_locations.each do |new_loc|
      if !LOCATIONS.include?(new_loc.to_sym)
        raise ArgumentError, "#{self} (#{self.graphql_name}) has an invalid directive location: `locations #{new_loc}` "
      end
    end
    @locations = new_locations
  else
    @locations ||= (superclass.respond_to?(:locations) ? superclass.locations : [])
  end
end

.on_field? ⇒ Boolean

Returns:



83
84
85
 
# File 'lib/graphql/schema/directive.rb', line 83

def on_field?
  locations.include?(FIELD)
end

.on_fragment? ⇒ Boolean

Returns:



87
88
89
 
# File 'lib/graphql/schema/directive.rb', line 87

def on_fragment?
  locations.include?(FRAGMENT_SPREAD) && locations.include?(INLINE_FRAGMENT)
end

.on_operation? ⇒ Boolean

Returns:



91
92
93
 
# File 'lib/graphql/schema/directive.rb', line 91

def on_operation?
  locations.include?(QUERY) && locations.include?(MUTATION) && locations.include?(SUBSCRIPTION)
end

.path ⇒ Object 



18
19
20
 
# File 'lib/graphql/schema/directive.rb', line 18

def path
  "@#{super}"
end

.repeatable(new_value) ⇒ Object 



99
100
101
 
# File 'lib/graphql/schema/directive.rb', line 99

def repeatable(new_value)
  @repeatable = new_value
end

.repeatable? ⇒ Boolean

Returns:



95
96
97
 
# File 'lib/graphql/schema/directive.rb', line 95

def repeatable?
  !!@repeatable
end

.resolve(object, arguments, context) ⇒ Object

Continuing is passed as a block; yield to continue



70
71
72
 
# File 'lib/graphql/schema/directive.rb', line 70

def resolve(object, arguments, context)
  yield
end

.resolve_each(object, arguments, context) ⇒ Object

Continuing is passed as a block, yield to continue.



75
76
77
 
# File 'lib/graphql/schema/directive.rb', line 75

def resolve_each(object, arguments, context)
  yield
end

.static_include?(_arguments, _context) ⇒ Boolean

Determines whether Execution::Lookahead considers the field to be selected

Returns:



65
66
67
 
# File 'lib/graphql/schema/directive.rb', line 65

def static_include?(_arguments, _context)
  true
end

.validate!(arguments, context) ⇒ Object 



79
80
81
 
# File 'lib/graphql/schema/directive.rb', line 79

def validate!(arguments, context)
  Schema::Validator.validate!(validators, self, context, arguments)
end

Instance Method Details

#graphql_name ⇒ Object 



157
158
159
 
# File 'lib/graphql/schema/directive.rb', line 157

def graphql_name
  self.class.graphql_name
end