nested_select 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 295706af2c9d8f419f850ddcc81775e1ebb9708320fb6c06bd1d2fcc8f57405b
-  data.tar.gz: a9270172f9899183ca057294c5dbf358486ae7ca6cf97c2387ef3f009f4ca99c
+  metadata.gz: b07e539c2e4dd0ab26ae3991c3af0cf5943601dae0c538774cff62ac9709db21
+  data.tar.gz: af8cdda70c7dfff3b6fe1feba72d39b5c8bcf372c285ef6110d4f45fa471fbee
 SHA512:
-  metadata.gz: 539b57d526b2d3d6a15f9bef1a8bfe104779e02c409aa64fd6765aaee0fc5b4c4a86d2a92fd44f559dbde686d5fb7713ee81e72df815aeada368fc28eeb9a480
-  data.tar.gz: e9bd63e18fd429b8e2443e3c20d34c5a37b9eb7dd9e408ded4bcee3d109c4617e15e006cec32f996aff299ac3bdbb7b0150b637a756e6d388980f8f07fcb7f58
+  metadata.gz: ebbc597b3ecf57cb80da6cff33852a7dff935cb8b8fcd30d2d5223dcfb54b31c415b80df0c05bb48a46ea6bd4f54d158e1a68c3516d3014622b3fc3ebaf81744
+  data.tar.gz: 0aebc50d2cb3dcd2363dd6167f30dc479f0c415e6b5cc1786e623c0cb8be3544df9c4aae2426f77ed5c5fe335b1c2986a8587d5910ba7d8e30fe6cbb516ceb5d

data/.idea/nested_select.iml

