graphql-remote_loader 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 994f881ffc8571f96fbe6c969cba79f030b6bbb6
-  data.tar.gz: 4bdf0b71e51d6e9acc7611e46197615165cd33cb
+  metadata.gz: b4e6ea2888b09a78e64eeec68a7905e5932c0aa2
+  data.tar.gz: 93ff402aaff2686821e835ecf1200b894f00c61a
 SHA512:
-  metadata.gz: 3e2caaa027c826d9a116c892792f65f915f850a8d324b118809806def027e1f3eecf6aa37748a6bac23b276bad54606519a80c9127121bc1ebeefb917c86677d
-  data.tar.gz: 9225082887eb70fc5e42eea716df857b928ab0b6ba6bef9150d064785520005fa40c3bb0cfed373963e2634ba6c3903fcebf6af931f1982191e355a136f3ec88
+  metadata.gz: 103d053506f99d3b285122a1eef0bf5dbb6cd685978a0cd78a316644211eb97a6bd6ccc1a0e18374b922011e94a7e54278b03650e147aa47b765f048179a3a18
+  data.tar.gz: f22cc0abee65eaa738c640abff3dce91fa7fd17f58523d4abde0094f1000c4d7f7a05e80fe8608172a95dc51383f8db0ad28a469ff660199433c1449235cb1e7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql-remote_loader (0.0.1)
+    graphql-remote_loader (0.0.2)
       graphql (~> 1.6)
       graphql-batch (~> 0.3)
 
@@ -46,7 +46,7 @@ DEPENDENCIES
   graphql-remote_loader!
   pry-byebug (~> 3.4)
   rake (~> 10.0)
-  rspec
+  rspec (~> 3.6)
 
 BUNDLED WITH
    1.15.4

data/README.md

