graphql-remote_loader 1.0.5 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d72d37be4701ca0a4dd4bad71e989241b8557f01
-  data.tar.gz: 0e4c7d0613383cd441d2dc887cc7c5647296a780
+  metadata.gz: acdeaf8aaaccf5ffeba1afb1f2034fb7d41fba34
+  data.tar.gz: c5478e13983b4ca67867571fc25553dadfd82ffa
 SHA512:
-  metadata.gz: 53941e0b529fcf5c9f89809de804faf1f52e162c3fa8cccbb2f2c6a0b1f44c8d713a4bf291055504ae75c2fa001f926aa6e15a5bed1acfa949e4ec2d2f3553b1
-  data.tar.gz: 017da570ea18310a6b3eb4801ffa24ff1e22d087cca6daf2b4d1370813c419443b809dfbdc6337b6f9c0690742b540bb2e0e89b1f3342cf32d12406684f9354e
+  metadata.gz: 8d3c97bbe137b06cff20c4687c2088e8ac0819963e1ee5ab493650508de826ecbeee872f13e2356ee00336713d4c52089fccc13e8cefa662f034b1c4e2feccf7
+  data.tar.gz: cd28610ee919d38b4f59e6bb271a4ea81a79dfcf5b1559a23fa94621120787fe6324cd4e3feda388af24b52e82fc356320b0b7a5500bafcf93c9041a56a57ad2

data/.github/workflows/ruby.yml

@@ -0,0 +1,24 @@
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby 2.6
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.6.x
+    - name: Build and test with Rake
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rspec

data/graphql-remote_loader.gemspec

@@ -1,4 +1,6 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'graphql/remote_loader/version'

data/lib/graphql/remote_loader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "graphql"
 require "graphql/batch"
 

data/lib/graphql/remote_loader/loader.rb

@@ -1,4 +1,5 @@
-require "prime"
+# frozen_string_literal: true
+
 require "json"
 require_relative "query_merger"
 
@@ -6,22 +7,18 @@ module GraphQL
   module RemoteLoader
     class Loader < GraphQL::Batch::Loader
       # Delegates to GraphQL::Batch::Loader#load
-      # We include a unique prime as part of the batch key to use as part
+      # We include a unique id as part of the batch key to use as part
       # of the alias on all fields. This is used to
       # a) Avoid name collisions in the generated query
       # b) Determine which fields in the result JSON should be
       #    handed fulfilled to each promise
       def self.load(query, context: {}, variables: {})
-        @index ||= 1
+        @index ||= 0
         @index += 1
 
-        prime = Prime.take(@index - 1).last
-
         store_context(context)
 
-        interpolate_variables!(query, variables)
-
-        self.for.load([query, prime, @context])
+        self.for.load([interpolate_variables(query, variables), @index, @context])
       end
 
       # Loads the value, then if the query was successful, fulfills promise with
@@ -69,24 +66,24 @@ module GraphQL
 
       private
 
-      def perform(queries_and_primes)
-        query_string = QueryMerger.merge(queries_and_primes).gsub(/\s+/, " ")
-        context = queries_and_primes[-1][-1]
+      def perform(queries_and_ids)
+        query_string = QueryMerger.merge(queries_and_ids).gsub(/\s+/, " ")
+        context = queries_and_ids[-1][-1]
         response = query(query_string, context: context).to_h
 
         data, errors = response["data"], response["errors"]
 
-        queries_and_primes.each do |query, prime, context|
+        queries_and_ids.each do |query, caller_id, context|
           response = {}
 
-          response["data"] = filter_keys_on_data(data, prime)
+          response["data"] = filter_keys_on_data(data, caller_id)
 
-          errors_key = filter_errors(errors, prime)
+          errors_key = filter_errors(errors, caller_id)
           response["errors"] = dup(errors_key) unless errors_key.empty?
 
