graphql-rb 0.0.2

data/lib/graphql/type/scalar_type.rb

@@ -0,0 +1,137 @@
+require 'graphql/configuration'
+
+module GraphQL
+
+
+  # GraphQL Scalar Type Configuration
+  #
+  class GraphQLScalarTypeConfiguration < GraphQL::Configuration::Base
+    slot :name,             String
+    slot :description,      String, null: true
+    slot :serialize,        Proc
+    slot :parse_value,      Proc
+    slot :parse_literal,    Proc
+  end
+
+  # GraphQL Scalar Type
+  #
+  class GraphQLScalarType < GraphQL::Configuration::Configurable
+
+    include GraphQLType
+    include GraphQLInputType
+    include GraphQLOutputType
+    include GraphQLLeafType
+    include GraphQLNullableType
+    include GraphQLNamedType
+
+    configure_with GraphQLScalarTypeConfiguration
+
+    def initialize(configuration)
+      super
+      raise RuntimeError.new("Name should present in #{self.class}") if name.nil? || name.size == 0
+    end
+
+    def serialize(value)
+      @configuration.serialize.call(value)
+    end
+
+    def parse_value(value)
+      @configuration.parse_value.call(value)
+    end
+
+    def parse_literal(ast)
+      @configuration.parse_literal.call(ast)
+    end
+
+    def to_s
+      name
+    end
+
+  end
+
+  # Int
+  #
+  GraphQLInt = GraphQLScalarType.new do
+    name 'Int'
+
+    serialize lambda { |value|
+      value = value.to_s
+      return nil unless value =~ /\A[-+]?[0-9]*\.?[0-9]+\Z/
+      value.to_f.round
+    }
+
+    parse_value serialize #-> (value) { serialize(value) }
+
+    parse_literal lambda { |ast|
+      ast[:kind] == :int ? ast[:value].to_i : nil
+    }
+  end
+
+  # Float
+  #
+  GraphQLFloat = GraphQLScalarType.new do
+    name 'Float'
+
+    serialize lambda { |value|
+      value = value.to_s
+      return nil unless value =~ /\A[-+]?[0-9]*\.?[0-9]+\Z/
+      value.to_f
+    }
+
+    parse_value serialize
+
+    parse_literal lambda { |ast|
+      ast[:kind] == :int || ast[:kind] == :float ? ast[:value].to_f : nil
+    }
+  end
+
+  # String
+  #
+  GraphQLString = GraphQLScalarType.new do
+    name 'String'
+
+    serialize lambda { |value|
+      value.to_s
+    }
+
+    parse_value serialize
+
+    parse_literal lambda { |ast|
+      ast[:kind] == :string ? ast[:value] : nil
+    }
+  end
+
+  # Boolean
+  #
+  GraphQLBoolean = GraphQLScalarType.new do
+    name 'Boolean'
+
+    serialize lambda { |value|
+      return false if value == 0
+      !!value
+    }
+
+    parse_value serialize
+
+    parse_literal lambda { |ast|
+      ast[:kind] == :boolean ? ast[:value] : nil
+    }
+  end
+
+  # ID
+  #
+  GraphQLID = GraphQLScalarType.new do
+    name 'ID'
+
+    serialize lambda { |value|
+      value.to_s
+    }
+
+    parse_value serialize
+
+    parse_literal lambda { |ast|
+      ast[:kind] == :string || ast[:kind] == :int ? ast[:value] : nil
+    }
+  end
+
+end

data/lib/graphql/type/schema.rb

@@ -0,0 +1,49 @@
+module GraphQL
+
+  class GraphQLSchemaConfiguration < GraphQL::Configuration::Base
+
+    slot :name,       String
+    slot :query,      GraphQLObjectType
+    slot :mutation,   GraphQLObjectType, null: true
+
+  end
+
+  class GraphQLSchema < GraphQL::Configuration::Configurable
+
+    configure_with GraphQLSchemaConfiguration
+
+    def query_type
+      @configuration.query
+    end
+
+    def mutation_type
+      @configuration.mutation
+    end
+
+    def type_map
+      @type_map ||= [query_type, mutation_type, Introspection::Schema__].reduce({}, &TypeMapReducer)
+    end
+
+    def type_names
+      @type_names ||= type_map.keys
+    end
+
+    def types
+      @types ||= type_map.values
+    end
+
+    def type(name)
+      type_map[name]
+    end
+
+    def directives
+      @directives ||= [GraphQLSkipDirective, GraphQLIncludeDirective]
+    end
+
+    def to_s
+      name
+    end
+
+  end
+
+end

