graphiti_graphql 0.1.4 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bee75fe735608862a522a16be4a9ab31900b45af74ff48d4294d114227bd543
-  data.tar.gz: ade635fd51be3820845bfccb79bd17c2b5bcff0c961a930910299dda6c90fad2
+  metadata.gz: 40128f0eaf0ad7859fa35c67bb73b2a2fccf51829bb3914877ce0c19730def91
+  data.tar.gz: 6f3fe80c618aaa093dd2daec4aa726621c32d2228bb92ddfdfd00f6a610490af
 SHA512:
-  metadata.gz: e6720bf46431df3c5f5c2906fdf94aac13e4255cdfcdb2c2eb1fbd40d58bd2e28b231a9e2238d13e5ec7aaab9bd9ff60f86de9086972e90ec372bd12fe902978
-  data.tar.gz: 0aff8b2e2459bd1c94b674dce2ce9e618f63c1b0dffc3fe49a1766c59b6aa692db2d14ca05d45747f990069d2bf39ee1ac3d9413732ba14c88ffeebbf20fa351
+  metadata.gz: f957bb6f2092f052d683c94008940823a29cb0a995d4741eaadbf2b87f0e3585268e01819a7fde057afd0a99c0f2b4dd14d2fc76903f3e44cc51c05724a0bd69
+  data.tar.gz: 30c3b26190d74c0559553458d05fdd36367fb9742b320322138d0f7a9ac503775d14edddb3a25b28276b5c099588186554f6ac686da0095175c557a921c1029e

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    graphiti_graphql (0.1.2)
+    graphiti_graphql (0.1.6)
       activesupport (>= 4.1)
-      graphiti (>= 1.2.36)
+      graphiti (~> 1.3)
       graphql (~> 1.12)
 
 GEM
@@ -28,13 +28,13 @@ GEM
     dry-configurable (0.12.1)
       concurrent-ruby (~> 1.0)
       dry-core (~> 0.5, >= 0.5.0)
-    dry-container (0.7.2)
+    dry-container (0.8.0)
       concurrent-ruby (~> 1.0)
       dry-configurable (~> 0.1, >= 0.1.3)
-    dry-core (0.5.0)
+    dry-core (0.7.1)
       concurrent-ruby (~> 1.0)
-    dry-inflector (0.2.0)
-    dry-logic (1.1.0)
+    dry-inflector (0.2.1)
+    dry-logic (1.2.0)
       concurrent-ruby (~> 1.0)
       dry-core (~> 0.5, >= 0.5)
     dry-types (1.5.1)
@@ -44,7 +44,7 @@ GEM
       dry-inflector (~> 0.1, >= 0.1.2)
       dry-logic (~> 1.0, >= 1.0.2)
     google-protobuf (3.15.2)
-    graphiti (1.2.36)
+    graphiti (1.3.0)
       activesupport (>= 4.1)
       concurrent-ruby (~> 1.0)
       dry-types (>= 0.15.0, < 2.0)
@@ -137,4 +137,4 @@ DEPENDENCIES
   standardrb
 
 BUNDLED WITH
-   2.0.2
+   2.2.16

data/bin/bundle

@@ -31,7 +31,7 @@ m = Module.new do
         bundler_version = a
       end
       next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
-      bundler_version = $1 || ">= 0.a"
+      bundler_version = $1
       update_index = i
     end
     bundler_version
@@ -61,32 +61,41 @@ m = Module.new do
   end
 
   def bundler_version
-    @bundler_version ||= begin
+    @bundler_version ||=
       env_var_version || cli_arg_version ||
-        lockfile_version || "#{Gem::Requirement.default}.a"
-    end
+        lockfile_version
+  end
+
+  def bundler_requirement
+    return "#{Gem::Requirement.default}.a" unless bundler_version
+
+    bundler_gem_version = Gem::Version.new(bundler_version)
+
+    requirement = bundler_gem_version.approximate_recommendation
+
+    return requirement unless Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.7.0")
+
+    requirement += ".a" if bundler_gem_version.prerelease?
+
+    requirement
   end
 
   def load_bundler!
     ENV["BUNDLE_GEMFILE"] ||= gemfile
 