-          scrub_primes_from_error_paths!(response["errors"])
+          scrub_caller_ids_from_error_paths!(response["errors"])
 
-          fulfill([query, prime, context], response)
+          fulfill([query, caller_id, context], response)
         end
       end
 
@@ -97,23 +94,37 @@ module GraphQL
       # E.g.
       #   interpolate_variables("foo(bar: $my_var)", { my_var: "buzz" })
       #   => "foo(bar: \"buzz\")"
+      def self.interpolate_variables(query, variables = {})
+        query.dup.tap { |mutable_query| interpolate_variables!(mutable_query, variables) }
+      end
+
       def self.interpolate_variables!(query, variables = {})
-        variables.each do |variable, value|
-          case value
-          when Integer, Float, TrueClass, FalseClass
-            # These types are safe to directly interpolate into the query, and GraphQL does not expect these types to be quoted.
-            query.gsub!("$#{variable.to_s}", value.to_s)
-          else
-            # A string is either a GraphQL String or ID type.
-            # This means we need to
-            # a) Surround the value in quotes
-            # b) escape special characters in the string
-            #
-            # This else also catches unknown objects, which could break the query if we directly interpolate.
-            # These objects get converted to strings, then escaped.
-
-            query.gsub!("$#{variable.to_s}", value.to_s.inspect)
-          end
+        variables.each { |variable, value| query.gsub!("$#{variable.to_s}", stringify_variable(value)) }
+      end
+
+      def self.stringify_variable(value)
+        case value
+        when Integer, Float, TrueClass, FalseClass
+          # These types are safe to directly interpolate into the query, and GraphQL does not expect these types to be quoted.
+          value.to_s
+        when Array
+          # Arrays can contain elements with various types, so we need to check them one by one
+          stringified_elements = value.map { |element| stringify_variable(element) }
+          "[#{stringified_elements.join(', ')}]"
+        when Hash
+          # Hashes can contain values with various types, so we need to check them one by one
+          stringified_key_value_pairs = value.map { |key, value| "#{key}: #{stringify_variable(value)}" }
+          "{#{stringified_key_value_pairs.join(', ')}}"
+        else
+          # A string is either a GraphQL String or ID type.
+          # This means we need to
+          # a) Surround the value in quotes
+          # b) escape special characters in the string
+          #
+          # This else also catches unknown objects, which could break the query if we directly interpolate.
+          # These objects get converted to strings, then escaped.
+
+          value.to_s.inspect
         end
       end
 
@@ -121,10 +132,10 @@ module GraphQL
         JSON.parse(hash.to_json)
       end
 
-      def filter_keys_on_data(obj, prime)
+      def filter_keys_on_data(obj, caller_id)
         case obj
         when Array
-          obj.map { |element| filter_keys_on_data(element, prime) }
+          obj.map { |element| filter_keys_on_data(element, caller_id) }
         when Hash
           filtered_results = {}
 
@@ -133,27 +144,26 @@ module GraphQL
 
           # Filter methods that were not requested in this sub-query
           fields = fields.select do |field|
-            prime_factor = field.match(/\Ap([0-9]+)/)[1].to_i
-            (prime_factor % prime) == 0
+            graphql_caller = field.match(/\Ap([0-9]+)/)[1].to_i
+            graphql_caller[caller_id] == 1 # Fixnum#[] accesses bitwise representation of num
           end
 
-          # redefine methods on new obj, recursively filter sub-selections
-          fields.each do |method|
-            method_name = method.match(/\Ap[0-9]+(.*)/)[1]
-
-            method_value = obj[method]
-            filtered_value = filter_keys_on_data(method_value, prime)
+          # redefine fields on new obj, recursively filter sub-selections
+          fields.each do |field|
+            field_name = field.match(/\Ap[0-9]+(.*)/)[1]
 
-            filtered_results[underscore(method_name)] = filtered_value
+            value = obj[field]
+            filtered_results[underscore(field_name)] = filter_keys_on_data(value, caller_id)
           end
 
           filtered_results
         else
