graphql 0.0.4 → 0.1.0

data/lib/graphql/introspection/type_type.rb

@@ -1,18 +0,0 @@
-class GraphQL::Introspection::TypeType < GraphQL::Node
-  exposes "GraphQL::Node"
-  type "__type__"
-  field.string(:name)
-  field.string(:description)
-  field.introspection_connection(:fields)
-
-  cursor :name
-
-  # they're actually {FieldMapping}s
-  def fields
-    target.all_fields.values
-  end
-
-  def name
-    schema_name
-  end
-end

data/lib/graphql/node.rb

@@ -1,244 +0,0 @@
-# Node is the base class for your GraphQL nodes.
-# It's essentially a delegator that only delegates methods you whitelist with {.field}.
-# To use it:
-#
-# - Extend `GraphQL::Node`
-# - Declare what this node will wrap with {.exposes}
-# - Declare fields with {.field}
-# - Declare calls with {.call}
-#
-# @example Expose a class in your app
-#   class PostNode < GraphQL::Node
-#     exposes('Post')
-#
-#     cursor(:id)
-#
-#     field.number(:id)
-#     field.string(:title)
-#     field.string(:content)
-#     field.connection(:comments)
-#   end
-#
-# @example Expose a data type
-#   class DateType < GraphQL::Node
-#     exposes "Date"
-#     type :date
-#     call :minus_days, -> (prev_value, minus_days) { prev_value - minus_days.to_i }
-#     field.number(:year)
-#     field.number(:month)
-#   end
-#
-#   # now you could use it
-#   class PostNode
-#     field.date(:published_at)
-#   end
-class GraphQL::Node
-  # The object wrapped by this `Node`, _before_ calls are applied
-  attr_reader :original_target
-  # The object wrapped by this `Node`, _after_ calls are applied
-  attr_reader :target
-  # Fields parsed from the query string
-  attr_reader :syntax_fields
-  # The query to which this `Node` belongs. Used for accessing its {Query#context}.
-  attr_reader :query
-
-  def initialize(target=nil, fields:, query:, calls: [])
-    @query = query
-    @calls = calls
-    @syntax_fields = fields
-    @original_target = target
-    @target = apply_calls(target)
-  end
-
-  # If the target responds to `method_name`, send it to target.
-  def method_missing(method_name, *args, &block)
-    if target.respond_to?(method_name)
-      target.public_send(method_name, *args, &block)
-    else
-      super
-    end
-  end
-
-  # Looks up {#syntax_fields} against this node and returns the results
-  def as_result
-    @as_result ||= begin
-      json = {}
-      syntax_fields.each do |syntax_field|
-        key_name = syntax_field.alias_name || syntax_field.identifier
-        if key_name == 'node'
-          clone_node = self.class.new(target, fields: syntax_field.fields, query: query, calls: syntax_field.calls)
-          json[key_name] = clone_node.as_result
-        elsif key_name == 'cursor'
-          json[key_name] = cursor
-        elsif key_name[0] == "$"
-          fragment = query.fragments[key_name]
-          # execute the fragment and merge it into this result
-          clone_node = self.class.new(target, fields: fragment.fields, query: query, calls: @calls)
-          json.merge!(clone_node.as_result)
-        else
-          field = get_field(syntax_field)
-          new_target = public_send(field.name)
-          new_node = field.type_class.new(new_target, fields: syntax_field.fields, query: query, calls: syntax_field.calls)
-          json[key_name] = new_node.as_result
-        end
-      end
-      json
-    end
-  end
-
-  # The object passed to {Query#initialize} as `context`.
-  def context
-    query.context
-  end
-
-  def __type__
-    self.class
-  end
-
-  def apply_calls(value)
-    finished_value(value)
-  end
-
-  def finished_value(raw_value)
-    @finished_value ||= begin
-      val = raw_value
-      @calls.each do |call|
-        registered_call = self.class.calls[call.identifier]
-        if registered_call.nil?
-          raise "Call not found: #{self.class.name}##{call.identifier}"
-        end
-        val = registered_call.lambda.call(val, *call.arguments)
-      end
-      val
-    end
-  end
-
-  class << self
-    # @param [String] class_name name of the class this node will wrap.
-    def exposes(*exposes_class_names)
-      @exposes_class_names = exposes_class_names
-      GraphQL::SCHEMA.add_type(self)
-    end
-
-    # The names of the classes wrapped by this node
-    def exposes_class_names
-      @exposes_class_names || []
-    end
-
-    # @param [String] describe
-    # Provide a description for this node which will be accessible from {SCHEMA}
-    def desc(describe)
-      @description = describe
-    end
-
-    # The description of this node
-    def description
-      @description || raise("#{name}.description isn't defined")
-    end
-
-    # @param [String] type_name
-    # Declares an alternative name to use in {GraphQL::SCHEMA}
-    def type(type_name)
-      @type_name = type_name.to_s
-      GraphQL::SCHEMA.add_type(self)
-    end
-
-    # Returns the name of this node used by {GraphQL::SCHEMA}
-    def schema_name
-      @type_name || default_schema_name
-    end
-
-    def default_schema_name
-      name.split("::").last.sub(/(Node|Type)$/, '').underscore
-    end
-
-    # @param [String] field_name name of the field to be used as the cursor
-    # Declares what field will be used as the cursor for this node.
-    def cursor(field_name)
-      define_method "cursor" do
-        field_mapping = self.class.all_fields[field_name.to_s]
-        public_send(field_mapping.name).to_s
-      end
-    end
-
-    # All accessible fields on this node (including those defined in parent classes)
-    def all_fields
-      superclass.all_fields.merge(own_fields)
-    rescue NoMethodError
-      own_fields
-    end
-
-    # Fields defined by this class, but not its parents
-    def own_fields
-      @own_fields ||= {}
-    end
-
-    # @return [GraphQL::FieldDefiner] definer
-    def field
-      @field_definer ||= GraphQL::FieldDefiner.new(self)
-    end
-
-    # @param [String] field_name
-    # Un-define field with name `field_name`
-    def remove_field(field_name)
-      own_fields.delete(field_name.to_s)
-    end
-
-    # Can the node handle a field with this name?
-    def respond_to_field?(field_name)
-      if all_fields[field_name.to_s].blank?
-        false
-      elsif method_defined?(field_name)
-        true
-      elsif exposes_class_names.any? do |exposes_class_name|
-          exposes_class = Object.const_get(exposes_class_name)
-          exposes_class.method_defined?(field_name) || exposes_class.respond_to?(field_name)
-        end
-        true
-      else
-        false
-      end
-    end
-
-    def calls
-      superclass.calls.merge(own_calls)
-    rescue NoMethodError
-      {}
-    end
-    # @param [String] name the identifier for this call
-    # @param [lambda] operation the transformation this call makes
-    #
-    # Define a call that can be made on nodes of this type.
-    # The `lambda` receives arguments:
-    # - 1: `previous_value` -- the value of this node
-    # - *: arguments passed in the query (as strings)
-    #
-    # @example
-    #   # upcase a string field:
-    #   call :upcase, -> (prev_value) { prev_value.upcase }
-    # @example
-    #   # tests a number field:
-    #   call :greater_than, -> (prev_value, test_value) { prev_value > test_value.to_f }
-    #   # (`test_value` is passed in as a string)
-    def call(name, lambda)
-      own_calls[name.to_s] = GraphQL::Call.new(name: name.to_s, lambda: lambda)
-    end
-
-    def own_calls
-      @own_calls ||= {}
-    end
-  end
-
-  private
-
-  def get_field(syntax_field)
-    field_mapping = self.class.all_fields[syntax_field.identifier]
-    if syntax_field.identifier == "cursor"
-      cursor
-    elsif field_mapping.nil?
-      raise GraphQL::FieldNotDefinedError.new(self.class, syntax_field.identifier)
-    else
-      field_mapping
-    end
-  end
-end

data/lib/graphql/parser/parser.rb

@@ -1,39 +0,0 @@
-# Parser is a [parslet](http://kschiess.github.io/parslet/) parser for parsing queries.
-#
-# If it failes to parse, a {SyntaxError} is raised.
-class GraphQL::Parser::Parser < Parslet::Parser
-  root(:query)
-  rule(:query) { node.repeat.as(:nodes) >> variable.repeat.as(:variables) >> fragment.repeat.as(:fragments) }
-
-  # node
-  rule(:node) { space? >> call >> space? >> fields.as(:fields) }
-
-  # fragment
-  rule(:fragment) { space? >> fragment_identifier >> str(":") >> space? >> fields.as(:fields) >> space?}
-  rule(:fragment_identifier) { (str("$") >> name).as(:identifier) }
-
-  # field set
-  rule(:fields) { str("{") >> space? >> (field >> separator?).repeat(1) >> space? >> str("}") >> space?}
-
-  # call
-  rule(:call) { identifier >> str("(") >> (argument.as(:argument) >> separator?).repeat(0).as(:arguments) >> str(")") }
-  rule(:dot) { str(".") }
-  rule(:argument) { (identifier | variable_identifier)}
-
-  # field
-  rule(:field) { (identifier | fragment_identifier) >> call_chain.maybe >> alias_name.maybe >> space? >> fields.as(:fields).maybe }
-  rule(:call_chain) { (dot >> call).repeat(0).as(:calls) }
-  rule(:alias_name) { space >> str("as") >> space >> name.as(:alias_name) }
-
-  # variable
-  rule(:variable) { space? >> variable_identifier >> str(":") >> space? >> (name | json_string ).as(:json_string) >> space?}
-  rule(:json_string) { str("{") >> (match('[^{}]') | json_string).repeat >> str("}")}
-  rule(:variable_identifier) { (str("<") >> name >> str(">")).as(:identifier) }
-
-  # general purpose
-  rule(:separator?) { str(",").maybe >> space? }
-  rule(:identifier) { name.as(:identifier) }
-  rule(:name) { match('\w').repeat(1) }
-  rule(:space) { match('[\s\n]+').repeat(1) }
-  rule(:space?) { space.maybe }
-end

