graphql 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea9221c87a055fadbddc1b61de970e61b993e074
-  data.tar.gz: 289bff890b6c2fb4ff3487cd74f8333375dcdbe9
+  metadata.gz: 7b1fdc7f41a30030c670d131b5725c04e6a19090
+  data.tar.gz: 5a6326377c36595c319f710c2f2e429188589266
 SHA512:
-  metadata.gz: 28d366cd1a906295fe885728ad08f1b13bcbd3b36ad35ac3aed6603d54a680a9e01ed048393f040f59d3b649c261e82958ef2432f652fa78d8a97d88ea69ca2b
-  data.tar.gz: eb17ca9aa091ccc42a85ecbf59b45bbbe61fa9dc154cb0794cbe59cae6bdc0a1e082fe35f95f8878c6b0dbe59432a420c58068f00f40eb594c00ef083d5c73a6
+  metadata.gz: 12d6d135cde8e87dc9ba32dab2c5e02bb418dd76922c086de95223f62fa544b87049dc15845a5f03818492324cc963715259a926e234263fd00e0ae336970fb4
+  data.tar.gz: 25e46e69f7210ace996eb2c2d93c52a03ae75944c58d269709e61200a6a872479edbe5ede7b7e446f30f3dd458abbbf736881da13b4969c8daaa1c3be99da1d5

data/lib/graph_ql/directive.rb

@@ -0,0 +1,36 @@
+class GraphQL::Directive < GraphQL::ObjectType
+  LOCATIONS = [
+    ON_OPERATION =  :on_operation?,
+    ON_FRAGMENT =   :on_fragment?,
+    ON_FIELD =      :on_field?,
+  ]
+  LOCATIONS.each do |location|
+    define_method(location) { self.on.include?(location) }
+  end
+
+  attr_definable :on, :arguments
+
+  def initialize(&block)
+    @arguments = {}
+    @on = []
+    yield(self) if block_given?
+  end
+
+  def resolve(proc_or_arguments, proc=nil)
+    if proc.nil?
+      @resolve_proc = proc_or_arguments
+    else
+      @resolve_proc.call(proc_or_arguments, proc)
+    end
+  end
+
+  def arguments(new_arguments=nil)
+    if new_arguments.nil?
+      @arguments
+    else
+      @arguments = new_arguments
+        .reduce({}) {|memo, (k, v)| memo[k.to_s] = v; memo}
+        .each { |k, v| v.respond_to?("name=") && v.name = k}
+    end
+  end
+end

data/lib/graph_ql/directives/directive_chain.rb

@@ -0,0 +1,33 @@
+class GraphQL::DirectiveChain
+  DIRECTIVE_ON = {
+    GraphQL::Nodes::Field =>          GraphQL::Directive::ON_FIELD,
+    GraphQL::Nodes::InlineFragment => GraphQL::Directive::ON_FRAGMENT,
+    GraphQL::Nodes::FragmentSpread => GraphQL::Directive::ON_FRAGMENT,
+  }
+
+  GET_DIRECTIVES = {
+    GraphQL::Nodes::Field =>          Proc.new { |n, f| n.directives },
+    GraphQL::Nodes::InlineFragment => Proc.new { |n, f| n.directives },
+    GraphQL::Nodes::FragmentSpread => Proc.new { |n, f| n.directives + f[n.name].directives }, # get directives from definition too
+  }
+
+  attr_reader :result
+  def initialize(ast_node, operation_resolver, &block)
+    directives = operation_resolver.query.schema.directives
+    on_what = DIRECTIVE_ON[ast_node.class]
+    ast_directives = GET_DIRECTIVES[ast_node.class].call(ast_node, operation_resolver.query.fragments)
+    applicable_directives = ast_directives
+      .map { |ast_directive| [ast_directive, directives[ast_directive.name]] }
+      .select { |directive_pair| directive_pair.last.on.include?(on_what) }
+
+    if applicable_directives.none?
+      @result = block.call
+    else
+      applicable_directives.map do |(ast_directive, directive)|
+        args = GraphQL::Query::Arguments.new(ast_directive.arguments, operation_resolver.variables).to_h
+        @result = directive.resolve(args, block)
+      end
+      @result ||= {}
+    end
+  end
+end

data/lib/graph_ql/directives/include_directive.rb

@@ -0,0 +1,15 @@
+GraphQL::IncludeDirective = GraphQL::Directive.new do |d|
+  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})
+  })
+  d.resolve -> (arguments, proc) {
+    if arguments["if"]
+      proc.call
+    else
+      nil
+    end
+  }
+end

data/lib/graph_ql/directives/skip_directive.rb

@@ -0,0 +1,15 @@
+GraphQL::SkipDirective = GraphQL::Directive.new do |d|
+  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})
+  })
+  d.resolve -> (arguments, proc) {
+    if !arguments["if"]
+      proc.call
+    else
+      nil
+    end
+  }
+end

data/lib/graph_ql/enum.rb

@@ -0,0 +1,34 @@
+class GraphQL::Enum
+  include GraphQL::NonNullWithBang
+  extend GraphQL::Definable
+  attr_definable :name, :description
+  attr_reader :values
+  def initialize
+    @values = {}
+    yield(self) if block_given?
+  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
+
+  class EnumValue
+    attr_reader :name, :description, :deprecation_reason
+    def initialize(name:, description:, deprecation_reason:)
+      @name = name
+      @description = description
+      @deprecation_reason = deprecation_reason
+    end
+    def deprecated?
+      !!deprecation_reason
+    end
+  end
+end

data/lib/graph_ql/fields/abstract_field.rb