-    # must dup string for RG < 1.8 compatibility
-    activate_bundler(bundler_version.dup)
+    activate_bundler
   end
 
-  def activate_bundler(bundler_version)
-    if Gem::Version.correct?(bundler_version) && Gem::Version.new(bundler_version).release < Gem::Version.new("2.0")
-      bundler_version = "< 2"
-    end
+  def activate_bundler
     gem_error = activation_error_handling do
-      gem "bundler", bundler_version
+      gem "bundler", bundler_requirement
     end
     return if gem_error.nil?
     require_error = activation_error_handling do
       require "bundler/version"
     end
-    return if require_error.nil? && Gem::Requirement.new(bundler_version).satisfied_by?(Gem::Version.new(Bundler::VERSION))
-    warn "Activating bundler (#{bundler_version}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_version}'`"
+    return if require_error.nil? && Gem::Requirement.new(bundler_requirement).satisfied_by?(Gem::Version.new(Bundler::VERSION))
+    warn "Activating bundler (#{bundler_requirement}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_requirement}'`"
     exit 42
   end
 

data/graphiti_graphql.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "graphiti", ">= 1.2.36"
+  spec.add_dependency "graphiti", "~> 1.3"
   spec.add_dependency "activesupport", ">= 4.1"
   spec.add_dependency "graphql", "~> 1.12"
 

data/lib/graphiti_graphql.rb

@@ -13,7 +13,7 @@ require "graphiti_graphql/util"
 
 module GraphitiGraphQL
   class Configuration
-    attr_accessor :schema_reloading
+    attr_accessor :schema_reloading, :federation_application_controller
 
     def initialize
       self.schema_reloading = true
@@ -74,6 +74,10 @@ module GraphitiGraphQL
     @config ||= Configuration.new
   end
 
+  def self.configure
+    yield config
+  end
+
   def self.schemas
     @schemas ||= SchemaProxy.new
   end

data/lib/graphiti_graphql/engine.rb

@@ -64,12 +64,15 @@ module GraphitiGraphQL
     end
 
     initializer "graphiti_graphql.define_controller" do
-      # rubocop:disable Lint/ConstantDefinitionInBlock(Standard)
-      class GraphitiGraphQL::ExecutionController < ::ApplicationController
-        register_exception Graphiti::Errors::UnreadableAttribute, message: true
-        def execute
-          params = request.params # avoid strong_parameters
-          render json: Graphiti.gql(params[:query], params[:variables])
+      GraphitiGraphQL::Engine.reloader_class.to_prepare do
+        app_controller = GraphitiGraphQL.config.federation_application_controller || ::ApplicationController
+        # rubocop:disable Lint/ConstantDefinitionInBlock(Standard)
+        class GraphitiGraphQL::ExecutionController < app_controller
+          register_exception Graphiti::Errors::UnreadableAttribute, message: true
+          def execute
+            params = request.params # avoid strong_parameters
+            render json: Graphiti.gql(params[:query], params[:variables])
+          end
         end
       end
     end

data/lib/graphiti_graphql/federation/federated_resource.rb

@@ -21,6 +21,18 @@ module GraphitiGraphQL
           @relationships[name].instance_eval(&blk)
         end
       end
+
+      def polymorphic?
+        @type_name.is_a?(Hash)
+      end
+
+      def klass_name
+        if polymorphic?
+          "I#{@relationships.keys[0].to_s.camelize}"
+        else
+          @type_name
+        end
+      end
     end
   end
 end

data/lib/graphiti_graphql/federation/loaders/has_many.rb

@@ -15,6 +15,19 @@ module GraphitiGraphQL
 
           @federated_relationship.params_block&.call(@params)
 
+          if (first = @params.delete(:first))
+            @params[:page] ||= {}
+            @params[:page][:size] = first
+          end
+          if (after = @params.delete(:after))
+            @params[:page] ||= {}
+            @params[:page][:after] = after
+          end
+          if (before = @params.delete(:before))
+            @params[:page] ||= {}
+            @params[:page][:before] = before
+          end
+
           if ids.length > 1 && @params[:page]
             raise Graphiti::Errors::UnsupportedPagination
           elsif !@params[:page]

