graphql 1.5.13 → 1.5.14

data/lib/graphql/language/lexer.rl

@@ -49,40 +49,40 @@
   UNKNOWN_CHAR =         /./;
 
   main := |*
-    INT           => { emit_token.call(:INT) };
-    FLOAT         => { emit_token.call(:FLOAT) };
-    ON            => { emit_token.call(:ON) };
-    FRAGMENT      => { emit_token.call(:FRAGMENT) };
-    TRUE          => { emit_token.call(:TRUE) };
-    FALSE         => { emit_token.call(:FALSE) };
-    NULL          => { emit_token.call(:NULL) };
-    QUERY         => { emit_token.call(:QUERY) };
-    MUTATION      => { emit_token.call(:MUTATION) };
-    SUBSCRIPTION  => { emit_token.call(:SUBSCRIPTION) };
-    SCHEMA        => { emit_token.call(:SCHEMA) };
-    SCALAR        => { emit_token.call(:SCALAR) };
-    TYPE          => { emit_token.call(:TYPE) };
-    IMPLEMENTS    => { emit_token.call(:IMPLEMENTS) };
-    INTERFACE     => { emit_token.call(:INTERFACE) };
-    UNION         => { emit_token.call(:UNION) };
-    ENUM          => { emit_token.call(:ENUM) };
-    INPUT         => { emit_token.call(:INPUT) };
-    DIRECTIVE     => { emit_token.call(:DIRECTIVE) };
-    RCURLY        => { emit_token.call(:RCURLY) };
-    LCURLY        => { emit_token.call(:LCURLY) };
-    RPAREN        => { emit_token.call(:RPAREN) };
-    LPAREN        => { emit_token.call(:LPAREN) };
-    RBRACKET      => { emit_token.call(:RBRACKET) };
-    LBRACKET      => { emit_token.call(:LBRACKET) };
-    COLON         => { emit_token.call(:COLON) };
+    INT           => { emit(:INT, ts, te, meta) };
+    FLOAT         => { emit(:FLOAT, ts, te, meta) };
+    ON            => { emit(:ON, ts, te, meta) };
+    FRAGMENT      => { emit(:FRAGMENT, ts, te, meta) };
+    TRUE          => { emit(:TRUE, ts, te, meta) };
+    FALSE         => { emit(:FALSE, ts, te, meta) };
+    NULL          => { emit(:NULL, ts, te, meta) };
+    QUERY         => { emit(:QUERY, ts, te, meta) };
+    MUTATION      => { emit(:MUTATION, ts, te, meta) };
+    SUBSCRIPTION  => { emit(:SUBSCRIPTION, ts, te, meta) };
+    SCHEMA        => { emit(:SCHEMA, ts, te, meta) };
+    SCALAR        => { emit(:SCALAR, ts, te, meta) };
+    TYPE          => { emit(:TYPE, ts, te, meta) };
+    IMPLEMENTS    => { emit(:IMPLEMENTS, ts, te, meta) };
+    INTERFACE     => { emit(:INTERFACE, ts, te, meta) };
+    UNION         => { emit(:UNION, ts, te, meta) };
+    ENUM          => { emit(:ENUM, ts, te, meta) };
+    INPUT         => { emit(:INPUT, ts, te, meta) };
+    DIRECTIVE     => { emit(:DIRECTIVE, ts, te, meta) };
+    RCURLY        => { emit(:RCURLY, ts, te, meta) };
+    LCURLY        => { emit(:LCURLY, ts, te, meta) };
+    RPAREN        => { emit(:RPAREN, ts, te, meta) };
+    LPAREN        => { emit(:LPAREN, ts, te, meta) };
+    RBRACKET      => { emit(:RBRACKET, ts, te, meta) };
+    LBRACKET      => { emit(:LBRACKET, ts, te, meta) };
+    COLON         => { emit(:COLON, ts, te, meta) };
     QUOTED_STRING => { emit_string(ts + 1, te - 1, meta) };
-    VAR_SIGN      => { emit_token.call(:VAR_SIGN) };
-    DIR_SIGN      => { emit_token.call(:DIR_SIGN) };
-    ELLIPSIS      => { emit_token.call(:ELLIPSIS) };
-    EQUALS        => { emit_token.call(:EQUALS) };
-    BANG          => { emit_token.call(:BANG) };
-    PIPE          => { emit_token.call(:PIPE) };
-    IDENTIFIER    => { emit_token.call(:IDENTIFIER) };
+    VAR_SIGN      => { emit(:VAR_SIGN, ts, te, meta) };
+    DIR_SIGN      => { emit(:DIR_SIGN, ts, te, meta) };
+    ELLIPSIS      => { emit(:ELLIPSIS, ts, te, meta) };
+    EQUALS        => { emit(:EQUALS, ts, te, meta) };
+    BANG          => { emit(:BANG, ts, te, meta) };
+    PIPE          => { emit(:PIPE, ts, te, meta) };
+    IDENTIFIER    => { emit(:IDENTIFIER, ts, te, meta) };
     COMMENT       => { record_comment(ts, te, meta) };
 
     NEWLINE => {
@@ -92,7 +92,7 @@
 
     BLANK   => { meta[:col] += te - ts };
 
-    UNKNOWN_CHAR => { emit_token.call(:UNKNOWN_CHAR) };
+    UNKNOWN_CHAR => { emit(:UNKNOWN_CHAR, ts, te, meta) };
 
   *|;
 }%%
@@ -131,11 +131,10 @@ module GraphQL
           previous_token: nil,
         }
 
-        %% write init;
+        p ||= 0
+        pe ||= data.length
 
-        emit_token = ->(name) {
-          emit(name, ts, te, meta)
-        }
+        %% write init;
 
         %% write exec;
 

data/lib/graphql/relay/connection_instrumentation.rb

@@ -32,8 +32,8 @@ module GraphQL
           connection_arguments = DEFAULT_ARGUMENTS.merge(field.arguments)
           original_resolve = field.resolve_proc
           original_lazy_resolve = field.lazy_resolve_proc