data/lib/graphql/type/union_type.rb

@@ -0,0 +1,39 @@
+module GraphQL
+
+  class GraphQLUnionTypeConfiguration < GraphQL::Configuration::Base
+    slot :name,           String
+    slot :types,          [-> { GraphQLObjectType }], singular: :type
+    slot :resolve_type,   Proc,     null: true
+    slot :description,    String,   null: true
+  end
+
+  class GraphQLUnionType < GraphQL::Configuration::Configurable
+
+    include GraphQLType
+    include GraphQLOutputType
+    include GraphQLCompositeType
+    include GraphQLAbstractType
+    include GraphQLNullableType
+    include GraphQLNamedType
+
+    configure_with GraphQLUnionTypeConfiguration
+
+    def possible_types
+      @configuration.types
+    end
+
+    def possible_type?(type)
+      @configuration.types.include?(type)
+    end
+
+    def resolve_type(type)
+      @configuration.resolve_type.nil? ? type_of(type) : @configuration.resolve_type.call(type)
+    end
+
+    def to_s
+      name
+    end
+
+  end
+
+end

data/lib/graphql/type.rb

@@ -0,0 +1,82 @@
+module GraphQL
+
+  module GraphQLType
+    def +@
+      GraphQLList.new(self)
+    end
+  end
+
+  module GraphQLInputType
+  end
+
+  module GraphQLOutputType
+  end
+
+  module GraphQLLeafType
+  end
+
+  module GraphQLCompositeType
+  end
+
+  module GraphQLNamedType
+  end
+
+  module GraphQLAbstractType
+
+    def type_of(value)
+      raise "Not implemented. Yet."
+    end
+
+  end
+
+  module GraphQLNullableType
+
+    def !
+      GraphQLNonNull.new(self)
+    end
+
+  end
+
+  def self.named_type(type)
+    type = type.of_type while type.is_a?(GraphQLList) || type.is_a?(GraphQLNonNull)
+  end
+
+  TypeMapReducer = lambda do |memo, type|
+    return TypeMapReducer.call(memo, type.of_type) if type.is_a?(GraphQLNonNull) || type.is_a?(GraphQLList)
+
+    return memo if type.nil? || memo.keys.include?(type.name)
+
+    memo[type.name] = type
+
+    if type.is_a?(GraphQLUnionType) || type.is_a?(GraphQLInterfaceType)
+      memo = type.possible_types.reduce(memo, &TypeMapReducer)
+    end
+
+    if type.is_a?(GraphQLObjectType)
+      memo = type.interfaces.reduce(memo, &TypeMapReducer)
+    end
+
+    if type.is_a?(GraphQLObjectType) || type.is_a?(GraphQLInterfaceType)
+      type.field_map.each do |name, field|
+        memo = field.args.map(&:type).reduce(memo, &TypeMapReducer)
+        memo = TypeMapReducer.call(memo, field.type)
+      end
+    end
+
+    memo
+  end
+
+end
+
+require_relative 'type/scalar_type'
+require_relative 'type/object_type'
+require_relative 'type/interface_type'
+require_relative 'type/union_type'
+require_relative 'type/enum_type'
+require_relative 'type/input_object_type'
+require_relative 'type/field'
+require_relative 'type/argument'
+require_relative 'type/list'
+require_relative 'type/non_null'
+require_relative 'type/schema'
+require_relative 'type/directive'

data/lib/graphql/validator.rb

@@ -0,0 +1,43 @@
+module GraphQL
+  class Validator
+
+    def self.coerce_value(value, type)
+      case type
+      when GraphQLNonNull
+        coerce_value(value, type.of_type)
+      when value.nil?
+        nil
+      when GraphQLList
+        values = value.is_a?(Array) ? value : [value]
+        values.map { |value| coerce_value(value, type.of_type) }
+      when GraphQLInputObjectType
+        raise "Not. Implemented. Yet."
+      when GraphQLScalarType, GraphQLEnumType
+        type.parse_value(value)
+      else
+        raise "Must be input type"
+      end
+    end
+
+    def self.valid_value?(value, type)
+      case type
+      when GraphQLNonNull
+        return false if value.nil?
+        valid_value?(value, type.of_type)
+      when value.nil?
+        true
+      when GraphQLList
+        values = value.is_a?(Array) ? value : [value]
+        values.all? { |value| valid_value?(value, type.of_type) }
+      when GraphQLInputObjectType
+        raise "Not. Implemented. Yet."
+      when GraphQLScalarType, GraphQLEnumType
+        !type.parse_value(value).nil?
+      else
+        raise "Must be input type"
+      end
+    end
+
+
+  end
+end