data/lib/graphiti_graphql/federation/resource_dsl.rb

@@ -64,18 +64,30 @@ module GraphitiGraphQL
         # * Add to the list of external graphql-ruby types we need in schema
         # * Add a gql-specific attribute to the serializer that gives apollo
         #   the representation it needs.
-        def federated_belongs_to(name, type: nil, foreign_key: nil)
+        def federated_belongs_to(name, type: nil, foreign_key: nil, foreign_type: nil)
           type ||= name.to_s.camelize
           foreign_key ||= :"#{name.to_s.underscore}_id"
           resource = FederatedResource.new(type)
           federated_resources << resource
           resource.add_relationship(:belongs_to, name, self, foreign_key)
 
+          foreign_type ||= :"#{name.to_s.underscore}_type" if resource.polymorphic?
+
           opts = {readable: :gql?, only: [:readable], schema: false}
           attribute name, :hash, opts do
             prc = self.class.attribute_blocks[foreign_key]
             fk = prc ? instance_eval(&prc) : @object.send(foreign_key)
-            {__typename: type, id: fk.to_s}
+
+            typename = type
+            if resource.polymorphic?
+              prc = self.class.attribute_blocks[foreign_type]
+              ft = prc ? instance_eval(&prc) : @object.send(foreign_type)
+              typename = type[ft]
+            end
+
+            if fk && typename.present?
+              {__typename: typename, id: fk.to_s}
+            end
           end
         end
       end

data/lib/graphiti_graphql/federation/schema_decorator.rb

@@ -66,19 +66,39 @@ module GraphitiGraphQL
           pre_registered = !!type_registry[federated_resource.type_name]
           type_class = if pre_registered
             type_registry[federated_resource.type_name][:type]
+          elsif federated_resource.polymorphic?
+            add_federated_resource_interface(federated_resource)
           else
-            add_federated_resource_type(federated_resource.type_name)
+            add_federated_resource_type(federated_resource.klass_name)
           end
 
           yield type_class, federated_resource
         end
       end
 
-      def add_federated_resource_type(klass_name)
+      def add_federated_resource_interface(federated_resource)
+        interface = define_polymorphic_federated_resource_interface(federated_resource.klass_name)
+        federated_resource.type_name.values.each do |name|
+          add_federated_resource_type(name, interface: interface)
+        end
+        interface
+      end
+
+      def define_polymorphic_federated_resource_interface(klass_name)
+        interface = Module.new
+        interface.send(:include, @schema.class.base_interface)
+        interface.graphql_name(klass_name)
+        interface.field :id, String, null: false, external: true
+        type_registry[klass_name] = {type: interface, interface: true}
+        interface
+      end
+
+      def add_federated_resource_type(klass_name, interface: nil)
         federated_type = Class.new(@schema.class.base_object)
         federated_type.graphql_name klass_name
         federated_type.key(fields: "id")
         federated_type.extend_type
+        federated_type.implements(interface) if interface
         federated_type.field :id, String, null: false, external: true
         federated_type.class_eval do
           def self.resolve_reference(reference, _context, _lookup)
@@ -161,7 +181,7 @@ module GraphitiGraphQL
 
         local_types.each do |local|
           local.field relationship.name,
-            type_registry[federated_resource.type_name][:type],
+            type_registry[federated_resource.klass_name][:type],
             null: true
         end
       end

data/lib/graphiti_graphql/runner.rb

@@ -282,11 +282,23 @@ module GraphitiGraphQL
     def gather_pages(params, selection, variable_hash, chained_name = nil)
       pages = {}.tap do |p|
         selection.arguments.each do |arg|
-          if arg.name == "page"
+          if ["page", "first", "after", "before"].include?(arg.name)
             value = if arg.value.respond_to?(:name) # is a variable
-              variable_hash[arg.value.name].to_h
+              variable_hash[arg.value.name]
             else
-              arg.value.to_h
+              arg.value
+            end
+
+            next unless value
+
+            value = if arg.name == "first"
+              {size: value}
+            elsif arg.name == "after"
+              {after: value}
+            elsif arg.name == "before"
+              {before: value}
+            else
+              value.to_h
             end
 
             if chained_name
@@ -304,6 +316,13 @@ module GraphitiGraphQL
         params[:page] ||= {}
         params[:page].merge!(pages)
       end
+
+      (selection.try(:selections) || []).each do |sub|
+        if sub.try(:name) == "pageInfo"
+          params[:fields] ||= {}
+          params[:fields][:page_info] = sub.selections.map(&:name).map(&:underscore).join(",")
+        end
+      end
     end
 
     def gather_stats(params, selection, variable_hash, chained_name = nil)

data/lib/graphiti_graphql/schema.rb

@@ -93,6 +93,7 @@ module GraphitiGraphQL
       query_class = Class.new(existing_query || self.class.base_object)
       # NB MUST be Query or federation-ruby will break things
       query_class.graphql_name "Query"
+      query_class.field_class BaseField
 
       get_entrypoints(entrypoint_resources).each do |resource|
         next if resource.remote?
@@ -145,22 +146,46 @@ module GraphitiGraphQL
         [type],
         "List #{resource.graphql_class_name(false).pluralize}",
         null: false
+
+      # Stats currently only supported on top level
       if top_level
+        klass.field :page_info, PageInfoType, null: false
         klass.field :stats, generate_stat_class(resource), null: false
       end
       register(name, klass)
       klass
     end
 
+    # def edge_type(name, type)
+    #   if (registered = type_registry[name])
+    #     return registered[:type]
+    #   end
+
+    #   klass = Class.new(BaseObject) do
+    #     graphql_name "#{name}Edge"
+    #     field :cursor, String, null: false
+    #     field :node, type, null: false
+    #   end
+    #   type_registry[name] = {type: klass}
+    #   klass
+    # end
+
     def add_index(query_class, resource)
       field_name = resource.graphql_entrypoint.to_s.underscore.to_sym
       field = query_class.field field_name,
         generate_connection_type(resource, top_level: true),
-        null: false
+        null: false,
+        connection: false
       @query_fields[field_name] = resource
       define_arguments_for_sideload_field(field, resource)
     end
 
+    def apply_connection_args(field)
+      field.argument :after, "String", "Cursor to paginate after", required: false
+      field.argument :before, "String", "Cursor to paginate before", required: false
+      field.argument :first, "Int", "Same as page.size", required: false
+    end
+
     def add_show(query_class, resource)
       field_name = resource.graphql_entrypoint.to_s.underscore.singularize.to_sym
       field = query_class.field field_name,
@@ -222,6 +247,7 @@ module GraphitiGraphQL
           field.argument :sort, [sort_type], required: false
         end
         field.argument :page, PageType, required: false
+        apply_connection_args(field)
 
         unless resource.filters.empty?
           filter_type = generate_filter_type(field, resource)
@@ -375,6 +401,8 @@ module GraphitiGraphQL
         end
       end
 
+      klass.field :_cursor, String, null: false
+
       register(type_name, klass, resource, poly_parent)
 
       resource.sideloads.each_pair do |name, sideload|
@@ -480,6 +508,16 @@ module GraphitiGraphQL
       graphql_name "Page"
       argument :size, Int, required: false
       argument :number, Int, required: false
+      argument :after, String, required: false
+      argument :before, String, required: false
+    end
+
+    class PageInfoType < BaseObject
+      graphql_name "PageInfo"
+      field :has_next_page, Boolean, null: false
+      field :has_previous_page, Boolean, null: false
+      field :start_cursor, String, null: false
+      field :end_cursor, String, null: false
     end
 
     class SortDirType < GraphQL::Schema::Enum

data/lib/graphiti_graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphitiGraphQL
-  VERSION = "0.1.4"
+  VERSION = "0.1.8"
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: graphiti_graphql
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.8
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-06-07 00:00:00.000000000 Z
+date: 2021-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphiti
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.36
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.36
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -274,7 +274,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: GraphQL support for Graphiti