graphiti_gql 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9a1b76315488d9389a214fc640f6029d9e1a05a08182ebbdb9ed7958565e4aa
-  data.tar.gz: e4d6952a6929bf8310a99ba5b2d40e3821fe8bad51e89b3012c041fed9f1c47a
+  metadata.gz: a0558a0d0edaf2e03b09fe28ce603afb10eb0cbd02e8aa56be43cfd1044bebab
+  data.tar.gz: 69660d61a4191bd6428a2ad33d2f9e3e6a4227c31d4be636a6b886af543f35f3
 SHA512:
-  metadata.gz: 30cb9c3f67aa059d0e68845fc64aee6313d9f0d14d36e19024357c619ca15e176d4178ae2836055c22b407a53187038b21b8447007e37fbed04ab70330c12ff4
-  data.tar.gz: 6ece60976b6d36294e9ef01e8521efdf26d9637b28c6fcfec833e3f2a81d493eece073137071e3373f2ac948c786c18e79734904b62e369a1cc0c0353860d71d
+  metadata.gz: 892b44992e36645282bd7003218067d248e04ac6f440feaac137afa1449f9b01017d7bcb577bbaf3bd8dc7f1c808b7f9b6eaf6e0c4474b4f1d6910dabb49ad3e
+  data.tar.gz: 3d29b975b6748e292e4420707c2f8e4825a8e743c197f70126863c230a22ad75f0efece663a2400704716d2c7621d8cdd90732185ee7540c317c23708004a4d0

data/lib/graphiti_gql/active_resource.rb

@@ -1,17 +1,24 @@
+# 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) }
               else
-                hash[key] = Node.new(sideload.resource.class, value)
+                hash[key] = Node.new(value, sideload.resource.class)
               end
             end
           end
@@ -19,6 +26,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 +45,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 +63,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,7 +110,10 @@ 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?
@@ -118,6 +146,7 @@ module GraphitiGql
                 node {|
 
         fields.each do |name|
+          next if name.is_a?(Hash)
           q << %|
                   #{name.to_s.camelize(:lower)}|
         end
@@ -129,17 +158,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 +248,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

@@ -24,6 +24,7 @@ module GraphitiGql
         :errors,
         :error_messages,
         :nodes,
+        :node,
         :stats
 
       Graphiti::Resource.send(:prepend, ScopeTrackable)
@@ -42,20 +43,20 @@ module GraphitiGql
         def self.except_fields(*fields)
           let(:except_fields) { fields }
         end
-      end
-    end
 
-    def fields
-      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) }
+        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
-      fields
     end
 
     def gql_datetime(timestamp, precise = false)
@@ -67,11 +68,8 @@ module GraphitiGql
     end
 
     def proxy
-      resource.gql(params.merge(fields: fields), ctx)
-    end
-
-    def query
-      proxy.query
+      q = defined?(query) ? query : nil
+      resource.gql(params.merge(fields: fields), ctx, q)
     end
 
     def run

data/lib/graphiti_gql/version.rb

@@ -1,3 +1,3 @@
 module GraphitiGql
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti_gql
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Lee Richmond
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-30 00:00:00.000000000 Z
+date: 2022-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql