graphql 0.17.2 → 0.18.0

data/lib/graphql/language/parser.y

@@ -11,6 +11,7 @@ rule
   definition:
       operation_definition
     | fragment_definition
+    | type_system_definition
 
   operation_definition:
       operation_type operation_name_opt variable_definitions_opt directives_list_opt selection_set {
@@ -52,7 +53,7 @@ rule
     | variable_definitions_list variable_definition { val[0] << val[1] }
 
   variable_definition:
-      VAR_SIGN name COLON variable_definition_type_name variable_definition_default_value_opt {
+      VAR_SIGN name COLON type default_value_opt {
         return make_node(:VariableDefinition, {
           name: val[1],
           type: val[3],
@@ -61,12 +62,12 @@ rule
         })
       }
 
-  variable_definition_type_name:
-      name                                            { return make_node(:TypeName, name: val[0])}
-    | variable_definition_type_name BANG              { return make_node(:NonNullType, of_type: val[0]) }
-    | RBRACKET variable_definition_type_name LBRACKET { return make_node(:ListType, of_type: val[1]) }
+  type:
+      name                   { return make_node(:TypeName, name: val[0])}
+    | type BANG              { return make_node(:NonNullType, of_type: val[0]) }
+    | RBRACKET type LBRACKET { return make_node(:ListType, of_type: val[1]) }
 
-  variable_definition_default_value_opt:
+  default_value_opt:
       /* none */          { return nil }
     | EQUALS input_value  { return val[1] }
 
@@ -116,14 +117,38 @@ rule
       name_without_on
     | ON
 
+  schema_keyword:
+      SCHEMA
+    | SCALAR
+    | TYPE
+    | IMPLEMENTS
+    | INTERFACE
+    | UNION
+    | ENUM
+    | INPUT
+
   name_without_on:
       IDENTIFIER
     | FRAGMENT
     | TRUE
     | FALSE
-    | QUERY
-    | MUTATION
-    | SUBSCRIPTION
+    | operation_type
+    | schema_keyword
+
+  enum_name: /* any identifier, but not "true", "false" or "null" */
+      IDENTIFIER
+    | FRAGMENT
+    | ON
+    | operation_type
+    | schema_keyword
+
+  name_list:
+      name             { return [val[0].to_s]}
+    | name_list name   { val[0] << val[1].to_s }
+
+  enum_name_list:
+      enum_name                  { return [val[0].to_s]}
+    | enum_name_list enum_name   { return val[0] << val[1].to_s }
 
   arguments_opt:
       /* none */                    { return [] }
@@ -171,14 +196,6 @@ rule
 
   enum_value: enum_name { return make_node(:Enum, name: val[0], position_source: val[0])}
 
-  enum_name: /* any identifier, but not "true", "false" or "null" */
-      IDENTIFIER
-    | FRAGMENT
-    | ON
-    | QUERY
-    | MUTATION
-    | SUBSCRIPTION
-
   directives_list_opt:
       /* none */      { return [] }
     | directives_list
@@ -221,6 +238,86 @@ rule
         }
       )
     }
+
+
+  type_system_definition:
+     schema_definition
+   | type_definition
+
+  schema_definition:
+      SCHEMA RCURLY operation_type_definition_list LCURLY { return make_node(:SchemaDefinition, val[2]) }
+
+  operation_type_definition_list:
+      operation_type_definition
+    | operation_type_definition_list operation_type_definition { return val[0].merge(val[1]) }
+
+  operation_type_definition:
+      operation_type COLON name { return { val[0].to_s.to_sym => val[2] } }
+
+  type_definition:
+      scalar_type_definition
+    | object_type_definition
+    | interface_type_definition
+    | union_type_definition
+    | enum_type_definition
+    | input_object_type_definition
+
+  scalar_type_definition: SCALAR name { return make_node(:ScalarTypeDefinition, name: val[1]) }
+
+  object_type_definition:
+      TYPE name implements_opt RCURLY field_definition_list LCURLY {
+        return make_node(:ObjectTypeDefinition, name: val[1], interfaces: val[2], fields: val[4])
+      }
+
+  implements_opt:
+      /* none */ { return [] }
+    | IMPLEMENTS name_list { return val[1] }
+
+  input_value_definition:
+      name COLON type default_value_opt {
+        return make_node(:InputValueDefinition, name: val[0], type: val[2], default_value: val[3])
+      }
+
+  input_value_definition_list:
+      input_value_definition                             { return [val[0]] }
+    | input_value_definition_list input_value_definition { val[0] << val[1] }
+
+  arguments_definitions_opt:
+      /* none */ { return [] }
+    | RPAREN input_value_definition_list LPAREN { return val[1] }
+
+  field_definition:
+      name arguments_definitions_opt COLON type {
+        return make_node(:FieldDefinition, name: val[0], arguments: val[1], type: val[3])
+      }
+
+  field_definition_list:
+      field_definition                       { return [val[0]] }
+    | field_definition_list field_definition { val[0] << val[1] }
+
+  interface_type_definition:
+      INTERFACE name RCURLY field_definition_list LCURLY {
+        return make_node(:InterfaceTypeDefinition, name: val[1], fields: val[3])
+      }
+
+  union_members:
+      name                    { return [val[0].to_s]}
+    | union_members PIPE name { val[0] << val[2].to_s }
+
+  union_type_definition:
+      UNION name EQUALS union_members {
+        return make_node(:UnionTypeDefinition, name: val[1], types: val[3])
+      }
+
+  enum_type_definition:
+      ENUM name RCURLY enum_name_list LCURLY {
+         return make_node(:EnumTypeDefinition, name: val[1], values: val[3])
+      }
+
+  input_object_type_definition:
+      INPUT name RCURLY input_value_definition_list LCURLY {
+        return make_node(:InputObjectTypeDefinition, name: val[1], fields: val[3])
+      }
 end
 
 ---- header ----

data/lib/graphql/query.rb

@@ -48,6 +48,8 @@ module GraphQL
           @fragments[part.name] = part
         elsif part.is_a?(GraphQL::Language::Nodes::OperationDefinition)
           @operations[part.name] = part
+        else
+          raise GraphQL::ExecutionError, "GraphQL query cannot contain a schema definition"
         end
       end
 
@@ -71,7 +73,10 @@ module GraphQL
     # If more than one operation is present, it must be named at runtime.
     # @return [GraphQL::Language::Nodes::OperationDefinition, nil]
     def selected_operation
-      @selected_operation ||= find_operation(@operations, @operation_name)
+      @selected_operation ||= begin
+        perform_validation
+        @selected_operation
+      end
     end
 
     # Determine the values for variables of this query, using default values
@@ -116,9 +121,18 @@ module GraphQL
     private
 
     def perform_validation
+      @selected_operation = find_operation(@operations, @operation_name)
       validation_result = schema.static_validator.validate(self)
       @validation_errors = validation_result[:errors]
       @internal_representation = validation_result[:irep]
+      if @validation_errors.none?
+        # Accessing variables will raise errors if there are any :S
+        variables
+      end
+      nil
+    rescue GraphQL::Query::OperationNameMissingError, GraphQL::Query::VariableValidationError => err
+      @validation_errors = [err.to_h]
+      @internal_representation = nil
       nil
     end
 

data/lib/graphql/relay.rb

@@ -0,0 +1,13 @@
+require 'base64'
+
+require 'graphql/relay/global_node_identification'
+require 'graphql/relay/page_info'
+require 'graphql/relay/edge'
+require 'graphql/relay/edge_type'
+require 'graphql/relay/base_connection'
+require 'graphql/relay/array_connection'
+require 'graphql/relay/relation_connection'
+require 'graphql/relay/global_id_resolve'
+require 'graphql/relay/mutation'
+require 'graphql/relay/connection_field'
+require 'graphql/relay/connection_type'

data/lib/graphql/relay/array_connection.rb

@@ -0,0 +1,80 @@
+module GraphQL
+  module Relay
+    class ArrayConnection < BaseConnection
+      def cursor_from_node(item)
+        idx = starting_offset + sliced_nodes.find_index(item) + 1
+        Base64.strict_encode64(idx.to_s)
+      end
+
+      def has_next_page
+        !!(first && sliced_nodes.count > limit)
+      end
+
+      def has_previous_page
+        !!(last && starting_offset > 0)
+      end
+
+      private
+
+      # apply first / last limit results
+      def paged_nodes
+        @paged_nodes = begin
+          items = sliced_nodes
+
+          if limit
+            items.first(limit)
+          else
+            items
+          end
+        end
+      end
+
+      # Apply cursors to edges
+      def sliced_nodes
+        @sliced_nodes ||= begin
+          items = object
+          items[starting_offset..-1]
+        end
+      end
+
+      def index_from_cursor(cursor)
+        Base64.decode64(cursor).to_i
+      end
+
+      def starting_offset
+        @starting_offset = if before
+          [previous_offset, 0].max
+        else
+          previous_offset
+        end
+      end
+
+      def previous_offset
+        @previous_offset ||= if after
+          index_from_cursor(after)
+        elsif before
+          prev_page_size = [max_page_size, last].compact.min || 0
+          index_from_cursor(before) - prev_page_size - 1
+        else
+          0
+        end
+      end
+
+      def limit
+        @limit ||= begin
+          limit_from_arguments = if first
+            first
+          else
+            if previous_offset < 0
+              previous_offset + (last ? last : 0)
+            else
+              last
+            end
+          end
+          [limit_from_arguments, max_page_size].compact.min
+        end
+      end
+    end
+    BaseConnection.register_connection_implementation(Array, ArrayConnection)
+  end
+end

data/lib/graphql/relay/base_connection.rb

