graphiti_gql 0.1.0

data/lib/graphiti_gql/graphiti_hax.rb

@@ -0,0 +1,71 @@
+# These should be in Graphiti itself, but can't do it quite yet b/c GQL coupling.
+# Ideally we eventually rip out the parts of Graphiti we need and roll this into
+# that effort.
+module ResourceExtras
+  extend ActiveSupport::Concern
+
+  included do
+    class << self
+      attr_accessor :graphql_name
+    end
+  end
+
+  class_methods do
+    def attribute(*args)
+      super(*args).tap do
+        opts = args.extract_options!
+        att = config[:attributes][args[0]]
+        att[:deprecation_reason] = opts[:deprecation_reason]
+        att[:null] = opts.key?(:null) ? opts[:null] : args[0] != :id
+      end
+    end
+  end
+end
+
+Graphiti::Resource.send(:include, ResourceExtras)
+
+module FilterExtras
+  def filter_param
+    default_filter = resource.default_filter if resource.respond_to?(:default_filter)
+    default_filter ||= {}
+    default_filter.merge(super)
+  end
+end
+Graphiti::Scoping::Filter.send(:prepend, FilterExtras)
+
+# ==================================================
+# Below is all to support pagination argument 'last'
+# ==================================================
+module SortExtras
+  def sort_param
+    param = super
+    if query_hash[:reverse]
+      param = [{ id: :asc }] if param == []
+      param = param.map do |p|
+        {}.tap do |hash|
+          dir = p[p.keys.first]
+          dir = dir == :asc ? :desc : :asc
+          hash[p.keys.first] = dir
+        end
+      end
+    end
+    param
+  end
+end
+Graphiti::Scoping::Sort.send(:prepend, SortExtras)
+module QueryExtras
+  def hash
+    hash = super
+    hash[:reverse] = true if @params[:reverse]
+    hash
+  end
+end
+Graphiti::Query.send(:prepend, QueryExtras)
+module ScopeExtras
+  def resolve(*args)
+    results = super
+    results.reverse! if @query.hash[:reverse]
+    results
+  end
+end
+Graphiti::Scope.send(:prepend, ScopeExtras)

data/lib/graphiti_gql/loaders/belongs_to.rb

@@ -0,0 +1,63 @@
+module GraphitiGql
+  module Loaders
+    class FakeRecord < Struct.new(:id, :type)
+    end
+
+    class BelongsTo < GraphQL::Batch::Loader
+      def initialize(sideload, params)
+        @sideload = sideload
+        @params = params
+      end
+
+      def perform(ids)
+        # process nils
+        ids.each { |id| fulfill(id, nil) if id.nil? }
+        ids.compact!
+        return if ids.empty?
+
+        if @params[:simpleid]
+          if @sideload.type == :polymorphic_belongs_to
+            ids.each do |id|
+              child = @sideload.children.values.find { |c| c.group_name == id[:type].to_sym }
+              type = Schema::Registry.instance.get(child.resource.class, interface: false)[:type]
+              fulfill(id, FakeRecord.new(id[:id], type))
+            end
+          else
+            type = Schema::Registry.instance.get(@sideload.resource.class)[:type]
+            ids.each { |id| fulfill(id, FakeRecord.new(id, type)) }
+          end
+          return
+        end
+
+        if @sideload.type == :polymorphic_belongs_to
+          groups = ids.group_by { |hash| hash[:type] }
+          payload = {}
+          groups.each_pair do |key, val|
+            payload[key] = val.map { |v| v[:id] }
+          end
+          futures = []
+          payload.each_pair do |key, value|
+            params = { filter: {} }
+            klass = @sideload.children.values.find { |c| c.group_name == key.to_sym }
+            params = {
+              filter: { id: { eq: value.join(",") } }
+            }
+            futures << Concurrent::Future.execute do
+               { type: key, data: klass.resource.class.all(params).data }
+            end
+          end
+          values = futures.map(&:value)
+          ids.each do |id|
+            val = values.find { |v| v[:type] == id[:type] }
+            fulfill(id, val[:data][0])
+          end
+        else
+          params = {filter: {id: {eq: ids.join(",")}}}
+          records = @sideload.resource.class.all(params).data
+          map = records.index_by { |record| record.id }
+          ids.each { |id| fulfill(id, map[id]) }
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/loaders/has_many.rb