data/lib/graphql/parser/transform.rb

@@ -1,22 +0,0 @@
-# {Transform} is a [parslet](http://kschiess.github.io/parslet/) transform for for turning the AST into objects in {GraphQL::Syntax}.
-class GraphQL::Parser::Transform < Parslet::Transform
-  # query
-  rule(nodes: sequence(:n), variables: sequence(:v), fragments: sequence(:f)) { GraphQL::Syntax::Query.new(nodes: n, variables: v, fragments: f)}
-  # node
-  rule(identifier: simple(:i), arguments: sequence(:a), fields: sequence(:f)) {GraphQL::Syntax::Node.new(identifier: i.to_s, arguments: a, fields: f)}
-  # field
-  rule(identifier: simple(:i), calls: sequence(:c), fields: sequence(:f), alias_name: simple(:a)) { GraphQL::Syntax::Field.new(identifier: i.to_s, fields: f, calls: c, alias_name: a.to_s)}
-  rule(identifier: simple(:i), calls: sequence(:c), alias_name: simple(:a)) { GraphQL::Syntax::Field.new(identifier: i.to_s, calls: c, alias_name: a.to_s)}
-  rule(identifier: simple(:i), calls: sequence(:c), fields: sequence(:f)) { GraphQL::Syntax::Field.new(identifier: i.to_s, fields: f, calls: c)}
-  rule(identifier: simple(:i), calls: sequence(:c)) { GraphQL::Syntax::Field.new(identifier: i.to_s, calls: c)}
-  rule(identifier: simple(:i), alias_name: simple(:a)) { GraphQL::Syntax::Field.new(identifier: i.to_s, alias_name: a.to_s)}
-  # call
-  rule(identifier: simple(:i), arguments: sequence(:a)) { GraphQL::Syntax::Call.new(identifier: i.to_s, arguments: a) }
-  # argument
-  rule(argument: simple(:a)) { a.to_s }
-  rule(identifier: simple(:i)) { i.to_s }
-  # variable
-  rule(identifier: simple(:i), json_string: simple(:j)) { GraphQL::Syntax::Variable.new(identifier: i.to_s, json_string: j.to_s)}
-  # fragment
-  rule(identifier: simple(:i), fields: sequence(:f)) { GraphQL::Syntax::Fragment.new(identifier: i, fields: f)}
-end

data/lib/graphql/query.rb

