brick 1.0.97 → 1.0.99

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c257a0a65807fa87a13d722f3cc30c38d51bde571a070df53f4277fc6db8b7ba
-  data.tar.gz: 74d7690a968fab671d9e9e8ac92e41885ceb44a700fd1cb293f3b79af819e463
+  metadata.gz: 431e2aee4c3c199095d8475eeedcc46bd95e86a47c51623e3cea7fbbde59edcd
+  data.tar.gz: 32144a9a9ab6ec60ef297f27ae73e35cc891e5f9462b9beae4e7a0534ab77135
 SHA512:
-  metadata.gz: 4337faa80a6f0d9c1dadcb3271aea14ec54bb91e72cd7eead7e59c860557f828ac073cab3768feaa2db2f664d63b1604bd8f8e0d53c64621b1fcf5cc041057d9
-  data.tar.gz: 541cade2070bd0a79b21dd7155df700b2739084ae81eaa02709f9e00164f956e62e8342330a78496c4b5fbf351cac9ea40483d3cdc32c1fb1dbe8d7e34499d2d
+  metadata.gz: f471bc993d97e92deae3c03e6cac9db0e350e72bd070afe5bcde1d0ca18d650b546db0d018a101009e429e9870a7e2c5e566f980c9e5b1319bc18873271c5550
+  data.tar.gz: 95f128f0f2a29cf0d1af1b5001eae27885b7e11ce23194e4a4da0141a0bfc059edd1917036f4addf1ee2aa4b69f763962e821ca31f9473048a6934dbecd8518e

data/lib/brick/extensions.rb

@@ -398,15 +398,27 @@ module ActiveRecord
     # Links from ActiveRecord association pathing names over to real table correlation names
     # that get chosen when the AREL AST tree is walked.
     def brick_links