-          connection_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_resolve)
-          connection_lazy_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_lazy_resolve)
+          connection_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_resolve, lazy: false)
+          connection_lazy_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_lazy_resolve, lazy: true)
           field.redefine(
             resolve: connection_resolve,
             lazy_resolve: connection_lazy_resolve,

data/lib/graphql/relay/connection_resolve.rb

@@ -2,21 +2,33 @@
 module GraphQL
   module Relay
     class ConnectionResolve
-      def initialize(field, underlying_resolve)
+      def initialize(field, underlying_resolve, lazy:)
         @field = field
         @underlying_resolve = underlying_resolve
         @max_page_size = field.connection_max_page_size
+        @lazy = lazy
       end
 
       def call(obj, args, ctx)
+        if @lazy && obj.is_a?(LazyNodesWrapper)
+          parent = obj.parent
+          obj = obj.lazy_object
+        else
+          parent = obj
+        end
+
         nodes = @underlying_resolve.call(obj, args, ctx)
 
         if nodes.nil?
           nil
         elsif ctx.schema.lazy?(nodes)
-          nodes
+          if !@lazy
+            LazyNodesWrapper.new(obj, nodes)
+          else
+            nodes
+          end
         else
-          build_connection(nodes, args, obj, ctx)
+          build_connection(nodes, args, parent, ctx)
         end
       end
 
@@ -31,6 +43,16 @@ module GraphQL
           connection_class.new(nodes, args, field: @field, max_page_size: @max_page_size, parent: parent, context: ctx)
         end
       end
+
+      # A container for the proper `parent` of connection nodes.
+      # Without this wrapper, the lazy object _itself_ is passed into `build_connection`
+      # and it becomes the parent, which is wrong.
+      #
+      # We can get away with it because we know that this instrumentation will be applied last.
+      # That means its code after `underlying_resolve` will be _last_ on the way in.
+      # And, its code before `underlying_resolve` will be _first_ during lazy resolution.
+      # @api private
+      LazyNodesWrapper = Struct.new(:parent, :lazy_object)
     end
   end
 end

data/lib/graphql/schema.rb

@@ -111,6 +111,7 @@ module GraphQL
       @parse_error_proc = DefaultParseError
       @instrumenters = Hash.new { |h, k| h[k] = [] }
       @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
+      @lazy_methods.set(GraphQL::Relay::ConnectionResolve::LazyNodesWrapper, :never_called)
       @cursor_encoder = Base64Encoder
       # Default to the built-in execution strategy:
       @query_execution_strategy = self.class.default_execution_strategy

data/lib/graphql/schema/unique_within_type.rb

@@ -15,8 +15,8 @@ module GraphQL
       def encode(type_name, object_value, separator: self.default_id_separator)
         object_value_str = object_value.to_s
 
-        if type_name.include?(separator) || object_value_str.include?(separator)
-          raise "encode(#{type_name}, #{object_value_str}) contains reserved characters `#{separator}`"
+        if type_name.include?(separator)
+          raise "encode(#{type_name}, #{object_value_str}) contains reserved characters `#{separator}` in the type name"
         end
 
         Base64.strict_encode64([type_name, object_value_str].join(separator))
@@ -25,7 +25,7 @@ module GraphQL
       # @param node_id [String] A unique ID generated by {.encode}
       # @return [Array<(String, String)>] The type name & value passed to {.encode}
       def decode(node_id, separator: self.default_id_separator)
-        Base64.decode64(node_id).split(separator)
+        Base64.decode64(node_id).split(separator, 2)
       end
     end
   end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.5.13"
+  VERSION = "1.5.14"
 end

data/spec/graphql/define/instance_definable_spec.rb

@@ -14,7 +14,7 @@ module Garden
     include GraphQL::Define::InstanceDefinable
     attr_accessor :name, :start_planting_on, :end_planting_on
     ensure_defined(:name, :start_planting_on, :end_planting_on)
-    accepts_definitions :name, plant_between: DefinePlantBetween, color: GraphQL::Define.assign_metadata_key(:color)
+    accepts_definitions :name, plant_between: DefinePlantBetween, has_leaves: GraphQL::Define.assign_metadata_key(:has_leaves), color: GraphQL::Define.assign_metadata_key(:color)
 
     # definition added later:
     attr_accessor :height
@@ -58,6 +58,14 @@ describe GraphQL::Define::InstanceDefinable do
       assert_equal Date.new(2000, 4, 20), tomato.start_planting_on
       assert_equal Date.new(2000, 6, 1), tomato.end_planting_on
     end
+
+    it "accepts bare definitions" do
+      radish = Garden::Vegetable.define do
+        name "Radish"
+        has_leaves
+      end
+      assert_equal true, radish.metadata[:has_leaves]
+    end
   end
 
   describe ".define with keywords" do

data/spec/graphql/relay/connection_resolve_spec.rb

@@ -11,6 +11,7 @@ describe GraphQL::Relay::ConnectionResolve do
               name
             }
           }
+          parentClassName
         }
       }
     }
@@ -43,6 +44,15 @@ describe GraphQL::Relay::ConnectionResolve do
     end
   end
 
+
+  describe "when a lazy object is returned" do
+    it "returns the items with the correct parent" do
+      result = star_wars_query(query_string, { "name" => "lazyObject"})
+      assert_equal 5, result["data"]["rebels"]["ships"]["edges"].length
+      assert_equal "StarWars::FactionRecord", result["data"]["rebels"]["ships"]["parentClassName"]
+    end
+  end
+
   describe "when nil is returned" do
     it "becomes null" do
       result = star_wars_query(query_string, { "name" => "null" })

data/spec/graphql/schema/unique_within_type_spec.rb

@@ -27,11 +27,18 @@ describe GraphQL::Schema::UniqueWithinType do
       assert_equal("250cda0e-a89d-41cf-99e1-2872d89f1100", id)
     end
 
