graphql 0.0.4 → 0.1.0

data/lib/graph_ql/query/fragment_spread_resolution_strategy.rb

@@ -0,0 +1,16 @@
+class GraphQL::Query::FragmentSpreadResolutionStrategy
+  attr_reader :result
+  def initialize(ast_fragment_spread, type, target, operation_resolver)
+    fragments = operation_resolver.query.fragments
+    fragment_def = fragments[ast_fragment_spread.name]
+    child_type = operation_resolver.query.schema.types[fragment_def.type]
+    resolved_type = GraphQL::Query::TypeResolver.new(target, child_type, type).type
+    if resolved_type.nil?
+      @result = {}
+    else
+      selections = fragment_def.selections
+      resolver = GraphQL::Query::SelectionResolver.new(target, resolved_type, selections, operation_resolver)
+      @result = resolver.result
+    end
+  end
+end

data/lib/graph_ql/query/inline_fragment_resolution_strategy.rb

@@ -0,0 +1,14 @@
+class GraphQL::Query::InlineFragmentResolutionStrategy
+  attr_reader :result
+  def initialize(ast_inline_fragment, type, target, operation_resolver)
+    child_type = operation_resolver.query.schema.types[ast_inline_fragment.type]
+    resolved_type = GraphQL::Query::TypeResolver.new(target, child_type, type).type
+    if resolved_type.nil?
+      @result = {}
+    else
+      selections = ast_inline_fragment.selections
+      resolver = GraphQL::Query::SelectionResolver.new(target, resolved_type, selections, operation_resolver)
+      @result = resolver.result
+    end
+  end
+end

data/lib/graph_ql/query/operation_resolver.rb

@@ -0,0 +1,28 @@
+class GraphQL::Query::OperationResolver
+  extend GraphQL::Forwardable
+  attr_reader :variables, :query
+
+  def initialize(operation_definition, query)
+    @operation_definition = operation_definition
+    @variables = query.params
+    @query = query
+  end
+
+  delegate :context, to: :query
+
+  def result
+    @result ||= execute(@operation_definition, query)
+  end
+
+  private
+
+  def execute(op_def, query)
+    root = if op_def.operation_type == "query"
+      query.schema.query
+    elsif op_def.operation_type == "mutation"
+      query.schema.mutation
+    end
+    resolver = GraphQL::Query::SelectionResolver.new(nil, root, op_def.selections, self)
+    resolver.result
+  end
+end

data/lib/graph_ql/query/selection_resolver.rb

@@ -0,0 +1,20 @@
+class GraphQL::Query::SelectionResolver
+  attr_reader :result
+
+  RESOLUTION_STRATEGIES = {
+    GraphQL::Nodes::Field =>          GraphQL::Query::FieldResolutionStrategy,
+    GraphQL::Nodes::FragmentSpread => GraphQL::Query::FragmentSpreadResolutionStrategy,
+    GraphQL::Nodes::InlineFragment => GraphQL::Query::InlineFragmentResolutionStrategy,
+  }
+
+  def initialize(target, type, selections, operation_resolver)
+    @result = selections.reduce({}) do |memo, ast_field|
+      chain = GraphQL::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
+      }
+      memo.merge(chain.result)
+    end
+  end
+end

data/lib/graph_ql/query/type_resolver.rb

@@ -0,0 +1,19 @@
+# Given an object, a type name (from the query) and a type object,
+# Return the type that should be used for `object`
+# or Return `nil` if it's a mismatch
+class GraphQL::Query::TypeResolver
+  attr_reader :type
+  def initialize(target, child_type, parent_type)
+    @type = if child_type.nil?
+      nil
+    elsif GraphQL::TypeKinds::UNION == parent_type.kind
+      parent_type.resolve_type(target)
+    elsif GraphQL::TypeKinds::INTERFACE == child_type.kind
+      child_type.resolve_type(target)
+    elsif child_type == parent_type
+      parent_type
+    else
+      nil
+    end
+  end
+end

data/lib/graph_ql/repl.rb