@@ -59,6 +59,7 @@
     <orderEntry type="library" scope="PROVIDED" name="reline (v0.6.0, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="rubocop (v1.70.0, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="rubocop-ast (v1.37.0, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rubocop-shopify (v2.15.1, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="ruby-progressbar (v1.13.0, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="securerandom (v0.4.1, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="sqlite3 (v2.5.0, RVM: ruby-3.3.4 [ns1]) [gem]" level="application" />
@@ -77,21 +78,21 @@
     <option name="myRootTask">
       <RakeTaskImpl id="rake">
         <subtasks>
-          <RakeTaskImpl description="Build nested_select-0.1.0.gem into the pkg directory" fullCommand="build" id="build" />
+          <RakeTaskImpl description="Build nested_select-0.3.0.gem into the pkg directory" fullCommand="build" id="build" />
           <RakeTaskImpl id="build">
             <subtasks>
-              <RakeTaskImpl description="Generate SHA512 checksum of nested_select-0.1.0.gem into the checksums directory" fullCommand="build:checksum" id="checksum" />
+              <RakeTaskImpl description="Generate SHA512 checksum of nested_select-0.3.0.gem into the checksums directory" fullCommand="build:checksum" id="checksum" />
             </subtasks>
           </RakeTaskImpl>
           <RakeTaskImpl description="Remove any temporary products" fullCommand="clean" id="clean" />
           <RakeTaskImpl description="Remove any generated files" fullCommand="clobber" id="clobber" />
-          <RakeTaskImpl description="Build and install nested_select-0.1.0.gem into system gems" fullCommand="install" id="install" />
+          <RakeTaskImpl description="Build and install nested_select-0.3.0.gem into system gems" fullCommand="install" id="install" />
           <RakeTaskImpl id="install">
             <subtasks>
-              <RakeTaskImpl description="Build and install nested_select-0.1.0.gem into system gems without network access" fullCommand="install:local" id="local" />
+              <RakeTaskImpl description="Build and install nested_select-0.3.0.gem into system gems without network access" fullCommand="install:local" id="local" />
             </subtasks>
           </RakeTaskImpl>
-          <RakeTaskImpl description="Create tag v0.1.0 and build and push nested_select-0.1.0.gem to https://rubygems.org" fullCommand="release[remote]" id="release[remote]" />
+          <RakeTaskImpl description="Create tag v0.3.0 and build and push nested_select-0.3.0.gem to https://rubygems.org" fullCommand="release[remote]" id="release[remote]" />
           <RakeTaskImpl description="Run RuboCop" fullCommand="rubocop" id="rubocop" />
           <RakeTaskImpl id="rubocop">
             <subtasks>

data/.rubocop.yml

@@ -6,3 +6,86 @@ Style/StringLiterals:
 
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
+
+Style/SingleLineMethods:
+  Description: 'Avoid single-line methods.'
+  StyleGuide: '#no-single-line-methods'
+  Enabled: false
+  VersionAdded: '0.9'
+  VersionChanged: '1.8'
+  AllowIfMethodIsEmpty: true
+
+Style/AsciiComments:
+  Description: 'Use only ascii symbols in comments.'
+  StyleGuide: '#english-comments'
+  Enabled: false
+  VersionAdded: '0.9'
+  VersionChanged: '1.21'
+  AllowedChars:
+    - ©
+
+Layout/LineLength:
+  Description: 'Checks that line length does not exceed the configured limit.'
+  StyleGuide: '#max-line-length'
+  Enabled: true
+  VersionAdded: '0.25'
+  VersionChanged: '1.4'
+  Max: 120
+  # To make it possible to copy or click on URIs in the code, we allow lines
+  # containing a URI to be longer than Max.
+  AllowHeredoc: true
+  AllowURI: true
+  URISchemes:
+    - http
+    - https
+  # The IgnoreCopDirectives option causes the LineLength rule to ignore cop
+  # directives like '# rubocop: enable ...' when calculating a line's length.
+  IgnoreCopDirectives: true
+  # The AllowedPatterns option is a list of !ruby/regexp and/or string
+  # elements. Strings will be converted to Regexp objects. A line that matches
+  # any regular expression listed in this option will be ignored by LineLength.
+  AllowedPatterns: []
+  IgnoredPatterns: [] # deprecated
+  Exclude:
+    - "./test/**/*"
+
+Metrics/ClassLength:
+  Description: 'Avoid classes longer than 100 lines of code.'
+  Enabled: false
+  VersionAdded: '0.25'
+  VersionChanged: '0.87'
+  CountComments: false  # count full line comments?
+  Max: 100
+  CountAsOne: []
+
+Lint/MissingCopEnableDirective:
+  Description: 'Checks for a `# rubocop:enable` after `# rubocop:disable`.'
+  Enabled: true
+  VersionAdded: '0.52'
+  # Maximum number of consecutive lines the cop can be disabled for.
+  # 0 allows only single-line disables
+  # 1 would mean the maximum allowed is the following:
+  #   # rubocop:disable SomeCop
+  #   a = 1
+  #   # rubocop:enable SomeCop
+  # .inf for any size
+  MaximumRangeSize: .inf
+
+Style/MethodCallWithArgsParentheses:
+  Enabled: true
+  IgnoredMethods:
+    - require
+    - require_relative
+    - require_dependency
+    - yield
+    - raise
+    - puts
+  Exclude:
+    - "/**/Gemfile"
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Lint/UnderscorePrefixedVariableName:
+  Exclude:
+    - "./test/**/**/*"

data/ABOUT_NESTED_SELECT.md

@@ -52,7 +52,8 @@ Regardless of the major rails version and implementation, you will end up patchi
 So you just need to define a way to deliver select_values to instance of `ActiveRecord::Associations::Preloader::Association`
 
 ### How preloading happens in rails >= 7.0
-To be honest ( and opinionated :) ), current preloading implementation is a kinda mess, and we need to adapt to this mess without delivering some more.
+To be honest ( and opinionated :) ), current preloading implementation is messy, 
+and we need to adapt to this mess without delivering some more.
 
 Let's look at the scopes example from a specs:
 ```ruby
@@ -83,5 +84,5 @@ To be able to select limited attributes sets, we need to deliver them to `Associ
 
 **_Rem:_** Each `Preloader::ThroughAssociation` object creates it's own `Preloader` and starts additional 'isolated' preloading process.
 
