graphql-remote_loader 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19a40470289cc44591c9356bf76c842507b9ac83
+  data.tar.gz: 043fe953bb41e7b8c19568463ef0679e00b35995
+SHA512:
+  metadata.gz: 90d83694e6182d95af2f20291def1f80edf8535eebf5738250585f9e1e6cb5e6c212e1ea9f27efe76bef9e79092863b1647b4122f6ad009ca91f23c4e9ef27bf
+  data.tar.gz: 69db4b3fa095275f946a23b4ce6edbe0d97bd2461d0282e283540338543bba77dd43d1669af299c786776ef8feefda7fb8f9e63e594d103fb7f56f8b68baedb4

data/.gitignore

@@ -0,0 +1 @@
+.byebug_history

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: .
+  specs:
+    graphql-remote_loader (0.0.1)
+      graphql (~> 1.6)
+      graphql-batch (~> 0.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (9.1.0)
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    graphql (1.7.14)
+    graphql-batch (0.3.9)
+      graphql (>= 0.8, < 2)
+      promise.rb (~> 0.7.2)
+    method_source (0.9.0)
+    promise.rb (0.7.4)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.5.0)
+      byebug (~> 9.1)
+      pry (~> 0.10)
+    rake (10.4.2)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.14)
+  graphql-remote_loader!
+  pry-byebug (~> 3.4)
+  rake (~> 10.0)
+  rspec
+
+BUNDLED WITH
+   1.15.4

data/lib/graphql/remote_loader.rb

@@ -0,0 +1,9 @@
+require "graphql"
+require "graphql/batch"
+
+require_relative "remote_loader/loader"
+
+module GraphQL
+  module RemoteLoader
+  end
+end

data/lib/graphql/remote_loader/loader.rb

@@ -0,0 +1,66 @@
+require "prime"
+require_relative "query_merger"
+
+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
+      # 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)
+        @index ||= 1
+        @index += 1
+
+        prime = Prime.take(@index - 1).last
+
+        self.for.load([query, prime])
+      end
+
+      # Given a query string, return a response JSON
+      def query(query_string)
+        raise NotImplementedError,
+          "RemoteLoader::Loader should be subclassed and #query must be defined"
+      end
+
+      private
+
+      def perform(queries_and_primes)
+        query_string = QueryMerger.merge(queries_and_primes)
+        response = query(query_string)
+
+        queries_and_primes.each do |query, prime|
+          fulfill([query, prime], filter_keys_on_response(response.to_h, prime))
+        end
+      end
+
+      def filter_keys_on_response(obj, prime)
+        return obj unless obj.is_a? Hash
+        filtered_results = {}
+
+        # Select field keys on the results hash
+        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|
+          prime_factor = field.match(/\Ap([0-9]+)/)[1].to_i
+          (prime_factor % prime) == 0
+        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_response(method_value, prime)
+
+          filtered_results[method_name.underscore] = filtered_value
+        end
+
+        filtered_results
+      end
+    end
+  end
+end

data/lib/graphql/remote_loader/query_merger.rb

@@ -0,0 +1,301 @@
+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
+
+        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]
+            end
+
+            if matching_field
+              matching_field[:primes] *= query_field[:primes]
+              merge_query(query_field[:body], matching_field[:body])
+            else
+              ast << query_field
+            end
+          end
+        end
+
+        def attach_primes!(query, prime)
+          query.each do |field|
+            field[:primes] = prime
+            attach_primes!(field[:body], prime)
+          end
+        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
+
+          args = node[:arguments].map do |arg, value|
+            value = "\"#{value}\"" if value.is_a? String
+
+            "#{arg}: #{value}"
+          end
+
+          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(" ")} }"
+          end
+
+          "#{field}#{arg_string} #{body_string}".strip
+        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)
+            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]
+            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
+              end
+
+              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
+
+            def validate_token_type(token, expected_type)
+              unless token[:type] == expected_type
+                raise ParseException, "Expected #{expected_type.to_s} token, got #{token[:string]}"
+              end
+            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
+
+              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
+
+            token_string
+          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 trim_leading_whitespace
+            while is_whitespace?(@query.first)
+              @query.shift
+            end
+          end
+
+          def is_whitespace?(char)
+            char == "\n" || char == " "
+          end
+
+          def is_brace_or_bracket_or_comma?(char)
+            char == "{" || char == "}" || char == "(" || char == ")" || char == ","
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/remote_loader/version.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module RemoteLoader
+    VERSION = "0.0.1"
+  end
+end

data/remote_graphql_loader.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'graphql/remote_loader/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "graphql-remote_loader"
+  spec.version       = GraphQL::RemoteLoader::VERSION
+  spec.authors       = ["Nathaniel Woodthorpe"]
+  spec.email         = ["d12@github.com", "njwoodthorpe@gmail.com"]
+
+  spec.summary       = "Performant remote GraphQL queries from within a Ruby GraphQL API."
+  spec.description   = "GraphQL::RemoteLoader allows performantly fetching data from remote GraphQL APIs in the resolvers of a graphql-ruby API."
+  spec.homepage      = "http://nwoodthorpe.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  # spec.bindir        = "bin"
+  # spec.executables   = [""]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "graphql", "~> 1.6"
+  spec.add_dependency "graphql-batch", "~> 0.3"
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.6"
+  spec.add_development_dependency "pry-byebug", "~> 3.4"
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: graphql-remote_loader
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nathaniel Woodthorpe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: graphql-batch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: GraphQL::RemoteLoader allows performantly fetching data from remote GraphQL
+  APIs in the resolvers of a graphql-ruby API.
+email:
+- d12@github.com
+- njwoodthorpe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- lib/graphql/remote_loader.rb
+- lib/graphql/remote_loader/loader.rb
+- lib/graphql/remote_loader/query_merger.rb
+- lib/graphql/remote_loader/version.rb
+- remote_graphql_loader.gemspec
+homepage: http://nwoodthorpe.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Performant remote GraphQL queries from within a Ruby GraphQL API.
+test_files: []