@@ -0,0 +1,27 @@
+require 'pp'
+class GraphQL::Repl
+  def initialize(schema)
+    @schema = schema
+  end
+
+  def run
+    puts "Starting a repl for schema (type 'quit' to exit)"
+    while line = gets do
+      if line == "quit\n"
+        exit
+      end
+      execute_query(line)
+    end
+  end
+
+  private
+
+  def execute_query(query_string)
+    begin
+      query = GraphQL::Query.new(@schema, query_string)
+      puts JSON.pretty_generate(query.execute)
+    rescue StandardError => err
+      puts "Couldn't parse: #{err}\n\n" # #{err.backtrace.join("\n")}"
+    end
+  end
+end

data/lib/graph_ql/schema.rb

@@ -0,0 +1,30 @@
+class GraphQL::Schema
+  extend ActiveSupport::Autoload
+  autoload(:TypeReducer)
+  DIRECTIVES = [GraphQL::SkipDirective, GraphQL::IncludeDirective]
+
+  attr_reader :query, :mutation, :directives
+  def initialize(query:, mutation:)
+    # Add fields to this query root for introspection:
+    query.fields = query.fields.merge({
+      "__type" =>     GraphQL::Field.new do |f|
+        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"]}'") }
+      end,
+      "__schema" =>   GraphQL::Field.new do |f|
+        f.description("This GraphQL schema")
+        f.type(!GraphQL::SchemaType)
+        f.resolve -> (o, a, c) { self }
+      end
+    })
+
+    @query    = query
+    @mutation = mutation
+    @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
+  end
+
+  def types
+    @types ||= TypeReducer.new(query, {}).result
+  end
+end

data/lib/graph_ql/schema/type_reducer.rb

@@ -0,0 +1,44 @@
+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)
+      @result = reduce_type(type.of_type, existing_type_hash)
+    elsif existing_type_hash.has_key?(type.name)
+      # been here, done that
+      @result = existing_type_hash
+    else
+      @result = find_types(type, existing_type_hash.dup)
+    end
+  end
+
+  private
+
+  def find_types(type, type_hash)
+    type_hash[type.name] = type
+    if FIELDS_TYPE_KINDS.include?(type.kind)
+      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))
+        end
+      end
+    end
+    if type.kind == GraphQL::TypeKinds::OBJECT
+      type.interfaces.each do |interface|
+        type_hash.merge!(reduce_type(interface, type_hash))
+      end
+    end
+    if POSSIBLE_TYPES_TYPE_KINDS.include?(type.kind)
+      type.possible_types.each do |possible_type|
+        type_hash.merge!(reduce_type(possible_type, type_hash))
+      end
+    end
+    type_hash
+  end
+
+  def reduce_type(type, type_hash)
+    self.class.new(type, type_hash).result
+  end
+end

data/lib/graph_ql/type_kinds.rb

@@ -0,0 +1,15 @@
+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)
+  end
+end

data/lib/graph_ql/types/abstract_type.rb

@@ -0,0 +1,14 @@
+# Any object can be a type as long as it implements:
+#  - #fields: Hash of { String => Field } pairs
+#  - #kind: one of GraphQL::TypeKinds
+#  - #interfaces: Array of Interfaces
+#  - #name: String
+#  - #description: String
+#
+class GraphQL::AbstractType
+  def fields; raise NotImplementedError; end
+  def kind; raise NotImplementedError; end
+  def interfaces; raise NotImplementedError; end
+  def name; raise NotImplementedError; end
+  def description; raise NotImplementedError; end
+end

data/lib/graph_ql/types/boolean_type.rb

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

data/lib/graph_ql/types/float_type.rb

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

data/lib/graph_ql/types/input_object_type.rb

@@ -0,0 +1,17 @@
+class GraphQL::InputObjectType < GraphQL::ObjectType
+  attr_definable :input_fields
+
+  def input_fields(new_fields=nil)
+    if new_fields.nil?
+      @new_fields
+    else
+      @new_fields = new_fields
+        .reduce({}) {|memo, (k, v)| memo[k.to_s] = v; memo}
+        .each { |k, v| v.respond_to?("name=") && v.name = k}
+    end
+  end
+
+  def kind
+    GraphQL::TypeKinds::INPUT_OBJECT
+  end
+end

data/lib/graph_ql/types/input_value.rb

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

data/lib/graph_ql/types/int_type.rb

@@ -0,0 +1,6 @@
+GraphQL::INT_TYPE = GraphQL::ScalarType.new do
+  name "Int"
+  def coerce(value)
+    value.to_i
+  end
+end

