graphiform 0.2.8 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 432786d8d7975e7f6e64f28d1bc59d0755ce92235a20316464443a919269ae0c
-  data.tar.gz: cd9e5a854f67606b057fb6e98d6a5b43958aa8d6434d8178e6bb85b568925b5e
+  metadata.gz: 68647a1e2a4781554b98f3e34e4b8d517bdee49c76459aa8445dffb13dd59f07
+  data.tar.gz: b66dcc28e233bf23a4468a1af531d1c650c50bf3d3054687e43831ee6fd3826f
 SHA512:
-  metadata.gz: 5ab126d3a8225ac6142b1e6088939d8e30dea963b9b1413ada93261e79a9324153e6307764fe11c7ff76180015ce359bee435c33d0ee950b213713bd71e986e6
-  data.tar.gz: 60e32edb27e043e3440d1b5c97128a7e7873a1df2df60386c86253653b7842b85f6f6300bb3b5b1ded0d02822db9af66f618ecd110b0fa22c13a43fb96f83b0e
+  metadata.gz: 9d87c2c3723f8e643a3370bce93a86231466aa6f8d90ef264b308942cc6b7d832e1c4db4e9ab3a503d6f13804f3beedaef70106fd253c7fb67f9ad4863af01b4
+  data.tar.gz: 6f4c3e3784b7c70aea0044fff3bda3dd9c79780e5835ee2ea2593025be264da83798a6379ea0f9acbbe807e08fb237946f7e04910c746f17a480ad083247bc2b

data/lib/graphiform.rb

@@ -19,4 +19,12 @@ module Graphiform
       include Graphiform::Fields
     end
   end
+
+  def self.configuration
+    @configuration ||= {}
+  end
+
+  def self.configure
+    yield(configuration)
+  end
 end

data/lib/graphiform/association_source.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Graphiform
+  class AssociationSource < GraphQL::Dataloader::Source
+    def initialize(model, attribute, **options)
+      super()
+
+      @model = model
+      @attribute = attribute
+      @options = options
+    end
+
+    def fetch(values)
+      normalized_values = normalize_values(values)
+      records = query(normalized_values.uniq).to_a
+      results(normalized_values, records)
+    end
+
+    def query(values)
+      query = @model.where(@attribute => values)
+
+      query = query.includes(@options[:includes]) if @options[:includes].present? && query.respond_to?(:includes)
+      query = query.apply_filters(@options[:where].to_h) if @options[:where].present? && query.respond_to?(:apply_filters)
+      query = query.apply_sorts(@options[:sort].to_h) if @options[:sort].present? && query.respond_to?(:apply_sorts)
+
+      query
+    end
+
+    def normalize_value(value)
+      value = value.downcase if !@options[:case_sensitive] && value.is_a?(String)
+
+      value
+    end
+
+    def normalize_values(values)
+      type_for_attribute = @model.type_for_attribute(@attribute) if @model.respond_to?(:type_for_attribute)
+      values.map do |value|
+        value = type_for_attribute.cast(value) if type_for_attribute.present?
+        normalize_value(value)
+      end
+    end
+
+    def results(values, records)
+      record_attributes = records.map { |record| normalize_value(record[@attribute]) }
+      values.map do |value|
+        if @options[:multi]
+          indexes = record_attributes.each_index.select { |index| record_attributes[index] == value }
+          indexes.map { |index| index && records[index] }
+        else
+          index = record_attributes.index(value)
+          index && records[index]
+        end
+      end
+    end
+  end
+end

data/lib/graphiform/core.rb

@@ -3,6 +3,7 @@
 require 'active_support/concern'
 
 require 'graphiform/helpers'
+require 'graphiform/association_source'
 
 module Graphiform
   module Core
@@ -37,6 +38,7 @@ module Graphiform
           end
           @filter.class_eval do
             argument 'OR', [self], required: false
+            argument 'AND', [self], required: false
           end
         end
 
@@ -52,6 +54,15 @@ module Graphiform
         end
       end
 
+      def graphql_grouping
+        local_demodulized_name = demodulized_name
+        Helpers.get_const_or_create(local_demodulized_name, ::Inputs::Groupings) do
+          Class.new(::Inputs::Groupings::BaseGrouping) do
+            graphql_name "#{local_demodulized_name}Grouping"
+          end
+        end
+      end
+
       def graphql_edge
         Helpers.get_const_or_create("#{demodulized_name}Edge", ::Types) do
           node_type = graphql_type
@@ -99,9 +110,10 @@ module Graphiform
                 @value
               end
 
