graphiti_gql 0.2.4 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84a7ebf615007ac087b7bab32e53b78fc1bbdb7abcd9d65e38beac1ec7e578fc
-  data.tar.gz: d5c625d0e34f750d8fc3bc8c71f39ccabb70aa1c87340978620e965137e15feb
+  metadata.gz: d38c8d27dc214efd323ee98932bcb858bca8553e45c5e4428858b3b5503db44d
+  data.tar.gz: ae38e08ba55f6c38b464ed9a3cbd592394568c080aac2361d0549adea259b9fe
 SHA512:
-  metadata.gz: e8ea8defdb4712239187bcbb14a0d5dbeee9e52bf11a7c32dd747da2eae62247ef66fda15dd63b57886920a895f8215fe7a33b8eb3dc156194b3b2e3fd2f75c6
-  data.tar.gz: 42f885befb9c54a6b915642e40f2d2bb8704571c901c392f2a6fe11196d805113ca7af546ff15db7b336fdceff172ba2c27e9f443381462db26b4b44461eab6b
+  metadata.gz: d50257d774787869a18187e76e924503fb34dfad8c4d93fd73d99289fc203626d120585448bc646175cb9ff80e607df5c374a6207a95732aeccedb2d20ea9d39
+  data.tar.gz: e1f1ff11574682dd8946907f2e76e3b9279c08039e29e4bc1f53436f184c1e6bd0e04f2ef52f391526abd1d837ef6a9dbd3f1a8a617528ee90942857b66d9706

data/.github/probots.yml

@@ -0,0 +1,2 @@
+enabled:
+  - cla

data/lib/graphiti_gql/active_resource.rb

@@ -1,17 +1,26 @@
+# TODO: Rushing here so tests are in app and code is gross
 module GraphitiGql
   module ActiveResource
     extend ActiveSupport::Concern
 
     class Node < OpenStruct
-      def initialize(resource, hash)
+      def initialize(hash, resource = nil)
         @resource = resource
+        @edges = {}
+        @node_id = hash.delete(:node_id)
         hash.each_pair do |key, value|
           if value.is_a?(Hash)
             if (sideload = resource.sideload(key))
               if value.key?(:edges) 
-                hash[key] = value[:edges].map { |v| Node.new(sideload.resource.class, v[:node]) }
+                @edges[key] = value[:edges].map do |edge|
+                  node_id = edge[:node][:id]
+                  Node.new(edge.except(:node).merge(node_id: node_id))
+                end
+                hash[key] = value[:edges].map { |v| Node.new(v[:node], sideload.resource.class) }
+              elsif value.key?(:nodes)
+                hash[key] = value[:nodes].map { |n| Node.new(n, sideload.resource.class) }
               else
-                hash[key] = Node.new(sideload.resource.class, value)
+                hash[key] = Node.new(value, sideload.resource.class)
               end
             end
           end
@@ -19,6 +28,15 @@ module GraphitiGql
         super(hash)
       end
 
+      def edge(name, node_id)
+        found = @edges[name].empty? ? nil : @edges[name]
+        if found && node_id
+          found.find { |f| f.instance_variable_get(:@node_id) == node_id.to_s }
+        else
+          found
+        end
+      end
+
       def decoded_id
         Base64.decode64(self.id)
       end
@@ -29,7 +47,8 @@ module GraphitiGql
     end
 
     class Proxy
-      def initialize(resource, params, ctx)
+      def initialize(resource, params, ctx, query)
+        @query = query
         @resource = resource
         @ctx = ctx
         @params = params.deep_transform_keys { |key| key.to_s.camelize(:lower).to_sym }
@@ -46,10 +65,18 @@ module GraphitiGql
         result
       end
 
+      def node(id)
+        nodes.find { |n| n.id == id.to_s }
+      end
+
       def nodes
         return [] unless data
-        nodes = edges.map { |e| underscore(e[:node]) }
-        nodes.map { |n| Node.new(@resource, n) }
+        elements = if edges
+          edges.map { |e| e[:node] }
+        else
+          data[data.keys.first][:nodes] || []
+        end
+        elements.map { |n| Node.new(underscore(n), @resource) }
       end
       alias :to_a :nodes
 