+          # Base case, no more recursion needed.
           return obj
         end
       end
 
-      def filter_errors(errors, prime)
+      def filter_errors(errors, caller_id)
         return [] unless errors
 
         errors.select do |error|
@@ -165,13 +175,13 @@ module GraphQL
           error["path"].all? do |path_key|
             next true if path_key.is_a? Integer
 
-            path_key_prime = path_key.match(/\Ap([0-9]+)/)[1].to_i
-            path_key_prime % prime == 0
+            path_key_caller_id = path_key.match(/\Ap([0-9]+)/)[1].to_i
+            path_key_caller_id[caller_id]
           end
         end
       end
 
-      def scrub_primes_from_error_paths!(error_array)
+      def scrub_caller_ids_from_error_paths!(error_array)
         return unless error_array
 
         error_array.map do |error|

data/lib/graphql/remote_loader/query_merger.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module GraphQL
   module RemoteLoader
-    # Given a list of queries and their prime UIDs, generate the merged and labeled
+    # Given a list of queries and their caller IDs, generate the merged and labeled
     # GraphQL query to be sent off to the remote backend.
     class QueryMerger
       class << self
-        def merge(queries_and_primes)
-          parsed_queries = queries_and_primes.map do |query, prime|
+        def merge(queries_and_caller_ids)
+          parsed_queries = queries_and_caller_ids.map do |query, caller_id|
             parsed_query = parse(query)
 
             parsed_query.definitions.each do |definition|
-              attach_primes!(definition.children, prime)
+              attach_caller_id!(definition.children, caller_id)
             end
 
             parsed_query
@@ -75,10 +77,10 @@ module GraphQL
             end
 
             if matching_field
-              new_prime = matching_field.instance_variable_get(:@prime) *
-                a_query_selection.instance_variable_get(:@prime)
+              new_binary_id = matching_field.instance_variable_get(:@binary_id) +
+                a_query_selection.instance_variable_get(:@binary_id)
 
-              matching_field.instance_variable_set(:@prime, new_prime)
+              matching_field.instance_variable_set(:@binary_id, new_binary_id)
               merge_query_recursive(a_query_selection, matching_field) unless exempt_node_types.any? { |type| matching_field.is_a?(type) }
             else
               b_query.instance_variable_set(:@selections, [b_query.selections, a_query_selection].flatten)
@@ -97,10 +99,10 @@ module GraphQL
             b.arguments.map { |arg| {name: arg.name, value: arg.value}.to_s }.sort
         end
 
-        def attach_primes!(query_fields, prime)
+        def attach_caller_id!(query_fields, caller_id)
           query_fields.each do |field|
-            field.instance_variable_set(:@prime, prime)
-            attach_primes!(field.children, prime)
+            field.instance_variable_set(:@binary_id, 2 ** caller_id)
+            attach_caller_id!(field.children, caller_id)
           end
         end
 
@@ -112,12 +114,12 @@ module GraphQL
 
           query_selections.each do |selection|
             unless exempt_node_types.any? { |type| selection.is_a? type }
-              prime_factor = selection.instance_variable_get(:@prime)
+              binary_id = selection.instance_variable_get(:@binary_id)
 
               selection.instance_variable_set(:@alias, if selection.alias
-                "p#{prime_factor}#{selection.alias}"
+                "p#{binary_id}#{selection.alias}"
               else
-                "p#{prime_factor}#{selection.name}"
+                "p#{binary_id}#{selection.name}"
               end)
             end
 

data/lib/graphql/remote_loader/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module GraphQL
   module RemoteLoader
-    VERSION = "1.0.5"
+    VERSION = "1.0.6"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-remote_loader
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
 platform: ruby
 authors:
 - Nathaniel Woodthorpe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-29 00:00:00.000000000 Z
+date: 2020-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -103,6 +103,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".travis.yml"
 - Gemfile