graphiti_graphql 0.1.1 → 0.1.2

data/lib/graphiti_graphql/federation/apollo_federation_override.rb

@@ -0,0 +1,54 @@
+# Hacky sack!
+# All we're doing here is adding extras: [:lookahead] to the _entities field
+# And passing to to the .resolve_reference method when arity is 3
+# This way we can request only fields the user wants when resolving the reference
+# Important because we blow up when a field is guarded, and the guard fails
+ApolloFederation::EntitiesField::ClassMethods.module_eval do
+  alias_method :define_entities_field_without_override, :define_entities_field
+  def define_entities_field(*args)
+    result = define_entities_field_without_override(*args)
+    extras = fields["_entities"].extras
+    extras |= [:lookahead]
+    fields["_entities"].instance_variable_set(:@extras, extras)
+    result
+  end
+end
+
+module GraphitiGraphQL
+  module Federation
+    module EntitiesFieldOverride
+      # accept the lookahead as argument
+      def _entities(representations:, lookahead:)
+        representations.map do |reference|
+          typename = reference[:__typename]
+          type = context.warden.get_type(typename)
+          if type.nil? || type.kind != GraphQL::TypeKinds::OBJECT
+            raise "The _entities resolver tried to load an entity for type \"#{typename}\"," \
+                  " but no object type of that name was found in the schema"
+          end
+
+          type_class = type.is_a?(GraphQL::ObjectType) ? type.metadata[:type_class] : type
+          if type_class.respond_to?(:resolve_reference)
+            meth = type_class.method(:resolve_reference)
+            # ** THIS IS OUR EDIT **
+            result = if meth.arity == 3
+              type_class.resolve_reference(reference, context, lookahead)
+            else
+              type_class.resolve_reference(reference, context)
+            end
+          else
+            result = reference
+          end
+
+          context.schema.after_lazy(result) do |resolved_value|
+            context[resolved_value] = type
+            resolved_value
+          end
+        end
+      end
+    end
+  end
+end
+
+ApolloFederation::EntitiesField.send :prepend,
+  GraphitiGraphQL::Federation::EntitiesFieldOverride

data/lib/graphiti_graphql/federation/federated_relationship.rb

@@ -0,0 +1,26 @@
+module GraphitiGraphQL
+  module Federation
+    class FederatedRelationship
+      attr_reader :name, :local_resource_class, :foreign_key, :params_block
+
+      def initialize(kind, name, local_resource_class, foreign_key)
+        @kind = kind
+        @name = name
+        @local_resource_class = local_resource_class
+        @foreign_key = foreign_key
+      end
+
+      def has_many?
+        @kind == :has_many
+      end
+
+      def belongs_to?
+        @kind == :belongs_to
+      end
+
+      def params(&blk)
+        @params_block = blk
+      end
+    end
+  end
+end

data/lib/graphiti_graphql/federation/federated_resource.rb

