graphql 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b1fdc7f41a30030c670d131b5725c04e6a19090
-  data.tar.gz: 5a6326377c36595c319f710c2f2e429188589266
+  metadata.gz: 45c3f35aae5e941e7bad2109eb9405e6afc081cc
+  data.tar.gz: 3cd3d8dd85a88e341552d0709aff11361937d157
 SHA512:
-  metadata.gz: 12d6d135cde8e87dc9ba32dab2c5e02bb418dd76922c086de95223f62fa544b87049dc15845a5f03818492324cc963715259a926e234263fd00e0ae336970fb4
-  data.tar.gz: 25e46e69f7210ace996eb2c2d93c52a03ae75944c58d269709e61200a6a872479edbe5ede7b7e446f30f3dd458abbbf736881da13b4969c8daaa1c3be99da1d5
+  metadata.gz: 274f08f78112de84f94dcb9fcdcc62da63a36a29000aad2055cf5e353327bb9ba3f673fe3e83c3a3c6405b360847f17104ab97c66a08323400f6df3f27f6044a
+  data.tar.gz: 82f47b290d9779b1214bb59857edb079369932d08686a8ac1af47c15ab1f3e549e4c8f9f269947836fe2093fc49badc6986e397466cb2d1010520bc3a765e7ff

data/lib/graph_ql/directive.rb

@@ -10,14 +10,15 @@ class GraphQL::Directive < GraphQL::ObjectType
 
   attr_definable :on, :arguments
 
-  def initialize(&block)
+  def initialize
     @arguments = {}
     @on = []
-    yield(self) if block_given?
+    yield(self, GraphQL::TypeDefiner.instance, GraphQL::FieldDefiner.instance, GraphQL::ArgumentDefiner.instance)
   end
 
   def resolve(proc_or_arguments, proc=nil)
     if proc.nil?
+      # resolve is being defined, just set it
       @resolve_proc = proc_or_arguments
     else
       @resolve_proc.call(proc_or_arguments, proc)
@@ -25,12 +26,15 @@ class GraphQL::Directive < GraphQL::ObjectType
   end
 
   def arguments(new_arguments=nil)
-    if new_arguments.nil?
-      @arguments
-    else
+    if !new_arguments.nil?
       @arguments = new_arguments
         .reduce({}) {|memo, (k, v)| memo[k.to_s] = v; memo}
         .each { |k, v| v.respond_to?("name=") && v.name = k}
     end
+    @arguments
   end
 end
+
+require 'graph_ql/directives/directive_chain'
+require 'graph_ql/directives/include_directive'
+require 'graph_ql/directives/skip_directive'

data/lib/graph_ql/directives/include_directive.rb