@@ -85,10 +112,14 @@ module GraphitiGql
         underscore(data[data.keys.first][:pageInfo])
       end
 
+      # barf
       def query
+        return @query if @query
+
         name = Schema.registry.key_for(@resource)
-        filter_bang = "!" if @resource.filters.values.any? { |f| f[:required] }
         sortvar = "$sort: [#{name}Sort!]," if @resource.sorts.any?
+        filter_bang = "!" if @resource.filters.values.any? { |f| f[:required] }
+        filtervar = "$filter: #{name}Filter#{filter_bang}," if @resource.filters.any?
 
         if !(fields = @params[:fields])
           fields = []
@@ -99,7 +130,7 @@ module GraphitiGql
 
         q = %|
           query #{name} (
-            $filter: #{name}Filter#{filter_bang},
+            #{filtervar}
             #{sortvar}
             $first: Int,
             $last: Int,
@@ -107,7 +138,7 @@ module GraphitiGql
             $after: String,
           ) {
             #{@resource.graphql_entrypoint} (
-              filter: $filter,
+              #{ 'filter: $filter,' if filtervar }
               #{ 'sort: $sort,' if sortvar }
               first: $first,
               last: $last,
@@ -118,6 +149,7 @@ module GraphitiGql
                 node {|
 
         fields.each do |name|
+          next if name.is_a?(Hash)
           q << %|
                   #{name.to_s.camelize(:lower)}|
         end
@@ -129,17 +161,36 @@ module GraphitiGql
             sideload = @resource.sideload(inc.to_sym)
             to_one = [:belongs_to, :has_one, :polymorphic_belongs_to].include?(sideload.type)
             indent = "    " if !to_one
+
+            edge_fields = []
+            runtime_sideload_fields = @params[:fields].find { |f| f.is_a?(Hash) && f.key?(inc.to_sym) }
+            if runtime_sideload_fields
+              runtime_sideload_fields = runtime_sideload_fields.values
+              edge_fields = runtime_sideload_fields.find { |f| f.is_a?(Hash) && f.key?(:edge) }
+              runtime_sideload_fields = runtime_sideload_fields.reject { |f| f.is_a?(Hash) }
+              edge_fields = edge_fields[:edge] if edge_fields
+            end
+
             q << %|
                   #{inc.to_s.camelize(:lower)} {|
             if !to_one
               q << %|
-                    edges {
+                    edges {|
+
+              edge_fields.each do |ef|
+                q << %|
+                      #{ef.to_s.camelize(:lower)}|
+              end
+
+              q << %|
                       node {|
             end
 
-            r = @resource.sideload(inc.to_sym).resource
-            r.attributes.each_pair do |name, config|
-              next unless config[:readable]
+            sideload_fields = runtime_sideload_fields
+            if sideload_fields.blank?
+              sideload_fields = @resource.sideload(inc.to_sym).resource.attributes.select { |_, config| config[:readable] }.map(&:first)
+            end
+            sideload_fields.each do |name|
               q << %|
                     #{indent}#{name.to_s.camelize(:lower)}|
             end
@@ -200,8 +251,8 @@ module GraphitiGql
     end
 
     class_methods do
-      def gql(params = {}, ctx = {})
-        Proxy.new(self, params, ctx)
+      def gql(params = {}, ctx = {}, query = nil)
+        Proxy.new(self, params, ctx, query)
       end
     end
   end

data/lib/graphiti_gql/graphiti_hax.rb

@@ -143,22 +143,41 @@ module GraphitiGql
   Graphiti::Scoping::Paginate.send(:prepend, PaginateExtras)
 
   module ManyToManyExtras
-    extend ActiveSupport::Concern
+    def self.prepended(klass)
+      klass.class_eval do
+        class << self
+          attr_accessor :edge_resource
 
-    class_methods do
-      attr_accessor :edge_resource
+          def attribute(*args, &blk)
+            @edge_resource ||= Class.new(Graphiti::Resource) do
+              def self.abstract_class?
+                true
+              end
+            end
+            @edge_resource.attribute(*args, &blk)
+          end
+        end
+      end
+    end
+
+    def apply_belongs_to_many_filter
+      super
+      self_ref = self
+      fk_type = parent_resource_class.attributes[:id][:type]
+      fk_type = :hash if polymorphic?
+      filters = resource_class.config[:filters]
 
-      def attribute(*args, &blk)
-        @edge_resource = Class.new(Graphiti::Resource) do
-          def self.abstract_class?
-            true
+      # Keep the options, apply the eq proc
+      if (filter = filters[inverse_filter.to_sym])
+        if filter[:operators][:eq].nil?
+          filter[:operators][:eq] = proc do |scope, value|
+            self_ref.belongs_to_many_filter(scope, value)
           end
         end
-        @edge_resource.attribute(*args, &blk)
       end
     end
   end
-  Graphiti::Sideload::ManyToMany.send(:include, ManyToManyExtras)
+  Graphiti::Sideload::ManyToMany.send(:prepend, ManyToManyExtras)
 
   module StatsExtras
     def calculate_stat(name, function)

data/lib/graphiti_gql/loaders/belongs_to.rb

@@ -42,6 +42,7 @@ module GraphitiGql
             params = {
               filter: { id: { eq: value.join(",") } }
             }
+
             futures << Concurrent::Future.execute do
                { type: key, data: klass.resource.class.all(params).data }
             end

data/lib/graphiti_gql/loaders/many_to_many.rb

@@ -19,8 +19,11 @@ module GraphitiGql
       def add_join_table_magic(proxy)
         if defined?(ActiveRecord) && proxy.resource.model.ancestors.include?(ActiveRecord::Base)
           thru = @sideload.foreign_key.keys.first
-          thru_model = proxy.resource.model.reflect_on_association(thru).klass
+          reflection = @sideload.parent_resource.model.reflect_on_association(thru)
+          thru_model = reflection.klass
+
           names = thru_model.column_names.map do |n|
+            next if n == :id
             "#{thru_model.table_name}.#{n} as _edge_#{n}"
           end
           scope = proxy.scope.object

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

@@ -38,7 +38,7 @@ module GraphitiGql
 
             value = if _config[:proc]
               if _sideload
-                instance_exec(edge_attrs, &_config[:proc])
+                instance_exec(edge_attrs, object.node, &_config[:proc])
               else
                 instance_eval(&_config[:proc])
               end

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

@@ -42,24 +42,41 @@ module GraphitiGql
         end
 
         def build_customized_edge_type(sideload_type)
-          # build the edge class
-          prior_edge_class = sideload_type.edge_type_class
-          edge_class = Class.new(prior_edge_class)
+          edge_type_class = build_edge_type_class(sideload_type)
+
+          # Build the sideload type with new edge class applied
+          if sideload_type.is_a?(Module)
+            klass = sideload_type
+            # There's some magic that happens when subclassing, but modules
+            # don't subclass. This is the kind of resetting we need to happen.
+            # Might be a graphql-ruby issue.
+            klass.instance_variable_set(:@connection_type, nil)
+            klass.instance_variable_set(:@edge_type, nil)
+            klass.edge_type_class(edge_type_class)
+            klass
+          else
+            klass = Class.new(sideload_type)
+            klass.edge_type_class(edge_class)
+            klass
+          end
+        end
+
+        def build_edge_type_class(sideload_type)
+          prior_edge_type_class = sideload_type.edge_type_class
+          edge_type_class = Class.new(prior_edge_type_class)
           edge_resource = @sideload.class.edge_resource
           edge_resource.attributes.each_pair do |name, config|
             next if name == :id
-            Schema::Fields::Attribute.new(name, config, @sideload).apply(edge_class)
+            Schema::Fields::Attribute.new(name, config, @sideload).apply(edge_type_class)
           end
           registered_parent = Schema.registry.get(@sideload.parent_resource.class)
           parent_name = registered_parent[:type].graphql_name
-          edge_class.define_method :graphql_name do
-            "#{parent_name}To#{sideload_type.graphql_name}Edge"
+          edge_type_class_name = "#{parent_name}To#{sideload_type.graphql_name}Edge"
+          edge_type_class.define_method :graphql_name do
+            edge_type_class_name
           end
-
-          # build the sideload type with new edge class applied
-          klass = Class.new(sideload_type)
-          klass.edge_type_class(edge_class)
-          klass
+          edge_type_class.graphql_name(edge_type_class_name)
+          edge_type_class
         end
       end
     end

data/lib/graphiti_gql/schema/resource_type.rb

@@ -34,14 +34,19 @@ module GraphitiGql
 
       private
 
-      def process_polymorphic_parent(type)
+      def process_polymorphic_parent(interface_type)
+        registry_name = registry.key_for(@resource, interface: false)
+        type = Class.new(Schema.base_object)
+        type.graphql_name(registry_name)
+        type.implements(interface_type)
+
         # Define the actual class that implements the interface
         registry.set(@resource, type, interface: false)
         @resource.children.each do |child|
           if (registered = registry.get(child))
-            registered[:type].implements(type)
+            registered[:type].implements(interface_type)
           else
-            self.class.new(child, implements: type).build
+            self.class.new(child, implements: interface_type).build
           end
         end
       end

data/lib/graphiti_gql/spec_helper.rb

@@ -2,6 +2,21 @@ module GraphitiGql
   module SpecHelper
     extend ActiveSupport::Concern
 
+    module ScopeTrackable
+      def self.prepended(klass)
+        klass.class_eval do
+          class << self
+            attr_accessor :resolved_scope
+          end
+        end
+      end
+
+      def resolve(scope)
+        self.class.resolved_scope = scope
+        super
+      end
+    end
+
     included do
       extend Forwardable
       def_delegators :result,
@@ -9,29 +24,37 @@ module GraphitiGql
         :errors,
         :error_messages,
         :nodes,
+        :node,
         :stats
 
+      Graphiti::Resource.send(:prepend, ScopeTrackable)
+
       if defined?(RSpec)
-        let(:params) do
-          fields = []
-          resource.attributes.each_pair do |name, config|
-            (fields << name) if config[:readable]
-          end
-          { fields: fields }
-        end
+        let(:params) { {} }
         let(:resource) { described_class }
         let(:ctx) { {} }
+        let(:only_fields) { [] }
+        let(:except_fields) { [] }
 
         def self.only_fields(*fields)
-          before do
-            fields.each { |f| params[:fields].select! { |p| p == f } }
-          end
+          let(:only_fields) { fields }
         end
 
         def self.except_fields(*fields)
-          before do
-            fields.each { |f| params[:fields].reject! { |p| p == f } }
+          let(:except_fields) { fields }
+        end
+
+        let(:fields) do
+          fields = []
+          resource.attributes.each_pair do |name, config|
+            (fields << name) if config[:readable]
+          end
+          if respond_to?(:only_fields) && only_fields.present?
+            fields.select! { |f| only_fields.include?(f) }
+          elsif respond_to?(:except_fields) && except_fields.present?
+            fields.reject! { |f| except_fields.include?(f) }
           end
+          fields
         end
       end
     end
@@ -44,9 +67,13 @@ module GraphitiGql
       end
     end
 
+    def proxy
+      q = defined?(query) ? query : nil
+      resource.gql(params.merge(fields: fields), ctx, q)
+    end
+
     def run
       lambda do
-        proxy = resource.gql(params, ctx)
         proxy.to_h
         proxy
       end

data/lib/graphiti_gql/version.rb

@@ -1,3 +1,3 @@
 module GraphitiGql
-  VERSION = "0.2.4"
+  VERSION = "0.2.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti_gql
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.7
 platform: ruby
 authors:
 - Lee Richmond
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-30 00:00:00.000000000 Z
+date: 2022-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -115,6 +115,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/probots.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"