@@ -0,0 +1,138 @@
+module GraphQL
+  module Relay
+    # Subclasses must implement:
+    #   - {#cursor_from_node}, which returns an opaque cursor for the given item
+    #   - {#sliced_nodes}, which slices by `before` & `after`
+    #   - {#paged_nodes}, which applies `first` & `last` limits
+    #
+    # In a subclass, you have access to
+    #   - {#object}, the object which the connection will wrap
+    #   - {#first}, {#after}, {#last}, {#before} (arguments passed to the field)
+    #   - {#max_page_size} (the specified maximum page size that can be returned from a connection)
+    #
+    class BaseConnection
+      # Just to encode data in the cursor, use something that won't conflict
+      CURSOR_SEPARATOR = "---"
+
+      # Map of collection class names -> connection_classes
+      # eg {"Array" => ArrayConnection}
+      CONNECTION_IMPLEMENTATIONS = {}
+
+      # Find a connection implementation suitable for exposing `items`
+      #
+      # @param [Object] A collection of items (eg, Array, AR::Relation)
+      # @return [subclass of BaseConnection] a connection Class for wrapping `items`
+      def self.connection_for_items(items)
+        # We check class membership by comparing class names rather than
+        # identity to prevent this from being broken by Rails autoloading.
+        # Changes to the source file for ItemsClass in Rails apps cause it to be
+        # reloaded as a new object, so if we were to use `is_a?` here, it would
+        # no longer match any registered custom connection types.
+        ancestor_names = items.class.ancestors.map(&:name)
+        implementation = CONNECTION_IMPLEMENTATIONS.find do |items_class_name, connection_class|
+          ancestor_names.include? items_class_name
+        end
+        if implementation.nil?
+          raise("No connection implementation to wrap #{items.class} (#{items})")
+        else
+          implementation[1]
+        end
+      end
+
+      # Add `connection_class` as the connection wrapper for `items_class`
+      # eg, `RelationConnection` is the implementation for `AR::Relation`
+      # @param [Class] A class representing a collection (eg, Array, AR::Relation)
+      # @param [Class] A class implementing Connection methods
+      def self.register_connection_implementation(items_class, connection_class)
+        CONNECTION_IMPLEMENTATIONS[items_class.name] = connection_class
+      end
+
+      attr_reader :object, :arguments, :max_page_size, :parent
+
+      # Make a connection, wrapping `object`
+      # @param The collection of results
+      # @param Query arguments
+      # @param max_page_size [Int] The maximum number of results to return
+      # @param parent [Object] The object which this collection belongs to
+      def initialize(object, arguments, max_page_size: nil, parent: nil)
+        @object = object
+        @arguments = arguments
+        @max_page_size = max_page_size
+        @parent = parent
+      end
+
+      # Provide easy access to provided arguments:
+      METHODS_FROM_ARGUMENTS = [:first, :after, :last, :before, :order]
+
+      # @!method first
+      #   The value passed as `first:`, if there was one
+      # @!method after
+      #   The value passed as `after:`, if there was one
+      # @!method last
+      #   The value passed as `last:`, if there was one
+      # @!method before
+      #   The value passed as `before:`, if there was one
+      # @!method order
+      #   The value passed as `order:`, if there was one
+      METHODS_FROM_ARGUMENTS.each do |arg_name|
+        define_method(arg_name) do
+          arguments[arg_name]
+        end
+      end
+
+      # These are the items to render for this connection,
+      # probably wrapped by {GraphQL::Relay::Edge}
+      def edge_nodes
+        @edge_nodes ||= paged_nodes
+      end
+
+      # Support the `pageInfo` field
+      def page_info
+        self
+      end
+
+      # Used by `pageInfo`
+      def has_next_page
+        !!(first && sliced_nodes.count > first)
+      end
+
+      # Used by `pageInfo`
+      def has_previous_page
+        !!(last && sliced_nodes.count > last)
+      end
+
+      # Used by `pageInfo`
+      def start_cursor
+        if start_node = (respond_to?(:paged_nodes_array, true) ? paged_nodes_array : paged_nodes).first
+          return cursor_from_node(start_node)
+        else
+          return nil
+        end
+      end
+
+      # Used by `pageInfo`
+      def end_cursor
+        if end_node = (respond_to?(:paged_nodes_array, true) ? paged_nodes_array : paged_nodes).last
+          return cursor_from_node(end_node)
+        else
+          return nil
+        end
+      end
+
+      # An opaque operation which returns a connection-specific cursor.
+      def cursor_from_node(object)
+        raise NotImplementedError, "must return a cursor for this object/connection pair"
+      end
+
+      private
+
+      def paged_nodes
+        raise NotImplementedError, "must return items for this connection after paging"
+      end
+
+      def sliced_nodes
+        raise NotImplementedError, "must return  all items for this connection after chopping off first and last"
+      end
+    end
+  end
+end