graphql 0.4.0 → 0.5.0

data/lib/graph_ql/introspection/arguments_field.rb

@@ -1,5 +1,5 @@
-GraphQL::Introspection::ArgumentsField = GraphQL::Field.new do |f|
-  f.description "Arguments allowed to this object"
-  f.type GraphQL::ListType.new(of_type: GraphQL::Introspection::InputValueType)
-  f.resolve -> (target, a, c) { target.arguments.values }
+GraphQL::Introspection::ArgumentsField = GraphQL::Field.define do
+  description "Arguments allowed to this object"
+  type GraphQL::ListType.new(of_type: GraphQL::Introspection::InputValueType)
+  resolve -> (target, a, c) { target.arguments.values }
 end

data/lib/graph_ql/introspection/directive_type.rb

@@ -1,12 +1,10 @@
-GraphQL::Introspection::DirectiveType = GraphQL::ObjectType.new do |t, type, field|
-  t.name "__Directive"
-  t.description "A query directive in this schema"
-  t.fields({
-    name:         field.build(type: !type.String, desc: "The name of this directive"),
-    description:  field.build(type: type.String, desc: "The description for this type"),
-    args:         GraphQL::Introspection::ArgumentsField,
-    onOperation:  field.build(type: !type.Boolean, property: :on_operation?, desc: "Does this directive apply to operations?"),
-    onFragment:   field.build(type: !type.Boolean, property: :on_fragment?, desc: "Does this directive apply to fragments?"),
-    onField:      field.build(type: !type.Boolean, property: :on_field?, desc: "Does this directive apply to fields?"),
-  })
+GraphQL::Introspection::DirectiveType = GraphQL::ObjectType.define do
+  name "__Directive"
+  description "A query directive in this schema"
+  field :name, !types.String, "The name of this directive"
+  field :description, types.String, "The description for this type"
+  field :args, field: GraphQL::Introspection::ArgumentsField
+  field :onOperation, !types.Boolean, "Does this directive apply to operations?", property: :on_operation?
+  field :onFragment, !types.Boolean, "Does this directive apply to fragments?", property: :on_fragment?
+  field :onField, !types.Boolean, "Does this directive apply to fields?", property: :on_field?
 end

data/lib/graph_ql/introspection/enum_value_type.rb

@@ -1,13 +1,10 @@
-GraphQL::Introspection::EnumValueType = GraphQL::ObjectType.new do |t, type, field|
-  t.name "__EnumValue"
-  t.description "A possible value for an Enum"
-  t.fields({
-    name:               field.build(type: !type.String),
-    description:        field.build(type: !type.String),
-    deprecationReason:  field.build(type: !type.String, property: :deprecation_reason),
-    isDeprecated: GraphQL::Field.new { |f|
-      f.type !type.Boolean
-      f.resolve -> (obj, a, c) { !!obj.deprecation_reason }
-    },
-  })
+GraphQL::Introspection::EnumValueType = GraphQL::ObjectType.define do
+  name "__EnumValue"
+  description "A possible value for an Enum"
+  field :name, !types.String
+  field :description, types.String
+  field :deprecationReason, types.String, property: :deprecation_reason
+  field :isDeprecated, !types.Boolean do
+    resolve -> (obj, a, c) { !!obj.deprecation_reason }
+  end
 end

data/lib/graph_ql/introspection/enum_values_field.rb

@@ -1,15 +1,13 @@
-GraphQL::Introspection::EnumValuesField = GraphQL::Field.new do |f, type, field, arg|
-  f.description "Values for this enum"
-  f.type type[!GraphQL::Introspection::EnumValueType]
-  f.arguments({
-    includeDeprecated: arg.build({type: GraphQL::BOOLEAN_TYPE, default_value: false})
-  })
-  f.resolve -> (object, arguments, context) {
+GraphQL::Introspection::EnumValuesField = GraphQL::Field.define do
+  description "Values for this enum"
+  type types[!GraphQL::Introspection::EnumValueType]
+  argument :includeDeprecated, types.Boolean, default_value: false
+  resolve -> (object, arguments, context) do
     return nil if !object.kind.enum?
     fields = object.values.values
     if !arguments["includeDeprecated"]
       fields = fields.select {|f| !f.deprecation_reason }
     end
     fields
-  }
+  end
 end

data/lib/graph_ql/introspection/field_type.rb

