graphql 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6184108ff2ba0151d12bfaeb02feeacbdeba74cc
-  data.tar.gz: 2a9cb034382d28f96a7e29024814848b63596a49
+  metadata.gz: ea9221c87a055fadbddc1b61de970e61b993e074
+  data.tar.gz: 289bff890b6c2fb4ff3487cd74f8333375dcdbe9
 SHA512:
-  metadata.gz: 7bb555f0b19ce78ea3f79ba7388f31509c26e2518fc1c207a25e83bcdd4f38e3670194bcb26a1447dc134a5949e58d10e12da79846bb2b3fb4dab0d688561a8a
-  data.tar.gz: 695837ba820b7709453584800eaa6d3f4082edc9d443055ab52d42e0db3b895189c2c10113a04d43e44c70726365621b99a878cc68a371acd85b46aeb05b925a
+  metadata.gz: 28d366cd1a906295fe885728ad08f1b13bcbd3b36ad35ac3aed6603d54a680a9e01ed048393f040f59d3b649c261e82958ef2432f652fa78d8a97d88ea69ca2b
+  data.tar.gz: eb17ca9aa091ccc42a85ecbf59b45bbbe61fa9dc154cb0794cbe59cae6bdc0a1e082fe35f95f8878c6b0dbe59432a420c58068f00f40eb594c00ef083d5c73a6

data/lib/graphql.rb

@@ -2,62 +2,77 @@ require "active_support/core_ext/object/blank"
 require "active_support/core_ext/string/inflections"
 require "json"
 require "parslet"
-require "singleton"
 
 module GraphQL
   autoload(:Call,                     "graphql/call")
   autoload(:Connection,               "graphql/connection")
-  autoload(:Field,                    "graphql/field")
   autoload(:FieldDefiner,             "graphql/field_definer")
+  autoload(:Field,                    "graphql/field")
   autoload(:Node,                     "graphql/node")
-  autoload(:Parser,                   "graphql/parser")
   autoload(:Query,                    "graphql/query")
   autoload(:RootCall,                 "graphql/root_call")
   autoload(:RootCallArgument,         "graphql/root_call_argument")
   autoload(:RootCallArgumentDefiner,  "graphql/root_call_argument_definer")
-  autoload(:Schema,                   "graphql/schema")
-  autoload(:Transform,                "graphql/transform")
   autoload(:VERSION,                  "graphql/version")
 
   # These objects are used for introspections (eg, responding to `schema()` calls).
   module Introspection
-    autoload(:CallNode,             "graphql/introspection/call_node")
+    autoload(:CallType,             "graphql/introspection/call_type")
     autoload(:Connection,           "graphql/introspection/connection")
-    autoload(:FieldNode,            "graphql/introspection/field_node")
+    autoload(:FieldType,            "graphql/introspection/field_type")
     autoload(:RootCallArgumentNode, "graphql/introspection/root_call_argument_node")
-    autoload(:RootCallNode,         "graphql/introspection/root_call_node")
+    autoload(:RootCallType,         "graphql/introspection/root_call_type")
     autoload(:SchemaCall,           "graphql/introspection/schema_call")
-    autoload(:SchemaNode,           "graphql/introspection/schema_node")
+    autoload(:SchemaType,           "graphql/introspection/schema_type")
     autoload(:TypeCall,             "graphql/introspection/type_call")
-    autoload(:TypeNode,             "graphql/introspection/type_node")
+    autoload(:TypeType,             "graphql/introspection/type_type")
+  end
+
+  # These objects are singletons used to parse queries
+  module Parser
+    autoload(:Parser,     "graphql/parser/parser")
+    autoload(:Transform,  "graphql/parser/transform")
+  end
+
+  # These objects are used to track the schema of the graph
+  module Schema
+    autoload(:ALL,              "graphql/schema/all")
+    autoload(:Schema,           "graphql/schema/schema")
+    autoload(:SchemaValidation, "graphql/schema/schema_validation")
   end
 
   # These objects are skinny wrappers for going from the AST to actual {Node} and {Field} instances.
   module Syntax
-    autoload(:Call,       "graphql/syntax/call")
-    autoload(:Field,      "graphql/syntax/field")
-    autoload(:Query,      "graphql/syntax/query")
-    autoload(:Node,       "graphql/syntax/node")
-    autoload(:Variable,   "graphql/syntax/variable")
+    autoload(:Call,     "graphql/syntax/call")
+    autoload(:Field,    "graphql/syntax/field")
+    autoload(:Query,    "graphql/syntax/query")
+    autoload(:Fragment, "graphql/syntax/fragment")
+    autoload(:Node,     "graphql/syntax/node")
+    autoload(:Variable, "graphql/syntax/variable")
   end
 
-  # These fields wrap Ruby data types and some GraphQL internal values.
+  # These objects expose values
   module Types
-    autoload(:BooleanField,     "graphql/types/boolean_field")
-    autoload(:ConnectionField,  "graphql/types/connection_field")
-    autoload(:CursorField,      "graphql/types/cursor_field")
-    autoload(:NumberField,      "graphql/types/number_field")
-    autoload(:ObjectField,      "graphql/types/object_field")
-    autoload(:StringField,      "graphql/types/string_field")
-    autoload(:TypeField,        "graphql/types/type_field")
+    autoload(:BooleanType, "graphql/types/boolean_type")
+    autoload(:ObjectType, "graphql/types/object_type")
+    autoload(:StringType, "graphql/types/string_type")
+    autoload(:NumberType, "graphql/types/number_type")
   end
   # @abstract
   # Base class for all errors, so you can rescue from all graphql errors at once.
   class Error < RuntimeError; end
   # This node doesn't have a field with that name.
   class FieldNotDefinedError < Error
-    def initialize(class_name, field_name)
-      super("#{class_name}##{field_name} was requested, but it isn't defined. Defined fields are: #{SCHEMA.field_names}")
+    def initialize(node_class, field_name)
+      class_name = node_class.name
+      defined_field_names = node_class.all_fields.keys
+      super("#{class_name}##{field_name} was requested, but it isn't defined. Defined fields are: #{defined_field_names}")
+    end
+  end
+  # The class that this node is supposed to expose isn't defined
+  class ExposesClassMissingError < Error
+    def initialize(node_class)
+      super("#{node_class.name} exposes #{node_class.exposes_class_names.join(", ")}, but that class wasn't found.")
     end
   end
   # There's no Node defined for that kind of object.
@@ -92,12 +107,14 @@ module GraphQL
     end
   end
 
-  PARSER = Parser.new
+  # Singleton {Parser::Parser} instance
+  PARSER = Parser::Parser.new
   # This singleton contains all defined nodes and fields.
-  SCHEMA = Schema.instance
-  TRANSFORM = Transform.new
+  SCHEMA = Schema::Schema.instance
+  # Singleton {Parser::Transform} instance
+  TRANSFORM = Parser::Transform.new
   # preload these so they're in SCHEMA
-  ["types", "introspection"].each do |preload_dir|
+  ["introspection", "types"].each do |preload_dir|
     Dir["#{File.dirname(__FILE__)}/graphql/#{preload_dir}/*.rb"].each { |f| require f }
   end
   Node.field.__type__(:__type__)

data/lib/graphql/call.rb

@@ -1,4 +1,4 @@
-# Created by {Field.call}, used internally by GraphQL.
+# Created by {Node.call}, used internally by GraphQL.
 class GraphQL::Call
   attr_reader :name, :lambda
   def initialize(name:, lambda:)

data/lib/graphql/connection.rb

@@ -2,27 +2,27 @@
 #
 # Out of the box, the only field it has is `edges`, which provides access to the members of the collection.
 #
-# You can define a custom {Connection} to use. This allows you to define fields at the collection level (rather than the item level)
+# You can define a custom {Connection} to use. This allows you to define fields and calls at the collection level (rather than the item level)
 #
-# Custom fields can access the collection as {Field#items}.
+# You can access the collection as `target` ({Node#target}).
 #
 # @example
 #   class UpvotesConnection < GraphQL::Collection
