graphiform 0.4.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fe59e03d0206ec1a77e8c8528e5950fbc31129bba16f8a3a7fe8019cf7f6961
-  data.tar.gz: cb4292984369688038ba1b6b4c60900c5bca472be376106442e2425f5b035e44
+  metadata.gz: 19e01a0f9ea8fdc89179e49ae39577309e7c0db74ba008322c67aa0ca9f00a64
+  data.tar.gz: 5aeb7bf5df444d7bb20609dbf3bfb9653245418361c6c1a91d8186d9bad8b205
 SHA512:
-  metadata.gz: 1ec2b1bc0fc661c2f1353b62ccf8d689c8919722a4364a5239d01e7fa35760ee17a11eb9f9a2cdda197a50cf1be3fb58559ac7d684f8a5f0d1a07bd76a3b1646
-  data.tar.gz: 057d78c54bbe196ba1e6fb37dfbc43c2334d58683def817f2352e61361943b5843aaed46f40e2f774f28d34c33b8db56ca8786ae78550304bf5883c6c78a055e
+  metadata.gz: 5e128eb6bedb679a8895ad62c5f8bcfefa683e8021f93d64362f4935e6ed22556f1968c97267714d4bdeb6d21020ca76168391b3f5aea4196d009dbf00e6ec15
+  data.tar.gz: 35e63ac4f74add2bb905d01d38d6b377dadd5719d0ca1d80153ae4ef65a0149882c0c703d69df36e24a62b4e39f23662050c7799f549bb2f70886cdadaf7339a

data/lib/graphiform/core.rb

@@ -3,7 +3,8 @@
 require 'active_support/concern'
 
 require 'graphiform/helpers'
-require 'graphiform/association_source'
+require 'graphiform/preloader_source'
+require 'graphiform/scope_composer'
 
 module Graphiform
   module Core
@@ -43,49 +44,87 @@ module Graphiform
       def graphql_filter
         unless defined? @filter
           local_demodulized_name = demodulized_name
+          model_class = self
           @filter = Helpers.get_const_or_create(local_demodulized_name, ::Inputs::Filters) do
             Class.new(::Inputs::Filters::BaseFilter) do
               graphql_name "#{local_demodulized_name}Filter"
+
+              define_singleton_method(:arguments) do |context = nil|
+                model_class.send(:flush_pending_filters!)
+                super(context)
+              end
+
+              define_singleton_method(:own_arguments) do
+                model_class.send(:flush_pending_filters!)
+                super()
+              end
             end
           end
           @filter.class_eval do
             argument_class Graphiform.configuration[:argument_class] if Graphiform.configuration[:argument_class].present?
-            argument 'OR', [self], required: false
-            argument 'AND', [self], required: false
           end
+          Helpers.add_unless_exists(@filter, 'OR')  { @filter.class_eval { argument 'OR',  [self], required: false } }
+          Helpers.add_unless_exists(@filter, 'AND') { @filter.class_eval { argument 'AND', [self], required: false } }
         end
 
+        flush_pending_filters!
         @filter
       end
 
       def graphql_sort
         unless defined? @graphql_sort
           local_demodulized_name = demodulized_name
+          model_class = self
           @graphql_sort = Helpers.get_const_or_create(local_demodulized_name, ::Inputs::Sorts) do
             Class.new(::Inputs::Sorts::BaseSort) do
               graphql_name "#{local_demodulized_name}Sort"
+
+              define_singleton_method(:arguments) do |context = nil|
+                model_class.send(:flush_pending_sorts!)
+                super(context)
+              end
+
+              define_singleton_method(:own_arguments) do
+                model_class.send(:flush_pending_sorts!)
+                super()
+              end
             end
           end
           @graphql_sort.class_eval do
             argument_class Graphiform.configuration[:argument_class] if Graphiform.configuration[:argument_class].present?
           end
         end
+
+        flush_pending_sorts!
         @graphql_sort
       end
 
       def graphql_grouping
         unless defined? @graphql_grouping
           local_demodulized_name = demodulized_name
+          model_class = self
           @graphql_grouping = Helpers.get_const_or_create(local_demodulized_name, ::Inputs::Groupings) do
             Class.new(::Inputs::Groupings::BaseGrouping) do
               graphql_name "#{local_demodulized_name}Grouping"
               argument_class Graphiform.configuration[:argument_class] if Graphiform.configuration[:argument_class].present?
+
+              define_singleton_method(:arguments) do |context = nil|
+                model_class.send(:flush_pending_groupings!)
+                super(context)
+              end
+
+              define_singleton_method(:own_arguments) do
+                model_class.send(:flush_pending_groupings!)
+                super()
+              end
             end
           end
           @graphql_grouping.class_eval do
             argument_class Graphiform.configuration[:argument_class] if Graphiform.configuration[:argument_class].present?
           end
         end
+
+        flush_pending_groupings!
         @graphql_grouping
       end
 
@@ -137,11 +176,7 @@ module Graphiform
               end
 
               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
+                @value = Graphiform::ScopeComposer.compose(@value, where: where, sort: sort, group: group)
               end
 
               # Default resolver - meant to be overridden
@@ -164,8 +199,8 @@ module Graphiform
             end
 
             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?
+            argument :sort, local_graphql_sort, required: false unless local_graphql_sort.own_arguments.empty?
+            argument :group, local_graphql_grouping, required: false unless local_graphql_grouping.own_arguments.empty?
           end
         end
 
@@ -201,7 +236,7 @@ module Graphiform
         end
       end
 
-      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], **)
+      def graphql_create_resolver(method_name, resolver_type = graphql_type, read_prepare: nil, read_resolve: nil, null: true, skip_dataloader: false, **)
         Class.new(graphql_base_resolver) do
           type resolver_type, null: null
 
@@ -212,7 +247,7 @@ module Graphiform
 
             skip_dataloader ||=
               !association_def ||
-              !Helpers.dataloader_support?(dataloader, association_def, association_def.join_foreign_key) ||
+              !Helpers.dataloader_support?(dataloader, association_def) ||
               read_resolve ||
               read_prepare ||
               args[:group]
@@ -226,35 +261,33 @@ module Graphiform
             else
               dataloader
                 .with(
-                  AssociationSource,
-                  association_def.klass,
-                  association_def.join_primary_key,
+                  Graphiform::PreloaderSource,
+                  association_def.name,
+                  klass: association_def.klass,
                   scope: association_def.scope,
                   where: args[:where],
                   sort: args[:sort],
-                  multi: true,
-                  case_sensitive: case_sensitive,
-                )
-                .load(
-                  @value.public_send(association_def.join_foreign_key)
                 )
+                .load(@value)
             end
           end
         end
       end
 
-      def graphql_create_association_resolver(association_def, resolver_type, null: true, skip_dataloader: false, case_sensitive: nil, **)
+      def graphql_create_association_resolver(association_def, resolver_type, null: true, skip_dataloader: false, **)
         Class.new(::Resolvers::BaseResolver) do
           type resolver_type, null: null
 
           define_method :resolve do |*|
-
-            skip_dataloader ||= !Helpers.dataloader_support?(dataloader, association_def, association_def.join_foreign_key)
-
+            skip_dataloader ||= !Helpers.dataloader_support?(dataloader, association_def)
             return object.public_send(association_def.name) if skip_dataloader
 
-            value = object.public_send(association_def.join_foreign_key)
-            dataloader.with(AssociationSource, association_def.klass, association_def.join_primary_key, scope: association_def.scope, case_sensitive: case_sensitive).load(value)
+            dataloader.with(
+              Graphiform::PreloaderSource,
+              association_def.name,
+              klass: association_def.klass,
+              scope: association_def.scope
+            ).load(object)
           end
         end
       end
@@ -273,6 +306,69 @@ module Graphiform
         end
       end
 