@@ -1,109 +0,0 @@
-# Executes queries from strings against {GraphQL::SCHEMA}.
-#
-# @example
-#   query_str = "post(1) { title, comments { count } }"
-#   query_ctx = {user: current_user}
-#   query = GraphQL::Query.new(query_str, context: query_ctx)
-#   result = query.as_result
-
-class GraphQL::Query
-  # This is the object passed to {#initialize} as `context:`
-  attr_reader :context
-  attr_reader :query_string, :root
-
-  # @param [String] query_string the string to be parsed
-  # @param [Object] context an object which will be available to all nodes and fields in the schema
-  def initialize(query_string, context: nil)
-    if !query_string.is_a?(String) || query_string.length == 0
-      raise "You must send a query string, not a #{query_string.class.name}"
-    end
-    @query_string = query_string
-    @root = parse(query_string)
-    @context = context
-  end
-
-  # @return [Hash] result the JSON response to this query
-  # Calling {#as_result} more than once won't cause the query to be re-run
-  def as_result
-    @as_result ||= execute!
-  end
-
-  # Provides access to query variables, raises an error if not found
-  # @example
-  #   query.variables["<person_data>"]
-  def variables
-    @variables ||= LookupHash.new("variable", @root.variables)
-  end
-
-  # Provides access to query fragments, raises an error if not found
-  # @example
-  #   query.fragments["$personData"]
-  def fragments
-    @fragments ||= LookupHash.new("fragment", @root.fragments)
-  end
-
-  private
-
-  def execute!
-    root_syntax_node = root.nodes[0]
-    root_call_class = GraphQL::SCHEMA.get_call(root_syntax_node.identifier)
-    root_call = root_call_class.new(query: self, syntax_arguments: root_syntax_node.arguments)
-    result_object = root_call.as_result
-    return_declarations = root_call_class.return_declarations
-    result = {}
-
-    if result_object.is_a?(Hash)
-      result_object.each do |name, value|
-        node_class = GraphQL::SCHEMA.type_for_object(value)
-        field_for_node = root_syntax_node.fields.find {|f| f.identifier == name.to_s }
-        if field_for_node.present?
-          fields_for_node = field_for_node.fields
-          node_value = node_class.new(value,query: self, fields: fields_for_node)
-          result[name.to_s] = node_value.as_result
-        end
-      end
-    elsif result_object.is_a?(Array)
-      fields_for_node = root_syntax_node.fields
-      result_object.each do |item|
-        node_class = GraphQL::SCHEMA.type_for_object(item)
-        node_value = node_class.new(item, query: self, fields: fields_for_node)
-        result[node_value.cursor] = node_value.as_result
-      end
-    else
-      node_class = GraphQL::SCHEMA.type_for_object(result_object)
-      fields_for_node = root_syntax_node.fields
-      node_value = node_class.new(result_object, query: self, fields: fields_for_node)
-      result[node_value.cursor] = node_value.as_result
-    end
-
-    result
-  end
-
-  def parse(query_string)
-    parsed_hash = GraphQL::PARSER.parse(query_string)
-    root_node = GraphQL::TRANSFORM.apply(parsed_hash)
-  rescue Parslet::ParseFailed => error
-    line, col = error.cause.source.line_and_column
-    raise GraphQL::SyntaxError.new(line, col, query_string)
-  end
-
-  # Caches items by name, raises an error if not found
-  class LookupHash
-    attr_reader :item_name, :items
-    def initialize(item_name, items)
-      @items = items
-      @item_name = item_name
-      @storage = Hash.new do |hash, identifier|
-        value = items.find {|i| i.identifier == identifier }
-        if value.blank?
-          "No #{item_name} found for #{identifier}, defined #{item_name}s are: #{items.map(&:identifier)}"
-        end
-        hash[identifier] = value
-      end
-    end
-
-    def [](identifier)
-      @storage[identifier]
-    end
-  end
-end

data/lib/graphql/root_call.rb

@@ -1,202 +0,0 @@
-# Every query begins with a root call. It might find data or mutate data and return some results.
-#
-# A root call should:
-#
-# - declare any arguments with {.argument}, or declare `argument.none`
-# - declare returns with {.return}
-# - implement {#execute!} to take those arguments and return values
-#
-# @example
-#   FindPostCall < GraphQL::RootCall
-#     argument.number(:ids, any_number: true)
-#     returns :post
-#
-#     def execute!(*ids)
-#       ids.map { |id| Post.find(id) }
-#     end
-#   end
-#
-# @example
-#   CreateCommentCall < GraphQL::RootCall
-#     argument.number(:post_id)
-#     argument.object(:comment)
-#     returns :post, :comment
-#
-#     def execute!(post_id, comment)
-#       post = Post.find(post_id)
-#       new_comment = post.comments.create!(comment)
-#       {
-#         comment: new_comment,
-#         post: post,
-#       }
-#     end
-#   end
-#
-class GraphQL::RootCall
-  attr_reader :query, :arguments
-
-  # Validates arguments against declared {.argument}s
-  def initialize(query:, syntax_arguments:)
-    @query = query
-
-    raise "#{self.class.name} must declare arguments" unless self.class.arguments
-    @arguments = syntax_arguments.each_with_index.map do |syntax_arg, idx|
-
-      value = if syntax_arg[0] == "<"
-          query.variables[syntax_arg].json_string
-        else
-          syntax_arg
-        end
-
-      typecast(idx, value)
-    end
-  end
-
-  # @param [Array] args (splat) all args provided in query string (as strings)
-  # This method is invoked with the arguments provided to the query.
-  # It should do work and return values matching the {.returns} declarations
-  def execute!(*args)
-    raise NotImplementedError, "Do work in this method"
-  end
-
-  # The object passed to {Query#initialize} as `context`
-  def context
-    query.context
-  end
-
-  # Executes the call, validates the return values against declared {.returns}, then returns the return values.
-  def as_result
-    return_declarations = self.class.return_declarations
-    raise "#{self.class.name} must declare returns" unless return_declarations.present?
-    return_values = execute!(*arguments)
-
-    if return_values.is_a?(Hash)
-      unexpected_returns = return_values.keys - return_declarations.keys
-      missing_returns = return_declarations.keys - return_values.keys
-      if unexpected_returns.any?
-        raise "#{self.class.name} returned #{unexpected_returns}, but didn't declare them."
-      elsif missing_returns.any?
-        raise "#{self.class.name} declared #{missing_returns}, but didn't return them."
-      end
-    end
-    return_values
-  end
-
-  class << self
-    # @param [String] ident_name
-    # Declare an alternative name used in a query string
-    def indentifier(ident_name)
-      @identifier = ident_name
-      GraphQL::SCHEMA.add_call(self)
-    end
-
-    # The name used by {GraphQL::SCHEMA}. Uses {.identifier} or derives a name from the class name.
-    def schema_name
-      @identifier || name.split("::").last.sub(/Call$/, '').underscore
-    end
-
-    def inherited(child_class)
-      GraphQL::SCHEMA.add_call(child_class)
-    end
-
-    # This call won't be visible in `schema()`
-    def abstract!
-      GraphQL::SCHEMA.remove_call(self)
-    end
-
-    # @param [Symbol] return_declarations
-    # Name of returned values from this call
-    def returns(*return_declaration_names)
-      if return_declaration_names.last.is_a?(Hash)
-        return_declarations_hash = return_declaration_names.pop
-      else
-        return_declarations_hash = {}
-      end
-
-      raise "Return keys must be symbols" if  (return_declarations.keys + return_declaration_names).any? { |k| !k.is_a?(Symbol) }
-
-      return_declaration_names.each do |return_sym|
-        return_type = return_sym.to_s
-        return_declarations[return_sym] = return_type
-      end
-
-      return_declarations_hash.each do |return_sym, return_type|
-        return_declarations[return_sym] = return_type
-      end
-    end
-
-    def return_declarations
-      @return_declarations ||= {}
-    end
-
-    # @return [GraphQL::RootCallArgumentDefiner] definer
-    # Use this object to declare arguments. They must be declared in order
-    # @example
-    #   argument.string("post_title")
-    #   argument.object("comment_data") # allows a JSON object
-    def argument
-      @argument ||= GraphQL::RootCallArgumentDefiner.new(self)
-    end
-
-    def own_arguments
-      @own_arguments ||= {}
-    end
-
-    def arguments
-      superclass.arguments.merge(own_arguments)
-    rescue NoMethodError
-      {}
-    end
-
-    def add_argument(argument)
-      existing_argument = arguments[argument.name]
-      if existing_argument.blank?
-        # only assign an index if this variable wasn't already defined
-        argument.index = arguments.keys.length
-      else
-        # use the same index as the already-defined one
-        argument.index = existing_argument.index
-      end
-
-      own_arguments[argument.name] = argument
-    end
-
-    def argument_at_index(idx)
-      if arguments.values.first.any_number
-        arguments.values.first
-      else
-        arguments.values.find { |arg| arg.index == idx } || raise("No argument found for #{name} at index #{JSON.dump(idx)} (argument indexes: #{arguments.values.map(&:index)})")
-      end
-    end
-  end
-
-  private
-
-  TYPE_CHECKS = {
-    "object" => Hash,
-    "number" => Numeric,
-    "string" => String,
-  }
-
-
-  def typecast(idx, value)
-    arg_dec = self.class.argument_at_index(idx)
-    expected_type = arg_dec.type
-    expected_type_class = TYPE_CHECKS[expected_type]
-
-    if expected_type == "string"
-      parsed_value = value
-    else
-      parsed_value = JSON.parse('{ "value" : ' + value + '}')["value"]
-    end
-
-    if !parsed_value.is_a?(expected_type_class)
-      raise GraphQL::RootCallArgumentError.new(arg_dec, value)
-    end
-
-    parsed_value
-  rescue JSON::ParserError
-    raise GraphQL::RootCallArgumentError.new(arg_dec, value)
-  end
-
-end