-#     field.number(:count)
-#     field.boolean(:any)
+#     type :upvotes # adds it to the schema
+#     call :first, -> (prev_items, first) { prev_items.first(first.to_i) }
+#     call :after, -> (prev_items, after) { prev_items.select {|i| i.id > after.to_i } }
 #
-#     def count
-#       items.count
-#     end
+#     field.number(:count) # delegates to the underlying collection
+#     field.boolean(:any)
 #
 #     def any
-#       items.any?
+#       target.any?
 #     end
 #   end
 #
 #   # Then, this connection will be used for connections whose names match:
 #   class PostNode < GraphQL::Node
-#     field.connection(:upvotes)
+#     field.upvotes(:upvotes)
 #     # ^^ uses `UpvotesConnection` based on naming convention
 #   end
 #
@@ -41,28 +41,15 @@
 #   QUERY
 class GraphQL::Connection < GraphQL::Node
   exposes "Array"
-  field.any(:edges)
-
-  attr_reader :calls, :syntax_fields, :query
-
-  def initialize(items, query:, fields: [])
-    @target = items
-    @syntax_fields = fields
-    @query = query
-  end
-
-  # Returns the members of the collection, after any calls on the corresponding {Field} have been applied
-  def items
-    @target
-  end
+  field.object(:edges)
 
   def edge_fields
     @edge_fields ||= syntax_fields.find { |f| f.identifier == "edges" }.fields
   end
 
   def edges
-    raise "#{self.class} expected a connection, but got `nil`" if items.nil?
-    items.map do |item|
+    raise "#{self.class} expected a connection, but got `nil`" if target.nil?
+    target.map do |item|
       node_class = GraphQL::SCHEMA.type_for_object(item)
       node = node_class.new(item, fields: edge_fields, query: query)
       res = node.as_result
@@ -74,15 +61,5 @@ class GraphQL::Connection < GraphQL::Node
     def default_schema_name
       name.split("::").last.sub(/Connection$/, '').underscore
     end
-
-    attr_accessor :default_connection
-    # Call this to make a the class the default connection
-    # when one isn't found by name.
-    def default_connection!
-      GraphQL::Connection.default_connection = self
-    end
-
   end
-
-  self.default_connection!
 end

data/lib/graphql/field.rb

@@ -1,182 +1,12 @@
-# {Field}s are used to safely lookup values on {Node}s. When you define a custom field, you can access it from {Node.field}
-#
-# `graphql` has built-in fields for some Ruby data types:
-# - `boolean`: {Types::BooleanField}
-# - `number`: {Types::NumberField}
-# - `string`: {Types::StringField}
-#
-# You can define custom fields that allow you to control how values are exposed.
-# - {Field.type} defines how it can be used inside {Node.field} calls.
-# - {Field.call} defines calls that can mutate the value before it is added to the response.
-#
-# @example
-#   # For example, an `AddressField` which wraps a string but exposes address-specific information
-#   class AddressField < GraphQL::Field
-#     type :address
-#     # ^^ now you can use it with `field.address` in node definitions
-#
-#     # calls can modify the value:
-#     # eg, get the numbers at the beginning:
-#     call :house_number, -> (prev_value) { prev_value[/^\d*/]}
-#     # get everything after a space:
-#     call :street_name,  -> (prev_value) { prev_value[/\s.*$/].strip }
-#   end
-#
-#   # Then, use it in a node definition:
-#   class HouseNode < GraphQL::Node
-#     exposes("House")
-#     # create an `AddressField` for this node called `street_address`:
-#     field.address(:street_address)
-#   end
-#
-#   # Then, use the field in queries:
-#   <<QUERY
-#   find_house(1) {
-#     street_address,
-#     street_address.house_number() as number,
-#     street_address.street_name() as street,
-#   }
-#   QUERY
+# Each {Node} has {Field}s that are used to look up connected nodes at query-time
 class GraphQL::Field
-  attr_reader :query, :owner, :calls, :fields
-  def initialize(query: nil, owner: nil, calls: [], fields: [])
-    @query = query
-    @owner = owner
-    @calls = calls
-    @fields = fields
+  attr_reader :type, :name
+  def initialize(name:, type:)
+    @name = name
+    @type = type.to_s
   end
 