-    it "raises an error if you try and use a reserved character in the ID" do
+    it "allows using the separator in the ID" do
+      global_id = GraphQL::Schema::UniqueWithinType.encode("SomeUUIDType", "250cda0e-a89d-41cf-99e1-2872d89f1100")
+      type_name, id = GraphQL::Schema::UniqueWithinType.decode(global_id)
+      assert_equal("SomeUUIDType", type_name)
+      assert_equal("250cda0e-a89d-41cf-99e1-2872d89f1100", id)
+    end
+
+    it "raises an error if you try and use a reserved character in the typename" do
       err = assert_raises(RuntimeError) {
-        GraphQL::Schema::UniqueWithinType.encode("Best-Thing", "234")
+        GraphQL::Schema::UniqueWithinType.encode("Best-Thing", "234-567")
       }
-      assert_includes err.message, "encode(Best-Thing, 234) contains reserved characters `-`"
+      assert_includes err.message, "encode(Best-Thing, 234-567) contains reserved characters `-` in the type name"
     end
   end
 end

data/spec/support/star_wars/data.rb

@@ -55,7 +55,18 @@ module StarWars
   class SequelBase < Sequel::Model(:bases)
   end
 
-  rebels  = OpenStruct.new({
+  class FactionRecord
+    attr_reader :id, :name, :ships, :bases, :basesClone
+    def initialize(id:, name:, ships:, bases:, basesClone:)
+      @id = id
+      @name = name
+      @ships = ships
+      @bases = bases
+      @basesClone = basesClone
+    end
+  end
+
+  rebels  = FactionRecord.new({
     id: '1',
     name: 'Alliance to Restore the Republic',
     ships:  ['1', '2', '3', '4', '5'],
@@ -64,7 +75,7 @@ module StarWars
   })
 
 
-  empire = OpenStruct.new({
+  empire = FactionRecord.new({
     id: '2',
     name: 'Galactic Empire',
     ships: ['6', '7', '8'],

data/spec/support/star_wars/schema.rb

@@ -83,13 +83,20 @@ module StarWars
     type Ship.connection_type
   end
 
+  ShipConnectionWithParentType = Ship.define_connection do
+    name "ShipConnectionWithParent"
+    field :parentClassName, !types.String do
+      resolve ->(o, a, c) { o.parent.class.name }
+    end
+  end
+
   Faction = GraphQL::ObjectType.define do
     name "Faction"
     interfaces [GraphQL::Relay::Node.interface]
 
     field :id, !types.ID, resolve: GraphQL::Relay::GlobalIdResolve.new(type: Faction)
     field :name, types.String
-    connection :ships, Ship.connection_type do
+    connection :ships, ShipConnectionWithParentType do
       resolve ->(obj, args, ctx) {
         all_ships = obj.ships.map {|ship_id| StarWars::DATA["Ship"][ship_id] }
         if args[:nameIncludes]
@@ -104,6 +111,9 @@ module StarWars
             all_ships = LazyWrapper.new { raise GraphQL::ExecutionError.new("lazy raised error from within connection") }
           when "null"
             all_ships = nil
+          when "lazyObject"
+            prev_all_ships = all_ships
+            all_ships = LazyWrapper.new { prev_all_ships }
           else
             all_ships = all_ships.select { |ship| ship.name.include?(args[:nameIncludes])}
           end
@@ -154,7 +164,7 @@ module StarWars
       resolve ->(obj, args, ctx) {
         all_bases = SequelBase.where(faction_id: obj.id)
         if args[:nameIncludes]
-          all_bases = all_bases.where("name LIKE ?", "%#{args[:nameIncludes]}%")
+          all_bases = all_bases.where(Sequel.like(:name, "%#{args[:nameIncludes]}%"))
         end
         all_bases
       }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.5.13
+  version: 1.5.14
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-11 00:00:00.000000000 Z
+date: 2017-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips