graphql 0.1.0 → 0.2.0

data/lib/graph_ql/static_validation/fragments_are_used.rb

@@ -0,0 +1,30 @@
+class GraphQL::StaticValidation::FragmentsAreUsed
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def validate(context)
+    v = context.visitor
+    used_fragments = []
+    defined_fragments = []
+    v[GraphQL::Nodes::FragmentSpread] << -> (node, parent) { used_fragments <<  node }
+    v[GraphQL::Nodes::FragmentDefinition] << -> (node, parent) { defined_fragments << node}
+    v[GraphQL::Nodes::Document].leave << -> (node, parent) { add_errors(context.errors, used_fragments, defined_fragments) }
+  end
+
+  private
+
+  def add_errors(errors, used_fragments, defined_fragments)
+    undefined_fragments = find_difference(used_fragments, defined_fragments.map(&:name))
+    undefined_fragments.each do |fragment|
+      errors << message("Fragment #{fragment.name} was used, but not defined", fragment)
+    end
+
+    unused_fragments = find_difference(defined_fragments, used_fragments.map(&:name))
+    unused_fragments.each do |fragment|
+      errors << message("Fragment #{fragment.name} was defined, but not used", fragment)
+    end
+  end
+
+  def find_difference(fragments, allowed_fragment_names)
+    fragments.select {|f| !allowed_fragment_names.include?(f.name) }
+  end
+end

data/lib/graph_ql/static_validation/literal_validator.rb

@@ -0,0 +1,27 @@
+# Test whether `ast_value` is a valid input for `type`
+class GraphQL::StaticValidation::LiteralValidator
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  attr_reader :errors
+  def validate(ast_value, type)
+    if type.kind.non_null?
+      (!ast_value.nil?) && validate(ast_value, type.of_type)
+    elsif type.kind.list? && ast_value.is_a?(Array)
+      item_type = type.of_type
+      ast_value.all? { |val| validate(val, item_type) }
+    elsif type.kind.scalar?
+      !type.coerce(ast_value).nil?
+    elsif type.kind.enum? && ast_value.is_a?(GraphQL::Nodes::Enum)
+      !type.coerce(ast_value.name).nil?
+    elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Nodes::InputObject)
+      fields = type.input_fields
+      ast_value.pairs.all? do |value|
+        field_type = fields[value.name].type
+        present_if_required = field_type.kind.non_null? ? !value.nil? : true
+        present_if_required && validate(value.value, field_type)
+      end
+    else
+      false
+    end
+  end
+end

data/lib/graph_ql/static_validation/message.rb

@@ -0,0 +1,29 @@
+# Generates GraphQL-compliant validation message.
+# Only supports one "location", too bad :(
+class GraphQL::StaticValidation::Message
+  # Convenience for validators
+  module MessageHelper
+    # Error `message` is located at `node`
+    def message(message, node)
+      GraphQL::StaticValidation::Message.new(message, line: node.line, col: node.col)
+    end
+  end
+  attr_reader :message, :line, :co
+  def initialize(message, line: nil, col: nil)
+    @message = message
+    @line = line
+    @col = col
+  end
+  def to_h
+    {
+      "message" => message,
+      "locations" => locations
+    }
+  end
+
+  private
+
+  def locations
+    @line.nil? && @col.nil ? [] : [{"line" => @line, "column" => @col}]
+  end
+end

data/lib/graph_ql/static_validation/required_arguments_are_present.rb

@@ -0,0 +1,13 @@
+class GraphQL::StaticValidation::RequiredArgumentsArePresent < GraphQL::StaticValidation::ArgumentsValidator
+  def validate_node(node, defn, context)
+    present_argument_names = node.arguments.map(&:name)
+    required_argument_names = defn.arguments.values
+      .select { |a| a.type.kind.non_null? }
+      .map(&:name)
+
+    missing_names = required_argument_names - present_argument_names
+    if missing_names.any?
+      context.errors << message("#{node.class.name.split("::").last} '#{node.name}' is missing required arguments: #{missing_names.join(", ")}", node)
+    end
+  end
+end

data/lib/graph_ql/static_validation/type_stack.rb

