graphql 0.1.0 → 0.2.0

data/lib/graph_ql/schema.rb

@@ -1,20 +1,19 @@
 class GraphQL::Schema
-  extend ActiveSupport::Autoload
-  autoload(:TypeReducer)
   DIRECTIVES = [GraphQL::SkipDirective, GraphQL::IncludeDirective]
 
-  attr_reader :query, :mutation, :directives
+  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" =>     GraphQL::Field.new do |f, type, field, arg|
         f.description("A type in the GraphQL system")
-        f.type(!GraphQL::TypeType)
-        f.resolve -> (o, a, c) { self.types[a["name"]] || raise("No type found in schema for '#{a["name"]}'") }
+        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::SchemaType)
+        f.type(!GraphQL::Introspection::SchemaType)
         f.resolve -> (o, a, c) { self }
       end
     })
@@ -22,9 +21,22 @@ class GraphQL::Schema
     @query    = query
     @mutation = mutation
     @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
+    @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
+
+    errors = SchemaValidator.new.validate(self)
+    if errors.any?
+      raise("Schema is invalid: \n#{errors.join("\n")}")
+    end
   end
 
   def types
     @types ||= TypeReducer.new(query, {}).result
   end
 end
+
+require 'graph_ql/schema/each_item_validator'
+require 'graph_ql/schema/field_validator'
+require 'graph_ql/schema/implementation_validator'
+require 'graph_ql/schema/schema_validator'
+require 'graph_ql/schema/type_reducer'
+require 'graph_ql/schema/type_validator'

data/lib/graph_ql/schema/each_item_validator.rb

@@ -0,0 +1,12 @@
+class GraphQL::Schema::EachItemValidator
+  def initialize(errors)
+    @errors = errors
+  end
+
+  def validate(items, as:, must_be:)
+    invalid_items = items.select {|k| !yield(k) }
+    if invalid_items.any?
+      @errors << "#{as} must be #{must_be}, but some aren't: #{invalid_items.map(&:to_s).join(", ")}"
+    end
+  end
+end

data/lib/graph_ql/schema/field_validator.rb

@@ -0,0 +1,13 @@
+class GraphQL::Schema::FieldValidator
+  def validate(field, errors)
+    implementation = GraphQL::Schema::ImplementationValidator.new(field, as: "Field", errors: errors)
+    implementation.must_respond_to(:name)
+    implementation.must_respond_to(:type)
+    implementation.must_respond_to(:description)
+    implementation.must_respond_to(:arguments) do |arguments|
+      validator = GraphQL::Schema::EachItemValidator.new(errors)
+      validator.validate(arguments.keys, as: "#{field.name}.arguments keys", must_be: "Strings") { |k| k.is_a?(String) }
+    end
+    implementation.must_respond_to(:deprecation_reason)
+  end
+end

data/lib/graph_ql/schema/implementation_validator.rb

@@ -0,0 +1,21 @@
+# A helper to ensure `object` implements the concept `as`
+class GraphQL::Schema::ImplementationValidator
+  attr_reader :object, :errors, :implementation_as
+  def initialize(object, as:, errors:)
+    @object = object
+    @implementation_as = as
+    @errors = errors
+  end
+
+  # Ensure the object responds to `method_name`.
+  # If `block_given?`, yield the return value of that method
+  # If provided, use `as` in the error message, overriding class-level `as`.
+  def must_respond_to(method_name, args: [], as: nil)
+    if !object.respond_to?(method_name)
+      local_as = as || implementation_as
+      errors << "#{object.to_s} must respond to ##{method_name}(#{args.join(", ")}) to be a #{local_as}"
+    elsif block_given?
+      yield(object.public_send(method_name))
+    end
+  end
+end

data/lib/graph_ql/schema/schema_validator.rb

@@ -0,0 +1,10 @@
+class GraphQL::Schema::SchemaValidator
+  def validate(schema)
+    errors = []
+    schema.types.each do |name, type|
+      type_validator = GraphQL::Schema::TypeValidator.new
+      type_validator.validate(type, errors)
+    end
+    errors
+  end
+end

data/lib/graph_ql/schema/type_reducer.rb

@@ -1,6 +1,6 @@
+# Starting from a given type, discover other types in the system by
+# traversing that type's fields, possible_types, etc
 class GraphQL::Schema::TypeReducer
-  FIELDS_TYPE_KINDS = [GraphQL::TypeKinds::OBJECT, GraphQL::TypeKinds::INTERFACE]
-  POSSIBLE_TYPES_TYPE_KINDS = [GraphQL::TypeKinds::INTERFACE, GraphQL::TypeKinds::UNION]
   attr_reader :type, :result
   def initialize(type, existing_type_hash)
     if [GraphQL::TypeKinds::NON_NULL, GraphQL::TypeKinds::LIST].include?(type.kind)
@@ -17,20 +17,20 @@ class GraphQL::Schema::TypeReducer
 
   def find_types(type, type_hash)
     type_hash[type.name] = type
-    if FIELDS_TYPE_KINDS.include?(type.kind)
+    if type.kind.fields?
       type.fields.each do |name, field|
         type_hash.merge!(reduce_type(field.type, type_hash))
         field.arguments.each do |name, argument|
-          type_hash.merge!(reduce_type(argument[:type], type_hash))
+          type_hash.merge!(reduce_type(argument.type, type_hash))
         end
       end
     end
-    if type.kind == GraphQL::TypeKinds::OBJECT
+    if type.kind.object?
       type.interfaces.each do |interface|
         type_hash.merge!(reduce_type(interface, type_hash))
       end
     end
-    if POSSIBLE_TYPES_TYPE_KINDS.include?(type.kind)
+    if type.kind.resolves?
       type.possible_types.each do |possible_type|
         type_hash.merge!(reduce_type(possible_type, type_hash))
       end

data/lib/graph_ql/schema/type_validator.rb

@@ -0,0 +1,47 @@
+class GraphQL::Schema::TypeValidator
+  def validate(type, errors)
+    implementation = GraphQL::Schema::ImplementationValidator.new(type, as: "Type", errors: errors)
+    implementation.must_respond_to(:name)
+    implementation.must_respond_to(:kind)
+    type_name = type.name
+    kind_name = type.kind.name
+
+    implementation.must_respond_to(:description, as: kind_name)
+    each_item_validator = GraphQL::Schema::EachItemValidator.new(errors)
+
+    if type.kind.fields?
+      field_validator = GraphQL::Schema::FieldValidator.new
+      implementation.must_respond_to(:fields, as: kind_name) do |fields|
+        each_item_validator.validate(fields.keys, as: "#{type.name}.fields keys", must_be: "Strings") { |k| k.is_a?(String) }
+
+        fields.values.each do |field|
+          field_validator.validate(field, errors)
+        end
+      end
+    end
+
+    if type.kind.resolves?
+      implementation.must_respond_to(:resolve_type)
+      implementation.must_respond_to(:possible_types, as: kind_name) do |possible_types|
+        each_item_validator.validate(possible_types, as: "#{type_name}.possible_types", must_be: "objects") { |t| t.kind.object? }
+      end
+    end
+
+    if type.kind.object?
+      implementation.must_respond_to(:interfaces, as: kind_name) do |interfaces|
+        each_item_validator.validate(interfaces, as: "#{type_name}.interfaces", must_be: "interfaces") { |t| t.kind.interface? }
+      end
+    end
+
+    if type.kind.input_object?
+      implementation.must_respond_to(:input_fields, as: kind_name)
+    end
+
+    if type.kind.union?
+      union_types = type.possible_types
+      if union_types.length < 2
+        errors << "Union #{type_name} must be defined with 2 or more types, not #{union_types.length}"
+      end
+    end
+  end
+end

data/lib/graph_ql/static_validation.rb

@@ -0,0 +1,18 @@
+module GraphQL::StaticValidation
+end
+
+require 'graph_ql/static_validation/message'
+require 'graph_ql/static_validation/arguments_validator'
+
+require 'graph_ql/static_validation/argument_literals_are_compatible'
+require 'graph_ql/static_validation/arguments_are_defined'
+require 'graph_ql/static_validation/required_arguments_are_present'
+require 'graph_ql/static_validation/fragment_types_exist'
+require 'graph_ql/static_validation/directives_are_defined'
+require 'graph_ql/static_validation/fields_are_defined_on_type'
+require 'graph_ql/static_validation/fields_have_appropriate_selections'
+require 'graph_ql/static_validation/fields_will_merge'
+require 'graph_ql/static_validation/fragments_are_used'
+require 'graph_ql/static_validation/type_stack'
+require 'graph_ql/static_validation/validator'
+require 'graph_ql/static_validation/literal_validator'

data/lib/graph_ql/static_validation/argument_literals_are_compatible.rb

@@ -0,0 +1,13 @@
+class GraphQL::StaticValidation::ArgumentLiteralsAreCompatible < GraphQL::StaticValidation::ArgumentsValidator
+  def validate_node(node, defn, context)
+    args_with_literals = node.arguments.select {|a| !a.value.is_a?(GraphQL::Nodes::VariableIdentifier)}
+    validator = GraphQL::StaticValidation::LiteralValidator.new
+    args_with_literals.each do |arg|
+      arg_defn = defn.arguments[arg.name]
+      valid = validator.validate(arg.value, arg_defn.type)
+      if !valid
+        context.errors << message("#{arg.name} on #{node.class.name.split("::").last} '#{node.name}' has an invalid value", node)
+      end
+    end
+  end
+end

data/lib/graph_ql/static_validation/arguments_are_defined.rb

@@ -0,0 +1,10 @@
+class GraphQL::StaticValidation::ArgumentsAreDefined < GraphQL::StaticValidation::ArgumentsValidator
+  def validate_node(node, defn, context)
+    node.arguments.each do |argument|
+      argument_defn = defn.arguments[argument.name]
+      if argument_defn.nil?
+        context.errors << message("#{node.class.name.split("::").last} '#{node.name}' doesn't accept argument #{argument.name}", node)
+      end
+    end
+  end
+end

data/lib/graph_ql/static_validation/arguments_validator.rb

@@ -0,0 +1,16 @@
+# Implement validate_node
+class GraphQL::StaticValidation::ArgumentsValidator
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def validate(context)
+    visitor = context.visitor
+    visitor[GraphQL::Nodes::Field] << -> (node, parent) {
+      field_defn = context.field_definition
+      validate_node(node, field_defn, context)
+    }
+    visitor[GraphQL::Nodes::Directive] << -> (node, parent) {
+      directive_defn = context.schema.directives[node.name]
+      validate_node(node, directive_defn, context)
+    }
+  end
+end

data/lib/graph_ql/static_validation/directives_are_defined.rb

@@ -0,0 +1,18 @@
+class GraphQL::StaticValidation::DirectivesAreDefined
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def validate(context)
+    directive_names = context.schema.directives.keys
+    context.visitor[GraphQL::Nodes::Directive] << -> (node, parent) {
+      validate_directive(node, directive_names, context.errors)
+    }
+  end
+
+  private
+
+  def validate_directive(ast_directive, directive_names, errors)
+     if !directive_names.include?(ast_directive.name)
+       errors << message("Directive @#{ast_directive.name} is not defined", ast_directive)
+    end
+  end
+end

data/lib/graph_ql/static_validation/fields_are_defined_on_type.rb

@@ -0,0 +1,29 @@
+class GraphQL::StaticValidation::FieldsAreDefinedOnType
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  IS_FIELD = Proc.new {|f| f.is_a?(GraphQL::Nodes::Field) }
+
+  def validate(context)
+    visitor = context.visitor
+    visitor[GraphQL::Nodes::Field] << -> (node, parent) {
+      parent_type = context.object_types[-2]
+      parent_type = parent_type.kind.unwrap(parent_type)
+      validate_field(context.errors, node, parent_type, parent)
+    }
+  end
+
+  private
+
+  def validate_field(errors, ast_field, parent_type, parent)
+    if parent_type.kind.union?
+      errors << message("Selections can't be made directly on unions (see selections on #{parent_type.name})", parent)
+      return GraphQL::Visitor::SKIP
+    end
+
+    field =  parent_type.fields[ast_field.name]
+    if field.nil?
+      errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", parent)
+      return GraphQL::Visitor::SKIP
+    end
+  end
+end

data/lib/graph_ql/static_validation/fields_have_appropriate_selections.rb

@@ -0,0 +1,31 @@
+# Scalars _can't_ have selections
+# Objects _must_ have selections
+class GraphQL::StaticValidation::FieldsHaveAppropriateSelections
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  def validate(context)
+    context.visitor[GraphQL::Nodes::Field] << -> (node, parent)  {
+      field_defn = context.field_definition
+      validate_field_selections(node, field_defn, context.errors)
+    }
+  end
+
+  private
+
+  def validate_field_selections(ast_field, field_defn, errors)
+    resolved_type = field_defn.type.kind.unwrap(field_defn.type)
+
+    if resolved_type.kind.scalar? && ast_field.selections.any?
+      error = message("Selections can't be made on scalars (field '#{ast_field.name}' returns #{resolved_type.name} but has selections [#{ast_field.selections.map(&:name).join(", ")}])", ast_field)
+    elsif resolved_type.kind.object? && ast_field.selections.none?
+      error = message("Objects must have selections (field '#{ast_field.name}' returns #{resolved_type.name} but has no selections)", ast_field)
+    else
+      error = nil
+    end
+
+    if !error.nil?
+      errors << error
+      GraphQL::Visitor::SKIP
+    end
+  end
+end

