graphql 0.4.0 → 0.5.0

data/lib/graph_ql/scalar_type.rb

@@ -2,6 +2,28 @@ module GraphQL
   # The parent type for scalars, eg {GraphQL::STRING_TYPE}, {GraphQL::INT_TYPE}
   #
   class ScalarType < GraphQL::ObjectType
+    class DefinitionConfig < GraphQL::ObjectType::DefinitionConfig
+      attr_definable :coerce
+
+      def type_class
+        GraphQL::ScalarType
+      end
+
+      def to_instance
+        scalar_type = super
+        scalar_type.coerce = coerce
+        scalar_type
+      end
+    end
+
+    def coerce(value)
+      @coerce.call(value)
+    end
+
+    def coerce=(proc)
+      @coerce = proc
+    end
+
     def kind
       GraphQL::TypeKinds::SCALAR
     end

data/lib/graph_ql/schema.rb

@@ -7,7 +7,7 @@ class GraphQL::Schema
 
   # @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:)
+  def initialize(query:, mutation: nil)
     @query    = query
     @mutation = mutation
     @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }

data/lib/graph_ql/string_type.rb

@@ -1,6 +1,4 @@
-GraphQL::STRING_TYPE = GraphQL::ScalarType.new do |t|
-  t.name "String"
-  def t.coerce(value)
-    value.to_s
-  end
+GraphQL::STRING_TYPE = GraphQL::ScalarType.define do
+  name "String"
+  coerce -> (value) { value.to_s }
 end

data/lib/graph_ql/union_type.rb

@@ -1,15 +1,36 @@
 # A collection of {ObjectType}s
 #
 # @example a union of types
-#   PetUnion = GraphQL::UnionType.new("Pet", "House pets", [DogType, CatType])
+#
+#   PetUnion = GraphQL::UnionType.define do
+#     name "Pet"
+#     description "Animals that live in your house"
+#     possible_types [DogType, CatType, FishType]
+#   end
 #
 class GraphQL::UnionType
   include GraphQL::DefinitionHelpers::NonNullWithBang
-  attr_reader :name, :description, :possible_types
-  def initialize(name, desc, types)
+  include GraphQL::DefinitionHelpers::DefinedByConfig
+  attr_accessor :name, :description, :possible_types
+
+  class DefinitionConfig
+    extend GraphQL::DefinitionHelpers::Definable
+    attr_definable :name, :description, :possible_types
+
+    def to_instance
+      object = GraphQL::UnionType.new
+      object.name = name
+      object.description = description
+      object.possible_types = possible_types
+      object
+    end
+  end
+
+  def initialize(name = nil, desc = nil, types = nil)
     @name = name
     @description = desc
     @possible_types = types
+    name && warn("Initializing with .new is deprecated, use .define instead! (see #{self})")
   end
 
   def kind

data/lib/graph_ql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/graphql.rb

@@ -5,7 +5,7 @@ require "singleton"
 module GraphQL
   # Turn a query string into an AST
   # @param string [String] a GraphQL query string
-  # @param as [Symbol] If you want to use this to parse some _piece_ of a document, pass the rule name (from {GraphQL::Parser::Parser})
+  # @param as [Symbol] If you want to use this to parse some _piece_ of a document, pass the rule name (from {GraphQL::Parser})
   # @return [GraphQL::Nodes::Document]
   def self.parse(string, as: nil)
     parser = as ? GraphQL::PARSER.send(as) : GraphQL::PARSER

data/readme.md