@@ -0,0 +1,14 @@
+module GraphitiGql
+  module Loaders
+    class HasMany < Many
+      def assign(ids, proxy)
+        records = proxy.data
+        map = records.group_by { |record| record.send(@sideload.foreign_key) }
+        ids.each do |id|
+          data = [map[id] || [], proxy]
+          fulfill(id, data)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/loaders/many.rb

@@ -0,0 +1,79 @@
+module GraphitiGql
+  module Loaders
+    class Many < GraphQL::Batch::Loader
+      def self.factory(sideload, params)
+        if sideload.polymorphic_as
+          PolymorphicHasMany.for(sideload, params)
+        elsif sideload.type == :many_to_many
+          ManyToMany.for(sideload, params)
+        else
+          HasMany.for(sideload, params)
+        end
+      end
+
+      def initialize(sideload, params)
+        @sideload = sideload
+        @params = params
+      end
+
+      def perform(ids)
+        raise ::Graphiti::Errors::UnsupportedPagination if paginating? && ids.length > 1
+        raise Errors::UnsupportedStats if requesting_stats? && ids.length > 1 && !can_group?
+
+        build_params(ids)
+        proxy = @sideload.resource.class.all(@params)
+        assign(ids, proxy)
+      end
+
+      def assign(ids, proxy)
+        raise "implement in subclass"
+      end
+
+      private
+
+      def build_params(ids)
+        @params[:filter] ||= {}
+
+        if @sideload.polymorphic_as
+          type = ids[0][:"#{@sideload.polymorphic_as}_type"]
+          foreign_keys = ids.map { |id| id[@sideload.foreign_key] }
+          @params[:filter][:"#{@sideload.polymorphic_as}_type"] = type
+          @params[:filter][@sideload.foreign_key] = foreign_keys.join(",")
+        elsif @sideload.type == :many_to_many
+          fk = @sideload.foreign_key.values.first
+          @params[:filter].merge!(fk => { eq: ids.join(",") })
+        else
+          @params[:filter].merge!(@sideload.foreign_key => { eq: ids.join(",") })
+        end
+
+        if @params[:stats]
+          group_by = if @sideload.type ==:many_to_many
+            @sideload.foreign_key.values.first
+          else
+            @sideload.foreign_key
+          end
+          @params[:stats][:group_by] = group_by
+        end
+
+        unless @params.key?(:page) && @params[:page].key?(:size)
+          @params[:page] ||= {}
+          @params[:page][:size] = 999
+        end
+      end
+
+      def paginating?
+        pagination_key_present = @params.key?(:page) &&
+          [:size, :last, :before, :after].any? { |arg| @params[:page].key?(arg) }
+        pagination_key_present && @params[:page][:size] != 0 # stats
+      end
+
+      def requesting_stats?
+        @params.key?(:stats)
+      end
+
+      def can_group?
+        @sideload.resource.adapter.can_group?
+      end
+    end
+  end
+end

data/lib/graphiti_gql/loaders/many_to_many.rb

@@ -0,0 +1,16 @@
+module GraphitiGql
+  module Loaders
+    class ManyToMany < Many
+      def assign(ids, proxy)
+        records = proxy.data
+        thru = @sideload.foreign_key.keys.first
+        fk = @sideload.foreign_key[thru]
+        ids.each do |id|
+          match = ->(thru) { thru.send(fk) == id }
+          corresponding = records.select { |record| record.send(thru).any?(&match) }
+          fulfill(id, [corresponding, proxy])
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/loaders/polymorphic_has_many.rb

@@ -0,0 +1,17 @@
+module GraphitiGql
+  module Loaders
+    class PolymorphicHasMany < Many
+      def assign(ids, proxy)
+        records = proxy.data
+        ids.each do |id|
+          corresponding = records.select do |record|
+            record.send("#{@sideload.polymorphic_as}_type") == id[:"#{@sideload.polymorphic_as}_type"] &&
+              record.send(@sideload.foreign_key) == id[@sideload.foreign_key]
+          end
+          data = [corresponding || [], proxy]
+          fulfill(id, data)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/response_shim.rb

@@ -0,0 +1,13 @@
+# We need the raw records, but also the proxy so we can grab stats
+module GraphitiGql
+  class Schema
+    class ResponseShim
+      attr_reader :data, :proxy
+
+      def initialize(data, proxy)
+        @data = data
+        @proxy = proxy
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/connection.rb