@@ -0,0 +1,26 @@
+module GraphitiGraphQL
+  module Federation
+    class FederatedResource
+      attr_reader :type_name, :relationships
+
+      def initialize(type_name)
+        @type_name = type_name
+        @relationships = {}
+      end
+
+      def add_relationship(
+        kind,
+        name,
+        local_resource_class,
+        foreign_key,
+        &blk
+      )
+        @relationships[name] = FederatedRelationship
+          .new(kind, name, local_resource_class, foreign_key)
+        if blk
+          @relationships[name].instance_eval(&blk)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module GraphitiGraphQL
+  module Federation
+    module Loaders
+      class BelongsTo < GraphQL::Batch::Loader
+        def initialize(resource_class, fields)
+          @resource_class = resource_class
+          @fields = fields
+        end
+
+        def perform(ids)
+          Util.with_gql_context do
+            params = {filter: {id: {eq: ids.join(",")}}}
+            params[:fields] = {@resource_class.type => @fields.join(",")}
+            records = @resource_class.all(params).as_json[:data]
+            map = records.index_by { |record| record[:id].to_s }
+            ids.each { |id| fulfill(id, map[id]) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module GraphitiGraphQL
+  module Federation
+    module Loaders
+      class HasMany < GraphQL::Batch::Loader
+        def initialize(federated_relationship, params)
+          @federated_relationship = federated_relationship
+          @resource_class = federated_relationship.local_resource_class
+          @params = params
+          @foreign_key = federated_relationship.foreign_key
+        end
+
+        def perform(ids)
+          @params[:filter] ||= {}
+          @params[:filter][@foreign_key] = {eq: ids.join(",")}
+
+          @federated_relationship.params_block&.call(@params)
+
+          if ids.length > 1 && @params[:page]
+            raise Graphiti::Errors::UnsupportedPagination
+          elsif !@params[:page]
+            @params[:page] = {size: 999}
+          end
+
+          Util.with_gql_context do
+            records = @resource_class.all(@params).as_json[:data]
+            map = records.group_by { |record| record[@foreign_key].to_s}
+            ids.each { |id| fulfill(id, (map[id] || [])) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_graphql/federation/resource_dsl.rb

@@ -0,0 +1,89 @@
+module GraphitiGraphQL
+  module Federation
+    module ResourceDSL
+      class TypeProxy
+        def initialize(caller, type_name)
+          @caller = caller
+          @type_name = type_name
+        end
+
+        def has_many(relationship_name, foreign_key: nil, &blk)
+          @caller.federated_has_many relationship_name,
+            type: @type_name,
+            foreign_key: foreign_key,
+            &blk
+        end
+      end
+
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Sugar around federated_has_many
+        def federated_type(type_name)
+          TypeProxy.new(self, type_name)
+        end
+
+        # Add to Graphiti::Resource config as normal
+        # Helpful for inheritance + testing
+        def federated_resources
+          config[:federated_resources] ||= []
+        end
+
+        # * Add to the list of external graphql-ruby types we need in schema
+        # * Add a readable and filterable FK, without clobbering pre-existing
+        def federated_has_many(name, type:, foreign_key: nil, &blk)
+          foreign_key ||= :"#{type.underscore}_id"
+          resource = FederatedResource.new(type)
+          federated_resources << resource
+          resource.add_relationship(:has_many, name, self, foreign_key, &blk)
+
+          attribute = attributes.find { |name, config|
+            name.to_sym == foreign_key &&
+              !!config[:readable] &&
+              !!config[:filterable]
+          }
+          has_filter = filters.key?(foreign_key)
+          if !attribute && !has_filter
+            attribute foreign_key, :integer,
+              only: [:readable, :filterable],
+              schema: false,
+              readable: :gql?,
+              filterable: :gql?
+          elsif has_filter && !attribute
+            prior = filters[foreign_key]
+            attribute foreign_key, prior[:type],
+              only: [:readable, :filterable],
+              schema: false,
+              readable: :gql?
+            filters[foreign_key] = prior
+          elsif attribute && !has_filter
+            filter foreign_key, attribute[:type]
+          end
+        end
+
+        # * 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)
+          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)
+
+          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}
+          end
+        end
+      end
+
+      # Certain attributes should only work in GQL context
+      def gql?
+        Graphiti.context[:graphql]
+      end
+    end
+  end
+end

data/lib/graphiti_graphql/federation/schema_decorator.rb

@@ -0,0 +1,150 @@
+module GraphitiGraphQL
+  module Federation
+    class SchemaDecorator
+      def self.decorate(schema)
+        new(schema).decorate
+      end
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def decorate
+        @schema.schema.send(:include, ApolloFederation::Schema)
+        # NB if we add mutation support, make sure this is applied after
+        @schema.schema.use(GraphQL::Batch)
+        add_resolve_reference
+        add_federated_resources
+      end
+
+      # Add to all local resource types
+      # This is if a remote federated resource belongs_to a local resource
+      def add_resolve_reference
+        @schema.type_registry.each_pair do |name, config|
+          if config[:resource]
+            local_type = config[:type]
+            local_type.key(fields: "id") if local_type.respond_to?(:key)
+            local_resource = Graphiti.resources
+              .find { |r| r.name == config[:resource] }
+            # TODO: maybe turn off the graphiti debug for these?
+            local_type.define_singleton_method :resolve_reference do |reference, context, lookahead|
+              Federation::Loaders::BelongsTo
+                .for(local_resource, lookahead.selections.map(&:name))
+                .load(reference[:id])
+            end
+          end
+        end
+      end
+
+      def federated_resources
+        federated = []
+        Graphiti.resources.each do |r|
+          federated |= (r.config[:federated_resources] || [])
+        end
+        federated
+      end
+
+      def type_registry
+        @schema.type_registry
+      end
+
+      def add_federated_resources
+        each_federated_resource do |type_class, federated_resource|
+          federated_resource.relationships.each_pair do |name, relationship|
+            if relationship.has_many?
+              define_federated_has_many(type_class, relationship)
+            elsif relationship.belongs_to?
+              define_federated_belongs_to(federated_resource, relationship)
+            end
+          end
+        end
+      end
+
+      # NB: test already registered bc 2 things have same relationship
+      def each_federated_resource
+        federated_resources.each do |federated_resource|
+          pre_registered = !!type_registry[federated_resource.type_name]
+          type_class = if pre_registered
+            type_registry[federated_resource.type_name][:type]
+          else
+            add_federated_resource_type(federated_resource.type_name)
+          end
+
+          yield type_class, federated_resource
+        end
+      end
+
+      def add_federated_resource_type(klass_name)
+        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.field :id, String, null: false, external: true
+        federated_type.class_eval do
+          def self.resolve_reference(reference, _context, _lookup)
+            reference
+          end
+        end
+        # NB must be registered before processing relationships
+        type_registry[klass_name] = {type: federated_type}
+        federated_type
+      end
+
+      def define_federated_has_many(type_class, relationship)
+        local_name = GraphitiGraphQL::GraphitiSchema::Resource
+          .gql_name(relationship.local_resource_class.name)
+        local_type = type_registry[local_name][:type]
+        local_resource_name = type_registry[local_name][:resource]
+        local_resource = Graphiti.resources.find { |r| r.name == local_resource_name }
+
+        local_interface = type_registry["I#{local_name}"]
+        best_type = local_interface ? local_interface[:type] : local_type
+
+        field = type_class.field relationship.name,
+          [best_type],
+          null: false,
+          extras: [:lookahead]
+
+        @schema.send :define_arguments_for_sideload_field,
+          field, @schema.graphiti_schema.get_resource(local_resource_name)
+        type_class.define_method relationship.name do |lookahead:, **arguments|
+          # TODO test params...do version of sort with array/symbol keys and plain string
+          params = arguments.as_json
+            .deep_transform_keys { |key| key.to_s.underscore.to_sym }
+          selections = lookahead.selections.map(&:name)
+          selections << relationship.foreign_key
+          selections << :_type # polymorphism
+          params[:fields] = {local_resource.type => selections.join(",")}
+
+          if (sort = Util.parse_sort(params[:sort]))
+            params[:sort] = sort
+          end
+
+          Federation::Loaders::HasMany
+            .for(relationship, params)
+            .load(object[:id])
+        end
+      end
+
+      def define_federated_belongs_to(federated_resource, relationship)
+        type_name = GraphitiSchema::Resource.gql_name(relationship.local_resource_class.name)
+        local_type = type_registry[type_name][:type]
+
+        # Todo maybe better way here
+        interface = type_registry["I#{type_name}"]
+
+        local_type = interface[:type] if interface
+        local_types = [local_type]
+        if interface
+          local_types |= interface[:implementers]
+        end
+
+        local_types.each do |local|
+          local.field relationship.name,
+            type_registry[federated_resource.type_name][:type],
+            null: true
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_graphql/graphiti_schema/resource.rb

@@ -59,14 +59,6 @@ module GraphitiGraphQL
         !!config[:remote]
       end
 
-      def fetch_remote_schema!
-        parts = remote_url.split("/")
-        parts.pop
-        url = "#{parts.join("/")}/vandal/schema.json"
-        response = faraday.get(url)
-        JSON.parse(response.body).deep_symbolize_keys
-      end
-
       def name
         config[:name]
       end
@@ -102,16 +94,6 @@ module GraphitiGraphQL
       def all_attributes
         attributes.merge(extra_attributes)
       end
-
-      private
-
-      def faraday
-        if defined?(Faraday)
-          Faraday
-        else
-          raise "Faraday not defined. Please require the 'faraday' gem to use remote resources"
-        end
-      end
     end
   end
 end

data/lib/graphiti_graphql/graphiti_schema/wrapper.rb

@@ -16,21 +16,6 @@ module GraphitiGraphQL
       def resources
         schema[:resources].map { |r| get_resource(r[:name]) }
       end
-
-      # TODO some work here, dupes, refer back, etc
-      def merge_remotes!
-        resources.select(&:remote?).each do |resource|
-          remote_schema = resource.fetch_remote_schema!
-          remote_schema[:resources].each do |remote_config|
-            unless resources.map(&:name).include?(remote_config[:name])
-              remote_config[:name] = resource.name
-              schema[:resources].reject! { |r| r[:name] == resource.name }
-              schema[:resources] << remote_config
-              schema
-            end
-          end
-        end
-      end
     end
   end
 end