graphql 0.3.0 → 0.4.0

data/lib/graph_ql/introspection/schema_field.rb

@@ -0,0 +1,13 @@
+# A wrapper to implement `__schema`
+class GraphQL::Introspection::SchemaField
+  DEFINITION = Proc.new { |f, wrapped_type|
+    f.name("__schema")
+    f.description("This GraphQL schema")
+    f.type(!GraphQL::Introspection::SchemaType)
+    f.resolve -> (o, a, c) { wrapped_type }
+  }
+
+  def self.create(wrapped_type)
+     GraphQL::Field.new { |f| DEFINITION.call(f, wrapped_type) }
+  end
+end

data/lib/graph_ql/introspection/type_by_name_field.rb

@@ -0,0 +1,14 @@
+# A wrapper to create `__type(name: )` dynamically.
+class GraphQL::Introspection::TypeByNameField
+  DEFINITION = Proc.new { |f, type, field, arg, type_hash|
+    f.name("__type")
+    f.description("A type in the GraphQL system")
+    f.arguments({name: arg.build(type: !type.String)})
+    f.type(!GraphQL::Introspection::TypeType)
+    f.resolve -> (o, args, c) { type_hash[args["name"]] }
+  }
+
+  def self.create(type_hash)
+    GraphQL::Field.new { |f, type, field, arg| DEFINITION.call(f, type, field, arg, type_hash) }
+  end
+end

data/lib/graph_ql/introspection/type_kind_enum.rb

@@ -1,4 +1,4 @@
-GraphQL::Introspection::TypeKindEnum = GraphQL::Enum.new do |e|
+GraphQL::Introspection::TypeKindEnum = GraphQL::EnumType.new do |e|
   e.name "__TypeKind"
   e.description "The kinds of types in this GraphQL system"
   GraphQL::TypeKinds::KIND_NAMES.each do |kind_name|

data/lib/graph_ql/{types/list_type.rb → list_type.rb}

@@ -1,3 +1,6 @@
+# A list type wraps another type.
+#
+# See {TypeKind#unwrap} for accessing the modified type
 class GraphQL::ListType < GraphQL::ObjectType
   attr_reader :of_type
   def initialize(of_type:)

data/lib/graph_ql/{parser/nodes.rb → nodes.rb}

@@ -4,6 +4,8 @@ module GraphQL::Nodes
   # - expose accessors for keyword arguments
   class AbstractNode
     attr_accessor :line, :col
+
+    # @param options [Hash] Must contain all attributes defined by {required_attrs}, may also include `position_source`
     def initialize(options)
       required_keys = self.class.required_attrs
       allowed_keys = required_keys + [:line, :col]
@@ -31,15 +33,17 @@ module GraphQL::Nodes
       end
     end
 
+    # Test all attributes, checking for any other nodes below this one
     def children
       self.class.required_attrs
         .map { |attr| send(attr) }
-        .flatten # eg #fields is a list of children
+        .flatten
         .select { |val| val.is_a?(GraphQL::Nodes::AbstractNode) }
     end
 
     class << self
       attr_reader :required_attrs
+      # Defines attributes which are required at initialization.
       def attr_required(*attr_names)
         @required_attrs ||= []
         @required_attrs += attr_names
@@ -48,6 +52,9 @@ module GraphQL::Nodes
 
       # Create a new AbstractNode child which
       # requires and exposes {attr_names}.
+      # @param attr_names [Array<Symbol>] Attributes this node class will have
+      # @param block [Block] Block passed to `Class.new`
+      # @return [Class] A new node class
       def create(*attr_names, &block)
         cls = Class.new(self, &block)
         cls.attr_required(*attr_names)

data/lib/graph_ql/{types/non_null_type.rb → non_null_type.rb}

@@ -1,3 +1,6 @@
+# A non-null type wraps another type.
+#
+# See {TypeKind#unwrap} for accessing the modified type
 class GraphQL::NonNullType < GraphQL::ObjectType
   attr_reader :of_type
   def initialize(of_type:)

data/lib/graph_ql/object_type.rb