@@ -1,9 +1,9 @@
-GraphQL::IncludeDirective = GraphQL::Directive.new do |d|
+GraphQL::IncludeDirective = GraphQL::Directive.new do |d, type, field, arg|
   d.name "include"
   d.description "Include this part of the query if `if` is true"
   d.on([GraphQL::Directive::ON_FIELD, GraphQL::Directive::ON_FRAGMENT])
   d.arguments({
-    if: d.arg({type: !GraphQL::BOOLEAN_TYPE})
+    if: arg.build({type: !GraphQL::BOOLEAN_TYPE})
   })
   d.resolve -> (arguments, proc) {
     if arguments["if"]

data/lib/graph_ql/directives/skip_directive.rb

@@ -1,9 +1,9 @@
-GraphQL::SkipDirective = GraphQL::Directive.new do |d|
+GraphQL::SkipDirective = GraphQL::Directive.new do |d, type, field, arg|
   d.name "skip"
   d.description "Ignore this part of the query if `if` is true"
   d.on([GraphQL::Directive::ON_FIELD, GraphQL::Directive::ON_FRAGMENT])
   d.arguments({
-    if: d.arg({type: !GraphQL::BOOLEAN_TYPE})
+    if: arg.build({type: !GraphQL::BOOLEAN_TYPE})
   })
   d.resolve -> (arguments, proc) {
     if !arguments["if"]

data/lib/graph_ql/enum.rb

@@ -5,21 +5,21 @@ class GraphQL::Enum
   attr_reader :values
   def initialize
     @values = {}
-    yield(self) if block_given?
+    yield(self, GraphQL::TypeDefiner.instance, GraphQL::FieldDefiner.instance, GraphQL::ArgumentDefiner.instance)
   end
 
   def value(name, description=nil, deprecation_reason: nil)
     @values[name] = EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason)
   end
 
-  def [](val)
-    @values[val]
-  end
-
   def kind
     GraphQL::TypeKinds::ENUM
   end
 
+  def coerce(value)
+    @values[value]
+  end
+
   class EnumValue
     attr_reader :name, :description, :deprecation_reason
     def initialize(name:, description:, deprecation_reason:)
@@ -27,8 +27,5 @@ class GraphQL::Enum
       @description = description
       @deprecation_reason = deprecation_reason
     end
-    def deprecated?
-      !!deprecation_reason
-    end
   end
 end

data/lib/graph_ql/field.rb

@@ -0,0 +1,50 @@
+class GraphQL::Field
+  extend GraphQL::Definable
+  attr_definable(:arguments, :deprecation_reason, :name, :description, :type)
+
+  def initialize
+    @arguments = {}
+    @resolve_proc = -> (o, a, c) { GraphQL::Query::DEFAULT_RESOLVE }
+    yield(self, GraphQL::TypeDefiner.instance, GraphQL::FieldDefiner.instance, GraphQL::ArgumentDefiner.instance)
+  end
+
+  def arguments(new_arguments=nil)
+    if !new_arguments.nil?
+      self.arguments=(new_arguments)
+    end
+    @arguments
+  end
+
+  def arguments=(new_arguments)
+    stringified_arguments = new_arguments
+      .reduce({}) { |memo, (key, value)| memo[key.to_s] = value; memo }
+    # Set the name from its context on this type:
+    stringified_arguments.each {|k, v| v.respond_to?("name=") && v.name = k }
+    @arguments = stringified_arguments
+  end
+
+
+  # Used when defining:
+  #   resolve -> (obj, args, ctx) { obj.get_value }
+  # Also used when executing queries:
+  #   field.resolve(obj, args, ctx)
+  def resolve(proc_or_object, arguments=nil, ctx=nil)
+    if arguments.nil? && ctx.nil?
+      @resolve_proc = proc_or_object
+    else
+      @resolve_proc.call(proc_or_object, arguments, ctx)
+    end
+  end
+
+  # You can pass a proc which will cause the type to be lazy-evaled,
+  # That's nice if you have load-order issues
+  def type(type_or_proc=nil)
+    if !type_or_proc.nil?
+      @type = type_or_proc
+    elsif @type.is_a?(Proc)
+      # lazy-eval it
+      @type = @type.call
+    end
+    @type
+  end
+end

data/lib/graph_ql/interface.rb

@@ -11,4 +11,8 @@ class GraphQL::Interface < GraphQL::ObjectType
   def resolve_type(object)
     @possible_types.find {|t| t.name == object.class.name }
   end
+
+  def to_s
+    "<GraphQL::Interface #{name}>"
+  end
 end

data/lib/graph_ql/introspection/arguments_field.rb

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

data/lib/graph_ql/introspection/directive_type.rb

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

data/lib/graph_ql/introspection/enum_value_type.rb

@@ -1,10 +1,13 @@
-GraphQL::EnumValueType = GraphQL::ObjectType.new do
-  name "__EnumValue"
-  description "A possible value for an Enum"
-  fields({
-    name: field(type: !type.String),
-    description: field(type: !type.String),
-    deprecationReason: field(type: !type.String, property: :deprecation_reason),
-    isDeprecated: field(type: !type.Boolean, property: :deprecated?),
+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 }
+    },
   })
 end

data/lib/graph_ql/introspection/enum_values_field.rb

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

data/lib/graph_ql/introspection/field_type.rb

@@ -1,11 +1,15 @@
-GraphQL::FieldType = GraphQL::ObjectType.new do
-  name "__Field"
-  description "Field on a GraphQL type"
-  self.fields = {
-    name: field(type: !type.String, desc: "The name for accessing this field"),
-    description: field(type: !type.String, desc: "The description of this field"),
-    type: field(type: !GraphQL::TypeType, desc: "The return type of this field"),
-    isDeprecated: field(type: !type.Boolean, property: :deprecated?, desc: "Is this field deprecated?"),
-    deprecationReason: field(type: type.String, property: :deprecation_reason, desc: "Why this field was deprecated"),
-  }
+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 }
+    },
+    deprecationReason: field.build(type: type.String, property: :deprecation_reason, desc: "Why this field was deprecated"),
+  })
 end