@@ -1,16 +1,12 @@
-GraphQL::Introspection::FieldType = GraphQL::ObjectType.new do |t, type, field|
-  t.name "__Field"
-  t.description "Field on a GraphQL type"
-  t.fields({
-    name:         field.build(type: !type.String, desc: "The name for accessing this field"),
-    description:  field.build(type: !type.String, desc: "The description of this field"),
-    type:         field.build(type: !GraphQL::Introspection::TypeType, desc: "The return type of this field"),
-    isDeprecated: GraphQL::Field.new { |f|
-      f.type !type.Boolean
-      f.description "Is this field deprecated?"
-      f.resolve -> (obj, a, c) { !!obj.deprecation_reason }
-    },
-    args:  GraphQL::Introspection::ArgumentsField,
-    deprecationReason: field.build(type: type.String, property: :deprecation_reason, desc: "Why this field was deprecated"),
-  })
+GraphQL::Introspection::FieldType = GraphQL::ObjectType.define do
+  name "__Field"
+  description "Field on a GraphQL type"
+  field :name, !types.String, "The name for accessing this field"
+  field :description, !types.String, "The description of this field"
+  field :type, !GraphQL::Introspection::TypeType, "The return type of this field"
+  field :isDeprecated, !types.Boolean, "Is this field deprecated?" do
+      resolve -> (obj, a, c) { !!obj.deprecation_reason }
+  end
+  field :args, field: GraphQL::Introspection::ArgumentsField
+  field :deprecationReason, types.String,  "Why this field was deprecated", property: :deprecation_reason
 end

data/lib/graph_ql/introspection/fields_field.rb