data/lib/graph_ql/types/list_type.rb

@@ -0,0 +1,10 @@
+class GraphQL::ListType < GraphQL::ObjectType
+  attr_reader :of_type
+  def initialize(of_type:)
+    @of_type = of_type
+  end
+
+  def kind
+    GraphQL::TypeKinds::LIST
+  end
+end

data/lib/graph_ql/types/non_null_type.rb

@@ -0,0 +1,18 @@
+class GraphQL::NonNullType < GraphQL::ObjectType
+  attr_reader :of_type
+  def initialize(of_type:)
+    @of_type = of_type
+  end
+
+  def name
+    "Non-Null"
+  end
+
+  def coerce(value)
+    of_type.coerce(value)
+  end
+
+  def kind
+    GraphQL::TypeKinds::NON_NULL
+  end
+end

data/lib/graph_ql/types/non_null_with_bang.rb

@@ -0,0 +1,5 @@
+module GraphQL::NonNullWithBang
+  def !
+    GraphQL::NonNullType.new(of_type: self)
+  end
+end

data/lib/graph_ql/types/object_type.rb

@@ -0,0 +1,62 @@
+class GraphQL::ObjectType
+  extend GraphQL::Definable
+  attr_definable :name, :description, :interfaces, :fields
+  include GraphQL::NonNullWithBang
+
+  def initialize(&block)
+    self.fields = []
+    self.interfaces = []
+    instance_eval(&block)
+  end
+
+  def fields(new_fields=nil)
+    if new_fields
+      self.fields = new_fields
+    else
+      @fields
+    end
+  end
+
+  def fields=(new_fields)
+    stringified_fields = new_fields
+      .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
+    @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
+      @interfaces = new_interfaces
+      new_interfaces.each {|i| i.possible_types << self }
+    end
+  end
+
+  def kind
+    GraphQL::TypeKinds::OBJECT
+  end
+
+  def to_s
+    name
+  end
+end

data/lib/graph_ql/types/scalar_type.rb

@@ -0,0 +1,5 @@
+class GraphQL::ScalarType < GraphQL::ObjectType
+  def kind
+    GraphQL::TypeKinds::SCALAR
+  end
+end

data/lib/graph_ql/types/string_type.rb

@@ -0,0 +1,6 @@
+GraphQL::STRING_TYPE = GraphQL::ScalarType.new do
+  name "String"
+  def coerce(value)
+    value.to_s
+  end
+end

data/lib/graph_ql/types/type_definer.rb

@@ -0,0 +1,16 @@
+class GraphQL::TypeDefiner
+  TYPES = {
+    Int:     GraphQL::INT_TYPE,
+    String:  GraphQL::STRING_TYPE,
+    Float:   GraphQL::FLOAT_TYPE,
+    Boolean: GraphQL::BOOLEAN_TYPE,
+  }
+
+  TYPES.each do |method_name, type|
+    define_method(method_name) { type }
+  end
+
+  def [](type)
+    GraphQL::ListType.new(of_type: type)
+  end
+end

data/lib/graph_ql/union.rb

@@ -0,0 +1,35 @@
+class GraphQL::Union
+  include GraphQL::NonNullWithBang
+  attr_reader :name, :possible_types
+  def initialize(name, types)
+    if types.length < 2
+      raise ArgumentError, "Union #{name} must be defined with 2 or more types, not #{types.length}"
+    end
+
+    non_object_types = types.select {|t| t.kind != GraphQL::TypeKinds::OBJECT}
+    if non_object_types.any?
+      types_string = non_object_types.map{|t| "#{t.name} #{t.kind}"}.join(", ")
+      raise ArgumentError, "Unions can only consist of Object types, but #{name} has non-object types: #{types_string}"
+    end
+
+    @name = name
+    @possible_types = types
+  end
+
+  def kind; GraphQL::TypeKinds::UNION; end
+
+  def include?(type)
+    possible_types.include?(type)
+  end
+
+  # Find a type in this union for a given object.
+  # Reimplement if needed
+  def resolve_type(object)
+    type_name = object.class.name
+    possible_types.find {|t| t.name == type_name}
+  end
+
+  def to_s
+    "<GraphQL::Union #{name} [#{possible_types.map(&:name).join(", ")}]>"
+  end
+end