-              def apply_built_ins(where: nil, sort: nil, **)
+              def apply_built_ins(where: nil, sort: nil, group: nil, **)
                 @value = @value.apply_filters(where.to_h) if where.present? && @value.respond_to?(:apply_filters)
                 @value = @value.apply_sorts(sort.to_h) if sort.present? && @value.respond_to?(:apply_sorts)
+                @value = @value.apply_groupings(group.to_h) if group.present? && @value.respond_to?(:apply_groupings)
 
                 @value
               end
@@ -115,6 +127,7 @@ module Graphiform
 
           local_graphql_filter = graphql_filter
           local_graphql_sort = graphql_sort
+          local_graphql_grouping = graphql_grouping
 
           model = self
           @base_resolver.class_eval do
@@ -126,6 +139,7 @@ module Graphiform
 
             argument :where, local_graphql_filter, required: false
             argument :sort, local_graphql_sort, required: false unless local_graphql_sort.arguments.empty?
+            argument :group, local_graphql_grouping, required: false unless local_graphql_grouping.arguments.empty?
           end
         end
 
@@ -141,7 +155,7 @@ module Graphiform
             def base_resolve(**args)
               @value = model.all
               apply_built_ins(**args)
-              @value.first
+              @value.take
             end
           end
         end
@@ -161,18 +175,61 @@ module Graphiform
         end
       end
 
-      def graphql_create_resolver(method_name, resolver_type = graphql_type, read_prepare: nil, read_resolve: nil, null: true, **)
+      def graphql_create_resolver(method_name, resolver_type = graphql_type, read_prepare: nil, read_resolve: nil, null: true, skip_dataloader: false, case_sensitive: Graphiform.configuration[:case_sensitive], **)
         Class.new(graphql_base_resolver) do
           type resolver_type, null: null
 
           define_method :base_resolve do |**args|
             @value = object
 
-            @value = instance_exec(@value, context, &read_resolve) if read_resolve
-            @value = @value.public_send(method_name) if !read_resolve && @value.respond_to?(method_name)
-            @value = instance_exec(@value, context, &read_prepare) if read_prepare
+            association_def = @value.association(method_name)&.reflection
+            join_keys = association_def&.join_keys
+
+            skip_dataloader ||=
+              !association_def ||
+              !Helpers.dataloader_support?(dataloader, association_def, join_keys.foreign_key) ||
+              read_resolve ||
+              read_prepare ||
+              args[:group]
+
+            if skip_dataloader
+              @value = instance_exec(@value, context, &read_resolve) if read_resolve
+              @value = @value.public_send(method_name) if !read_resolve && @value.respond_to?(method_name)
+              @value = instance_exec(@value, context, &read_prepare) if read_prepare
+
+              apply_built_ins(**args)
+            else
+              dataloader
+                .with(
+                  AssociationSource,
+                  association_def.klass,
+                  join_keys.key,
+                  where: args[:where],
+                  sort: args[:sort],
+                  multi: true,
+                  case_sensitive: case_sensitive,
+                )
+                .load(
+                  @value.public_send(join_keys.foreign_key)
+                )
+            end
+          end
+        end
+      end
+
+      def graphql_create_association_resolver(association_def, resolver_type, null: true, skip_dataloader: false, case_sensitive: nil, **)
+        Class.new(::Resolvers::BaseResolver) do
+          type resolver_type, null: null
+
+          define_method :resolve do |*|
+            join_keys = association_def.join_keys
+
+            skip_dataloader ||= !Helpers.dataloader_support?(dataloader, association_def, join_keys.foreign_key)
+
+            return object.public_send(association_def.name) if skip_dataloader
 
-            apply_built_ins(**args)
+            value = object.public_send(join_keys.foreign_key)
+            dataloader.with(AssociationSource, association_def.klass, join_keys.key, case_sensitive: case_sensitive).load(value)
           end
         end
       end

data/lib/graphiform/fields.rb

@@ -12,15 +12,17 @@ module Graphiform
         as: nil,
         **options
       )
-        column_def = column(as || name)
-        association_def = association(as || name)
+        identifier = as || name
+        column_def = column(identifier)
+        association_def = association(identifier)
 
         graphql_add_column_field(name, column_def, as: as, **options) if column_def.present?
         graphql_add_association_field(name, association_def, as: as, **options) if association_def.present?
         graphql_add_method_field(name, as: as, **options) unless column_def.present? || association_def.present?
 