@@ -0,0 +1,87 @@
+# - Ride along with `GraphQL::Visitor`
+# - Track type info, expose it to validators
+class GraphQL::StaticValidation::TypeStack
+  # These are jumping-off points for infering types down the tree
+  TYPE_INFERRENCE_ROOTS = [
+    GraphQL::Nodes::OperationDefinition,
+    GraphQL::Nodes::FragmentDefinition,
+  ]
+
+  attr_reader :schema, :object_types, :field_definitions
+  def initialize(schema, visitor)
+    @schema = schema
+    @object_types = []
+    @field_definitions = []
+    visitor.enter << -> (node, parent) { PUSH_STRATEGIES[node.class].push(self, node) }
+    visitor.leave << -> (node, parent) { PUSH_STRATEGIES[node.class].pop(self, node) }
+  end
+
+  private
+
+  # Look up strategies by name and use singleton instance to push and pop
+  PUSH_STRATEGIES = Hash.new { |hash, key| hash[key] = get_strategy_for_node_class(key) }
+
+  def self.get_strategy_for_node_class(node_class)
+    node_class_name = node_class.name.split("::").last
+    strategy_key = "#{node_class_name}Strategy"
+    const_defined?(strategy_key) ? const_get(strategy_key).new : NullStrategy.new
+  end
+
+  class FragmentWithTypeStrategy
+    def push(stack, node)
+      object_type = stack.schema.types[node.type]
+      if !object_type.nil?
+        object_type = object_type.kind.unwrap(object_type)
+      end
+      stack.object_types.push(object_type)
+    end
+
+    def pop(stack, node)
+      stack.object_types.pop
+    end
+  end
+
+  class FragmentDefinitionStrategy < FragmentWithTypeStrategy; end
+  class InlineFragmentStrategy < FragmentWithTypeStrategy; end
+
+  class OperationDefinitionStrategy
+    def push(stack, node)
+      # query or mutation
+      object_type = stack.schema.public_send(node.operation_type)
+      stack.object_types.push(object_type)
+    end
+    def pop(stack, node)
+      stack.object_types.pop
+    end
+  end
+
+  class FieldStrategy
+    def push(stack, node)
+      parent_type = stack.object_types.last
+      parent_type = parent_type.kind.unwrap(parent_type)
+      if parent_type.kind.fields?
+        field_class = parent_type.fields[node.name]
+        stack.field_definitions.push(field_class)
+        if !field_class.nil?
+          next_object_type = field_class.type
+          stack.object_types.push(next_object_type)
+        else
+          stack.object_types.push(nil)
+        end
+      else
+        stack.field_definitions.push(nil)
+        stack.object_types.push(parent_type)
+      end
+    end
+
+    def pop(stack, node)
+      stack.field_definitions.pop
+      stack.object_types.pop
+    end
+  end
+
+  class NullStrategy
+    def push(stack, node);  end
+    def pop(stack, node);   end
+  end
+end

data/lib/graph_ql/static_validation/validator.rb

@@ -0,0 +1,48 @@
+class GraphQL::StaticValidation::Validator
+  VALIDATORS = [
+    GraphQL::StaticValidation::DirectivesAreDefined,
+    GraphQL::StaticValidation::ArgumentsAreDefined,
+    GraphQL::StaticValidation::RequiredArgumentsArePresent,
+    GraphQL::StaticValidation::ArgumentLiteralsAreCompatible,
+    GraphQL::StaticValidation::FragmentTypesExist,
+    GraphQL::StaticValidation::FragmentsAreUsed,
+    GraphQL::StaticValidation::FieldsAreDefinedOnType,
+    GraphQL::StaticValidation::FieldsWillMerge,
+    GraphQL::StaticValidation::FieldsHaveAppropriateSelections,
+  ]
+
+  def initialize(schema:, validators: VALIDATORS)
+    @schema = schema
+    @validators = validators
+  end
+
+  def validate(document)
+    context = Context.new(@schema, document)
+    @validators.each do |validator|
+      validator.new.validate(context)
+    end
+    context.visitor.visit(document)
+    context.errors.map(&:to_h)
+  end
+
+  class Context
+    attr_reader :schema, :document, :errors, :visitor, :fragments
+    def initialize(schema, document)
+      @schema = schema
+      @document = document
+      @fragments = {}
+      @errors = []
+      @visitor = GraphQL::Visitor.new
+      @visitor[GraphQL::Nodes::FragmentDefinition] << -> (node, parent) { @fragments[node.name] = node }
+      @type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
+    end
+
+    def object_types
+      @type_stack.object_types
+    end
+
+    def field_definition
+      @type_stack.field_definitions.last
+    end
+  end
+end