@@ -0,0 +1,92 @@
+# This type exposes fields on an object.
+#
+#
+class GraphQL::ObjectType
+  include GraphQL::DefinitionHelpers::NonNullWithBang
+  extend GraphQL::DefinitionHelpers::Definable
+  attr_definable :name, :description, :interfaces, :fields
+
+  def initialize(&block)
+    self.fields = []
+    self.interfaces = []
+    yield(
+      self,
+      GraphQL::DefinitionHelpers::TypeDefiner.instance,
+      GraphQL::DefinitionHelpers::FieldDefiner.instance,
+      GraphQL::DefinitionHelpers::ArgumentDefiner.instance
+    )
+  end
+
+  # @overload fields(new_fields)
+  #   Define `new_fields` as the fields this type exposes, uses {#fields=}
+  #
+  # @overload fields()
+  #   @return [Hash] fields this type exposes
+  def fields(new_fields=nil)
+    if !new_fields.nil?
+      self.fields = new_fields
+    end
+    @fields
+  end
+
+
+  # Define fields to be `new_fields`, normalize with {StringNamedHash}
+  # @param new_fields [Hash] The fields exposed by this type
+  def fields=(new_fields)
+    @fields = GraphQL::DefinitionHelpers::StringNamedHash.new(new_fields).to_h
+  end
+
+  # @overload interfaces(new_interfaces)
+  #   Declare that this type implements `new_interfaces`.
+  #   Shovel this type into each interface's `possible_types` array.
+  #
+  #   (There's a bug here: if you define interfaces twice, it won't remove previous definitions.)
+  #
+  #   @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
+  #
+  # @overload interfaces
+  #   @return [Array<GraphQL::Interface>] interfaces that this type implements
+  #
+  def interfaces(new_interfaces=nil)
+    if !new_interfaces.nil?
+      @interfaces = new_interfaces
+      new_interfaces.each {|i| i.possible_types << self }
+    end
+    @interfaces
+  end
+
+  def kind
+    GraphQL::TypeKinds::OBJECT
+  end
+
+  # Print the human-readable name of this type
+  def to_s
+    Printer.instance.print(self)
+  end
+
+  alias :inspect :to_s
+
+  # @param other [GraphQL::ObjectType] compare to this object
+  # @return [Boolean] are these types equivalent? (incl. non-null, list)
+  def ==(other)
+    if other.is_a?(GraphQL::ObjectType)
+      self.to_s == other.to_s
+    else
+      super
+    end
+  end
+
+  # Print a type, using the query-style naming pattern
+  class Printer
+    include Singleton
+    def print(type)
+      if type.kind.non_null?
+        "#{print(type.of_type)}!"
+      elsif type.kind.list?
+        "[#{print(type.of_type)}]"
+      else
+        type.name
+      end
+    end
+  end
+end

data/lib/graph_ql/parser.rb

@@ -1,9 +1,110 @@
-require 'graph_ql/parser/nodes'
-require 'graph_ql/parser/parser'
-require 'graph_ql/parser/transform'
-require 'graph_ql/parser/visitor'
-
 module GraphQL