@@ -1,10 +1,8 @@
-GraphQL::Introspection::FieldsField = GraphQL::Field.new do |f, type, field, arg|
-  f.description "List of fields on this object"
-  f.type -> { type[!GraphQL::Introspection::FieldType] }
-  f.arguments({
-    includeDeprecated: arg.build({type: GraphQL::BOOLEAN_TYPE, default_value: false})
-  })
-  f.resolve -> (object, arguments, context) {
+GraphQL::Introspection::FieldsField = GraphQL::Field.define do
+  description "List of fields on this object"
+  type -> { types[!GraphQL::Introspection::FieldType] }
+  argument :includeDeprecated, GraphQL::BOOLEAN_TYPE, default_value: false
+  resolve -> (object, arguments, context) {
     return nil if !object.kind.fields?
     fields = object.fields.values
     if !arguments["includeDeprecated"]

data/lib/graph_ql/introspection/input_fields_field.rb

@@ -1,8 +1,8 @@
-GraphQL::Introspection::InputFieldsField = GraphQL::Field.new do |f, type|
-  f.name "inputFields"
-  f.description "fields on this input object"
-  f.type type[GraphQL::Introspection::InputValueType]
-  f.resolve -> (target, a, c) {
+GraphQL::Introspection::InputFieldsField = GraphQL::Field.define do
+  name "inputFields"
+  description "fields on this input object"
+  type types[GraphQL::Introspection::InputValueType]
+  resolve -> (target, a, c) {
     if target.kind.input_object?
       target.input_fields.values
     else

data/lib/graph_ql/introspection/input_value_type.rb

@@ -1,10 +1,8 @@
-GraphQL::Introspection::InputValueType = GraphQL::ObjectType.new do |t, type, field|
-  t.name "__InputValue"
-  t.description "An input for a field or InputObject"
-  t.fields({
-    name:         field.build(type: !type.String, desc: "The key for this value"),
-    description:  field.build(type: type.String, desc: "What this value is used for"),
-    type:         field.build(type: -> { GraphQL::Introspection::TypeType }, desc: "The expected type for this value"),
-    defaultValue: field.build(type: type.String, property: :default_value, desc: "The value applied if no other value is provided")
-  })
+GraphQL::Introspection::InputValueType = GraphQL::ObjectType.define do
+  name "__InputValue"
+  description "An input for a field or InputObject"
+  field :name, !types.String, "The key for this value"
+  field :description, types.String, "What this value is used for"
+  field :type, -> { GraphQL::Introspection::TypeType }, "The expected type for this value"
+  field :defaultValue, types.String, "The value applied if no other value is provided", property: :default_value
 end

data/lib/graph_ql/introspection/interfaces_field.rb

@@ -1,5 +1,5 @@
-GraphQL::Introspection::InterfacesField = GraphQL::Field.new do |f, type|
-  f.description "Interfaces which this object implements"
-  f.type -> { !type[!GraphQL::Introspection::TypeType] }
-  f.resolve -> (target, a, c) { target.kind.object? ? target.interfaces : nil }
+GraphQL::Introspection::InterfacesField = GraphQL::Field.define do
+  description "Interfaces which this object implements"
+  type -> { !types[!GraphQL::Introspection::TypeType] }
+  resolve -> (target, a, c) { target.kind.object? ? target.interfaces : nil }
 end

data/lib/graph_ql/introspection/of_type_field.rb

@@ -1,6 +1,6 @@
-GraphQL::Introspection::OfTypeField = GraphQL::Field.new do |f|
-  f.name "ofType"
-  f.description "The modified type of this type"
-  f.type -> { GraphQL::Introspection::TypeType }
-  f.resolve -> (obj, args, ctx) { obj.kind.wraps? ? obj.of_type : nil }
+GraphQL::Introspection::OfTypeField = GraphQL::Field.define do
+  name "ofType"
+  description "The modified type of this type"
+  type -> { GraphQL::Introspection::TypeType }
+  resolve -> (obj, args, ctx) { obj.kind.wraps? ? obj.of_type : nil }
 end

data/lib/graph_ql/introspection/possible_types_field.rb

@@ -1,5 +1,5 @@
-GraphQL::Introspection::PossibleTypesField = GraphQL::Field.new do |f, type|
-  f.description "Types which compose this Union or Interface"
-  f.type -> { type[GraphQL::Introspection::TypeType] }
-  f.resolve -> (target, a, c) { target.kind.resolves? ? target.possible_types : nil }
+GraphQL::Introspection::PossibleTypesField = GraphQL::Field.define do
+  description "Types which compose this Union or Interface"
+  type -> { types[GraphQL::Introspection::TypeType] }
+  resolve -> (target, a, c) { target.kind.resolves? ? target.possible_types : nil }
 end

data/lib/graph_ql/introspection/schema_field.rb

@@ -1,13 +1,11 @@
 # A wrapper to implement `__schema`
 class GraphQL::Introspection::SchemaField
-  DEFINITION = Proc.new { |f, wrapped_type|
-    f.name("__schema")
-    f.description("This GraphQL schema")
-    f.type(!GraphQL::Introspection::SchemaType)
-    f.resolve -> (o, a, c) { wrapped_type }
-  }
-
   def self.create(wrapped_type)
-     GraphQL::Field.new { |f| DEFINITION.call(f, wrapped_type) }
+     GraphQL::Field.define do
+       name("__schema")
+       description("This GraphQL schema")
+       type(!GraphQL::Introspection::SchemaType)
+       resolve -> (o, a, c) { wrapped_type }
+     end
   end
 end

data/lib/graph_ql/introspection/schema_type.rb

@@ -1,26 +1,20 @@
-GraphQL::Introspection::SchemaType = GraphQL::ObjectType.new do |t, type|
-  t.name "__Schema"
-  t.description "A GraphQL schema"
-  t.fields({
-    types: GraphQL::Field.new { |f|
-      f.type !type[!GraphQL::Introspection::TypeType]
-      f.description "Types in this schema"
-      f.resolve -> (obj, arg, ctx) { obj.types.values }
-    },
-    directives: GraphQL::Field.new { |f|
-      f.type !type[!GraphQL::Introspection::DirectiveType]
-      f.description "Directives in this schema"
-      f.resolve -> (obj, arg, ctx) { obj.directives.values }
-    },
-    queryType: GraphQL::Field.new { |f|
-      f.type !GraphQL::Introspection::TypeType
-      f.description "The query root of this schema"
-      f.resolve -> (obj, arg, ctx) { obj.query }
-    },
-    mutationType: GraphQL::Field.new { |f|
-      f.type GraphQL::Introspection::TypeType
-      f.description "The mutation root of this schema"
-      f.resolve -> (obj, arg, ctx) { obj.mutation }
-    },
-  })
+GraphQL::Introspection::SchemaType = GraphQL::ObjectType.define do
+  name "__Schema"
+  description "A GraphQL schema"
+
+  field :types, !types[!GraphQL::Introspection::TypeType], "Types in this schema" do
+    resolve -> (obj, arg, ctx) { obj.types.values }
+  end
+
+  field :directives, !types[!GraphQL::Introspection::DirectiveType], "Directives in this schema" do
+    resolve -> (obj, arg, ctx) { obj.directives.values }
+  end
+
+  field :queryType, !GraphQL::Introspection::TypeType, "The query root of this schema" do
+    resolve -> (obj, arg, ctx) { obj.query }
+  end
+
+  field :mutationType, GraphQL::Introspection::TypeType, "The mutation root of this schema" do
+    resolve -> (obj, arg, ctx) { obj.mutation }
+  end
 end

data/lib/graph_ql/introspection/type_by_name_field.rb

@@ -9,6 +9,12 @@ class GraphQL::Introspection::TypeByNameField
   }
 
   def self.create(type_hash)
-    GraphQL::Field.new { |f, type, field, arg| DEFINITION.call(f, type, field, arg, type_hash) }
+    GraphQL::Field.define do
+      name("__type")
+      description("A type in the GraphQL system")
+      type(!GraphQL::Introspection::TypeType)
+      argument :name, !types.String
+      resolve -> (o, args, c) { type_hash[args["name"]] }
+    end
   end
 end

data/lib/graph_ql/introspection/type_kind_enum.rb

@@ -1,7 +1,7 @@
-GraphQL::Introspection::TypeKindEnum = GraphQL::EnumType.new do |e|
-  e.name "__TypeKind"
-  e.description "The kinds of types in this GraphQL system"
+GraphQL::Introspection::TypeKindEnum = GraphQL::EnumType.define do
+  name "__TypeKind"
+  description "The kinds of types in this GraphQL system"
   GraphQL::TypeKinds::KIND_NAMES.each do |kind_name|
-    e.value(kind_name)
+    value(kind_name)
   end
 end

data/lib/graph_ql/introspection/type_type.rb

@@ -1,20 +1,20 @@
-GraphQL::Introspection::TypeType = GraphQL::ObjectType.new do |t, type, field|
-  t.name "__Type"
-  t.description "A type in the GraphQL schema"
+GraphQL::Introspection::TypeType = GraphQL::ObjectType.define do
+  name "__Type"
+  description "A type in the GraphQL schema"
 
-  t.fields = {
-    name:           field.build(type: !type.String, desc: "The name of this type"),
-    kind:           GraphQL::Field.new { |f|
-                      f.type GraphQL::Introspection::TypeKindEnum
-                      f.description "The kind of this type"
-                      f.resolve -> (target, a, c) { target.kind.name }
-                    },
-    description:    field.build(type: type.String, desc: "The description for this type"),
-    fields:         GraphQL::Introspection::FieldsField,
-    ofType:         GraphQL::Introspection::OfTypeField,
-    inputFields:    GraphQL::Introspection::InputFieldsField,
-    possibleTypes:  GraphQL::Introspection::PossibleTypesField,
-    enumValues:     GraphQL::Introspection::EnumValuesField,
-    interfaces:     GraphQL::Introspection::InterfacesField,
-  }
+  field :name, !types.String,  "The name of this type"
+  field :description, types.String, "What this type represents"
+
+  field :kind do
+    type GraphQL::Introspection::TypeKindEnum
+    description "The kind of this type"
+    resolve -> (target, a, c) { target.kind.name }
+  end
+
+  field :fields,          field: GraphQL::Introspection::FieldsField
+  field :ofType,          field: GraphQL::Introspection::OfTypeField
+  field :inputFields,     field: GraphQL::Introspection::InputFieldsField
+  field :possibleTypes,   field: GraphQL::Introspection::PossibleTypesField
+  field :enumValues,      field: GraphQL::Introspection::EnumValuesField
+  field :interfaces,      field: GraphQL::Introspection::InterfacesField
 end

data/lib/graph_ql/introspection/typename_field.rb

@@ -1,15 +1,11 @@
 # A wrapper to create `__typename`.
-# Uses `.create` because I couldn't figure out how to
-# pass `DEFINITION` via `super` (then I could extend GraphQL::Field)
 class GraphQL::Introspection::TypenameField
-  DEFINITION = Proc.new { |f, wrapped_type|
-    f.name "__typename"
-    f.description "The name of this type"
-    f.type -> { !GraphQL::STRING_TYPE }
-    f.resolve -> (obj, a, c) { wrapped_type.name }
-  }
-
   def self.create(wrapped_type)
-     GraphQL::Field.new { |f| DEFINITION.call(f, wrapped_type) }
+    GraphQL::Field.define do
+      name "__typename"
+      description "The name of this type"
+      type -> { !GraphQL::STRING_TYPE }
+      resolve -> (obj, a, c) { wrapped_type.name }
+    end
   end
 end

data/lib/graph_ql/object_type.rb

@@ -1,23 +1,92 @@
 # This type exposes fields on an object.
 #
+#  @example defining a type for your IMDB clone
+#    MovieType = GraphQL::ObjectType.define do
+#      name "Movie"
+#      description "A full-length film or a short film"
+#      interfaces [ProductionInterface, DurationInterface]
+#
+#      field :runtimeMinutes, !types.Int, property: :runtime_minutes
+#      field :director, PersonType
+#      field :cast, CastType
+#      field :starring, types[PersonType] do
+#        arguments :limit, types.Int
+#        resolve -> (object, args, ctx) {
+#          stars = object.cast.stars
+#          args[:limit] && stars = stars.limit(args[:limit])
+#          stars
+#        }
+#       end
+#    end
 #
 class GraphQL::ObjectType
   include GraphQL::DefinitionHelpers::NonNullWithBang
   extend GraphQL::DefinitionHelpers::Definable
+  include GraphQL::DefinitionHelpers::DefinedByConfig
   attr_definable :name, :description, :interfaces, :fields
 
+  class DefinitionConfig
+    extend GraphQL::DefinitionHelpers::Definable
+    attr_definable :name, :description, :interfaces
+    def initialize
+      @interfaces = []
+      @fields = {}
+    end
+
+    def types
+      GraphQL::DefinitionHelpers::TypeDefiner.instance
+    end
+
+    def field(name_or_pair, type = nil, desc = nil, field: nil, property: nil, &block)
+      if name_or_pair.is_a?(Hash)
+        name = name_or_pair.keys.first
+        value = name_or_pair[name]
+        if value.is_a?(GraphQL::Field)
+          field = value
+        else
+          property = value
+        end
+      else
+        name = name_or_pair
+      end
+      field ||= GraphQL::Field.define(&block)
+      type && field.type = type
+      desc && field.description = desc
+      property && field.resolve = -> (t,a,c) { t.public_send(property)}
+      field.name ||= name.to_s
+      @fields[name.to_s] = field
+    end
+
+    def type_class
+      GraphQL::ObjectType
+    end
+
+    def to_instance
+      object = type_class.new
+      object.name = name
+      object.description = description
+      object.fields = @fields
+      object.interfaces = interfaces
+      object
+    end
+  end
+
   def initialize(&block)
-    self.fields = []
+    self.fields = {}
     self.interfaces = []
-    yield(
-      self,
-      GraphQL::DefinitionHelpers::TypeDefiner.instance,
-      GraphQL::DefinitionHelpers::FieldDefiner.instance,
-      GraphQL::DefinitionHelpers::ArgumentDefiner.instance
-    )
+    if block_given?
+      yield(
+        self,
+        GraphQL::DefinitionHelpers::TypeDefiner.instance,
+        GraphQL::DefinitionHelpers::FieldDefiner.instance,
+        GraphQL::DefinitionHelpers::ArgumentDefiner.instance
+      )
+      warn("Initializing with .new is deprecated, use .define instead! (see #{self})")
+    end
   end
 
   # @overload fields(new_fields)
+  #   @deprecated use {.define} API instead
   #   Define `new_fields` as the fields this type exposes, uses {#fields=}
   #
   # @overload fields()
@@ -37,10 +106,8 @@ class GraphQL::ObjectType
   end
 
   # @overload interfaces(new_interfaces)
+  #   @deprecated use {.define} API instead
   #   Declare that this type implements `new_interfaces`.
-  #   Shovel this type into each interface's `possible_types` array.
-  #
-  #   (There's a bug here: if you define interfaces twice, it won't remove previous definitions.)
   #
   #   @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
   #
@@ -49,12 +116,20 @@ class GraphQL::ObjectType
   #
   def interfaces(new_interfaces=nil)
     if !new_interfaces.nil?
-      @interfaces = new_interfaces
-      new_interfaces.each {|i| i.possible_types << self }
+      self.interfaces = new_interfaces
     end
     @interfaces
   end
 
+  #   Shovel this type into each interface's `possible_types` array.
+  #
+  #   (There's a bug here: if you define interfaces twice, it won't remove previous definitions.)
+  #   @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
+  def interfaces=(new_interfaces)
+    new_interfaces.each {|i| i.possible_types << self }
+    @interfaces = new_interfaces
+  end
+
   def kind
     GraphQL::TypeKinds::OBJECT
   end