@@ -0,0 +1,65 @@
+# GraphQL Remote Loader
+Performant, batched GraphQL queries from within the resolvers of a [`graphql-ruby`](https://github.com/rmosolgo/graphql-ruby) API.
+
+## Example
+
+```ruby
+  field :repositoryUrl, !types.String do
+    description "The repository URL"
+
+    resolve ->(obj, args, ctx) do
+      query = <<-GQL
+        node(id: "#{obj.global_relay_id}"){
+          ... on Repository {
+            url
+          }
+        }
+      GQL
+    
+      GitHubLoader.load(query).then do |results|
+        results["node"]["url"]
+      end
+    end
+  end
+```
+
+## Description
+`graphql-remote_loader` allows for querying GraphQL APIs from within resolvers of a [`graphql-ruby`](https://github.com/rmosolgo/graphql-ruby) API. 
+
+This can be used to create GraphQL APIs that depend on data from other GraphQL APIs, either remote or local. 
+
+A promise-based resolution strategy from Shopify's [`graphql-batch`](https://github.com/Shopify/graphql-batch) is used to batch all requested data into a single GraphQL query. Promises are fulfilled with only the data they requested.
+
+You can think of it as a lightweight version of schema-stitching.
+
+## How to use
+First, you'll need to install the gem. Either do `gem install graphql-remote_loader` or add this to your Gemfile:
+
+```
+gem "graphql-remote_loader"
+```
+
+The gem provides a base loader `GraphQL::RemoteLoader::Loader` which does most of the heavy lifting. In order to remain client-agnostic, there's an unimplemented no-op that queries the external GraphQL API.
+
+To use, create a new class that inherits from `GraphQL::RemoteLoader::Loader` and define `def query(query_string)`. The method takes a query String as input. The expected output is a response `Hash`, or some object that responds to `#to_h`.
+
+Example:
+
+```ruby
+require "graphql/remote_loader"
+
+module MyApp
+  class GitHubLoader < GraphQL::RemoteLoader::Loader
+    def query(query_string)
+      parsed_query = MyApp::Client.parse(query_string)
+      MyApp.query(parsed_query)
+    end
+  end
+end
+```
+
+This example uses [`graphql-client`](https://github.com/github/graphql-client). Any client, or even just plain `cURL`/`HTTP` can be used.
+
+## Current State
+
+This project is very much WIP. Some TODOs are listed in the issues. Bugs and feature requests should be added as issues.

data/lib/graphql/remote_loader/loader.rb

@@ -19,6 +19,10 @@ module GraphQL
         self.for.load([query, prime])
       end
 
+      def self.reset_index
+        @index = nil
+      end
+
       # Given a query string, return a response JSON
       def query(query_string)
         raise NotImplementedError,
@@ -41,7 +45,7 @@ module GraphQL
         filtered_results = {}
 
         # Select field keys on the results hash
-        fields = obj.keys.select { |k| k.match? /\Ap[0-9]+.*[^?]\z/ }
+        fields = obj.keys.select { |k| k.match /\Ap[0-9]+.*[^?]\z/ }
 
         # Filter methods that were not requested in this sub-query
         fields = fields.select do |field|
@@ -56,11 +60,19 @@ module GraphQL
           method_value = obj[method]
           filtered_value = filter_keys_on_response(method_value, prime)
 
-          filtered_results[method_name.underscore] = filtered_value
+          filtered_results[underscore(method_name)] = filtered_value
         end
 
         filtered_results
       end
+
+      def underscore(str)
+        str.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+      end
     end
   end
 end

data/lib/graphql/remote_loader/query_merger.rb

@@ -1,299 +1,127 @@
 module GraphQL
   module RemoteLoader
-
     # Given a list of queries and their prime UIDs, generate the merged and labeled
     # GraphQL query to be sent off to the remote backend.
     class QueryMerger
       class << self
         def merge(queries_and_primes)
-          new_ast = []
-
-          queries_and_primes.each do |query, prime|
-            parsed_query = [parse(query)]
-            attach_primes!(parsed_query, prime)
-            merge_query(parsed_query, new_ast)
-          end
-
-          query_string_from_ast(new_ast)
-        end
+          parsed_queries = queries_and_primes.map do |query, prime|
+            parsed_query = parse(query)
 
-        private
-
-        def merge_query(query, ast)
-          query.each do |query_field|
-            matching_field = ast.find do |ast_field|
-              query_field[:field] == ast_field[:field] &&
-                query_field[:arguments] == ast_field[:arguments]
+            parsed_query.definitions.each do |definition|
+              attach_primes!(definition.children, prime)
             end
 
-            if matching_field
-              matching_field[:primes] *= query_field[:primes]
-              merge_query(query_field[:body], matching_field[:body])
-            else
-              ast << query_field
-            end
+            parsed_query
           end
-        end
 
-        def attach_primes!(query, prime)
-          query.each do |field|
-            field[:primes] = prime
-            attach_primes!(field[:body], prime)
-          end
+          merge_parsed_queries(parsed_queries).to_query_string
         end
 
-        def query_string_from_ast(ast)
-          ast_node_strings = ast.map do |ast_node|
-            query_string_for_node(ast_node)
-          end.join(" ")
-          ast_node_strings
-        end
-
-        def query_string_for_node(node)
-          field = node[:field]
-
-          # TODO: This won't work for fields named `query`. Fix once
-          # I move to Roberts non-jank parser
-          unless field.include?("...") || field == "query"
-            # assign preix if not a spread
-            field = "p#{node[:primes]}#{field}: #{field}"
-          end
+        private
 
-          args = node[:arguments].map do |arg, value|
-            value = "\"#{value}\"" if value.is_a? String
+        def merge_parsed_queries(parsed_queries)
+          merged_query = parsed_queries.pop
 
-            "#{arg}: #{value}"
-          end
+          parsed_queries.each do |query|
+            merge_query_recursive(query.definitions[0], merged_query.definitions[0])
+            merge_fragment_definitions(query, merged_query)
 
-          arg_string = unless args.empty?
-            "(#{args.join(",")})"
-          else
-            ""
           end
 
-          body_string = unless node[:body].empty?
-            str = node[:body].map do |node|
-              query_string_for_node(node)
-            end
-
-            "{ #{str.join(" ")} }"
+          merged_query.definitions.each do |definition|
+            apply_aliases!(definition.selections)
           end
 
-          "#{field}#{arg_string} #{body_string}".strip
+          merged_query
         end
 
-        def parse(query)
-          tokenizer = QueryTokenizer.new("query { #{query} }")
-          QueryAST.build(tokenizer)
-        end
-
-        class QueryAST
-          class ParseException < Exception; end
-
-          class << self
-            def build(tokenizer)
-              result = build_node(tokenizer)
+        # merges a_query's fragment definitions into b_query
+        def merge_fragment_definitions(a_query, b_query)
+          a_query.definitions[1..-1].each do |a_definition|
+            matching_fragment_definition = b_query.definitions.find do |b_definition|
+              a_definition.name == b_definition.name
             end
 
-            def build_node(tokenizer)
-              {
-                field: get_field(tokenizer),
-                arguments: get_args(tokenizer),
-                body: build_body(tokenizer)
-              }
-            end
-
-            def get_field(tokenizer)
-              token = tokenizer.pop
-
-              if token[:type] == :spread
-                validate_token_type(tokenizer.pop, :on)
-                spread_type = tokenizer.pop[:string]
-
-                return "... on #{spread_type}"
-              end
-
-              validate_token_type(token, :field)
-
-              throw_parse_exception(token, "field") unless (token[:type] == :field)
-
-              token[:string]
+            if matching_fragment_definition
+              merge_query_recursive(a_definition, matching_fragment_definition)
+            else
+              b_query.definitions << a_definition
             end
+          end
+        end
 
-            def get_args(tokenizer)
-              args = {}
-              return args unless (tokenizer.peek[:type] == :left_paren)
-
-              # remove "("
-              tokenizer.pop
-
-              while true
-                token = tokenizer.pop
-                validate_token_type(token, :key)
-
-                # Remove :
-                key = token[:string].sub(":", "")
-
-                token = tokenizer.pop
-                value = case token[:type]
-                        when :string
-                          token[:string][1..-2] # remove ""
-                        when :int
-                          Integer(token[:string])
-                        when :float
-                          Float(token[:string])
-                        when :true
-                          true
-                        when :false
-                          false
-                        else
-                          raise ParseException, "Expected string, int, float, or boolean, got #{token[:string]}"
-                        end
-
-                args[key.to_sym] = value
-
-                if tokenizer.peek[:type] == :comma
-                  tokenizer.pop
-                elsif tokenizer.peek[:type] == :right_paren
-                  tokenizer.pop
-                  break
-                else
-                  raise ParseException, "Expected comma or right paren, got #{tokenizer[:string]}"
-                end
+        # merges a_query into b_query
+        def merge_query_recursive(a_query, b_query)
+          exempt_node_types = [
+            GraphQL::Language::Nodes::InlineFragment,
+            GraphQL::Language::Nodes::FragmentSpread
+          ]
+
+          a_query.selections.each do |a_query_selection|
+            matching_field = b_query.selections.find do |b_query_selection|
+              same_name = a_query_selection.name == b_query_selection.name
+              same_args = if exempt_node_types.any? { |type| b_query_selection.is_a?(type) }
+                true
+              else
+                arguments_equal?(a_query_selection, b_query_selection)
               end
 
-              args
+              same_name && same_args
             end
 
-            def build_body(tokenizer)
-              body = []
-              return body unless (tokenizer.peek[:type] == :left_brace)
-
-              # remove "{"
-              tokenizer.pop
-
-              while true
-                body << build_node(tokenizer)
-                break if (tokenizer.peek[:type] == :right_brace)
-              end
-
-              # remove "}"
-              tokenizer.pop
-
-              body
-            end
+            if matching_field
+              new_prime = matching_field.instance_variable_get(:@prime) *
+                a_query_selection.instance_variable_get(:@prime)
 
-            def validate_token_type(token, expected_type)
-              unless token[:type] == expected_type
-                raise ParseException, "Expected #{expected_type.to_s} token, got #{token[:string]}"
-              end
+              matching_field.instance_variable_set(:@prime, new_prime)
+              merge_query_recursive(a_query_selection, matching_field) unless exempt_node_types.any? { |type| matching_field.is_a?(type) }
+            else
+              b_query.selections << a_query_selection
             end
           end
         end
 
-        class QueryTokenizer
-          def initialize(query)
-            @query = query.chars
-            set_next_token
-          end
-
-          # Get next token, without removing from stream
-          def peek
-            @next_token
-          end
-
-          # Pop next token
-          def pop
-            token = @next_token
-            set_next_token if token
-
-            token
-          end
-
-          private
-
-          # Read @query to set @next_token
-          def set_next_token
-            next_token_string = extract_token_string_from_query
-            @next_token = tokenize_string(next_token_string)
-          end
-
-          def extract_token_string_from_query
-            trim_leading_whitespace
-
-            token_string = ""
-            while true
-              next_char = @query.first || break
+        # Are two lists of arguments equal?
+        def arguments_equal?(a, b)
+          # Return true if both don't have args.
+          # Return false if only one doesn't have args
+          return true unless a.respond_to?(:arguments) && b.respond_to?(:arguments)
+          return false unless a.respond_to?(:arguments) || b.respond_to?(:arguments)
 
-              if is_brace_or_bracket_or_comma?(next_char)
-                if token_string.length == 0
-                  token_string << @query.shift
-                end
-
-                break
-              else
-                if !is_whitespace?(@query.first)
-                  token_string << @query.shift
-                else
-                  break
-                end
-              end
-            end
+          a.arguments.map { |arg| {name: arg.name, value: arg.value}.to_s }.sort ==
+            b.arguments.map { |arg| {name: arg.name, value: arg.value}.to_s }.sort
+        end
 
-            token_string
+        def attach_primes!(query_fields, prime)
+          query_fields.each do |field|
+            field.instance_variable_set(:@prime, prime)
+            attach_primes!(field.children, prime)
           end
+        end
 
-          def tokenize_string(next_token_string)
-            token = case next_token_string
-            when '{'
-              :left_brace
-            when '}'
-              :right_brace
-            when '('
-              :left_paren
-            when ')'
-              :right_paren
-            when ','
-              :comma
-            when /\A[[:digit:]]+\z/
-              :int
-            when /\A[[:digit:]]+\.[[:digit:]]+\z/
-              :float
-            when 'true'
-              :true
-            when 'false'
-              :false
-            when 'on'
-              :on
-            when /\A".*"\z/
-              :string
-            when /\A.+:\z/
-              :key
-            when ''
-              next_token_string = "END OF STREAM"
-              :empty
-            when '...'
-              :spread
-            else
-              :field
-            end
-
-            { type: token, string: next_token_string }
-          end
+        def apply_aliases!(query_selections)
+          exempt_node_types = [
+            GraphQL::Language::Nodes::InlineFragment,
+            GraphQL::Language::Nodes::FragmentSpread
+          ]
 
-          def trim_leading_whitespace
-            while is_whitespace?(@query.first)
-              @query.shift
+          query_selections.each do |selection|
+            unless exempt_node_types.any? { |type| selection.is_a? type  }
+              prime_factor = selection.instance_variable_get(:@prime)
+              selection.alias = "p#{prime_factor}#{selection.name}"
             end
-          end
 
-          def is_whitespace?(char)
-            char == "\n" || char == " "
+            # Some nodes don't have selections (e.g. fragment spreads)
+            apply_aliases!(selection.selections) if selection.respond_to? :selections
           end
+        end
 
-          def is_brace_or_bracket_or_comma?(char)
-            char == "{" || char == "}" || char == "(" || char == ")" || char == ","
-          end
+        # Allows "foo" or "query { foo }"
+        def parse(query)
+          GraphQL.parse(query)
+        rescue GraphQL::ParseError
+          GraphQL.parse("query { #{query} }")
         end
       end
     end

data/lib/graphql/remote_loader/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module RemoteLoader
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-remote_loader
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Nathaniel Woodthorpe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-09 00:00:00.000000000 Z
+date: 2018-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -106,6 +106,7 @@ files:
 - ".gitignore"
 - Gemfile
 - Gemfile.lock
+- README.md
 - graphql-remote_loader.gemspec
 - lib/graphql/remote_loader.rb
 - lib/graphql/remote_loader/loader.rb