-  def raw_value
-    owner.send(name)
+  def type_class
+    GraphQL::SCHEMA.get_type(type)
   end
-
-  def as_result
-    finished_value
-  end
-
-  def finished_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
-
-  # instance `const_get` reaches up to class namespace
-  def const_get(const_name)
-    self.class.const_get(const_name)
-  rescue
-    nil
-  end
-
-  # delegate to class constant
-  ["name", "description"].each do |method_name|
-    define_method(method_name) do
-      const_get(method_name.upcase)
-    end
-  end
-
-  class << self
-    def inherited(child_class)
-      GraphQL::SCHEMA.add_field(child_class)
-    end
-
-    def create_class(name:, owner_class:, type:, description: nil, connection_class_name: nil, node_class_name: nil)
-      if type.is_a?(Symbol)
-        type = GraphQL::SCHEMA.get_field(type)
-      end
-
-      field_superclass = type || self
-      new_class = Class.new(field_superclass)
-      new_class.const_set :NAME, name
-      new_class.const_set :OWNER_CLASS, owner_class
-      new_class.const_set :DESCRIPTION , description
-      new_class.const_set :CONNECTION_CLASS_NAME, connection_class_name
-      new_class.const_set :NODE_CLASS_NAME, node_class_name
-      new_class
-    end
-
-    def to_s
-      if const_defined?(:NAME)
-        "<FieldClass: #{const_get(:OWNER_CLASS).name}::#{const_get(:NAME)}>"
-      else
-        super
-      end
-    end
-    # @param [Symbol] type_name the name used for getting this field from the {GraphQL::SCHEMA}.
-    # Defines the name used for getting fields of this type from the schema.
-    # @example
-    #   # define the field with its type:
-    #   class IPAddressField < GraphQL::Field
-    #     type :ip_address
-    #   end
-    #
-    #   # then, attach fields of this type to your nodes:
-    #   class ServerNode < GraphQL::Field
-    #     field.ip_address(:static_ip_address)
-    #   end
-    def type(value_type_name)
-      @value_type = value_type_name.to_s
-      GraphQL::SCHEMA.add_field(self)
-    end
-
-    def value_type
-      @value_type || superclass.value_type
-    end
-
-    def schema_name
-      @value_type || (name.present? ? default_schema_name : nil)
-    end
-
-    def default_schema_name
-      name.split("::").last.sub(/Field$/, '').underscore
-    end
-
-    def field_name
-      const_get(:NAME)
-    end
-
-    def description
-      const_get(:DESCRIPTION)
-    end
-
-    def calls
-      superclass.calls.merge(_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 this field.
-    # The `lambda` receives arguments:
-    # - 1: `previous_value` -- the value of this field
-    # - *: 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)
-      _calls[name.to_s] = GraphQL::Call.new(name: name.to_s, lambda: lambda)
-    end
-
-    private
-
-    def _calls
-      @calls ||= {}
-    end
-
-  end
-
-  type :any
 end

data/lib/graphql/field_definer.rb

@@ -9,27 +9,17 @@ class GraphQL::FieldDefiner
   # `method_name` is used as a field type and looked up against {GraphQL::SCHEMA}.
   # `args[0]` is the name for the field of that type.
   def method_missing(method_name, *args, &block)
-    type = GraphQL::SCHEMA.get_field(method_name)
-    if type.present?
-      create_field(args[0], type: type, description: args[1])
-    else
-      super
-    end
+    map_field(args[0], type: method_name, description: args[1])
   end
 
   private
 
-  def create_field(field_name, type: nil, description: nil)
+  def map_field(field_name, type: nil, description: nil)
     field_name = field_name.to_s
-    field_class = GraphQL::Field.create_class({
+    mapping = GraphQL::Field.new(
       name: field_name,
       type: type,
-      owner_class: owner_class,
-      description: description,
-    })
-
-    field_class_name = field_name.camelize + "Field"
-    owner_class.const_set(field_class_name, field_class)
-    owner_class.own_fields[field_name] = field_class
+    )
+    owner_class.own_fields[field_name] = mapping
   end
 end