@@ -0,0 +1,57 @@
+module GraphitiGql
+  class Schema
+    class Connection < ::GraphQL::Pagination::Connection
+      def nodes
+        return @items if @run_once
+        @proxy = @items.proxy
+        @items = @items.data
+        @run_once = true
+        @items
+      end
+
+      def proxy
+        nodes
+        @proxy
+      end
+
+      def has_previous_page
+        proxy.pagination.has_previous_page?
+      end
+
+      def has_next_page
+        nodes
+        return false if @items.length.zero?
+        cursor = JSON.parse(Base64.decode64(cursor_for(@items.last)))
+        cursor["offset"] < @proxy.pagination.send(:item_count)
+      end
+
+      def cursor_for(item)
+        nodes
+        starting_offset = 0
+        page_param = proxy.query.pagination
+        if (page_number = page_param[:number])
+          page_size = page_param[:size] || proxy.resource.default_page_size
+          starting_offset = (page_number - 1) * page_size
+        end
+  
+        if (cursor = page_param[:after])
+          starting_offset = cursor[:offset]
+        end
+  
+        current_offset = @items.index(item)
+        offset = starting_offset + current_offset + 1 # (+ 1 b/c o-base index)
+        Base64.encode64({offset: offset}.to_json).chomp
+      end
+    end
+
+    class ToManyConnection < Connection
+      def nodes
+        return @items if @run_once
+        @proxy = @items[1]
+        @items = @items[0]
+        @run_once = true
+        @items
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/fields/attribute.rb

@@ -0,0 +1,46 @@
+module GraphitiGql
+  class Schema
+    module Fields
+      class Attribute
+        def initialize(name, config)
+          @name = name
+          @config = config
+        end
+
+        def apply(type)
+          is_nullable = !!@config[:null]
+          _config = @config
+          _name = @name
+          opts = @config.slice(:null, :deprecation_reason)
+          type.field(@name, field_type, **opts)
+          type.define_method @name do
+            if (readable = _config[:readable]).is_a?(Symbol)
+              resource = object.instance_variable_get(:@__graphiti_resource)
+              unless resource.send(readable)
+                path = Graphiti.context[:object][:current_path].join(".")
+                raise Errors::UnauthorizedField.new(path)
+              end
+            end
+            value = if _config[:proc]
+              instance_eval(&_config[:proc])
+            else
+              object.send(_name)
+            end
+            return if value.nil?
+            Graphiti::Types[_config[:type]][:read].call(value)
+          end
+        end
+
+        private
+
+        def field_type
+          canonical_graphiti_type = Graphiti::Types.name_for(@config[:type])
+          field_type = GQL_TYPE_MAP[canonical_graphiti_type.to_sym]
+          field_type = String if @name == :id
+          field_type = [field_type] if @config[:type].to_s.starts_with?("array_of")
+          field_type
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/fields/index.rb

@@ -0,0 +1,33 @@
+module GraphitiGql
+  class Schema
+    module Fields
+      class Index
+        def initialize(registered)
+          @registered = registered
+        end
+
+        def apply(query)
+          resource = @registered[:resource]
+          field = query.field resource.graphql_entrypoint,
+            @registered[:type].connection_type,
+            null: false,
+            connection: false,
+            extensions: [RelayConnectionExtension],
+            extras: [:lookahead]
+          ListArguments.new(resource).apply(field)
+          query.define_method name do |**arguments|
+            params = Util.params_from_args(arguments)
+            proxy = resource.all(params)
+            ResponseShim.new(proxy.data, proxy)
+          end
+        end
+
+        private
+
+        def name
+          @registered[:resource].graphql_entrypoint
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/fields/show.rb

@@ -0,0 +1,33 @@
+module GraphitiGql
+  class Schema
+    module Fields
+      class Show
+        def initialize(registered)
+          @registered = registered
+        end
+
+        def apply(query)
+          field = query.field name,
+            @registered[:type],
+            null: true,
+            extras: [:lookahead]
+          field.argument(:id, String, required: true)
+          _registered = @registered
+          query.define_method name do |**arguments|
+            params = Util.params_from_args(arguments)
+            _registered[:resource].all(params).data[0]
+          end
+        end
+
+        private
+
+        def name
+          @registered[:resource]
+            .graphql_entrypoint.to_s
+            .underscore
+            .singularize.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/fields/stats.rb