-        graphql_add_scopes_to_filter(name, as || name)
-        graphql_field_to_sort(name, as || name)
+        graphql_add_scopes_to_filter(name, identifier)
+        graphql_field_to_sort(name, identifier)
+        graphql_field_to_grouping(name, identifier)
       end
 
       def graphql_writable_field(
@@ -120,9 +122,11 @@ module Graphiform
           type = association_def.klass.graphql_filter
         end
 
-        non_sort_by_scopes = added_scopes.select { |scope_def| !scope_def.options || scope_def.options[:type] != :sort }
+        filter_only_by_scopes = added_scopes.select do |scope_def|
+          !scope_def.options || scope_def.options[:type].blank? || scope_def.options[:type] == :enum
+        end
 
-        non_sort_by_scopes.each do |added_scope|
+        filter_only_by_scopes.each do |added_scope|
           scope_argument_type = type || added_scope.options[:argument_type]
           if added_scope.options[:type] == :enum
             enum = graphql_create_enum(name)
@@ -175,6 +179,28 @@ module Graphiform
         end
       end
 
+      def graphql_field_to_grouping(name, as)
+        column_def = column(as || name)
+        association_def = association(as || name)
+
+        type = GraphQL::Types::Boolean if column_def.present?
+        type = association_def.klass.graphql_grouping if Helpers.association_arguments_valid?(association_def, :graphql_grouping)
+
+        return if type.blank?
+
+        local_graphql_grouping = graphql_grouping
+
+        local_graphql_grouping.class_eval do
+          argument(
+            name,
+            type,
+            required: false,
+            as: as,
+            method_access: false
+          )
+        end
+      end
+
       def graphql_add_field_to_type(
         field_name,
         type,
@@ -241,6 +267,8 @@ module Graphiform
         include_connection: true,
         read_prepare: nil,
         read_resolve: nil,
+        skip_dataloader: false,
+        case_sensitive: Graphiform.configuration[:case_sensitive],
         **options
       )
         unless association_def.klass.respond_to?(:graphql_type)
@@ -266,7 +294,9 @@ module Graphiform
               klass.graphql_connection,
               read_prepare: read_prepare,
               read_resolve: read_resolve,
-              null: false
+              null: false,
+              skip_dataloader: true,
+              case_sensitive: case_sensitive
             ),
             false,
             **options
@@ -281,10 +311,17 @@ module Graphiform
                 [klass.graphql_type],
                 read_prepare: read_prepare,
                 read_resolve: read_resolve,
-                null: false
+                null: false,
+                skip_dataloader: skip_dataloader,
+                case_sensitive: case_sensitive
               )
             else
-              klass.graphql_type
+              klass.graphql_create_association_resolver(
+                association_def,
+                klass.graphql_type,
+                skip_dataloader: skip_dataloader,
+                case_sensitive: case_sensitive
+              )
             end
           )
 

data/lib/graphiform/helpers.rb

@@ -5,7 +5,7 @@ module Graphiform
     def self.logger
       return Rails.logger if Rails.logger.present?
 
-      @logger ||= Logger.new(STDOUT)
+      @logger ||= Logger.new($stdout)
       @logger
     end
 
@@ -32,6 +32,8 @@ module Graphiform
         GraphQL::Types::Float
       when :boolean
         GraphQL::Types::Boolean
+      when :json, :jsonb
+        GraphQL::Types::JSON
       else
         active_record_type
       end
@@ -70,5 +72,15 @@ module Graphiform
         association_def.klass.send(method).respond_to?(:arguments) &&
         !association_def.klass.send(method).arguments.empty?
     end
+
+    def self.dataloader_support?(dataloader, association_def, keys)
+      (
+        association_def.present? &&
+        !association_def.polymorphic? &&
+        !association_def.through_reflection? &&
+        !keys.is_a?(Array) &&
+        !dataloader.is_a?(GraphQL::Dataloader::NullDataloader)
+      )
+    end
   end
 end

data/lib/graphiform/skeleton.rb

@@ -45,6 +45,14 @@ module Graphiform
       Class.new(::GraphQL::Schema::InputObject)
     end
 
+    Helpers.get_const_or_create('Groupings', ::Inputs) do
+      Module.new
+    end
+
+    Helpers.get_const_or_create('BaseGrouping', ::Inputs::Groupings) do
+      Class.new(::GraphQL::Schema::InputObject)
+    end
+
     # Resolvers
     Helpers.get_const_or_create('Resolvers') do
       Module.new

data/lib/graphiform/version.rb

@@ -1,3 +1,3 @@
 module Graphiform
-  VERSION = '0.2.8'.freeze
+  VERSION = '0.2.12'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiform
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.12
 platform: ruby
 authors:
 - jayce.pulsipher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-01 00:00:00.000000000 Z
+date: 2021-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.6
+        version: 0.2.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.6
+        version: 0.2.9
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -120,6 +120,7 @@ files:
 - Rakefile
 - lib/graphiform.rb
 - lib/graphiform/active_record_helpers.rb
+- lib/graphiform/association_source.rb
 - lib/graphiform/core.rb
 - lib/graphiform/fields.rb
 - lib/graphiform/helpers.rb