-      @brick_links ||= {}
+      @brick_links ||= { '' => table_name }
     end
 
     def brick_select(params, selects = [], order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
       is_add_bts = is_add_hms = true
 
-      # Build out cust_cols, bt_descrip and hm_counts now so that they are available on the
-      # model early in case the user wants to do an ORDER BY based on any of that.
-      model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
+      if selects.empty?
+        # Build out cust_cols, bt_descrip and hm_counts now so that they are available on the
+        # model early in case the user wants to do an ORDER BY based on any of that.
+        model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
+      else
+        is_api = true
+        # If there are any provided selects, treat them as API columns and build them as cust_cols since they
+        # can be built using DSL.
+        # false = not polymorphic, and true = yes -- please emit_dsl
+        selects.each do |api_col|
+          pieces, my_dsl = brick_parse_dsl(join_array, [], translations, false, "[#{api_col}]", true)
+          _br_cust_cols[api_col.tr('.', '_')] = [pieces, my_dsl]
+        end
+        selects.clear # Now these have become custom columns
+      end
 
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
@@ -414,7 +426,7 @@ module ActiveRecord
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
-        next if ['_brick_schema', '_brick_order', 'controller', 'action'].include?(k)
+        next if ['_brick_schema', '_brick_order', '_brick_api', 'controller', 'action'].include?(k)
 
         if (where_col = (ks = k.split('.')).last)[-1] == '!'
           where_col = where_col[0..-2]
@@ -436,11 +448,14 @@ module ActiveRecord
 
       # %%% Skip the metadata columns
       if selects.empty? # Default to all columns
+        id_parts = (id_col = klass.primary_key).is_a?(Array) ? id_col : [id_col]
         tbl_no_schema = table.name.split('.').last
         # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
         #     ActiveRecord::StatementInvalid (TinyTds::Error: DBPROCESS is dead or not enabled)
         #     Relevant info here:  https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/402
         columns.each do |col|
+          next if is_api && id_parts.exclude?(col.name) # Only keep the ID columns if this is an API request
+
           col_alias = " AS #{col.name}_" if (col_name = col.name) == 'class'
           selects << if is_mysql
                        "`#{tbl_no_schema}`.`#{col_name}`#{col_alias}"
@@ -490,22 +505,28 @@ module ActiveRecord
             # binding.pry
             next
           end
-
           key_klass = nil
           key_tbl_name = nil
           dest_pk = nil
           key_alias = nil
           cc.first.each do |cc_part|
-            dest_klass = cc_part[0..-2].inject(klass) { |kl, cc_part_term| kl.reflect_on_association(cc_part_term).klass }
+            dest_klass = cc_part[0..-2].inject(klass) do |kl, cc_part_term|
+              # %%% Clear column info properly so we can do multiple subsequent requests
+              # binding.pry unless kl.reflect_on_association(cc_part_term)
+              kl.reflect_on_association(cc_part_term)&.klass || klass
+            end
             tbl_name = rel_dupe.brick_links[cc_part[0..-2].map(&:to_s).join('.')]
             # Deal with the conflict if there are two parts in the custom column named the same,
             # "category.name" and "product.name" for instance will end up with aliases of "name"
             # and "product__name".
-            cc_part_idx = cc_part.length - 1
-            while cc_part_idx > 0 &&
-                  (col_alias = "br_cc_#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__')}") &&
-                  used_col_aliases.key?(col_alias)
-              cc_part_idx -= 1
+            if (cc_part_idx = cc_part.length - 1).zero?
+              col_alias = "br_cc_#{k}__#{table_name.tr('.', '_')}"
+            else
+              while cc_part_idx > 0 &&
+                    (col_alias = "br_cc_#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__').tr('.', '_')}") &&
+                    used_col_aliases.key?(col_alias)
+                cc_part_idx -= 1
+              end
             end
             used_col_aliases[col_alias] = nil
             # Set up custom column links by preparing key_klass and key_alias
@@ -540,7 +561,11 @@ module ActiveRecord
             tbl_name = "\"#{tbl_name}\"" if ::Brick.is_oracle && rel_dupe.brick_links.values.include?(tbl_name)
             field_tbl_name = nil
             v1.map { |x| [x[0..-2].map(&:to_s).join('.'), x.last] }.each_with_index do |sel_col, idx|
-              field_tbl_name = rel_dupe.brick_links[sel_col.first].split('.').last
+              # %%% Strangely in Rails 7.1 on a slower system then very rarely brick_link comes back nil...
+              brick_link = rel_dupe.brick_links[sel_col.first]
+              field_tbl_name = brick_link&.split('.')&.last ||
+                # ... so here's a best-effort guess for what the table name might be.
+                rel_dupe.klass.reflect_on_association(sel_col.first).klass.table_name
               # If it's Oracle, quote any AREL aliases that had been applied
               field_tbl_name = "\"#{field_tbl_name}\"" if ::Brick.is_oracle && rel_dupe.brick_links.values.include?(field_tbl_name)
 
@@ -825,80 +850,9 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
 end
 
 if Object.const_defined?('ActionView')
+  require 'brick/frameworks/rails/form_tags'
   module ActionView::Helpers::FormTagHelper
-    def link_to_brick(*args, **kwargs)
-      return unless ::Brick.config.mode == :on
-
-      text = (args.first.is_a?(String) && args.first) || args[1]
-      klass_or_obj = ((args.first.is_a?(ActiveRecord::Relation) ||
-                       args.first.is_a?(ActiveRecord::Base) ||
-                       args.first.is_a?(Class)) &&
-                      args.first) ||
-                     @_brick_model
-      # If not provided, do a best-effort to automatically determine the resource class or object
-      filter_parts = []
-      klass_or_obj ||= begin
-                         klass, sti_type = ::Brick.ctrl_to_klass(controller_path)
-                         if klass
-                           type_col = klass.inheritance_column # Usually 'type'
-                           filter_parts << "#{type_col}=#{sti_type}" if sti_type && klass.column_names.include?(type_col)
-                           path_params = request.path_parameters.dup
-                           path_params.delete(:controller)
-                           path_params.delete(:action)
-                           pk = (klass.primary_key || ActiveRecord::Base.primary_key).to_sym
-                           # Used to also have this but it's a bit too permissive to identify a primary key:  (path_params.length == 1 && path_params.values.first) ||
-                           if ((id = (path_params[pk] || path_params[:id] || path_params["#{klass.name.underscore}_id".to_sym])) && (obj = klass.find_by(pk => id))) ||
-                              (['show', 'edit', 'update', 'destroy'].include?(action_name) && (obj = klass.first))
-                             obj
-                           else
-                             # %%% If there is a HMT that refers to some ___id then try to identify an appropriate filter
-                             # %%% If there is a polymorphic association that might relate to stuff in the path_params,
-                             # try to identify an appropriate ___able_id and ___able_type filter
-                             ((klass.column_names - [pk.to_s]) & path_params.keys.map(&:to_s)).each do |path_param|
-                               filter_parts << "#{path_param}=#{path_params[path_param.to_sym]}"
-                             end
-                             klass
-                           end
-                         end
-                       rescue
-                       end
-      if klass_or_obj
-        if klass_or_obj.is_a?(ActiveRecord::Relation)
-          klass_or_obj.where_values_hash.each do |whr|
-            filter_parts << "#{whr.first}=#{whr.last}" if whr.last && !whr.last.is_a?(Array)
-          end
-          klass_or_obj = klass_or_obj.klass
-          type_col = klass_or_obj.inheritance_column
-          if klass_or_obj.column_names.include?(type_col) && klass_or_obj.name != klass_or_obj.base_class.name
-            filter_parts << "#{type_col}=#{klass_or_obj.name}"
-          end
-        elsif klass_or_obj.is_a?(ActiveRecord::Base) && klass_or_obj.new_record?
-          klass_or_obj = klass_or_obj.class
-        end
-        filter = "?#{filter_parts.join('&')}" if filter_parts.present?
-        if (klass_or_obj&.is_a?(Class) && klass_or_obj < ActiveRecord::Base) ||
-           (klass_or_obj&.is_a?(ActiveRecord::Base) && klass_or_obj.new_record? && (klass_or_obj = klass_or_obj.class))
-          lt_args = [text || "Index for #{klass_or_obj.name.pluralize}",
-                    "#{send("#{klass_or_obj._brick_index}_path")}#{filter}"]
-        else
-          # If there are multiple incoming parameters then last one is probably the actual ID, and first few might be some nested tree of stuff leading up to it
-          lt_args = [text || "Show this #{klass_or_obj.class.name}",
-                    "#{send("#{klass_or_obj.class._brick_index(:singular)}_path", klass_or_obj)}#{filter}"]
-        end
-        link_to(*lt_args, **kwargs)
-      else
-        # puts "Warning:  link_to_brick could not find a class for \"#{controller_path}\" -- consider setting @_brick_model within that controller."
-        # if (hits = res_names.keys & instance_variables.map { |v| v.to_s[1..-1] }).present?
-        links = instance_variables.each_with_object([]) do |name, s|
-                  iv_name = name.to_s[1..-1]
-                  case (val = instance_variable_get(name))
-                  when ActiveRecord::Relation, ActiveRecord::Base
-                    s << link_to_brick(val, iv_name) if val
-                  end
-                end
-        links.join(' &nbsp; ').html_safe
-      end
-    end
+    include ::Brick::Rails::FormTags
   end
 end
 
@@ -1002,6 +956,7 @@ Module.class_exec do
     end
     class_name = ::Brick.namify(requested)
     relations = ::Brick.relations
+    #        CONTROLLER
     result = if ::Brick.enable_controllers? &&
                 is_controller && (plural_class_name = class_name[0..-11]).length.positive?
                # Otherwise now it's up to us to fill in the gaps
@@ -1020,6 +975,8 @@ Module.class_exec do
                  # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
                  Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
                end
+
+             # MODULE
              elsif (::Brick.enable_models? || ::Brick.enable_controllers?) && # Schema match?
                    base_module == Object && # %%% This works for Person::Person -- but also limits us to not being able to allow more than one level of namespacing
                    (schema_name = [(singular_table_name = class_name.underscore),
@@ -1036,6 +993,50 @@ Module.class_exec do
 
                [built_module, "module #{schema_name}; end\n"]
                #  # %%% Perhaps an option to use the first module just as schema, and additional modules as namespace with a table name prefix applied
+
+             # AVO Resource
+             elsif base_module == Object && Object.const_defined?('Avo') && requested.end_with?('Resource') &&
+                   ['MotorResource'].exclude?(requested) # Expect that anything called MotorResource could be from that administrative gem
+               if (model = Object.const_get(requested[0..-9]))
+                 require 'generators/avo/resource_generator'
+                 field_generator = Generators::Avo::ResourceGenerator.new([''])
+                 field_generator.instance_variable_set(:@model, model)
+                 fields = field_generator.send(:generate_fields).split("\n")
+                                         .each_with_object([]) do |f, s|
+                                           if (f = f.strip).start_with?('field ')
+                                             f = f[6..-1].split(',')
+                                             s << [f.first[1..-1].to_sym, [f[1][1..-1].split(': :').map(&:to_sym)].to_h]
+                                           end
+                                         end
+                 built_resource = Class.new(Avo::BaseResource) do |new_resource_class|
+                   self.model_class = model
+                   self.title = :brick_descrip
+                   self.includes = []
+                   if (!model.is_view? && mod_pk = model.primary_key)
+                     field((mod_pk.is_a?(Array) ? mod_pk.first : mod_pk).to_sym, { as: :id })
+                   end
+                   # Create a call such as:  field :name, as: :text
+                   fields.each do |f|
+                     # Add proper types if this is a polymorphic belongs_to
+                     if f.last == { as: :belongs_to } &&
+                        (fk = ::Brick.relations[model.table_name][:fks].find { |k, v| v[:assoc_name] == f.first.to_s }) &&
+                        fk.last.fetch(:polymorphic, nil)
+                       poly_types = fk.last.fetch(:inverse_table, nil)&.each_with_object([]) do |poly_table, s|
+                         s << Object.const_get(::Brick.relations[poly_table][:class_name])
+                       end
+                       if poly_types.present?
+                         f.last[:polymorphic_as] = f.first
+                         f.last[:types] = poly_types
+                       end
+                     end
+                     self.send(:field, *f)
+                   end
+                 end
+                 Object.const_set(requested.to_sym, built_resource)
+                 [built_resource, nil]
+               end
+
+             # MODEL
              elsif ::Brick.enable_models?
                # Custom inheritable Brick base model?
                class_name = (inheritable_name = class_name)[5..-1] if class_name.start_with?('Brick')
@@ -1392,19 +1393,24 @@ class Object
       when Symbol
         order_tbl[order_default] || order_default
       else
-        pk.map(&:to_sym) # If it's not a custom ORDER BY, just use the key
+        pk.map { |part| "#{table_name}.#{part}"}.join(', ') # If it's not a custom ORDER BY, just use the key
       end
     end
 
     def build_controller(namespace, class_name, plural_class_name, model, relations)
+      if (is_avo = (namespace.name == 'Avo' && Object.const_defined?('Avo')))
+        # Basic Avo functionality is available via its own generic controller.
+        # (More information on https://docs.avohq.io/2.0/controllers.html)
+        controller_base = Avo::ResourcesController
+      end
       table_name = ActiveSupport::Inflector.underscore(plural_class_name)
       singular_table_name = ActiveSupport::Inflector.singularize(table_name)
       pk = model&._brick_primary_key(relations.fetch(table_name, nil))
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
 
-      code = +"class #{class_name} < ApplicationController\n"
-      built_controller = Class.new(ActionController::Base) do |new_controller_class|
+      code = +"class #{class_name} < #{controller_base&.name || 'ApplicationController'}\n"
+      built_controller = Class.new(controller_base || ActionController::Base) do |new_controller_class|
         (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
         # Brick-specific pages
@@ -1501,118 +1507,129 @@ class Object
         end
 
         self.protect_from_forgery unless: -> { self.request.format.js? }
-        self.define_method :index do
-          if (is_openapi || request.env['REQUEST_PATH'].start_with?(::Brick.api_root)) &&
-             !params&.key?('_brick_schema') &&
-             (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.map { |x| x.split('=') }).present?
-            if params
-              referrer_params.each { |k, v| params.send(:parameters)[k] = v }
-            else
-              api_params = referrer_params&.to_h
+        unless is_avo
+          self.define_method :index do
+            if (is_openapi || request.env['REQUEST_PATH'].start_with?(::Brick.api_root)) &&
+               !params&.key?('_brick_schema') &&
+               (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.map { |x| x.split('=') }).present?
+              if params
+                referrer_params.each { |k, v| params.send(:parameters)[k] = v }
+              else
+                api_params = referrer_params&.to_h
+              end
             end
-          end
-          _schema, @_is_show_schema_list = ::Brick.set_db_schema(params || api_params)
-
-          if is_openapi
-            json = { 'openapi': '3.0.1', 'info': { 'title': Rswag::Ui.config.config_object[:urls].last&.fetch(:name, 'API documentation'), 'version': ::Brick.config.api_version },
-                     'servers': [
-                       { 'url': '{scheme}://{defaultHost}', 'variables': {
-                         'scheme': { 'default': request.env['rack.url_scheme'] },
-                         'defaultHost': { 'default': request.env['HTTP_HOST'] }
-                       } }
-                     ]
-                   }
-            json['paths'] = relations.inject({}) do |s, relation|
-              unless ::Brick.config.enable_api == false
-                table_description = relation.last[:description]
-                s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}"] = {
-                  'get': {
-                    'summary': "list #{relation.first}",
-                    'description': table_description,
-                    'parameters': relation.last[:cols].map do |k, v|
-                                    param = { 'name' => k, 'schema': { 'type': v.first } }
-                                    if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
-                                      param['description'] = col_descrip
-                                    end
-                                    param
-                                  end,
-                    'responses': { '200': { 'description': 'successful' } }
-                  }
-                }
-
-                s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}/{id}"] = {
-                  'patch': {
-                    'summary': "update a #{relation.first.singularize}",
-                    'description': table_description,
-                    'parameters': relation.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
-                      param = { 'name' => k, 'schema': { 'type': v.first } }
-                      if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
-                        param['description'] = col_descrip
-                      end
-                      param
-                    end,
-                    'responses': { '200': { 'description': 'successful' } }
+            _schema, @_is_show_schema_list = ::Brick.set_db_schema(params || api_params)
+
+            if is_openapi
+              json = { 'openapi': '3.0.1', 'info': { 'title': Rswag::Ui.config.config_object[:urls].last&.fetch(:name, 'API documentation'), 'version': ::Brick.config.api_version },
+                       'servers': [
+                         { 'url': '{scheme}://{defaultHost}', 'variables': {
+                           'scheme': { 'default': request.env['rack.url_scheme'] },
+                           'defaultHost': { 'default': request.env['HTTP_HOST'] }
+                         } }
+                       ]
+                     }
+              json['paths'] = relations.inject({}) do |s, relation|
+                unless ::Brick.config.enable_api == false
+                  table_description = relation.last[:description]
+                  s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}"] = {
+                    'get': {
+                      'summary': "list #{relation.first}",
+                      'description': table_description,
+                      'parameters': relation.last[:cols].map do |k, v|
+                                      param = { 'name' => k, 'schema': { 'type': v.first } }
+                                      if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
+                                        param['description'] = col_descrip
+                                      end
+                                      param
+                                    end,
+                      'responses': { '200': { 'description': 'successful' } }
+                    }
                   }
-                } unless relation.last.fetch(:isView, nil)
-                s
+
+                  s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}/{id}"] = {
+                    'patch': {
+                      'summary': "update a #{relation.first.singularize}",
+                      'description': table_description,
+                      'parameters': relation.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
+                        param = { 'name' => k, 'schema': { 'type': v.first } }
+                        if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
+                          param['description'] = col_descrip
+                        end
+                        param
+                      end,
+                      'responses': { '200': { 'description': 'successful' } }
+                    }
+                  } unless relation.last.fetch(:isView, nil)
+                  s
+                end
               end