data/lib/graph_ql/introspection/fields_field.rb

@@ -1,13 +1,13 @@
-GraphQL::FieldsField = GraphQL::Field.new do |f|
+GraphQL::Introspection::FieldsField = GraphQL::Field.new do |f, type, field, arg|
   f.description "List of fields on this object"
-  f.type -> { GraphQL::ListType.new(of_type: GraphQL::NonNullType.new(of_type: GraphQL::FieldType)) }
+  f.type -> { type[!GraphQL::Introspection::FieldType] }
   f.arguments({
-    includeDeprecated: {type: GraphQL::BOOLEAN_TYPE, default_value: false}
+    includeDeprecated: arg.build({type: GraphQL::BOOLEAN_TYPE, default_value: false})
   })
   f.resolve -> (object, arguments, context) {
     fields = object.fields.values
     if !arguments["includeDeprecated"]
-      fields = fields.select {|f| !f.deprecated? }
+      fields = fields.select {|f| !f.deprecation_reason }
     end
     fields
   }

data/lib/graph_ql/introspection/input_fields_field.rb

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

data/lib/graph_ql/introspection/input_value_type.rb

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

data/lib/graph_ql/introspection/interfaces_field.rb

@@ -0,0 +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 }
+end

data/lib/graph_ql/introspection/of_type_field.rb

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

data/lib/graph_ql/introspection/possible_types_field.rb

@@ -1,12 +1,5 @@
-GraphQL::PossibleTypesField = GraphQL::Field.new do |f|
-  POSSIBLE_TYPE_KINDS = [GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE]
+GraphQL::Introspection::PossibleTypesField = GraphQL::Field.new do |f, type|
   f.description "Types which compose this Union or Interface"
-  f.type -> { GraphQL::ListType.new(of_type: GraphQL::TypeType) }
-  f.resolve -> (target, a, c) {
-    if POSSIBLE_TYPE_KINDS.include?(target.kind)
-      target.possible_types
-    else
-      nil
-    end
-  }
+  f.type -> { type[GraphQL::Introspection::TypeType] }
+  f.resolve -> (target, a, c) { target.kind.resolves? ? target.possible_types : nil }
 end

data/lib/graph_ql/introspection/schema_type.rb

@@ -1,32 +1,26 @@
-GraphQL::SchemaType = GraphQL::ObjectType.new do
-  name "__Schema"
-  description "A GraphQL schema"
-  fields({
+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::TypeType]
+      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::DirectiveType]
+      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::TypeType
+      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::TypeType
+      f.type GraphQL::Introspection::TypeType
       f.description "The mutation root of this schema"
       f.resolve -> (obj, arg, ctx) { obj.mutation }
     },
   })
 end
-# type __Schema {
-#   types: [__Type!]!
-#   queryType: __Type!
-#   mutationType: __Type
-#   directives: [__Directive!]!
-# }

data/lib/graph_ql/introspection/type_kind_enum.rb

@@ -1,4 +1,4 @@
-GraphQL::TypeKindEnum = GraphQL::Enum.new do |e|
+GraphQL::Introspection::TypeKindEnum = GraphQL::Enum.new do |e|
   e.name "__TypeKind"
   e.description "The kinds of types in this GraphQL system"
   GraphQL::TypeKinds::KIND_NAMES.each do |kind_name|

data/lib/graph_ql/introspection/type_type.rb

@@ -1,22 +1,20 @@
-GraphQL::TypeType = GraphQL::ObjectType.new do
-  name "__Type"
-  description "A type in the GraphQL schema"
+GraphQL::Introspection::TypeType = GraphQL::ObjectType.new do |t, type, field|
+  t.name "__Type"
+  t.description "A type in the GraphQL schema"
 
-  self.fields = {
-    name: field(type: !type.String, desc: "The name of this type"),
-    kind: field(type: GraphQL::TypeKindEnum, desc: "The kind of this type"),
-    description: field(type: type.String, desc: "The description for this type"),
-    fields: GraphQL::FieldsField,
-    ofType: GraphQL::OfTypeField,
-    inputFields: GraphQL::InputFieldsField,
-    possibleTypes: GraphQL::PossibleTypesField,
-    enumValues: GraphQL::EnumValuesField
+  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,
   }
 end
-# type __Type {
-#   # OBJECT only
-#   interfaces: [__Type!]
-#
-#   # ENUM only
-#   enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
-# }