data/lib/graphql/version.rb

@@ -0,0 +1,3 @@
+module GraphQL
+  VERSION = '0.0.2'
+end

data/lib/graphql.rb

@@ -0,0 +1,21 @@
+require 'graphql/errors'
+require 'graphql/configuration'
+require 'graphql/type'
+require 'graphql/introspection'
+require 'graphql/language'
+require 'graphql/version'
+require 'graphql/executor'
+require 'graphql/validator'
+
+module GraphQL
+
+  def self.graphql(schema, query, root, params, operation = nil)
+    document  = GraphQL::Language.parse(query)
+    executor  = GraphQL::Executor.new(document, schema)
+    result    = executor.execute(root, params, operation)
+    { data: result }
+  rescue StandardError => e
+    { errors: [e] }
+  end
+
+end

data/spec/configuration/configuration_spec.rb

@@ -0,0 +1,4 @@
+require 'graphql'
+
+RSpec.describe GraphQL::Configuration do
+end

data/spec/data.rb

@@ -0,0 +1,89 @@
+require 'celluloid/current'
+require 'logger'
+
+module StarWars
+  class Data
+    include Celluloid
+
+    Human   = Struct.new('Human', :id, :name, :friends, :appears_in, :home_planet)
+    Droid   = Struct.new('Droid', :id, :name, :friends, :appears_in, :primary_function)
+
+    Luke    = Human.new('1000', 'Like Skywalker',   ['1002', '1003', '2000', '2001'],   [4, 5, 6], 'Tatooine')
+    Vader   = Human.new('1001', 'Darth Vader',      ['1004'],                           [4, 5, 6], 'Tatooine')
+    Han     = Human.new('1002', 'Han Solo',         ['1000', '1003', '2001'],           [4, 5, 6])
+    Leia    = Human.new('1003', 'Lea Organa',       ['1000', '1002', '2000', '2001'],   [4, 5, 6], 'Alderaan')
+    Tarkin  = Human.new('1004', 'Wilhuff Tarkin',   ['1001'],                           [4])
+
+    ThreePO = Droid.new('2000', 'C-3PO',            ['1000', '1002', '1003', '2001'],   [4, 5, 6], 'Protocol')
+    Artoo   = Droid.new('2001', 'R2-D2',            ['1000', '1002', '1003'],           [4, 5, 6], 'Astromech')
+
+    Characters = [Luke, Vader, Han, Leia, Tarkin, ThreePO, Artoo]
+
+    def self.logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def self.get(id)
+      Fetcher.fetch(id)
+    end
+
+    def self.select(ids)
+      Fetcher.fetch(ids)
+    end
+
+
+    class Fetcher
+      include Celluloid
+
+      def self.logger
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      def self.fetch(id_or_ids)
+        logger.info "Fetching `#{id_or_ids}`"
+        pool.future.fetch(id_or_ids)
+      end
+
+      def self.pool
+        @pool ||= new
+      end
+
+      def initialize
+        @timer  = after(0.01) { perform_fetch }
+        @data   = {}
+      end
+
+      def restart
+        @timer.reset
+      end
+
+      def fetch(id_or_ids)
+        condition = Celluloid::Condition.new
+        (@data[id_or_ids] ||= []) << lambda { |value| condition.signal(value) }
+        restart
+        condition.wait
+      end
+
+      def perform_fetch
+        self.class.logger.info "Performing fetch"
+        data        = @data
+        @data       = {}
+        ids         = data.keys.flatten.uniq
+        self.class.logger.info "select * from table where id in #{ids}"
+        # sleep 1
+        characters  = Data::Characters.select { |c| ids.include?(c.id) }
+        data.each do |key, blocks|
+          result = if key.is_a?(Array)
+            result = characters.select { |c| key.include?(c.id) }
+          else
+            result = characters.find { |c| key == (c.id) }
+          end
+          blocks.each { |block| block.call(result) }
+        end
+      end
+
+    end
+
+
+  end
+end

data/spec/introspection/full_spec.rb

@@ -0,0 +1,12 @@
+require 'graphql'
+require_relative '../schema'
+
+RSpec.describe "Introspection - Full" do
+
+  it "Should allow querying the schema" do
+    expect {
+      GraphQL::graphql(StarWars::Schema, GraphQL::Introspection::Query, {}, {})
+    }.not_to raise_error
+  end
+
+end

data/spec/introspection/simple_spec.rb