+              render inline: json.to_json, content_type: request.format
+              return
             end
-            render inline: json.to_json, content_type: request.format
-            return
-          end
 
-          if request.format == :csv # Asking for a template?
-            require 'csv'
-            exported_csv = CSV.generate(force_quotes: false) do |csv_out|
-              model.df_export(model.brick_import_template).each { |row| csv_out << row }
+            if request.format == :csv # Asking for a template?
+              require 'csv'
+              exported_csv = CSV.generate(force_quotes: false) do |csv_out|
+                model.df_export(model.brick_import_template).each { |row| csv_out << row }
+              end
+              render inline: exported_csv, content_type: request.format
+              return
+            elsif request.format == :js || request.path.start_with?('/api/') # Asking for JSON?
+              data = (model.is_view? || !Object.const_defined?('DutyFree')) ? model.limit(1000) : model.df_export(model.brick_import_template)
+              render inline: data.to_json, content_type: request.format == '*/*' ? 'application/json' : request.format
+              return
             end
-            render inline: exported_csv, content_type: request.format
-            return
-          elsif request.format == :js || request.path.start_with?('/api/') # Asking for JSON?
-            data = (model.is_view? || !Object.const_defined?('DutyFree')) ? model.limit(1000) : model.df_export(model.brick_import_template)
-            render inline: data.to_json, content_type: request.format == '*/*' ? 'application/json' : request.format
-            return
-          end
 