@@ -9,72 +9,72 @@
  - [Introduction](https://github.com/rmosolgo/graphql-ruby/blob/master/guides/introduction.md)
  - [API Documentation](http://www.rubydoc.info/github/rmosolgo/graphql-ruby)
 
+## Installation
+
+Install from RubyGems by adding it to your `Gemfile`, then bundling.
+
+```ruby
+# Gemfile
+gem 'graphql'
+```
+
+```
+$ bundle install
+```
+
 ## Overview
 
-- __Install the gem__:
-
-  ```ruby
-  # Gemfile
-  gem 'graphql'
-  ```
-
-  ```
-  $ bundle install
-  ```
-
-- __Declare types & build a schema__:
-
-  ```ruby
-  # Declare a type...
-  PostType = GraphQL::ObjectType.new do |t, types, field|
-    t.name "Post"
-    t.description "A blog post"
-    t.fields({
-      id:       field.build(type: !types.Int),
-      title:    field.build(type: !types.String),
-      body:     field.build(type: !types.String),
-      comments: field.build(type: types[!CommentType])
-    })
-  end
+#### Declare types & build a schema
 
-  # ...and a query root
-  QueryType = GraphQL::ObjectType.new do |t, types, field, arg|
-    t.name "Query"
-    t.description "The query root of this schema"
-    t.fields({
-      post: GraphQL::Field.new do |f|
-        f.arguments(id: arg.build(type: !types.Int))
-        f.resolve -> (object, args, context) {
-          Post.find(args["id"])
-        }
-      end
-    })
-  end
+```ruby
+# Declare a type...
+PostType = GraphQL::ObjectType.define do
+  name "Post"
+  description "A blog post"
+
+  field :id, !types.ID
+  field :title, !types.String
+  field :body, !types.String
+  field :comments, types[!CommentType]
+end
+
+# ...and a query root
+QueryType = GraphQL::ObjectType.define do
+  name "Query"
+  description "The query root of this schema"
 
-  # Then create your schema
-  Schema = GraphQL::Schema.new(query: QueryType, mutation: nil)
-  ```
-
-  See also:
-    - the [test schema](https://github.com/rmosolgo/graphql-ruby/blob/master/spec/support/dummy_app.rb)
-    - [`graphql-ruby-demo`](https://github.com/rmosolgo/graphql-ruby-demo) for an example schema on Rails
-
-- __Execute queries__:
-
-  ```ruby
-  query = GraphQL::Query.new(Schema, query_string)
-  result_hash = query.result
-  # {
-  #   "data" => {
-  #     "post" => {
-  #        "id" => 1,
-  #        "title" => "GraphQL is nice"
-  #     }
-  #   }
-  # }
-  ```
-
-  See also:
+  field :post do
+    argument :id, !types.ID
+    resolve -> (obj, args, ctx) { Post.find(args["id"]) }
+  end
+end
+
+# Then create your schema
+Schema = GraphQL::Schema.new(query: QueryType)
+```
+
+See also:
+  - the [test schema](https://github.com/rmosolgo/graphql-ruby/blob/master/spec/support/dairy_app.rb)
+  - [`graphql-ruby-demo`](https://github.com/rmosolgo/graphql-ruby-demo) for an example schema on Rails
+
+#### Execute queries
+
+Execute GraphQL queries on a given schema, from a query string.
+
+```ruby
+query = GraphQL::Query.new(Schema, query_string)
+result_hash = query.result
+# {
+#   "data" => {
+#     "post" => {
+#        "id" => 1,
+#        "title" => "GraphQL is nice"
+#     }
+#   }
+# }
+```
+
+See also:
   - [query_spec.rb](https://github.com/rmosolgo/graphql-ruby/blob/master/spec/graph_ql/query_spec.rb) for an example of query execution.
   -  [`queries_controller.rb`](https://github.com/rmosolgo/graphql-ruby-demo/blob/master/app/controllers/queries_controller.rb) for a Rails example
   - Try it on [heroku](http://graphql-ruby-demo.herokuapp.com)
@@ -85,16 +85,17 @@
   - Directives:
     - `@skip` has precedence over `@include`
     - directives on fragments: http://facebook.github.io/graphql/#sec-Fragment-Directives
+  - Add static validation for empty string
+  - Only run named operation
 - Field merging
   - if you were to request a field, then request it in a fragment, it would get looked up twice
   - https://github.com/graphql/graphql-js/issues/19#issuecomment-118515077
 - Code clean-up
   - Unify unwrapping types (It's on `TypeKind` but it's still not right)
-- Better definition API
+  - Accept native Ruby types in definitions, then convert them to GraphQL types
 - Cook up some path other than "n+1s everywhere"
   - See Sangria's `project` approach ([in progress](https://github.com/rmosolgo/graphql-ruby/pull/15))
 
-
 ## Goals
 
 - Implement the GraphQL spec & support a Relay front end
@@ -118,3 +119,4 @@
 ## P.S.
 
 Thanks to @sgwilym for the great logo!
+Definition API heavily inspired by @seanchas's [implementation of GraphQL](https://github.com/seanchas/graphql)

data/spec/graph_ql/field_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe GraphQL::Field do
   it 'accepts a proc as type' do
-    field = GraphQL::Field.new { |f|
-      f.type(-> { DairyProductUnion })
-    }
+    field = GraphQL::Field.define do
+      type(-> { DairyProductUnion })
+    end
     assert_equal(DairyProductUnion, field.type)
   end
 end

data/spec/support/dairy_app.rb

@@ -1,164 +1,150 @@
 require_relative './dairy_data'
 
-EdibleInterface = GraphQL::InterfaceType.new do |i, type, field|
-  i.name "Edible"
-  i.description "Something you can eat, yum"
-  i.fields({
-    fatContent: field.build(
-      type: !type.Float,
-      property: :non_existent_field_that_should_never_be_called,
-      desc: "Percentage which is fat"),
-  })
+EdibleInterface = GraphQL::InterfaceType.define do
+  name "Edible"
+  description "Something you can eat, yum"
+  field :fatContent, !types.Float, "Percentage which is fat", property: :bogus_property
 end
 
-AnimalProductInterface = GraphQL::InterfaceType.new do |i, type, field|
-  i.name "AnimalProduct"
-  i.description "Comes from an animal, no joke"
-  i.fields({
-    source: field.build(type: !type.String, desc: "Animal which produced this product"),
-  })
+AnimalProductInterface = GraphQL::InterfaceType.define do
+  name "AnimalProduct"
+  description "Comes from an animal, no joke"
+  field :source, !types.String, "Animal which produced this product"
 end
 
-DairyAnimalEnum = GraphQL::EnumType.new do |e|
-  e.name "DairyAnimal"
-  e.description "An animal which can yield milk"
-  e.value("COW",    "Animal with black and white spots", value: 1)
-  e.value("GOAT",   "Animal with horns")
-  e.value("SHEEP",  "Animal with wool")
-  e.value("YAK",    "Animal with long hair", deprecation_reason: "Out of fashion")
+DairyAnimalEnum = GraphQL::EnumType.define do
+  name "DairyAnimal"
+  description "An animal which can yield milk"
+  value("COW",    "Animal with black and white spots", value: 1)
+  value("GOAT",   "Animal with horns")
+  value("SHEEP",  "Animal with wool")
+  value("YAK",    "Animal with long hair", deprecation_reason: "Out of fashion")
 end
 
-CheeseType = GraphQL::ObjectType.new do |t, type, field, arg|
-  t.name "Cheese"
-  t.description "Cultured dairy product"
-  t.interfaces [EdibleInterface, AnimalProductInterface]
-  t.fields = {
-    id:           field.build(type: !type.Int, desc: "Unique identifier"),
-    flavor:       field.build(type: !type.String, desc: "Kind of cheese"),
-    source:       field.build(type: !DairyAnimalEnum, desc: "Animal which produced the milk for this cheese"),
-    similarCheeses: GraphQL::Field.new do |f|
-      f.description "Cheeses like this one"
-      f.type(t)
-      f.arguments({source: arg.build(type: !type[!DairyAnimalEnum])})
-      f.resolve -> (t, a, c) { CHEESES.values.find { |c| c.source == a["source"] } }
-    end,
-    fatContent:   field.build(type: !type.Float, desc: "Percentage which is milkfat", deprecation_reason: "Diet fashion has changed"),
-  }
-end
+CheeseType = GraphQL::ObjectType.define do
+  name "Cheese"
+  description "Cultured dairy product"
+  interfaces [EdibleInterface, AnimalProductInterface]
 
-MilkType = GraphQL::ObjectType.new do |t, type, field, arg|
-  t.name 'Milk'
-  t.description "Dairy beverage"
-  t.interfaces [EdibleInterface, AnimalProductInterface]
-  t.fields = {
-    id:           field.build(type: !type.ID, desc: "Unique identifier"),
-    source:       field.build(type: DairyAnimalEnum, desc: "Animal which produced this milk"),
-    fatContent:   field.build(type: !type.Float, desc: "Percentage which is milkfat"),
-    flavors:      field.build(
-          type: type[type.String],
-          desc: "Chocolate, Strawberry, etc",
-          args: {limit: arg.build({type: type.Int})}
-        ),
-  }
-end
+  # Can have (name, type, desc)
+  field :id, !types.Int, "Unique identifier"
+  field :flavor, !types.String, "Kind of Cheese"
 
-DairyProductUnion = GraphQL::UnionType.new(
-  "DairyProduct",
-  "Kinds of food made from milk",
-  [MilkType, CheeseType]
-)
-
-DairyProductInputType = GraphQL::InputObjectType.new {|t, type, field, arg|
-  t.name "DairyProductInput"
-  t.description "Properties for finding a dairy product"
-  t.input_fields({
-    source:     arg.build({type: DairyAnimalEnum}),
-    fatContent: arg.build({type: type.Float}),
-  })
-}
+  # Or can define by block:
+  field :source do
+    type(!DairyAnimalEnum)
+    description("Animal which produced the milk for this cheese")
+  end
 
+  field :similarCheeses do
+    type -> { CheeseType }
+    description("Cheeses like this one")
+    argument :source, !types[!DairyAnimalEnum]
+    resolve -> (t, a, c) { CHEESES.values.find { |c| c.source == a["source"] } }
+  end
 
-class FetchField
-  attr_reader :type, :arguments, :deprecation_reason
-  attr_accessor :name
-  def initialize(type:, data:, id_type: !GraphQL::INT_TYPE)
-    @type = type
-    @data = data
-    @arguments = {"id" => GraphQL::Argument.new(type: id_type, name: "id")}
-    @deprecation_reason = nil
+  field fatContent: :fat_content do
+    type(!GraphQL::FLOAT_TYPE)
+    description("Percentage which is milkfat")
+    deprecation_reason("Diet fashion has changed")
   end
+end
 
-  def description
-    "Find a #{@type.name} by id"
+MilkType = GraphQL::ObjectType.define do
+  name 'Milk'
+  description "Dairy beverage"
+  interfaces [EdibleInterface, AnimalProductInterface]
+  field :id, !types.ID
+  field :source, DairyAnimalEnum, "Animal which produced this milk"
+  field :fatContent, !types.Float, "Percentage which is milkfat"
+  field :flavors, types[types.String], "Chocolate, Strawberry, etc" do
+    argument :limit, types.Int
   end
+end
 
-  def resolve(target, arguments, context)
-    @data[arguments["id"].to_i]
+DairyProductUnion = GraphQL::UnionType.define do
+  name "DairyProduct"
+  description "Kinds of food made from milk"
+  possible_types [MilkType, CheeseType]
+end
+
+DairyProductInputType = GraphQL::InputObjectType.define {
+  name "DairyProductInput"
+  description "Properties for finding a dairy product"
+  input_field :source, DairyAnimalEnum
+  input_field :fatContent, types.Float
+}
+
+
+class FetchField
+  def self.create(type:, data:, id_type: !GraphQL::INT_TYPE)
+    desc = "Find a #{type.name} by id"
+    return_type = type
+    GraphQL::Field.define do
+      type(return_type)
+      description(desc)
+      argument :id, id_type
+
+      resolve -> (t, a, c) { data[a["id"].to_i] }
+    end
   end
 end
 
-SourceField = GraphQL::Field.new do |f, type, field, arg|
-  f.type GraphQL::ListType.new(of_type: CheeseType)
-  f.description "Cheese from source"
-  f.arguments(source: arg.build(type: !DairyAnimalEnum))
-  f.resolve -> (target, arguments, context) {
+SourceFieldDefn = Proc.new {
+  type GraphQL::ListType.new(of_type: CheeseType)
+  description "Cheese from source"
+  argument :source, !DairyAnimalEnum
+  resolve -> (target, arguments, context) {
     CHEESES.values.select{ |c| c.source == arguments["source"] }
   }
-end
+}
 
-FavoriteField = GraphQL::Field.new do |f|
-  f.description "My favorite food"
-  f.type EdibleInterface
-  f.resolve -> (t, a, c) { MILKS[1] }
-end
+FavoriteFieldDefn = Proc.new {
+  description "My favorite food"
+  type EdibleInterface
+  resolve -> (t, a, c) { MILKS[1] }
+}
 
+QueryType = GraphQL::ObjectType.define do
+  name "Query"
+  description "Query root of the system"
+  field :cheese, field: FetchField.create(type: CheeseType, data: CHEESES)
+  field :milk, field: FetchField.create(type: MilkType, data: MILKS, id_type: !types.ID)
+  field :fromSource, &SourceFieldDefn
+  field :favoriteEdible, &FavoriteFieldDefn
+  field :searchDairy do
+    description "Find dairy products matching a description"
+    type !DairyProductUnion
+    argument :product, DairyProductInputType
+    resolve -> (t, a, c) {
+      products = CHEESES.values + MILKS.values
+      source =  a["product"][:source] # String or sym is ok
+      if !source.nil?
+        products = products.select { |p| p.source == source }
+      end
+      products.first
+    }
+  end
 
-QueryType = GraphQL::ObjectType.new do |t, types, field, arg|
-  t.name "Query"
-  t.description "Query root of the system"
-  t.fields({
-    cheese: FetchField.new(type: CheeseType, data: CHEESES),
-    milk: FetchField.new(type: MilkType, data: MILKS, id_type: !types.ID),
-    fromSource: SourceField,
-    favoriteEdible: FavoriteField,
-    searchDairy: GraphQL::Field.new { |f|
-      f.name "searchDairy"
-      f.description "Find dairy products matching a description"
-      f.type !DairyProductUnion
-      f.arguments({product: arg.build({type: DairyProductInputType})})
-      f.resolve -> (t, a, c) {
-        products = CHEESES.values + MILKS.values
-        source =  a["product"][:source] # String or sym is ok
-        if !source.nil?
-          products = products.select { |p| p.source == source }
-        end
-        products.first
-      }
-    },
-    error: GraphQL::Field.new { |f|
-      f.description "Raise an error"
-      f.type GraphQL::STRING_TYPE
-      f.resolve -> (t, a, c) { raise("This error was raised on purpose") }
-    },
-  })
+  field :error do
+    description "Raise an error"
+    type GraphQL::STRING_TYPE
+    resolve -> (t, a, c) { raise("This error was raised on purpose") }
+  end
 end
 
 GLOBAL_VALUES = []
-
-MutationType = GraphQL::ObjectType.new do |t, type, field, arg|
-  t.name "Mutation"
-  t.description "The root for mutations in this schema"
-  t.fields({
-    pushValue: GraphQL::Field.new { |f|
-      f.description("Push a value onto a global array :D")
-      f.type(!type[!type.Int])
-      f.arguments(value: arg.build(type: !type.Int))
-      f.resolve -> (o, args, ctx) {
-        GLOBAL_VALUES << args[:value]
-        GLOBAL_VALUES
-      }
+MutationType = GraphQL::ObjectType.define do
+  name "Mutation"
+  description "The root for mutations in this schema"
+  field :pushValue, !types[!types.Int] do
+    description("Push a value onto a global array :D")
+    argument :value, !types.Int
+    resolve -> (o, args, ctx) {
+      GLOBAL_VALUES << args[:value]
+      GLOBAL_VALUES
     }
-  })
+  end
 end
 
 DummySchema = GraphQL::Schema.new(query: QueryType, mutation: MutationType)