graphiti_gql 0.2.5 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9a1b76315488d9389a214fc640f6029d9e1a05a08182ebbdb9ed7958565e4aa
-  data.tar.gz: e4d6952a6929bf8310a99ba5b2d40e3821fe8bad51e89b3012c041fed9f1c47a
+  metadata.gz: c8711fac905c21ac485bec3ead197d2c5a8e2135eb5fcf1ff4156fec2a34d3ec
+  data.tar.gz: 82a643591b6f630d78d67e480cf915b8dbf1c0531fa0c817f204a9ae405d237c
 SHA512:
-  metadata.gz: 30cb9c3f67aa059d0e68845fc64aee6313d9f0d14d36e19024357c619ca15e176d4178ae2836055c22b407a53187038b21b8447007e37fbed04ab70330c12ff4
-  data.tar.gz: 6ece60976b6d36294e9ef01e8521efdf26d9637b28c6fcfec833e3f2a81d493eece073137071e3373f2ac948c786c18e79734904b62e369a1cc0c0353860d71d
+  metadata.gz: 6a6935dda01d0d68bacfc8c49252469322e93c96613a852f092dc76aa80cc44545b7e3c3d478fd5da28d6039c1a33940c9164f8bb1aad0b8018b1d2a5c92de72
+  data.tar.gz: fd9004e64db1c3dc39321e4eb2df56e5a7bf37a221c5323b062ddce182446ea1a4285649f61fdbb8508ac0b1a654c3311a7429bdc535f2589866b053c9d0617e

data/.github/probots.yml

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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphiti_gql (0.2.2)
+    graphiti_gql (0.2.7)
       graphiti (~> 1.3.9)
       graphql (~> 2.0)
       graphql-batch (~> 0.5)

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,42 @@ 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
+      return unless respond_to?(:belongs_to_many_filter) # activerecord
+      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

@@ -4,11 +4,8 @@ module GraphitiGql
       class ToMany
         def initialize(sideload, sideload_type)
           @sideload = sideload
-          @sideload_type = if customized_edge?
-              build_customized_edge_type(sideload_type)
-            else
-              sideload_type
-            end
+          @sideload_type = sideload_type
+          @connection_type = find_or_build_connection
         end
 
         def apply(type)
@@ -18,7 +15,7 @@ module GraphitiGql
             extras: [:lookahead]
           }
           opts[:extensions] = [RelayConnectionExtension] unless has_one?
-          field_type = has_one? ? @sideload_type : @sideload_type.connection_type
+          field_type = has_one? ? @sideload_type : @connection_type
           field = type.field @sideload.name,
             field_type,
             **opts
@@ -41,25 +38,39 @@ module GraphitiGql
           @sideload.type == :many_to_many && @sideload.class.edge_resource
         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)
+        def find_or_build_connection
+          if customized_edge?
+            prior = @sideload_type.connection_type
+            klass = Class.new(prior)
+            registered_parent = Schema.registry.get(@sideload.parent_resource.class)
+            parent_name = registered_parent[:type].graphql_name
+            name = "#{parent_name}To#{@sideload_type.graphql_name}Connection"
+            klass.graphql_name(name)
+            edge_type_class = build_edge_type_class(@sideload_type)
+            edge_type_class.node_type(prior.node_type)
+            klass.edge_type(edge_type_class)
+            klass
+          else
+            @sideload_type.connection_type
+          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/list_arguments.rb

@@ -23,12 +23,15 @@ module GraphitiGql
         Registry.instance
       end
 
+      # TODO - when no sorts schema error, when no filters schema error
       def define_filters(field)
         filter_type = generate_filter_type(field)
         required = @resource.filters.any? { |name, config|
           value = !!config[:required]
           if @sideload
-            value && @sideload.foreign_key != name
+            fk = @sideload.foreign_key
+            fk = fk.values.first if fk.is_a?(Hash)
+            value && fk != name
           else
             value
           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.8"
 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.8
 platform: ruby
 authors:
 - Lee Richmond
-autorequire: 
+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
@@ -108,13 +108,14 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '7.0'
-description: 
+description:
 email:
 - richmolj@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/probots.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -169,7 +170,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://www.graphiti.dev
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -184,8 +185,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: GraphQL support for Graphiti
 test_files: []