-          # Normal (not swagger or CSV) request
-
-          # %%% Allow params to define which columns to use for order_by
-          # Overriding the default by providing a querystring param?
-          ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
-          order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
-
-          ar_relation = ActiveRecord.version < Gem::Version.new('4') ? model.preload : model.all
-          @_brick_params = ar_relation.brick_select(params, (selects = []), order_by,
-                                                             translations = {},
-                                                             join_array = ::Brick::JoinArray.new)
-          # %%% Add custom HM count columns
-          # %%% What happens when the PK is composite?
-          counts = model._br_hm_counts.each_with_object([]) do |v, s|
-            s << if is_mysql
-                   "`b_r_#{v.first}`.c_t_ AS \"b_r_#{v.first}_ct\""
-                 elsif is_postgres
-                   "\"b_r_#{v.first}\".c_t_ AS \"b_r_#{v.first}_ct\""
-                 else
-                   "b_r_#{v.first}.c_t_ AS \"b_r_#{v.first}_ct\""
-                 end
-          end
-          ar_select = ar_relation.respond_to?(:_select!) ? ar_relation.dup._select!(*selects, *counts) : ar_relation.select(selects + counts)
-          instance_variable_set("@#{table_name.pluralize}".to_sym, ar_select)
-          if namespace && (idx = lookup_context.prefixes.index(table_name))
-            lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
-          end
-          @_brick_excl = session[:_brick_exclude]&.split(',')&.each_with_object([]) do |excl, s|
-                           if (excl_parts = excl.split('.')).first == table_name
-                             s << excl_parts.last
+            # Normal (not swagger or CSV) request
+
+            # %%% Allow params to define which columns to use for order_by
+            # Overriding the default by providing a querystring param?
+            ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
+            order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
+
+            ar_relation = ActiveRecord.version < Gem::Version.new('4') ? model.preload : model.all
+
+            if (cc = params['_brick_api']&.split(','))
+              is_api = true
+              selects = cc
+              counts = [] # No need for any extra HM count columns
+              model._br_cust_cols.clear
+            end
+
+            @_brick_params = ar_relation.brick_select(params, (selects ||= []), order_by,
+                                                               translations = {},
+                                                               join_array = ::Brick::JoinArray.new)
+            # %%% Add custom HM count columns
+            # %%% What happens when the PK is composite?
+            counts = model._br_hm_counts.each_with_object([]) do |v, s|
+              s << if is_mysql
+                     "`b_r_#{v.first}`.c_t_ AS \"b_r_#{v.first}_ct\""
+                   elsif is_postgres
+                     "\"b_r_#{v.first}\".c_t_ AS \"b_r_#{v.first}_ct\""
+                   else
+                     "b_r_#{v.first}.c_t_ AS \"b_r_#{v.first}_ct\""
+                   end
+            end
+
+            ar_select = ar_relation.respond_to?(:_select!) ? ar_relation.dup._select!(*selects, *counts) : ar_relation.select(selects + counts)
+            instance_variable_set("@#{table_name.pluralize}".to_sym, ar_select)
+            if namespace && (idx = lookup_context.prefixes.index(table_name))
+              lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
+            end
+            @_brick_excl = session[:_brick_exclude]&.split(',')&.each_with_object([]) do |excl, s|
+                             if (excl_parts = excl.split('.')).first == table_name
+                               s << excl_parts.last
+                             end
                            end
-                         end
-          @_brick_bt_descrip = model._br_bt_descrip
-          @_brick_hm_counts = model._br_hm_counts
-          @_brick_join_array = join_array
-          @_brick_erd = params['_brick_erd']&.to_i
+            @_brick_bt_descrip = model._br_bt_descrip
+            @_brick_hm_counts = model._br_hm_counts
+            @_brick_join_array = join_array
+            @_brick_erd = params['_brick_erd']&.to_i
+          end
         end
 
-        unless is_openapi
+        unless is_openapi || is_avo
           _, order_by_txt = model._brick_calculate_ordering(default_ordering(table_name, pk)) if pk
           code << "  def index\n"
           code << "    @#{table_name.pluralize} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"

data/lib/brick/frameworks/rails/controller.rb

@@ -3,7 +3,7 @@
 module Brick
   module Rails
     # Extensions to rails controllers. Provides convenient ways to pass certain
-    # information to the model layer, with `controller_info` and `whodunnit`.
+    # information to the model layer, with `controller_info`.
     # Also includes a convenient on/off switch,
     # `brick_enabled_for_controller`.
     module Controller