graphiti_graphql 0.1.0

data/lib/graphiti_graphql/errors.rb

@@ -0,0 +1,5 @@
+module GraphitiGraphQL
+  module Errors
+    class Base < StandardError; end
+  end
+end

data/lib/graphiti_graphql/federation.rb

@@ -0,0 +1,263 @@
+begin
+  require "apollo-federation"
+rescue LoadError
+  raise "You must add the 'apollo-federation' gem to use GraphitiGraphQL federation"
+end
+
+begin
+  require "graphql/batch"
+rescue LoadError
+  raise "You must add the 'graphql-batch' gem to use GraphitiGraphQL federation"
+end
+
+# We don't want to add these as dependencies,
+# but do need to check things don't break
+if Gem::Version.new(ApolloFederation::VERSION) >= Gem::Version.new('2.0.0')
+  raise "graphiti_graphql federation is incompatible with apollo-federation >= 2"
+end
+
+if Gem::Version.new(GraphQL::Batch::VERSION) >= Gem::Version.new('1.0.0')
+  raise "graphiti_graphql federation is incompatible with graphql-batch >= 1"
+end
+
+require "graphiti_graphql"
+
+module GraphitiGraphQL
+  module Federation
+
+    def self.external_resources
+      @external_resources ||= {}
+    end
+
+    def self.clear!
+      @external_resources = {}
+    end
+
+    def self.setup!
+      Graphiti::Resource.send(:include, ResourceDSL)
+      schema = GraphitiGraphQL::Schema
+      schema.base_field = Class.new(schema.base_field) do
+        include ApolloFederation::Field
+      end
+      schema.base_object = Class.new(schema.base_object) do
+        include ApolloFederation::Object
+      end
+      schema.base_object.field_class(schema.base_field)
+      schema.base_interface = Module.new do
+        include GraphQL::Schema::Interface
+        include ApolloFederation::Interface
+      end
+      schema.base_interface.field_class(schema.base_field)
+      GraphitiGraphQL::Schema.federation = true
+    end
+
+    class HasManyLoader < GraphQL::Batch::Loader
+      def initialize(resource_class, params, foreign_key)
+        @resource_class = resource_class
+        @params = params
+        @foreign_key = foreign_key
+      end
+
+      def perform(ids)
+        @params[:filter] ||= {}
+        @params[:filter].merge!(@foreign_key => { eq: ids.join(",") })
+
+        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]
+          fk = ->(record) { record[@foreign_key].to_s }
+          map = records.group_by(&fk)
+          ids.each do |id|
+            fulfill(id, (map[id] || []))
+          end
+        end
+      end
+    end
+
+    class BelongsToLoader < 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]
+          pk = ->(record) { record[:id].to_s }
+          map = records.index_by(&pk)
+          ids.each { |id| fulfill(id, map[id]) }
+        end
+      end
+    end
+
+    class ExternalRelationship
+      attr_reader :name, :local_resource_class, :foreign_key
+
+      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
+    end
+
+    class ExternalResource
+      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
+      )
+        @relationships[name] = ExternalRelationship
+          .new(kind, name, local_resource_class, foreign_key)
+      end
+    end
+
+    class TypeProxy
+      def initialize(caller, type_name)
+        @caller = caller
+        @type_name = type_name
+      end
+
+      def has_many(relationship_name, foreign_key: nil)
+        @caller.federated_has_many relationship_name,
+          type: @type_name,
+          foreign_key: foreign_key
+      end
+    end
+
+    module ResourceDSL
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def federated_type(type_name)
+          TypeProxy.new(self, type_name)
+        end
+
+        # TODO: raise error if belongs_to doesn't have corresponding filter (on schema gen)
+        # TODO: hang these on the resource classes themselves
+        def federated_has_many(name, type:, foreign_key: nil)
+          foreign_key ||= :"#{type.underscore}_id"
+          resource = GraphitiGraphQL::Federation.external_resources[type] ||=
+            ExternalResource.new(type)
+          resource.add_relationship(:has_many, name, self, foreign_key)
+
+          attribute = attributes.find do |name, config|
+            name.to_sym == foreign_key && !!config[:readable] && !!config[:filterable]
+          end
+          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
+
+        def federated_belongs_to(name, type: nil, foreign_key: nil)
+          type ||= name.to_s.camelize
+          foreign_key ||= :"#{name.to_s.underscore}_id"
+          resource = GraphitiGraphQL::Federation.external_resources[type] ||=
+            ExternalResource.new(type)
+          resource.add_relationship(:belongs_to, name, self, foreign_key)
+
+          attribute name, :hash, readable: :gql?, only: [:readable], schema: false do
+            fk = if prc = self.class.attribute_blocks[foreign_key]
+              instance_eval(&prc)
+            else
+              @object.send(foreign_key)
+            end
+            {
+              __typename: type,
+              id: fk.to_s
+            }
+          end
+        end
+      end
+
+      def gql?
+        Graphiti.context[:graphql]
+      end
+    end
+  end
+end
+
+# 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 EntitiesFieldOverride
+  def _entities(representations:, lookahead:) # accept the lookahead as argument
+    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
+ApolloFederation::EntitiesField.send :prepend, EntitiesFieldOverride

data/lib/graphiti_graphql/graphiti_schema/resource.rb

@@ -0,0 +1,117 @@
+module GraphitiGraphQL
+  module GraphitiSchema
+    class Resource
+      attr_reader :schema, :config
+
+      def self.gql_name(name)
+        Graphiti::Util::Class.graphql_type_name(name)
+      end
+
+      def initialize(schema, config)
+        @schema = schema
+        @config = config
+      end
+
+      def graphql_class_name(allow_interface = true)
+        class_name = self.class.gql_name(name)
+        if allow_interface
+          if polymorphic? && !children.map(&:name).include?(name)
+            class_name = "I#{class_name}"
+          end
+        end
+        class_name
+      end
+
+      def sideloads
+        @sideloads ||= {}.tap do |sideloads|
+          config[:relationships].each_pair do |k, v|
+            sideload = Sideload.new(schema, v)
+            sideload.name = k
+            sideloads[k] = sideload
+          end
+        end
+      end
+
+      def related_resource(relationship_name)
+        resource_name = relationships[relationship_name][:resource]
+        schema.get_resource(resource_name)
+      end
+
+      def pbt?(name)
+        relationships[name][:type] == "polymorphic_belongs_to"
+      end
+
+      def polymorphic?
+        !!config[:polymorphic]
+      end
+
+      def children
+        config[:children].map do |name|
+          schema.get_resource(name)
+        end
+      end
+
+      def remote_url
+        config[:remote]
+      end
+
+      def remote?
+        !!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
+
+      def type
+        config[:type]
+      end
+
+      def graphql_entrypoint
+        config[:graphql_entrypoint]
+      end
+
+      def sorts
+        config[:sorts]
+      end
+
+      def filters
+        config[:filters]
+      end
+
+      def relationships
+        config[:relationships]
+      end
+
+      def extra_attributes
+        config[:extra_attributes]
+      end
+
+      def attributes
+        config[:attributes]
+      end
+
+      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/sideload.rb

@@ -0,0 +1,56 @@
+module GraphitiGraphQL
+  module GraphitiSchema
+    class Sideload
+      attr_reader :config, :schema
+      attr_accessor :name
+
+      def initialize(schema, config)
+        @config = config
+        @schema = schema
+      end
+
+      def graphql_class_name
+        if type == :polymorphic_belongs_to
+          parent_resource.graphql_class_name
+        else
+          resource.graphql_class_name
+        end
+      end
+
+      def to_many?
+        [:has_many, :many_to_many].include?(type)
+      end
+
+      def type
+        config[:type].to_sym
+      end
+
+      def resource_name
+        config[:resource]
+      end
+
+      def resource
+        schema.get_resource(resource_name)
+      end
+
+      def remote?
+        resources = child_resources? ? child_resources : [resource]
+        resources.any?(&:remote?)
+      end
+
+      def parent_resource
+        schema.get_resource(config[:parent_resource])
+      end
+
+      def child_resources?
+        !!config[:resources]
+      end
+
+      def child_resources
+        config[:resources].map do |name|
+          schema.get_resource(name)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_graphql/graphiti_schema/wrapper.rb

@@ -0,0 +1,36 @@
+module GraphitiGraphQL
+  module GraphitiSchema
+    class Wrapper
+      attr_reader :schema
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def get_resource(name)
+        config = schema[:resources].find { |r| r[:name] == name }
+        raise "Could not find resource #{name} in schema" unless config
+        Resource.new(self, schema[:resources].find { |r| r[:name] == name })
+      end
+
+      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