+      # --- Pending queues for lazy filter/sort/grouping wiring -------------
+      #
+      # graphql_readable_field pushes entries here instead of immediately
+      # invoking add_scope_def_to_filter / graphql_field_to_sort /
+      # graphql_field_to_grouping. The queues are drained the first time
+      # the corresponding builder is accessed.
+
+      def graphiform_pending_filters
+        @graphiform_pending_filters ||= []
+      end
+
+      def graphiform_pending_sorts
+        @graphiform_pending_sorts ||= []
+      end
+
+      def graphiform_pending_groupings
+        @graphiform_pending_groupings ||= []
+      end
+
+      def graphiform_pending_mutex
+        @graphiform_pending_mutex ||= Mutex.new
+      end
+
+      def flush_pending_filters!
+        return if @graphiform_pending_filters.nil? || @graphiform_pending_filters.empty?
+
+        pending = graphiform_pending_mutex.synchronize do
+          drained = @graphiform_pending_filters
+          @graphiform_pending_filters = []
+          drained
+        end
+        pending.each do |(name, identifier, options)|
+          graphql_add_scopes_to_filter(name, identifier, **options)
+        end
+      end
+
+      def flush_pending_sorts!
+        return if @graphiform_pending_sorts.nil? || @graphiform_pending_sorts.empty?
+
+        pending = graphiform_pending_mutex.synchronize do
+          drained = @graphiform_pending_sorts
+          @graphiform_pending_sorts = []
+          drained
+        end
+        pending.each do |(name, identifier, options)|
+          graphql_field_to_sort(name, identifier, **options)
+        end
+      end
+
+      def flush_pending_groupings!
+        return if @graphiform_pending_groupings.nil? || @graphiform_pending_groupings.empty?
+
+        pending = graphiform_pending_mutex.synchronize do
+          drained = @graphiform_pending_groupings
+          @graphiform_pending_groupings = []
+          drained
+        end
+        pending.each do |(name, identifier, options)|
+          graphql_field_to_grouping(name, identifier, **options)
+        end
+      end
+      # ----------------------------------------------------------------------
+
       private
 
       def demodulized_name
@@ -280,4 +376,4 @@ module Graphiform
       end
     end
   end
-end
+end

data/lib/graphiform/fields.rb

@@ -22,9 +22,11 @@ module Graphiform
         graphql_add_association_field(name, association_def, read_prepare: read_prepare, null: null, as: as, **options) if association_def.present?
         graphql_add_method_field(name, read_prepare: read_prepare, null: null, as: as, **options) unless column_def.present? || association_def.present?
 
-        graphql_add_scopes_to_filter(name, identifier, **options)
-        graphql_field_to_sort(name, identifier, **options)
-        graphql_field_to_grouping(name, identifier, **options)
+        # Defer filter/sort/grouping wiring — flushed on first access to
+        # graphql_filter / graphql_sort / graphql_grouping.
+        graphiform_pending_filters   << [name, identifier, options]
+        graphiform_pending_sorts     << [name, identifier, options]
+        graphiform_pending_groupings << [name, identifier, options]
       end
 
       def graphql_writable_field(
@@ -34,7 +36,6 @@ module Graphiform
         write_prepare: nil,
         prepare: nil,
         description: nil,
-        default_value: ::GraphQL::Schema::Argument::NO_DEFAULT,
         as: nil,
         **args
       )
@@ -49,19 +50,19 @@ module Graphiform
 
         prepare = write_prepare || prepare
 