+  # Parser is a [parslet](http://kschiess.github.io/parslet/) parser for parsing queries.
+  #
+  class Parser < Parslet::Parser
+    root(:document)
+    rule(:document) { (
+        space                |
+        operation_definition |
+        fragment_definition
+      ).repeat(1).as(:document_parts)
+    }
+
+    # TODO: whitespace sensitive regarding `on`, eg `onFood`, see lookahead note in spec
+    rule(:fragment_definition) {
+      str("fragment").as(:fragment_keyword) >>
+       space? >> name.as(:fragment_name) >>
+       space? >> str("on") >> space? >> name.as(:type_condition) >>
+       space? >> directives.maybe.as(:optional_directives).as(:directives) >>
+       space? >> selections.as(:selections)
+    }
+
+    rule(:fragment_spread) {
+      spread.as(:fragment_spread_keyword) >> space? >>
+      name.as(:fragment_spread_name) >> space? >>
+      directives.maybe.as(:optional_directives).as(:directives)
+    }
+    rule(:spread) { str("...") }
+    # TODO: `on` bug, see spec
+    rule(:inline_fragment) {
+      spread.as(:fragment_spread_keyword) >> space? >>
+      str("on ") >> name.as(:inline_fragment_type) >> space? >>
+      directives.maybe.as(:optional_directives).as(:directives) >> space? >>
+      selections.as(:selections)
+    }
+
+    rule(:operation_definition) { (unnamed_selections | named_operation_definition) }
+    rule(:unnamed_selections) { selections.as(:unnamed_selections)}
+    rule(:named_operation_definition) {
+      operation_type.as(:operation_type) >> space? >>
+      name.as(:name) >> space? >>
+      operation_variable_definitions.maybe.as(:optional_variables).as(:variables) >> space? >>
+      directives.maybe.as(:optional_directives).as(:directives) >> space? >>
+      selections.as(:selections)
+    }
+    rule(:operation_type) { (str("query") | str("mutation")) }
+    rule(:operation_variable_definitions) { str("(") >> space? >> (operation_variable_definition >> separator?).repeat(1) >> space? >> str(")") }
+    rule(:operation_variable_definition) {
+      value_variable.as(:variable_name) >> space? >>
+      str(":") >> space? >>
+      type.as(:variable_type) >> space? >>
+      (str("=") >> space? >> value.as(:variable_default_value)).maybe.as(:variable_optional_default_value)}
+
+    rule(:selection) { (inline_fragment | fragment_spread | field) >> space? >> separator? }
+    rule(:selections) { str("{") >> space? >> selection.repeat(1) >> space? >> str("}")}
+
+    rule(:field) {
+      field_alias.maybe.as(:alias) >>
+      name.as(:field_name) >>
+      field_arguments.maybe.as(:optional_field_arguments).as(:field_arguments) >> space? >>
+      directives.maybe.as(:optional_directives).as(:directives) >> space? >>
+      selections.maybe.as(:optional_selections).as(:selections)
+    }
+
+    rule(:field_alias) { name.as(:alias_name) >> space? >> str(":") >> space? }
+    rule(:field_arguments) { str("(") >> field_argument.repeat(1) >> str(")") }
+    rule(:field_argument) { name.as(:field_argument_name) >> str(":") >> space? >> value.as(:field_argument_value) >> separator? }
+
+    rule(:directives) { (directive >> separator?).repeat(1) }
+    rule(:directive) {
+      str("@") >> name.as(:directive_name) >>
+      directive_arguments.maybe.as(:optional_directive_arguments).as(:directive_arguments)
+    }
+    rule(:directive_arguments) { str("(") >> directive_argument.repeat(1) >> str(")") }
+    rule(:directive_argument) { name.as(:directive_argument_name) >> str(":") >> space? >> value.as(:directive_argument_value) >> separator? }
+
+    rule(:type) { (non_null_type | list_type | type_name)}
+    rule(:list_type) { str("[") >> type.as(:list_type) >> str("]")}
+    rule(:non_null_type) { (list_type | type_name).as(:non_null_type) >> str("!") }
+    rule(:type_name) { name.as(:type_name) }
+
+    rule(:value) {(
+      value_input_object  |
+      value_float         |
+      value_int           |
+      value_string        |
+      value_boolean       |
+      value_array         |
+      value_variable      |
+      value_enum
+    )}
+    rule(:value_sign?) { match('[\-\+]').maybe }
+    rule(:value_array) { (str("[") >> (value >> separator?).repeat(0) >> str("]")).as(:array) }
+    rule(:value_boolean) { (str("true") | str("false")).as(:boolean) }
+    rule(:value_float) { (value_sign? >> match('\d').repeat(1) >> str(".") >> match('\d').repeat(1) >> (match("[eE]") >> value_sign? >> match('\d').repeat(1)).maybe).as(:float) }
+    rule(:value_input_object) { str("{") >> value_input_object_pair.repeat(1).as(:input_object) >> str("}") }
+    rule(:value_input_object_pair) { space? >> name.as(:input_object_name) >>  space? >> str(":") >> space? >> value.as(:input_object_value) >> separator? }
+    rule(:value_int) { (value_sign? >> match('\d').repeat(1)).as(:int) }
+    # TODO: support unicode, escaped chars (match the spec)
+    rule(:value_string) { str('"') >> match('[^\"]').repeat(1).as(:string) >> str('"')}
+    rule(:value_enum) { name.as(:enum) }
+    rule(:value_variable) { str("$") >> name.as(:variable) }
+
+    rule(:separator?) { (space? >> str(",") >> space?).maybe }
+    rule(:name) { match('[_A-Za-z]') >> match('[_0-9A-Za-z]').repeat(0) }
+    rule(:comment) { str("#") >> match('[^\r\n]').repeat(0) }
+    rule(:space) { (match('[\s\n]+') | comment).repeat(1) }
+    rule(:space?) { space.maybe }
+  end
   PARSER = GraphQL::Parser.new