-The implementation of nested_seelct adds a `nested_select_values` attributes into instances of `Preloader`, `Branch`, `Association` hierarchy 
+The implementation of nested_select adds a `nested_select_values` attributes into instances of `Preloader`, `Branch`, `Association` hierarchy 
 and some methods to populate corresponding select_values over the tree, trying to be as less invasive as it could be.

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.3.0] - 2025-01-25
+
+- nested_select belongs_to limitation now prevents accidental foreign_key absence 
+- primary keys are no longer need to be nested_selected
+- nested selects will combine all selections on multiple select invocations like the usual select values does 
+- tests restructured 
+- test/README added
+- removed biolerplates for basic selection ( you don't need to specify "table.*" in the root collection seletc )
+
 ## [0.2.0] - 2025-01-25
 
 - Tests are now a part of this repo 

data/README.md

@@ -1,11 +1,10 @@
 # WIP disclaimer
-The gem is under active development now. As of version 0.2.0 you are safe to try in your prod console 
-to uncover it's potential, and try in dev/test env. 
-
-Use in prod with caution only if you are properly covered by your CI.
+The gem is under active development now. 
+Use in prod with caution only if you are properly covered by your CI. 
+Read **Safety** and **Limitations** sections before.
 
 # Nested select -- 7 times faster and 33 times less RAM on preloading relations with heavy columns!
-nested_select allows to select attributes of relations during preloading process, leading to less RAM and CPU usage.
+nested_select allows the partial selection of the relations attributes during preloading process, leading to less RAM and CPU usage.
 Here is a benchmark output for a [gist I've created](https://gist.github.com/alekseyl/5d08782808a29df6813f16965f70228a) to emulate real-life example: displaying a course with its structure.
 
 Given: 
@@ -24,9 +23,10 @@ nested_select  0.096008   0.002876   0.098884 (  0.466985)
 simple includes  0.209188   0.058340   0.267528 (  0.903893)                                                       
                                                                                                                    
 ----------------- Memory comparison, for root_collection_size: 1 ---------                                         
-
+# partial selection
 D, [2025-01-12T19:08:36.163282 #503] DEBUG -- :   Topic Load (4.1ms)  SELECT "topics"."id", "topics"."position", "topics"."title", "topics"."course_id" FROM "topics" WHERE "topics"."deleted_at" IS NULL AND "topics"."course_id" = $1  [["course_id", 1624]]                                                                 
 D, [2025-01-12T19:08:36.168803 #503] DEBUG -- :   Lesson Load (3.9ms)  SELECT "lessons"."id", "lessons"."title", "lessons"."topic_id", "lessons"."position", "lessons"."topic_id" FROM "lessons" WHERE "lessons"."deleted_at" IS NULL AND "lessons"."topic_id" = $1  [["topic_id", 7297]]                                      
+# includes in full 
 D, [2025-01-12T19:08:37.220379 #503] DEBUG -- :   Topic Load (4.2ms)  SELECT "topics"."id", "topics"."position", "topics"."title", "topics"."course_id" FROM "topics" WHERE "topics"."deleted_at" IS NULL AND "topics"."course_id" = $1  [["course_id", 1624]]                                                                 
 D, [2025-01-12T19:08:37.247484 #503] DEBUG -- :   Lesson Load (25.7ms)  SELECT "lessons".* FROM "lessons" WHERE "lessons"."deleted_at" IS NULL AND "lessons"."topic_id" = $1  [["topic_id", 7297]]
 
@@ -50,7 +50,7 @@ irb(main):280:0> compare_nested_select(ids, 100)
 ------- CPU comparison, for root_collection_size: 100 ----
                     user     system      total        real           
 nested_select    1.571095   0.021778   1.592873 (  2.263369)
-simple includes  5.374909   1.704284   7.079193 ( 15.488579)
+simple includes  5.374909   1.704284   7.079193 ( 15.488579) 
                                                         
 ----------------- Memory comparison, for root_collection_size: 100 ---------
 ------ Nested Select memory consumption for root_collection_size: 100 ------
@@ -64,9 +64,12 @@ Total allocated: 33.05 MB (38332 objects)
 Total retained:  32.00 MB (24057 objects)               
 RAM ratio improvements x15.57707431190517 on retain objects
 RAM ratio improvements x11.836000856510193 on total_allocated objects
-
 ```
 
+Despite this little click bait it's pretty obvious that it might not be even the biggest numbers, 
+if you have heavy relations instantiation for heavy views or reports generation, 
+and you want it to be less demanding in RAM and CPU -- you should try nested_select
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -78,19 +81,124 @@ If bundler is not being used to manage dependencies, install the gem by executin
     $ gem install nested_select
 
 ## Usage
+
+### Specify which attributes to load in preloading models   
 Assume you have a relation users <- profile, and you want to preview users in a paginated feed, 
-and you need only :photo attribute of a profile, with nested_select you can do it like this:  
+and you need only :photo_url attribute of a profile, with nested_select you can do it like this:  
 
 ```ruby
-# this will preload profile with exact attributes: :id, :user_id and :photo
-User.includes(:profile).select(profile: :photo).limit(10)
+class User
+  has_one :profile
+end
+
+class Profile
+  belongs_to :user
+end
+
+# this will preload profile with exact attributes: 
+# :id -- since its a primary key, 
+# :user_id -- since its a foreign_key
+# and the :photo_url as requested
+User.includes(:profile).select(profile: :photo_url).limit(10)
 ```
 
-## Safety
+### Partial through relations preloading
+Whenever you are using through relations between models rails will fully load all intermediate objects under the hood,
+that is definitely wastes lots of RAM, CPU including those on the DB side. 
+You can limit through objects only to relation columns. 
+Ex:
+
+```ruby
+class User
+  has_one :user_profile, inverse_of: :user
+  has_many :avatars, through: :user_profile, inverse_of: :user
+end
+
+  # pay attention user_profile relation, wasn't included explicitly, 
+  # but still rails needed to be preloaded to match and preload avatars here
+  user = User.includes(:avatars)
+             .select(avatars: [:img_url, { user_profile: [:zip_code] }]).first
+  
+  # Now user - loaded fully
+  # avatars - foreign and primary keys needed to establish relations + img_url
+  # user_profile - foreign and primary keys + zip_code
+```
+**REM:** Through preloading happens in reverse, so to nest their selection 
+you must start from the latest, in this case avatar, and go to the previous ones in this case its a user_profile
+
+If you want intermediate models to be completely skinny, you should select like this:
+
+```ruby
+class User
+  has_one :user_profile, inverse_of: :user
+  has_many :avatars, through: :user_profile, inverse_of: :user
+  has_many :through_avatar_images, through: :avatars, class_name: :Image, source: :images
+end
+
+  # only through_avatar_images is matter here, and we want everything 
+  user = User.includes(:through_avatar_images)
+             .select(through_avatar_images: ["images.*", avatars: [user_profile: [:id]]]).first
+  
+  # through_avatar_images -- loaded in full
+  # avatars, user_profile -- only relations columns id, user_profile_id e.t.c
+```
+**REM** As for version 0.4.0 for the earliest relation in a through chain you need to select something, 
+otherwise nested_select will select everything ))
+
+# Safety
 How safe is the partial model loading? Earlier version of rails and activerecord would return nil in the case, 
 when attribute wasn't selected from a DB, but rails 6 started to raise a ActiveModel::MissingAttributeError. 
 So the major problem is already solved -- your code will not operate based on falsy blank values, it will raise an exception. 
-Just cover your actions with proper tests and you are safe. 
+
+But if you are working with attributes directly ( which you should not btw ), you will see nil, without any exception. 
+Using as_json on such models will also deliver json without exception and without skipped attributes. 
+
+## Partial selection in multiple preloading branches
+If you are doing some strange or narrow cases whenever you preloading same objects via different preloading branches, 
+including the most common case through relations, which rails preloads in full, then you must be very accurate 
+with nested selection, cause rails loads and attach associations only once, if it was partial
+than you might get yourself into trouble. BUT nested_select will check and raise an exception 
+if you are trying to re-instantiate with a different set of attributes. Ex:
+
+```
+ActiveModel::MissingAttributeError: Reflection 'avatars' already loaded with a different set of basic attributes.
+expected: ["img_url", "user_profile_id", "id"], already loaded with: ["created_at", "user_profile_id", "id"]
+Hint: ensure that you are using same set of attributes for entrance of same relation
+      on nesting selection tree including reverse through relations
+```
+
+# Limitations
+
+## belongs_to foreign keys limitations 
+Rails preloading happens from loaded records to their reflections step by step. 
+That's makes it pretty easy to include foreign keys for has_* relations, and very hard for belongs_to, 
+to work this out you need to analyze includes based on the already loaded records, analyze and traverse their relations.
+This needs a lot of monkey patching, and for now I decided not to go this way.
+That means in case when nesting selects based on belongs_to reflections, 
+you'll need to select their foreign keys **EXPLICITLY!** 
+
+## will not work with ar_lazy_preload
+Right now it will not work with ar_lazy_preload gem. nested_select relies on the includes_values definition 
+of a relation. If you are doing it in a lazy way, there weren't any explicit includes, that means it will not extract any nested selection.
+
+```ruby
+class Avatar < ApplicationRecord
+  belongs_to user
+  has_one :image
+end
+
+class Image < ApplicationRecord
+  belongs_to :avatar
+end
+
+Image.includes(avatar: :user).select(avatar: [:size, { user: [:email] }]).load # <--- will raise a Missing Attribute exception 
+
+#> ActiveModel::MissingAttributeError: Parent reflection avatar was missing foreign key user_id in nested selection
+#> while trying to preload belongs_to reflection named user.
+#> Hint: didn't you forgot to add user_id inside [:id, :size]?
+
+Image.includes(avatar: :user).select(avatar: [:size, :user_id, { user: [:email] }]).load
+```
 
 ## Testing
 
@@ -98,15 +206,25 @@ Just cover your actions with proper tests and you are safe.
 docker compose run test 
 ```
 
-## Development
+## TODO
+- [x] Cover all relation combinations and add missing functionality
+  - [x] Ensure relations foreign keys are present on the selection
+  - [x] Ensure primary key will be added
+  - [-] Ensure belongs_to will add a foreign_key column (Too hard to manage :(, its definitely not a low hanging fruit)
+- [x] Optimize through relations ( since they loading a whole set of attributes )
+- [ ] Separated rails version testing
+- [x] Merge multiple nested selections 
+- [x] Don't apply any selection if blank ( allows to limit only part of subselection tree)
+- [x] Allows to use custom attributes
+- [ ] Eager loading? 
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+## Development
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/nested_select. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/nested_select/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/alekseyl/nested_select. This project is intended to be a safe, 
+welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/nested_select/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 

data/lib/nested_select/deep_merger.rb

@@ -0,0 +1,28 @@
+module NestedSelect
+  module DeepMerger
+
+    # {user_profile: [:zip_code]} + {user_profile: [:bio]} -> { user_profile: [:zip_code, :bio] }
+    refine Hash do
+      def deep_combine(other)
+        merge!(other.except(*keys))
+        merge!(other.slice(*keys).map{ |key, value| [key, [self[key], value].flatten.deep_combine_elements]}.to_h )
+      end
+
+      def relation_nesting_depth
+        1 + [*values.grep(Hash), *values.grep(Array)].map(&:relation_nesting_depth).max.to_i
+      end
+    end
+
+    refine Array do
+      def deep_combine_elements
+        [*grep_v(Hash), grep(Hash).inject(&:deep_combine)].uniq.compact
+      end
+      # in terms of relation/selection nesting every array node
+      # should not add +1 to depth, that mean that array nesting
+      # does not count as nesting [[[]]] has depth equal 0.
+      def relation_nesting_depth
+        [*grep(Hash), *grep(Array)].map(&:relation_nesting_depth).max.to_i
+      end
+    end
+  end
+end

data/lib/nested_select/preloader/association.rb

@@ -4,14 +4,46 @@ module NestedSelect
       attr_reader :nested_select_values
 
       def build_scope
-        nested_select_values.blank? ? super
-          : super.select(*nested_select_values)
+        nested_select_values.blank? ? super :
+          super.select(*nested_select_values.grep_v(Hash).map{_1.try(:to_s) }.uniq)
       end
 
       def apply_nested_select_values(partial_select_values)
         foreign_key = reflection.foreign_key unless reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+        @nested_select_values = [*partial_select_values, *foreign_key, *reflection.klass.primary_key]
+        ensure_nesting_selection_integrity!
+      end
+
+      def ensure_nesting_selection_integrity!
+        single_owner = owners.first
+        # do nothing unless not yet loaded
+        return unless single_owner.association(reflection.name).loaded?
+
+        single_reflection_record = single_owner.send(reflection.name)
+        return if single_reflection_record.blank?
+
+        single_reflection_record = single_reflection_record.first if single_reflection_record.is_a?(Enumerable)
+
+        attributes_loaded = single_reflection_record.attributes.keys.map(&:to_s)
+        current_selection = @nested_select_values.grep_v(Hash).map(&:to_s)
+
+        basic_attributes_matched = (attributes_loaded & reflection.klass.column_names).tally ==
+                                   (current_selection & reflection.klass.column_names).tally
+
+        # this is not a 100% safe verification, but it will match cases with custom attributes selection for example:
+        # "(SELECT COUNT(*) FROM images) as IMG_count" =~ /img_count/
+        custom_attributes_matched = (attributes_loaded - reflection.klass.column_names).all? do |loaded_attr|
+          (current_selection - reflection.klass.column_names).any? do |upcoming_custom_attr|
+            upcoming_custom_attr =~ /#{loaded_attr}/i
+          end
+        end
 
-        @nested_select_values = [*partial_select_values, *foreign_key].uniq
+        raise ActiveModel::MissingAttributeError, <<~ERR if !basic_attributes_matched || !custom_attributes_matched
+          Reflection '#{reflection.name}' already loaded with a different set of basic attributes.
+          expected: #{current_selection}, already loaded with: #{attributes_loaded}
+          Hint: ensure that you are using same set of attributes for entrance of same relation
+                on nesting selection tree including reverse through relations
+        ERR
       end
     end
   end

data/lib/nested_select/preloader/branch.rb

@@ -4,11 +4,30 @@ module NestedSelect
     module Branch
       attr_accessor :nested_select_values
       def preloaders_for_reflection(reflection, reflection_records)
+        prevent_belongs_to_foreign_key_absence!(reflection)
+
         super.tap do |ldrs|
+          # nested_select_values contains current level selection + nested relation selections
           ldrs.each{ _1.apply_nested_select_values(nested_select_values) } if nested_select_values.present?
         end
       end
 
+      private
+      def prevent_belongs_to_foreign_key_absence!(reflection)
+        return unless reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+
+        # ActiveRecord will not raise in case its missing, so we should prevent silent error here
+        if parent.nested_select_values.present? &&
+          !parent.nested_select_values.grep_v(Hash)
+                 .map(&:to_sym).include?(reflection.foreign_key.to_sym)
+
+          raise ActiveModel::MissingAttributeError, <<~ERR
+            Parent reflection #{parent.association} was missing foreign key #{reflection.foreign_key} in nested selection,
+            while trying to preload belongs_to reflection named #{reflection.name}. 
+            Hint: didn't you forgot to add #{reflection.foreign_key} inside #{parent.nested_select_values}?
+          ERR
+        end
+      end
     end
   end
 end

data/lib/nested_select/preloader/through_association.rb

@@ -1,22 +1,84 @@
 module NestedSelect
   module Preloader
     module ThroughAssociation
+      # this preloader root will preload intermediate records, so here we should apply 'through'
+      # selection limitation AS A BASIC nested selection and it wuold be either __minimize_through_selection sym OR
+      # nested_selection tree
+      # def source_preloaders
+      #   @source_preloaders ||= ActiveRecord::Associations::Preloader.new(
+      #     records: middle_records,
+      #     associations: source_reflection.name,
+      #     scope: scope,
+      #     associate_by_default: false
+      #   ).tap {
+      #     byebug
+      #     _1.apply_nested_select_values([*@limit_through_selection])
+      #   }.loaders
+      # end
       def through_preloaders
         @through_preloaders ||= ActiveRecord::Associations::Preloader.new(
           records: owners,
           associations: through_reflection.name,
           scope: through_scope,
           associate_by_default: false,
-          ).tap { _1.apply_nested_select_values(nested_select_values) }.loaders
+          ).tap do
+          _1.apply_nested_select_values(nested_select_values.grep(Hash))
+        end.loaders
       end
 
-      def apply_nested_select_values( partial_select_values )
-        return super unless reflection.parent_reflection.is_a?( ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+      # def through_scope
+      #   if @limit_through_selection.present?
+      #     # through_selection is either __minimize_through_selection symbol, or an array
+      #     through_selection = [*@limit_through_selection]
+      #     through_selection = [*through_selection.grep_v(Hash),
+      #                          *through_selection.grep(Hash).first&.dig(through_reflection.source_reflection_name)]
+      #     through_selection << through_reflection.foreign_key
+      #     through_selection << through_reflection.klass.primary_key
+      #     super.select(through_selection)
+      #   else
+      #     super
+      #   end
+      # end
 
-        # when parent reflection is a HasAndBelongsToManyReflection,
-        # then we don't need foreign_key to be included, as it does in super
-        @nested_select_values = partial_select_values
+      # def through_scope
+      #   if @limit_through_selection.present?
+      #     super.select(through_reflection.foreign_key.to_sym, through_reflection.klass.primary_key.to_sym)
+      #   else
+      #     super
+      #   end
+      # end
+      # def through_selection_nesting
+      #   return if @limit_through_selection.blank?
+      #   through_limit_selection = [through_reflection.foreign_key.to_sym, through_reflection.klass.primary_key.to_sym]
+      #   through_limit_selection << :__minimize_through_selection if through_reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+      #   through_limit_selection
+      # end
+
+      def apply_nested_select_values(partial_select_values)
+
+        if reflection.parent_reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+          # when parent reflection is a HasAndBelongsToManyReflection,
+          # then we don't need foreign_key to be included, as it does in super
+          @nested_select_values = partial_select_values
+        else
+          @limit_through_selection = partial_select_values.delete(:__minimize_through_selection)
+          super(partial_select_values)
+        end
       end
+      # def exract_through_selections(partial_select_values)
+      #   # __minimize_through_selection: [ :user_id, user_profile: [] ]
+      #   # there should not be more than one such limitation definition
+      #   through_selection_rules, cleaned_partial_select_values = partial_select_values&.partition do
+      #     _1 == :__minimize_through_selection || _1.is_a?(Hash) && _1[:__minimize_through_selection].present?
+      #   end
+      #   @limit_through_selection = through_selection_rules.map do
+      #     _1.is_a?(Hash) && _1[:__minimize_through_selection] || _1
+      #   end.first
+      #
+      #   byebug
+      #   cleaned_partial_select_values
+      # end
+
     end
   end
 end

data/lib/nested_select/preloader.rb

@@ -9,25 +9,41 @@ module NestedSelect
 
     included do
       ActiveRecord::Associations::Preloader::Branch.prepend(Branch)
-      ActiveRecord::Associations::Preloader::ThroughAssociation.prepend( ThroughAssociation )
-      ActiveRecord::Associations::Preloader::Association.prepend( Association )
+      ActiveRecord::Associations::Preloader::ThroughAssociation.prepend(ThroughAssociation)
+      ActiveRecord::Associations::Preloader::Association.prepend(Association)
     end
+
+    # first one will start from the roots [included_1: [{}], included_2: [{}] ]
     def apply_nested_select_values(nested_select_values)
       distribute_nested_select_over_loading_tree(@tree, nested_select_values)
     end
 
+    # this one either subtree roots only when its first, OR current branch selection root
+    # + its branches in array
+    # 1) [:__minimize_through_selection, ...]
+    # 2) []
+    # Логика следующая:
+    #  если мы передаем __minimize_through_selection как символ, то его надо пробросить до всех бранчей, они с этим разберутся, там где надо
+    #  если у нас там хеш, то его надо оставить на текущем уровне и дальше если это through, то оно превратит это в нестед селект для вложенных
     def distribute_nested_select_over_loading_tree(sub_tree, nested_select_values)
       #  nested_select_values = [:id, :title, comments: [:id, :body], cover: [:id, img: [:url]]]
       return if nested_select_values.blank?
 
-      sub_tree.nested_select_values = nested_select_values.grep_v(Hash)
+      sub_tree.nested_select_values = [*nested_select_values.grep_v(Hash)]
       # sub_nested_select_values = { comments: [:id, :body], cover: [:id, img: [:url]] }
-      sub_nested_select_values = nested_select_values.grep(Hash).inject(&:merge)&.symbolize_keys
+      sub_nested_select_values = nested_select_values.grep(Hash).inject({}, &:merge)&.symbolize_keys
+
       # it could be a case when selection tree is not that deep than Branch tree.
       return if sub_nested_select_values.blank?
 
-      sub_tree.children.each do
-        distribute_nested_select_over_loading_tree( _1, sub_nested_select_values[_1.association])
+      # its possible to subselect in reverse direction for through relation's
+      # in that case includes are implicit, but we need to add that reverse tree into nested select
+      reverse_nested_selections = sub_nested_select_values.except(*sub_tree.children.map(&:association))
+      # this is for reverse selection of through models
+      sub_tree.nested_select_values << reverse_nested_selections if reverse_nested_selections.present?
+
+      sub_tree.children.each do |chld_brnch|
+        distribute_nested_select_over_loading_tree(chld_brnch, sub_nested_select_values[chld_brnch.association])
       end
     end
   end

data/lib/nested_select/relation.rb

@@ -1,22 +1,38 @@
 # frozen_string_literal: true
+require_relative "deep_merger"
 
 module NestedSelect
   module Relation
+    using ::NestedSelect::DeepMerger
 
     attr_accessor :nested_select_values
     def select(*fields)
-      @nested_select_values = fields.grep(Hash)
-      super(*fields.grep_v(Hash))
+      # {user_profile: [:zip_code]} + {user_profile: [:bio]} -> { user_profile: [:zip_code, :bio] }
+      @nested_select_values = [*@nested_select_values, *fields.grep(Hash)].deep_combine_elements
+      # returning self means -- there was only nesting selection,
+      # and we should not interfere with default selection
+      fields.grep_v(Hash).present? ? super(*fields.grep_v(Hash)) : self
     end
 
+    # # when nested_select interferes the 'through' selection, its doing this in reverse
+    # # in this case the first one preload wins a selection scope,
+    # # so we need to make them all the same across all selection trees
+    # # ( except for the cases when traversing ends up in same place using different path,
+    # # this case is out of the normal sense )
+    # def combine_reverse_selection_sub_trees
+    #   @nested_select_values.permutation.each do |left, right|
+    #
+    #   end
+    # end
+
     def preload_associations(records) # :nodoc:
       preload = preload_values
       preload += includes_values unless eager_loading?
       scope = strict_loading_value ? StrictLoadingScope : nil
       preload.each do |associations|
         ActiveRecord::Associations::Preloader.new(records:, associations:, scope:)
-                                             .tap{ _1.apply_nested_select_values(nested_select_values) } # <-- Patching code
-                                             .call
+          .tap{_1.apply_nested_select_values(nested_select_values) } # <-- Patching code
+          .call
       end
     end
   end

data/lib/nested_select/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NestedSelect
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/nested_select.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 require_relative "nested_select/version"
 
 module NestedSelect

data/test_habtm_reflections.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class TestHabtmReflections < ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+
+  self.use_instantiated_fixtures = true
+
+
+  test "select allows nesting attribute selection" do
+    item = Item.includes(users: [user_profile: :avatars])
+               .select("items.*", users: [:id, :name, user_profile: [:id, :bio, avatars: [:img_url]]])
+               .find(identify(:mug))
+
+    user = item.users.first
+    assert_equal(user.name, "Frodo")
+    assert_raises(ActiveModel::MissingAttributeError) { user.membership }
+    assert_equal(user.reload.membership, "basic")
+
+    assert_includes(user.user_profile.avatars.map(&:img_url), avatars(:frodo_avatar).img_url)
+  end
+
+  test "works fine with inverse_of basic reflection" do
+    user = User.includes(user_profile: :avatars)
+               .select("users.*", user_profile: [:id, :user_id, avatars: [:id, :user_profile_id]])
+               .find(identify(:frodo))
+
+    # NestedSelect::Preloader::Branch#preloaders_for_reflection
+    assert_equal(user.user_profile.user.object_id, user.object_id)
+    assert_equal(user.user_profile.object_id, user.user_profile.avatars.first.user_profile.object_id)
+  end
+
+  test "works fine with through reflection" do
+    user = User.includes(:avatars)
+               .select("users.*", avatars: [:id, :user_profile_id])
+               .find(identify(:frodo))
+
+    assert_raises(ActiveModel::MissingAttributeError) { user.avatars.first.img_url }
+    assert_equal(user.avatars, [avatars(:frodo_avatar)])
+    assert_equal(user.avatars.first.reload.img_url, "https://api.rubyonrails.org/")
+  end
+
+  test "partial selection always includes foreign keys" do
+    user = User.includes(user_profile: :avatars)
+               .select("users.*", user_profile: [:id, :bio])
+               .find(identify(:frodo))
+
+    assert_equal(user.user_profile.user_id, user.id)
+  end
+
+  test "partial selection always includes foreign keys also for through reflection bb" do
+    user = User.includes(:avatars)
+               .select("users.*", avatars: [:id, :img_url])
+               .find(identify(:frodo))
+
+    assert_equal(user.avatars, [avatars(:frodo_avatar)])
+    assert_not_nil(user.avatars.first.user_profile_id)
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nested_select
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - alekseyl
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-25 00:00:00.000000000 Z
+date: 2025-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -164,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-shopify
+  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'
 description: ActiveRecord improved select on nested models, allows partial instantiation
   on nested models, easy one step improvements on performance and memory
 email:
@@ -188,6 +202,7 @@ files:
 - Rakefile
 - docker-compose.yml
 - lib/nested_select.rb
+- lib/nested_select/deep_merger.rb
 - lib/nested_select/preloader.rb
 - lib/nested_select/preloader/association.rb
 - lib/nested_select/preloader/branch.rb
@@ -195,6 +210,7 @@ files:
 - lib/nested_select/relation.rb
 - lib/nested_select/version.rb
 - sig/nested_select.rbs
+- test_habtm_reflections.rb
 homepage: https://github.com/alekseyl/nested_select
 licenses:
 - MIT