-        graphql_input.class_eval do
-          argument(
-            argument_name,
-            argument_type,
-            required: required,
-            prepare: prepare,
-            description: description,
-            default_value: default_value,
-            as: as,
-            method_access: false,
-            **args
-          )
-        end unless graphql_input.arguments.keys.any? { |key| Helpers.equal_graphql_names?(key, argument_name) }
+        Helpers.add_unless_exists(graphql_input, argument_name) do
+          graphql_input.class_eval do
+            argument(
+              argument_name,
+              argument_type,
+              required: required,
+              prepare: prepare,
+              description: description,
+              as: as,
+              **args
+            )
+          end
+        end
       end
 
       def graphql_field(
@@ -152,16 +153,17 @@ module Graphiform
         argument_name = "#{argument_prefix}#{argument_attribute}#{argument_suffix}".underscore
         scope_name = scope_def.name
 
-        graphql_filter.class_eval do
-          argument(
-            argument_name,
-            argument_type,
-            required: false,
-            as: scope_name,
-            method_access: false,
-            **options
-          )
-        end unless graphql_filter.arguments.keys.any? { |key| Helpers.equal_graphql_names?(key, argument_name) }
+        Helpers.add_unless_exists(graphql_filter, argument_name) do
+          graphql_filter.class_eval do
+            argument(
+              argument_name,
+              argument_type,
+              required: false,
+              as: scope_name,
+              **options
+            )
+          end
+        end
       end
 
       def graphql_field_to_sort(name, as, **options)
@@ -175,16 +177,17 @@ module Graphiform
 
         local_graphql_sort = graphql_sort
 
-        local_graphql_sort.class_eval do
-          argument(
-            name,
-            type,
-            required: false,
-            as: as,
-            method_access: false,
-            **options
-          )
-        end unless local_graphql_sort.arguments.keys.any? { |key| Helpers.equal_graphql_names?(key, name) }
+        Helpers.add_unless_exists(local_graphql_sort, name) do
+          local_graphql_sort.class_eval do
+            argument(
+              name,
+              type,
+              required: false,
+              as: as,
+              **options
+            )
+          end
+        end
       end
 
       def graphql_field_to_grouping(name, as, **options)
@@ -198,16 +201,17 @@ module Graphiform
 
         local_graphql_grouping = graphql_grouping
 
-        local_graphql_grouping.class_eval do
-          argument(
-            name,
-            type,
-            required: false,
-            as: as,
-            method_access: false,
-            **options
-          )
-        end unless local_graphql_grouping.arguments.keys.any? { |key| Helpers.equal_graphql_names?(key, name) }
+        Helpers.add_unless_exists(local_graphql_grouping, name) do
+          local_graphql_grouping.class_eval do
+            argument(
+              name,
+              type,
+              required: false,
+              as: as,
+              **options
+            )
+          end
+        end
       end
 
       def graphql_add_field_to_type(
@@ -239,21 +243,23 @@ module Graphiform
           field_options[:null] = null
         end
 
-        graphql_type.class_eval do
-          added_field = field(field_name, **field_options, **options)
+        Helpers.add_unless_exists(graphql_type, field_name) do
+          graphql_type.class_eval do
+            added_field = field(field_name, **field_options, **options)
 
-          if read_prepare || read_resolve
-            define_method(
-              added_field.method_sym,
-              lambda do
-                value = read_resolve ? instance_exec(object, context, &read_resolve) : object.public_send(added_field.method_sym)
-                value = instance_exec(value, context, &read_prepare) if read_prepare
+            if read_prepare || read_resolve
+              define_method(
+                added_field.method_sym,
+                lambda do
+                  value = read_resolve ? instance_exec(object, context, &read_resolve) : object.public_send(added_field.method_sym)
+                  value = instance_exec(value, context, &read_prepare) if read_prepare
 
-                value
-              end
-            )
+                  value
+                end
+              )
+            end
           end
-        end unless graphql_type.fields.keys.any? { |key| Helpers.equal_graphql_names?(key, field_name) }
+        end
       end
 
       def graphql_add_column_field(field_name, column_def, type: nil, null: nil, as: nil, **options)
@@ -277,7 +283,6 @@ module Graphiform
         read_prepare: nil,
         read_resolve: nil,
         skip_dataloader: false,
-        case_sensitive: Graphiform.configuration[:case_sensitive],
         **options
       )
         unless association_def.klass.respond_to?(:graphql_type)
@@ -304,8 +309,7 @@ module Graphiform
               read_prepare: read_prepare,
               read_resolve: read_resolve,
               null: false,
-              skip_dataloader: true,
-              case_sensitive: case_sensitive
+              skip_dataloader: true
             ),
             false,
             **options
@@ -321,15 +325,13 @@ module Graphiform
                 read_prepare: read_prepare,
                 read_resolve: read_resolve,
                 null: false,
-                skip_dataloader: skip_dataloader,
-                case_sensitive: case_sensitive
+                skip_dataloader: skip_dataloader
               )
             else
               klass.graphql_create_association_resolver(
                 association_def,
                 klass.graphql_type,
-                skip_dataloader: skip_dataloader,
-                case_sensitive: case_sensitive
+                skip_dataloader: skip_dataloader
               )
             end
           )
@@ -354,4 +356,4 @@ module Graphiform
       end
     end
   end
-end
+end

data/lib/graphiform/helpers.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'set'
+require 'monitor'
+
 module Graphiform
   module Helpers
     def self.logger
@@ -9,6 +12,68 @@ module Graphiform
       @logger
     end
 
+    # --- Name normalization & per-class registries -------------------------
+    #
+    # Replaces the O(n) `arguments.keys.any? { equal_graphql_names?(...) }`
+    # scan (and its repeated string allocations) with an O(1) Set lookup.
+
+    NAME_NORMALIZE_CACHE = {}
+    NAME_NORMALIZE_MUTEX = Mutex.new
+
+    # Canonicalize a name the same way graphql-ruby presents it externally,
+    # so `:my_field`, `"my_field"`, `"myField"`, `"MyField"` all collide.
+    def self.normalize_graphql_name(name)
+      key = name.is_a?(Symbol) ? name : name.to_s
+      cached = NAME_NORMALIZE_CACHE[key]
+      return cached if cached
+
+      NAME_NORMALIZE_MUTEX.synchronize do
+        NAME_NORMALIZE_CACHE[key] ||= key.to_s.camelize(:lower).freeze
+      end
+    end
+
+    # Fetch (and lazily seed) the registered-names Set for a generated
+    # GraphQL class. Seeding from existing `arguments` / `fields` makes this
+    # safe even when classes are pre-populated (e.g. `OR`/`AND` on filters,
+    # or manual user-defined args).
+    def self.tracked_names(klass)
+      set = klass.instance_variable_get(:@graphiform_names)
+      return set if set
+
+      set = Set.new
+
+      if klass.respond_to?(:own_arguments)
+        own_args = klass.instance_variable_get(:@own_arguments) || {}
+        set.merge(own_args.each_key.map { |k| normalize_graphql_name(k) })
+      end
+
+      if klass.respond_to?(:fields)
+        own_fields = klass.instance_variable_get(:@own_fields) || {}
+        set.merge(own_fields.each_key.map { |k| normalize_graphql_name(k) })
+      end
+
+      klass.instance_variable_set(:@graphiform_names, set)
+    end
+
+    # Guard helper: yield (which should add the field/argument) only if the
+    # name isn't already present. Returns true when the block ran.
+    def self.add_unless_exists(klass, name)
+      normalized = normalize_graphql_name(name)
+      set = tracked_names(klass)
+      return false if set.include?(normalized)
+
+      mutex = (klass.instance_variable_get(:@graphiform_names_mutex) ||
+        klass.instance_variable_set(:@graphiform_names_mutex, Monitor.new))
+      mutex.synchronize do
+        return false if set.include?(normalized)
+
+        yield
+        set << normalized
+      end
+      true
+    end
+    # -----------------------------------------------------------------------
+
     def self.graphql_type(active_record_type)
       is_array = active_record_type.is_a? Array
       active_record_type = is_array ? active_record_type[0] : active_record_type
@@ -27,23 +92,22 @@ module Graphiform
         val.ancestors.include?(GraphQL::Schema::Resolver)
     end
 
+    CONST_LOCKS = {}
+    CONST_LOCKS_MUTEX = Mutex.new
+
     def self.get_const_or_create(const, mod = Object)
-      new_full_const_name = full_const_name("#{mod}::#{const}")
-      new_full_const_name.constantize
-      Object.const_get(new_full_const_name)
-    rescue NameError => e
-      unless full_const_name(e.missing_name) == new_full_const_name.to_s
-        logger.warn "Failed to load #{e.missing_name} when loading constant #{new_full_const_name}"
-        return Object.const_get(new_full_const_name)
-      end
+      return mod.const_get(const) if mod.const_defined?(const, false)
 
-      val = yield
-      mod.const_set(const, val)
-      val
-    end
+      key = [mod, const.to_s]
+      lock = CONST_LOCKS_MUTEX.synchronize { CONST_LOCKS[key] ||= Monitor.new }
+
+      lock.synchronize do
+        return mod.const_get(const) if mod.const_defined?(const, false)
 
-    def self.equal_graphql_names?(key, name)
-      key.downcase == name.to_s.camelize.downcase || key.downcase == name.to_s.downcase
+        val = yield
+        mod.const_set(const, val)
+        val
+      end
     end
 
     def self.full_const_name(name)
@@ -54,25 +118,21 @@ module Graphiform
     end
 
     def self.association_arguments_valid?(association_def, method)
-      association_def.present? &&
-        association_def.klass.respond_to?(method) &&
-        association_def.klass.send(method).respond_to?(:arguments) &&
-        !association_def.klass.send(method).arguments.empty?
+      return false unless association_def.present?
+      return false unless association_def.klass.respond_to?(method)
+
+      target = association_def.klass.send(method)
+      return false unless target.respond_to?(:arguments)
+
+      own_args = target.instance_variable_get(:@own_arguments) || {}
+      !own_args.empty?
     end
 
-    def self.dataloader_support?(dataloader, association_def, keys)
-      (
-        association_def.present? &&
+    def self.dataloader_support?(dataloader, association_def)
+      association_def.present? &&
         !association_def.polymorphic? &&
-        !association_def.through_reflection? &&
         !association_def.inverse_of&.polymorphic? &&
-        (
-          !association_def.scope ||
-          association_def.scope.arity.zero?
-        ) &&
-        !keys.is_a?(Array) &&
         !dataloader.is_a?(GraphQL::Dataloader::NullDataloader)
-      )
     end
   end
-end
+end

data/lib/graphiform/preloader_source.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require 'graphql'
+require 'graphql/dataloader'
+require 'graphql/dataloader/source'
+require 'graphql/dataloader/active_record_association_source'
+require 'graphiform/scope_composer'
+
+module Graphiform
+  # Loads ActiveRecord associations through the dataloader, with optional
+  # Scopiform-style `where`/`sort`/`includes`/`scope` composition applied to
+  # the relation handed to ActiveRecord::Associations::Preloader.
+  #
+  # Inherits batching semantics (including `scope.to_sql`-based batch keys),
+  # `assoc.loaded?` short-circuiting, polymorphic handling, and cross-source
+  # cache reuse from GraphQL::Dataloader::ActiveRecordAssociationSource.
+  #
+  # Usage:
+  #
+  #   dataloader.with(
+  #     Graphiform::PreloaderSource,
+  #     :posts,
+  #     klass: User.reflect_on_association(:posts).klass,
+  #     scope: association_reflection.scope,
+  #     where: args[:where],
+  #     sort:  args[:sort],
+  #   ).load(user_record)
+  class PreloaderSource < ::GraphQL::Dataloader::ActiveRecordAssociationSource
+    # @param association_name [Symbol] the association on the parent record(s)
+    # @param klass            [Class, nil] target model class used to build the
+    #   composed scope. Required when any of `scope`/`where`/`sort`/`includes`
+    #   is given; may be nil for bare preloads.
+    # @param scope    [Proc, nil]
+    # @param where    [Hash, nil]
+    # @param sort     [Hash, nil]
+    # @param includes [Symbol, Array, Hash, nil]
+    def initialize(association_name, klass: nil, scope: nil, where: nil, sort: nil, includes: nil)
+      effective_scope = build_scope(klass, scope: scope, where: where, sort: sort, includes: includes)
+      super(association_name, effective_scope)
+    end
+
+    # Mirror initialize's scope composition so the batch key (which upstream
+    # derives from the scope via `scope.to_sql`) is consistent across loads
+    # that should batch together.
+    def self.batch_key_for(association_name, klass: nil, scope: nil, where: nil, sort: nil, includes: nil)
+      effective_scope = build_scope(klass, scope: scope, where: where, sort: sort, includes: includes)
+      super(association_name, effective_scope)
+    end
+
+    def self.build_scope(klass, scope: nil, where: nil, sort: nil, includes: nil)
+      return nil unless klass
+      return nil unless ScopeComposer.customized?(scope: scope, where: where, sort: sort, includes: includes)
+
+      ScopeComposer.compose(klass.all, scope: scope, where: where, sort: sort, includes: includes)
+    end
+
+    # Instance-level helper kept for symmetry / overrideability.
+    def build_scope(klass, **kwargs)
+      self.class.build_scope(klass, **kwargs)
+    end
+  end
+end