-  TRANSFORM = GraphQL::Transform.new
 end

data/lib/graph_ql/query.rb

@@ -5,6 +5,13 @@ class GraphQL::Query
   DEFAULT_RESOLVE = :__default_resolve
   attr_reader :schema, :document, :context, :fragments, :params
 
+  # Prepare query `query_string` on {GraphQL::Schema} `schema`
+  # @param schema [GraphQL::Schema]
+  # @param query_string [String]
+  # @param context [#[]] (default: `nil`) an arbitrary hash of values which you can access in {GraphQL::Field#resolve}
+  # @param params [Hash] (default: `{}`) values for `$variables` in the query
+  # @param debug [Boolean] (default: `true`) if true, errors are raised, if false, errors are put in the `errors` key
+  # @param validate [Boolean] (default: `true`) if true, `query_string` will be validated with {StaticValidation::Validator}
   def initialize(schema, query_string, context: nil, params: {}, debug: true, validate: true)
     @schema = schema
     @debug = debug
@@ -82,3 +89,4 @@ require 'graph_ql/query/inline_fragment_resolution_strategy'
 require 'graph_ql/query/operation_resolver'
 require 'graph_ql/query/selection_resolver'
 require 'graph_ql/query/type_resolver'
+require 'graph_ql/query/directive_chain'

data/lib/graph_ql/query/arguments.rb

@@ -1,8 +1,11 @@
-# Creates a plain hash out of arguments, looking up variables if necessary
+require 'forwardable'
+
+# Provide read-only access to arguments by string or symbol names.
 class GraphQL::Query::Arguments
-  attr_reader :to_h
+  extend Forwardable
+
   def initialize(ast_arguments, argument_hash, variables)
-    @to_h = ast_arguments.reduce({}) do |memo, arg|
+    @hash = ast_arguments.reduce({}) do |memo, arg|
       arg_defn = argument_hash[arg.name]
       value = reduce_value(arg.value, arg_defn, variables)
       memo[arg.name] = value
@@ -10,6 +13,12 @@ class GraphQL::Query::Arguments
     end
   end
 
+  def_delegators :@hash, :keys, :values
+
+  def [](key)
+    @hash[key.to_s]
+  end
+
   private
 
   def reduce_value(value, arg_defn, variables)
@@ -18,7 +27,7 @@ class GraphQL::Query::Arguments
     elsif value.is_a?(GraphQL::Nodes::Enum)
       value = arg_defn.type.coerce(value.name)
     elsif value.is_a?(GraphQL::Nodes::InputObject)
-      value = self.class.new(value.pairs, arg_defn.type.input_fields, variables).to_h
+      value = self.class.new(value.pairs, arg_defn.type.input_fields, variables)
     else
       value
     end

data/lib/graph_ql/{directives → query}/directive_chain.rb