@@ -0,0 +1,54 @@
+module GraphitiGql
+  class Schema
+    module Fields
+      class Stats
+        def initialize(resource)
+          @resource = resource
+        end
+
+        def apply(type)
+          type.field :stats, build_stat_class, null: false
+          type.define_method :stats do
+            # Process grouped (to-many relationship) stats
+            stats = object.proxy.stats.deep_dup
+            stats.each_pair do |attr, calc|
+              calc.each_pair do |calc_name, value|
+                if value.is_a?(Hash)
+                  stats[attr][calc_name] = value[parent.id]
+                end
+              end
+            end
+            stats
+          end
+          type
+        end
+
+        private
+
+        def build_stat_class
+          name = Registry.instance.key_for(@resource)
+          stat_graphql_name = "#{name}Stats"
+          return Registry.instance[stat_graphql_name][:type] if Registry.instance[stat_graphql_name]
+          klass = Class.new(GraphQL::Schema::Object)
+          klass.graphql_name(stat_graphql_name)
+          @resource.stats.each_pair do |name, config|
+            calc_class = build_calc_class(stat_graphql_name, name, config.calculations.keys)
+            klass.field name, calc_class, null: false
+          end
+          Registry.instance[stat_graphql_name] = { type: klass }
+          klass
+        end
+    
+        def build_calc_class(stat_graphql_name, stat_name, calculations)
+          name = "#{stat_graphql_name}#{stat_name}Calculations"
+          klass = Class.new(GraphQL::Schema::Object)
+          klass.graphql_name(name)
+          calculations.each do |calc|
+            klass.field calc, Float, null: false
+          end
+          klass
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/fields/to_many.rb

@@ -0,0 +1,37 @@
+module GraphitiGql
+  class Schema
+    module Fields
+      class ToMany
+        def initialize(sideload, sideload_type)
+          @sideload = sideload
+          @sideload_type = sideload_type
+        end
+
+        def apply(type)
+          field = type.field @sideload.name,
+            @sideload_type.connection_type,
+            null: false,
+            connection: false,
+            extensions: [RelayConnectionExtension],
+            extras: [:lookahead]
+          ListArguments.new(@sideload.resource.class, @sideload).apply(field)
+          _sideload = @sideload
+          type.define_method(@sideload.name) do |**arguments|
+            Util.is_readable_sideload!(_sideload)
+            params = Util.params_from_args(arguments)
+            pk = object.send(_sideload.primary_key)
+            id = if _sideload.polymorphic_as
+              hash = {}
+              hash[_sideload.foreign_key] = pk
+              hash[:"#{_sideload.polymorphic_as}_type"] = object.class.name
+              id = hash
+            else
+              id = pk
+            end
+            Loaders::Many.factory(_sideload, params).load(id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/schema/fields/to_one.rb

@@ -0,0 +1,47 @@
+module GraphitiGql
+  class Schema
+    module Fields
+      class ToOne
+        def initialize(sideload, sideload_type)
+          @sideload = sideload
+          @sideload_type = sideload_type
+        end
+
+        def apply(type)
+          field = type.field @sideload.name,
+            @sideload_type,
+            null: true,
+            extras: [:lookahead]
+          _sideload = @sideload
+          type.define_method(@sideload.name) do |**arguments|
+            Util.is_readable_sideload!(_sideload)
+
+            if _sideload.type == :has_one
+              id = object.send(_sideload.primary_key)
+              params = { filter: { _sideload.foreign_key => { eq: id } } }
+              return _sideload.resource.class.all(params).data[0]
+            end
+
+            lookahead = arguments[:lookahead]
+            id = object.send(_sideload.foreign_key)
+            if id.nil?
+              Loaders::BelongsTo.for(_sideload, {}).load(nil)
+            else
+              params = Util.params_from_args(arguments)
+
+              if _sideload.type == :polymorphic_belongs_to
+                id = { id: id, type: object.send(_sideload.grouper.field_name) }
+              end
+
+              selections = lookahead.selections.map(&:name).sort
+              if selections == [:id] || selections == [:__typename, :id]
+                params[:simpleid] = true
+              end
+              Loaders::BelongsTo.for(_sideload, params).load(id)
+            end
+          end
+        end
+      end
+    end
+  end
+end