@@ -0,0 +1,153 @@
+require 'graphql'
+require_relative '../schema'
+
+RSpec.describe "Introspection - Simple" do
+
+  def q1
+    %Q(
+      query Introspection {
+        __schema {
+          types {
+            name
+          }
+        }
+      }
+    )
+  end
+
+
+  def q2
+    %Q(
+      query Introspection {
+        __schema {
+          queryType {
+            name
+          }
+        }
+      }
+    )
+  end
+
+
+  def q3
+    %Q(
+      query Introspection {
+        __type(name: "Droid") {
+          name
+        }
+      }
+    )
+  end
+
+
+  def q4
+    %Q(
+      query Introspection {
+        __type(name: "Droid") {
+          name
+          kind
+        }
+      }
+    )
+  end
+
+
+  def q5
+    %Q(
+      query Introspection {
+        __type(name: "Character") {
+          name
+          kind
+        }
+      }
+    )
+  end
+
+
+  def q6
+    %Q(
+      query Introspection {
+        __type(name: "Droid") {
+          name
+          fields {
+            name
+            type {
+              name
+              kind
+            }
+          }
+        }
+      }
+    )
+  end
+
+
+  it "Should allow querying the schema for types" do
+    expectation = {
+      data: {
+        __schema: {
+          types: [
+            { name: "Query"         },
+            { name: "Episode"       },
+            { name: "Character"     },
+            { name: "Human"         },
+            { name: "String"        },
+            { name: "Droid"         },
+            { name: "__Schema"      },
+            { name: "__Type"        },
+            { name: "__TypeKind"    },
+            { name: "Boolean"       },
+            { name: "__Field"       },
+            { name: "__InputValue"  },
+            { name: "__EnumValue"   }
+          ]
+        }
+      }
+    }
+
+    result = GraphQL::graphql(StarWars::Schema, q1, {}, {})
+
+    expect(result).to eql(expectation)
+  end
+
+  it "Should allow querying the schema for query type" do
+    expectation = {
+      data: { __schema: { queryType: { name: "Query" } } }
+    }
+
+    result = GraphQL::graphql(StarWars::Schema, q2, {}, {})
+
+    expect(result).to eql(expectation)
+  end
+
+  it "Should allow querying the schema for a specific type" do
+    expectation = {
+      data: { __type: { name: 'Droid' } }
+    }
+
+    result = GraphQL::graphql(StarWars::Schema, q3, {}, {})
+
+    expect(result).to eql(expectation)
+  end
+
+  it "Should allow querying the schema for an object kind" do
+    expectation = {
+      data: { __type: { name: 'Droid', kind: 'OBJECT' } }
+    }
+
+    result = GraphQL::graphql(StarWars::Schema, q4, {}, {})
+
+    expect(result).to eql(expectation)
+  end
+
+  it "Should allow querying the schema for an interface kind" do
+    expectation = {
+      data: { __type: { name: 'Character', kind: 'INTERFACE' } }
+    }
+
+    result = GraphQL::graphql(StarWars::Schema, q5, {}, {})
+
+    expect(result).to eql(expectation)
+  end
+
+end

data/spec/language/parser_spec.rb

@@ -0,0 +1,73 @@
+require 'awesome_print'
+require 'graphql'
+require_relative '../schema'
+
+RSpec.describe GraphQL::Language do
+
+
+  def hero_query
+    %Q(
+      query getHero($episode: Episode!, $heroes: [String] = ["1001", "1002"]) {
+        hero(episode: JEDI) {
+          id
+          name
+          friends {
+            name
+
+            ... humanFields
+
+            ... on Droid {
+              name
+              primary_function
+            }
+          }
+
+          ... humanFields
+
+          ... on Droid {
+            name
+            primary_function
+          }
+        }
+      }
+
+      fragment humanFields on Human {
+        name
+        home_planet
+      }
+    )
+  end
+
+
+  it "Should parse query" do
+
+    expectation = {
+      data: {
+        hero: {
+          id:       "1000",
+          name:     "Like Skywalker",
+          friends:  [
+            {
+              name:         "Han Solo",
+              home_planet:  nil
+            }, {
+              name:         "Lea Organa",
+              home_planet:  "Alderaan"
+            }, {
+              name:               "C-3PO",
+              primary_function:   "Protocol"
+            }, {
+              name:               "R2-D2",
+              primary_function:   "Astromech"
+            }
+          ],
+          home_planet: "Tatooine"
+        }
+      }
+    }
+
+    result = GraphQL::graphql(StarWars::Schema, hero_query, nil, { episode: 'JEDI', heroes: ['1001'] })
+    expect(result).to eql(expectation)
+  end
+
+end