@@ -0,0 +1,37 @@
+# Anything can be a Field as long as it responds to:
+#   - #name: String the name to access this field in a query
+#   - #type: Type returned by this field's resolve function
+#   - #description: String
+#   - #resolve(object, arguments, context): Object of Type `type`
+#   - #arguments: ???
+#   - #deprecation_reason
+class GraphQL::AbstractField
+  def name
+    raise NotImplementedError, "#{self.class.name}#name should return the name for accessing this field"
+  end
+
+  def type
+    raise NotImplementedError, "#{self.class.name}#type should return the type class which this field returns"
+  end
+
+  def description
+    raise NotImplementedError, "#{self.class.name}#description should return this field's description"
+  end
+
+
+  def resolve(object, arguments, context)
+    raise NotImplementedError, "#{self.class.name}#resolve(object, arguments, context) should execute this field for object"
+  end
+
+  def arguments
+    {}
+  end
+
+  def deprecated?
+    !!deprecation_reason
+  end
+
+  def deprecation_reason
+    nil
+  end
+end

data/lib/graph_ql/fields/access_field.rb

@@ -0,0 +1,24 @@
+# Implement {AbstractField} by calling the field name on its object
+# and returning the result.
+class GraphQL::AccessField < GraphQL::AbstractField
+  attr_accessor :name, :type
+  attr_reader :description, :arguments, :deprecation_reason
+  def initialize(type:, arguments:, description:, property: nil, deprecation_reason: nil)
+    @type = type
+    @arguments = arguments
+    @description = description
+    @property = property
+    @deprecation_reason = deprecation_reason
+  end
+
+  def resolve(object, args, context)
+    @property.nil? ? GraphQL::Query::DEFAULT_RESOLVE : object.send(@property)
+  end
+
+  def type
+    if @type.is_a?(Proc)
+      @type = @type.call
+    end
+    @type
+  end
+end

data/lib/graph_ql/fields/field.rb

@@ -0,0 +1,34 @@
+class GraphQL::Field < GraphQL::AbstractField
+  extend GraphQL::Definable
+  REQUIRED_DEFINITIONS = [:name, :description, :type]
+  attr_definable(:arguments, :deprecation_reason, *REQUIRED_DEFINITIONS)
+
+  def initialize(&block)
+    @arguments = {}
+    @resolve_proc = -> (o, a, c) { GraphQL::Query::DEFAULT_RESOLVE }
+    yield(self) if block_given?
+  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
+
+  def type(type_or_proc=nil)
+    if type_or_proc.nil?
+      if @type.is_a?(Proc)
+        @type = @type.call
+      end
+      @type
+    else
+      @type = type_or_proc
+    end
+  end
+end

data/lib/graph_ql/interface.rb

@@ -0,0 +1,14 @@
+class GraphQL::Interface < GraphQL::ObjectType
+  def kind
+    GraphQL::TypeKinds::INTERFACE
+  end
+
+  def possible_types
+    @possible_types ||= []
+  end
+
+  # Might have to override this in your own interface
+  def resolve_type(object)
+    @possible_types.find {|t| t.name == object.class.name }
+  end
+end

data/lib/graph_ql/introspection/arguments_field.rb

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

data/lib/graph_ql/introspection/directive_type.rb

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

data/lib/graph_ql/introspection/enum_value_type.rb

@@ -0,0 +1,10 @@
+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?),
+  })
+end

data/lib/graph_ql/introspection/enum_values_field.rb

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

data/lib/graph_ql/introspection/field_type.rb

@@ -0,0 +1,11 @@
+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"),
+  }
+end

data/lib/graph_ql/introspection/fields_field.rb

@@ -0,0 +1,14 @@
+GraphQL::FieldsField = GraphQL::Field.new do |f|
+  f.description "List of fields on this object"
+  f.type -> { GraphQL::ListType.new(of_type: GraphQL::NonNullType.new(of_type: GraphQL::FieldType)) }
+  f.arguments({
+    includeDeprecated: {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? }
+    end
+    fields
+  }
+end

data/lib/graph_ql/introspection/input_fields_field.rb

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

data/lib/graph_ql/introspection/input_value_type.rb

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

data/lib/graph_ql/introspection/of_type_field.rb

@@ -0,0 +1,12 @@
+GraphQL::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
+  }
+end

data/lib/graph_ql/introspection/possible_types_field.rb

@@ -0,0 +1,12 @@
+GraphQL::PossibleTypesField = GraphQL::Field.new do |f|
+  POSSIBLE_TYPE_KINDS = [GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE]
+  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
+  }
+end

data/lib/graph_ql/introspection/schema_type.rb

@@ -0,0 +1,32 @@
+GraphQL::SchemaType = GraphQL::ObjectType.new do
+  name "__Schema"
+  description "A GraphQL schema"
+  fields({
+    types: GraphQL::Field.new { |f|
+      f.type !type[!GraphQL::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.description "Directives in this schema"
+      f.resolve -> (obj, arg, ctx) { obj.directives.values }
+    },
+    queryType: GraphQL::Field.new { |f|
+      f.type !GraphQL::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.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

@@ -0,0 +1,7 @@
+GraphQL::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|
+    e.value(kind_name)
+  end
+end

data/lib/graph_ql/introspection/type_type.rb

@@ -0,0 +1,22 @@
+GraphQL::TypeType = GraphQL::ObjectType.new do
+  name "__Type"
+  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
+  }
+end
+# type __Type {
+#   # OBJECT only
+#   interfaces: [__Type!]
+#
+#   # ENUM only
+#   enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
+# }