data/lib/graph_ql/static_validation/fields_will_merge.rb

@@ -0,0 +1,93 @@
+class GraphQL::StaticValidation::FieldsWillMerge
+  def validate(context)
+    fragments = {}
+    has_selections = []
+    visitor = context.visitor
+    visitor[GraphQL::Nodes::OperationDefinition] << -> (node, parent) {
+      if node.selections.any?
+        has_selections << node
+      end
+    }
+    visitor[GraphQL::Nodes::Document].leave << -> (node, parent) {
+      has_selections.each { |node|
+        field_map = gather_fields_by_name(node.selections, {}, context)
+        find_conflicts(field_map, context)
+      }
+    }
+  end
+
+  private
+
+  def find_conflicts(field_map, context)
+    field_map.each do |name, ast_fields|
+      comparison = FieldDefinitionComparison.new(name, ast_fields)
+      context.errors.push(*comparison.errors)
+
+      subfield_map = ast_fields.reduce({}) do |memo, defn|
+        gather_fields_by_name(defn.selections, memo, context)
+      end
+      find_conflicts(subfield_map, context)
+    end
+  end
+
+  def gather_fields_by_name(fields, field_map, context)
+    fields.each do |field|
+      if field.is_a?(GraphQL::Nodes::InlineFragment)
+        next_fields = field.selections
+      elsif field.is_a?(GraphQL::Nodes::FragmentSpread)
+        fragment = context.fragments[field.name]
+        next_fields = fragment.selections
+      else
+        name_in_selection = field.alias || field.name
+        field_map[name_in_selection] ||= []
+        field_map[name_in_selection].push(field)
+        next_fields = []
+      end
+      gather_fields_by_name(next_fields, field_map, context)
+    end
+    field_map
+  end
+
+  # Compare two field definitions, add errors to the list if there are any
+  class FieldDefinitionComparison
+    include GraphQL::StaticValidation::Message::MessageHelper
+    NAMED_VALUES = [GraphQL::Nodes::Enum, GraphQL::Nodes::VariableIdentifier]
+    attr_reader :errors
+    def initialize(name, defs)
+      errors = []
+
+      names = defs.map(&:name).uniq
+      if names.length != 1
+        errors << message("Field '#{name}' has a field conflict: #{names.join(" or ")}?", defs.first)
+      end
+
+      args = defs.map { |defn| reduce_list(defn.arguments)}.uniq
+      if args.length != 1
+        errors << message("Field '#{name}' has an argument conflict: #{args.map {|a| JSON.dump(a) }.join(" or ")}?", defs.first)
+      end
+
+      directive_names = defs.map { |defn| defn.directives.map(&:name) }.uniq
+      if directive_names.length != 1
+        errors << message("Field '#{name}' has a directive conflict: #{directive_names.map {|names| "[#{names.join(", ")}]"}.join(" or ")}?", defs.first)
+      end
+
+      directive_args = defs.map {|defn| defn.directives.map {|d| reduce_list(d.arguments) } }.uniq
+      if directive_args.length != 1
+        errors << message("Field '#{name}' has a directive argument conflict: #{directive_args.map {|args| JSON.dump(args)}.join(" or ")}?", defs.first)
+      end
+
+      @errors = errors
+    end
+
+    private
+
+    # Turn AST tree into a hash
+    # can't look up args, the names just have to match
+    def reduce_list(args)
+      args.reduce({}) do |memo, a|
+        memo[a.name] = NAMED_VALUES.include?(a.value.class) ? a.value.name : a.value
+        memo
+      end
+    end
+  end
+end

data/lib/graph_ql/static_validation/fragment_types_exist.rb

@@ -0,0 +1,24 @@
+class GraphQL::StaticValidation::FragmentTypesExist
+  include GraphQL::StaticValidation::Message::MessageHelper
+
+  FRAGMENTS_ON_TYPES = [
+    GraphQL::Nodes::FragmentDefinition,
+    GraphQL::Nodes::InlineFragment,
+  ]
+
+  def validate(context)
+    FRAGMENTS_ON_TYPES.each do |node_class|
+      context.visitor[node_class] << -> (node, parent) { validate_type_exists(node, context) }
+    end
+  end
+
+  private
+
+  def validate_type_exists(node, context)
+    type = context.schema.types[node.type]
+    if type.nil?
+      context.errors << message("No such type #{node.type}, so it can't be a fragment condition", node)
+      GraphQL::Visitor::SKIP
+    end
+  end
+end