data/lib/graphiform/scope_composer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Graphiform
+  # Builds an ActiveRecord relation by applying Graphiform/Scopiform-style
+  # customizations on top of a base relation.
+  #
+  # Used by both PreloaderSource (to compose the `scope:` handed to
+  # ActiveRecord::Associations::Preloader) and Core#apply_built_ins (to apply
+  # the same chain to top-level resolver relations).
+  module ScopeComposer
+    module_function
+
+    # @param relation [ActiveRecord::Relation] starting relation (e.g. `Model.all`)
+    # @param scope    [Proc, nil] optional scope block, `instance_exec`'d on the relation
+    # @param where    [Hash, nil] Scopiform filter hash, applied via `apply_filters`
+    # @param sort     [Hash, nil] Scopiform sort hash, applied via `apply_sorts`
+    # @param includes [Symbol, Array, Hash, nil] eager-load spec passed to `includes`
+    # @return [ActiveRecord::Relation]
+    def compose(relation, scope: nil, where: nil, sort: nil, group: nil, includes: nil)
+      relation = relation.merge(relation.instance_exec(&scope)) if scope.respond_to?(:call)
+      relation = relation.includes(includes)                    if includes.present? && relation.respond_to?(:includes)
+      relation = relation.apply_filters(where.to_h)             if where.present?    && relation.respond_to?(:apply_filters)
+      relation = relation.apply_sorts(sort.to_h)                if sort.present?     && relation.respond_to?(:apply_sorts)
+      relation = relation.apply_groupings(group.to_h)           if group.present?    && relation.respond_to?(:apply_groupings)
+      relation
+    end
+
+    # True when any customization would actually modify the base relation.
+    # Used by PreloaderSource to decide whether to hand a scope to upstream
+    # (which disables result caching) or pass nil (which preserves it).
+    def customized?(scope: nil, where: nil, sort: nil, group: nil, includes: nil)
+      scope.respond_to?(:call) || where.present? || sort.present? || group.present? || includes.present?
+    end
+  end
+end

data/lib/graphiform/skeleton.rb

@@ -88,5 +88,6 @@ module Graphiform
     Helpers.get_const_or_create('BaseEnum', ::Enums) do
       Class.new(::GraphQL::Schema::Enum)
     end
+
   end
 end

data/lib/graphiform/version.rb

@@ -1,3 +1,3 @@
 module Graphiform
-  VERSION = '0.4.1'.freeze
+  VERSION = '0.5.1'.freeze
 end

data/lib/graphiform.rb

@@ -6,6 +6,8 @@ require 'graphiform/active_record_helpers'
 require 'graphiform/core'
 require 'graphiform/fields'
 require 'graphiform/sort_enum'
+require 'graphiform/scope_composer'
+require 'graphiform/preloader_source'
 class GraphiformConfigurationError < StandardError; end
 
 module Graphiform

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiform
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.1
 platform: ruby
 authors:
 - jayce.pulsipher
-autorequire: 
+- zack.denkers
 bindir: bin
 cert_chain: []
-date: 2025-05-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,42 +16,54 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0.rc1
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0.rc1
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.4
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '2.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: 2.5.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: scopiform
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.1
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +78,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: spy
   requirement: !ruby/object:Gem::Requirement
@@ -108,9 +148,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
 email:
 - jayce.pulsipher@3-form.com
+- zack.denkers@3-form.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -120,10 +160,11 @@ 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
+- lib/graphiform/preloader_source.rb
+- lib/graphiform/scope_composer.rb
 - lib/graphiform/skeleton.rb
 - lib/graphiform/sort_enum.rb
 - lib/graphiform/version.rb
@@ -132,7 +173,6 @@ homepage: https://github.com/3-form/graphiform
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -140,15 +180,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Generate GraphQL types, inputs, resolvers, queries, and connections based
   off whitelisted column and association definitions

data/lib/graphiform/association_source.rb

@@ -1,58 +0,0 @@
-# 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
-      query = query.merge(@model.instance_exec(&@options[:scope])) if @options[:scope].present?
-      query = query.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