data/lib/graph_ql/type_kinds.rb

@@ -1,15 +1,53 @@
 module GraphQL::TypeKinds
-  KIND_NAMES = %i{
-    SCALAR
-    OBJECT
-    INTERFACE
-    UNION
-    ENUM
-    INPUT_OBJECT
-    LIST
-    NON_NULL
-  }
-  KIND_NAMES.each do |type_kind|
-    const_set(type_kind, type_kind)
+  class TypeKind
+    attr_reader :name
+    def initialize(name, resolves: false, fields: false, wraps: false)
+      @name = name
+      @resolves = resolves
+      @fields = fields
+      @wraps = wraps
+    end
+
+    def resolves?;  @resolves;  end
+    def fields?;    @fields;    end
+    def wraps?;     @wraps;     end
+    def to_s;       @name;      end
+
+    def resolve(type, value)
+      if resolves?
+        type.resolve_type(value)
+      else
+        type
+      end
+    end
+
+    def unwrap(type)
+      if wraps?
+        wrapped_type = type.of_type
+        wrapped_type.kind.unwrap(wrapped_type)
+      else
+        type
+      end
+    end
+  end
+
+  TYPE_KINDS = [
+    SCALAR =        TypeKind.new("SCALAR"),
+    OBJECT =        TypeKind.new("OBJECT", fields: true),
+    INTERFACE =     TypeKind.new("INTERFACE", resolves: true, fields: true),
+    UNION =         TypeKind.new("UNION", resolves: true),
+    ENUM =          TypeKind.new("ENUM"),
+    INPUT_OBJECT =  TypeKind.new("INPUT_OBJECT"),
+    LIST =          TypeKind.new("LIST", wraps: true),
+    NON_NULL =      TypeKind.new("NON_NULL", wraps: true),
+  ]
+
+  KIND_NAMES = TYPE_KINDS.map(&:name)
+  class TypeKind
+    KIND_NAMES.each do |kind_name|
+      define_method("#{kind_name.downcase}?") do
+        self.name == kind_name
+      end
+    end
   end
 end

data/lib/graph_ql/types/argument_definer.rb

@@ -0,0 +1,7 @@
+class GraphQL::ArgumentDefiner
+  include Singleton
+
+  def build(type:, desc: "", default_value: nil)
+    GraphQL::InputValue.new(type: type, description: desc, default_value: default_value)
+  end
+end

data/lib/graph_ql/types/boolean_type.rb

@@ -1,6 +1,6 @@
-GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.new do
-  name "Boolean"
-  def coerce(value)
+GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.new do |t|
+  t.name "Boolean"
+  def t.coerce(value)
     !!value
   end
 end

data/lib/graph_ql/types/field_definer.rb

@@ -0,0 +1,19 @@
+class GraphQL::FieldDefiner
+  include Singleton
+
+  def build(type:, args: {}, property: nil, desc: "", deprecation_reason: nil)
+    resolve = if property.nil?
+      -> (o, a, c)  { GraphQL::Query::DEFAULT_RESOLVE }
+    else
+      -> (object, a, c) { object.send(property) }
+    end
+
+    GraphQL::Field.new do |f|
+      f.type(type)
+      f.arguments(args)
+      f.description(desc)
+      f.resolve(resolve)
+      f.deprecation_reason(deprecation_reason)
+    end
+  end
+end

data/lib/graph_ql/types/float_type.rb

@@ -1,6 +1,6 @@
-GraphQL::FLOAT_TYPE = GraphQL::ScalarType.new do
-  name "Float"
-  def coerce(value)
+GraphQL::FLOAT_TYPE = GraphQL::ScalarType.new do |t|
+  t.name "Float"
+  def t.coerce(value)
     value.to_f
   end
 end

data/lib/graph_ql/types/input_object_type.rb

@@ -14,4 +14,8 @@ class GraphQL::InputObjectType < GraphQL::ObjectType
   def kind
     GraphQL::TypeKinds::INPUT_OBJECT
   end
+
+  def to_s
+    "<GraphQL::InputObjectType #{name}>"
+  end
 end

data/lib/graph_ql/types/input_value.rb

@@ -1,7 +1,7 @@
 class GraphQL::InputValue
   attr_reader :type, :description, :default_value
   attr_accessor :name
-  def initialize(type:, description:, default_value:, name: nil)
+  def initialize(type:, description: nil, default_value: nil, name: nil)
     @type = type
     @description = description,
     @default_value = default_value

data/lib/graph_ql/types/int_type.rb

@@ -1,6 +1,6 @@
-GraphQL::INT_TYPE = GraphQL::ScalarType.new do
-  name "Int"
-  def coerce(value)
-    value.to_i
+GraphQL::INT_TYPE = GraphQL::ScalarType.new do |t|
+  t.name "Int"
+  def t.coerce(value)
+    value.is_a?(Numeric) ? value.to_i : nil
   end
 end

data/lib/graph_ql/types/list_type.rb

@@ -1,10 +1,14 @@
 class GraphQL::ListType < GraphQL::ObjectType
   attr_reader :of_type
   def initialize(of_type:)
+    @name = "List"
     @of_type = of_type
   end
-
   def kind
     GraphQL::TypeKinds::LIST
   end
+
+  def to_s
+    "<GraphQL::ListType(#{of_type.name})>"
+  end
 end

data/lib/graph_ql/types/non_null_type.rb

@@ -15,4 +15,8 @@ class GraphQL::NonNullType < GraphQL::ObjectType
   def kind
     GraphQL::TypeKinds::NON_NULL
   end
+
+  def to_s
+    "<GraphQL::NonNullType(#{of_type.name})>"
+  end
 end

data/lib/graph_ql/types/object_type.rb

@@ -6,7 +6,7 @@ class GraphQL::ObjectType
   def initialize(&block)
     self.fields = []
     self.interfaces = []
-    instance_eval(&block)
+    yield(self, GraphQL::TypeDefiner.instance, GraphQL::FieldDefiner.instance, GraphQL::ArgumentDefiner.instance)
   end
 
   def fields(new_fields=nil)
@@ -22,31 +22,16 @@ class GraphQL::ObjectType
       .reduce({}) { |memo, (key, value)| memo[key.to_s] = value; memo }
     # Set the name from its context on this type:
     stringified_fields.each {|k, v| v.respond_to?("name=") && v.name = k }
-    stringified_fields["__typename"] = GraphQL::Field.new do |f|
-      f.name "__typename"
-      f.description "The name of this type"
-      f.type -> { !GraphQL::STRING_TYPE }
-      f.resolve -> (o, a, c) { self.name }
-    end
+    stringified_fields["__typename"] = GraphQL::Introspection::TypenameField.create(self)
     @fields = stringified_fields
   end
 
-  def field(type:, args: {}, property: nil, desc: "", deprecation_reason: nil)
-    GraphQL::AccessField.new(type: type, arguments: args, property: property, description: desc, deprecation_reason: deprecation_reason)
-  end
-
-  def arg(type:, desc: "", default_value: nil)
-    GraphQL::InputValue.new(type: type, description: desc, default_value: default_value)
-  end
-
-  def type
-    @type ||= GraphQL::TypeDefiner.new
-  end
-
   def interfaces(new_interfaces=nil)
     if new_interfaces.nil?
       @interfaces
     else
+      # if you define interfaces twice, you're gonna have a bad time :(
+      # (because it gets registered with that interface, then overriden)
       @interfaces = new_interfaces
       new_interfaces.each {|i| i.possible_types << self }
     end
@@ -57,6 +42,10 @@ class GraphQL::ObjectType
   end
 
   def to_s
-    name
+    "<GraphQL::ObjectType #{name}>"
+  end
+
+  def inspect
+    to_s
   end
 end