@@ -1,4 +1,4 @@
-class GraphQL::DirectiveChain
+class GraphQL::Query::DirectiveChain
   DIRECTIVE_ON = {
     GraphQL::Nodes::Field =>          GraphQL::Directive::ON_FIELD,
     GraphQL::Nodes::InlineFragment => GraphQL::Directive::ON_FRAGMENT,
@@ -24,7 +24,7 @@ class GraphQL::DirectiveChain
       @result = block.call
     else
       applicable_directives.map do |(ast_directive, directive)|
-        args = GraphQL::Query::Arguments.new(ast_directive.arguments, directive.arguments, operation_resolver.variables).to_h
+        args = GraphQL::Query::Arguments.new(ast_directive.arguments, directive.arguments, operation_resolver.variables)
         @result = directive.resolve(args, block)
       end
       @result ||= {}

data/lib/graph_ql/query/field_resolution_strategy.rb

@@ -3,8 +3,8 @@ class GraphQL::Query::FieldResolutionStrategy
 
   def initialize(ast_field, parent_type, target, operation_resolver)
     field_name = ast_field.name
-    field = parent_type.fields[field_name] || raise("No field found on #{parent_type.name} '#{parent_type}' for '#{field_name}'")
-    arguments = GraphQL::Query::Arguments.new(ast_field.arguments, field.arguments, operation_resolver.variables).to_h
+    field = operation_resolver.query.schema.get_field(parent_type, field_name) || raise("No field found on #{parent_type.name} '#{parent_type}' for '#{field_name}'")
+    arguments = GraphQL::Query::Arguments.new(ast_field.arguments, field.arguments, operation_resolver.variables)
     value = field.resolve(target, arguments, operation_resolver.context)
     if value.nil?
       @result_value = value

data/lib/graph_ql/query/operation_resolver.rb

@@ -1,14 +1,14 @@
 class GraphQL::Query::OperationResolver
-  extend GraphQL::Forwardable
-  attr_reader :variables, :query
+  attr_reader :variables, :query, :context
 
   def initialize(operation_definition, query)
     @operation_definition = operation_definition
     @variables = query.params
     @query = query
+    @context = query.context
   end
 
-  delegate :context, to: :query
+
 
   def result
     @result ||= execute(@operation_definition, query)

data/lib/graph_ql/query/selection_resolver.rb

@@ -9,7 +9,7 @@ class GraphQL::Query::SelectionResolver
 
   def initialize(target, type, selections, operation_resolver)
     @result = selections.reduce({}) do |memo, ast_field|
-      chain = GraphQL::DirectiveChain.new(ast_field, operation_resolver) {
+      chain = GraphQL::Query::DirectiveChain.new(ast_field, operation_resolver) {
         strategy_class = RESOLUTION_STRATEGIES[ast_field.class]
         strategy = strategy_class.new(ast_field, type, target, operation_resolver)
         strategy.result

data/lib/graph_ql/scalar_type.rb

@@ -0,0 +1,9 @@
+module GraphQL
+  # The parent type for scalars, eg {GraphQL::STRING_TYPE}, {GraphQL::INT_TYPE}
+  #
+  class ScalarType < GraphQL::ObjectType
+    def kind
+      GraphQL::TypeKinds::SCALAR
+    end
+  end
+end

data/lib/graph_ql/schema.rb

@@ -1,23 +1,13 @@
+# A GraphQL schema which may be queried with {GraphQL::Query}.
 class GraphQL::Schema
-  DIRECTIVES = [GraphQL::SkipDirective, GraphQL::IncludeDirective]
+  DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective]
+  DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 
   attr_reader :query, :mutation, :directives, :static_validator
-  def initialize(query:, mutation:)
-    # Add fields to this query root for introspection:
-    query.fields = query.fields.merge({
-      "__type" =>     GraphQL::Field.new do |f, type, field, arg|
-        f.description("A type in the GraphQL system")
-        f.arguments({name: arg.build(type: !type.String)})
-        f.type(!GraphQL::Introspection::TypeType)
-        f.resolve -> (o, a, c) { self.types[a["name"]] }
-      end,
-      "__schema" =>   GraphQL::Field.new do |f|
-        f.description("This GraphQL schema")
-        f.type(!GraphQL::Introspection::SchemaType)
-        f.resolve -> (o, a, c) { self }
-      end
-    })
 
+  # @param query [GraphQL::ObjectType]  the query root for the schema
+  # @param mutation [GraphQL::ObjectType, nil] the mutation root for the schema
+  def initialize(query:, mutation:)
     @query    = query
     @mutation = mutation
     @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
@@ -29,8 +19,27 @@ class GraphQL::Schema
     end
   end
 
+  # A `{ name => type }` hash of types in this schema
+  # @returns Hash
   def types
-    @types ||= TypeReducer.new(query, {}).result
+    @types ||= TypeReducer.find_all([query, mutation, GraphQL::Introspection::SchemaType].compact)
+  end
+
+  # Resolve field named `field_name` for type `parent_type`.
+  # Handles dynamic fields `__typename`, `__type` and `__schema`, too
+  def get_field(parent_type, field_name)
+    defined_field = parent_type.fields[field_name]
+    if defined_field
+      defined_field
+    elsif field_name == "__typename"
+      GraphQL::Introspection::TypenameField.create(parent_type)
+    elsif field_name == "__schema" && parent_type == query
+      GraphQL::Introspection::SchemaField.create(self)
+    elsif field_name == "__type" && parent_type == query
+      GraphQL::Introspection::TypeByNameField.create(self.types)
+    else
+      nil
+    end
   end
 end