brick 1.0.228 → 1.0.230

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ada376a5ef8d35110b7228a583cdcb18e5246fcfa52b975aff872c9a2ac7e37d
-  data.tar.gz: 7621c881fcacca08f8b9543371fbcb190c0513e5d8c8b6bc2c767a51a48ef43e
+  metadata.gz: 5230864d4450f23406da3efcab54e2c337ae9029c2b9fea3d1b8df1bb34583dd
+  data.tar.gz: b16f195b58d0df45611f8a2251e005ae6cc841970fb1c6eea17119af678d62a8
 SHA512:
-  metadata.gz: 8ccbeae9b7cf7874653de1666af8a708e77126248eadec4cd80d1766f33063f93a7b198aabdb02895e9a8456d89b63f36a15d6348a70a9b9ead928b7a29c1567
-  data.tar.gz: 7fc00087943b2b7fdab18783793057772f59a1e98896239a8cc4c4d91f7aa41201265931393201a399c3b3261186a7e56deb4d8703cb46676eafd5a10ab3fa22
+  metadata.gz: 55e9c658e0c258be349866a82f7c5a62234779aa27e7a5e04517979dbccdf9475948fecb2de8f78604daf773094e9a19f8a3c32b9d64ef5c8948cbd3fa4dffe2
+  data.tar.gz: a00b991cd2d4125e10baada1d070440d4b25a99994e462e543acafdcdcf4cf5a4703e7b0fc60dd2e6989e933828a9eb0355610f6901b9b2ca9d5a047a61260a3

data/lib/brick/extensions.rb

@@ -979,7 +979,8 @@ module ActiveRecord
           next
         end
 
-        tbl_alias = unique63("b_r_#{hm.name}", previous)
+        tbl_alias = "b_r_#{hm.name}"
+        tbl_alias = unique63(tbl_alias, previous) if is_postgres
         on_clause = []
         hm_selects = if !pri_key.is_a?(Array) # Probable standard key?
                        if fk_col.is_a?(Array) # Foreign is composite but not Primary?  OK, or choose the first part of the foreign key if nothing else
@@ -1031,19 +1032,28 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
       unless wheres.empty?
         # Rewrite the wheres to reference table and correlation names built out by AREL
         where_nots = {}
+        where_comparisons = []
         wheres2 = wheres.each_with_object({}) do |v, s|
           is_not = if v.first[-1] == '!'
                      v[0] = v[0][0..-2] # Take off ending ! from column name
                    end
-          if (v_parts = v.first.split('.')).length == 1
-            (is_not ? where_nots : s)[v.first] = v.last
+          tbl_and_col_name = if (v_parts = v.first.split('.')).length == 1
+                               []
+                             else
+                               [brick_links[v_parts[0..-2].join('.')].split('.').last]
+                             end
+          tbl_and_col_name << v_parts.last
+          if ['>', '<'].include?(first_char = v.last.first[0]) # Greater than or less than?
+            col_name = v.last.first[1..-1]
+            col_name = "'#{col_name}'" unless [:integer, :boolean, :decimal, :float].include?(klass.columns_hash[v.first].type)
+            where_comparisons << "#{tbl_and_col_name.join('.')} #{first_char} #{col_name}"
           else
-            tbl_name = brick_links[v_parts[0..-2].join('.')].split('.').last
-            (is_not ? where_nots : s)["#{tbl_name}.#{v_parts.last}"] = v.last
+            (is_not ? where_nots : s)[tbl_and_col_name.join('.')] = v.last
           end
         end
         if respond_to?(:where!)
           where!(wheres2) if wheres2.present?
+          where_comparisons.each { |wc| where!(wc) }
           if where_nots.present?
             self.where_clause += WhereClause.new(predicate_builder.build_from_hash(where_nots)).invert
           end
@@ -1106,8 +1116,7 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
 
     # Build out an AR relation that queries for a list of objects, and include all the appropriate JOINs to later apply DSL using #brick_descrip
     def brick_list
-      pks = klass.primary_key.is_a?(String) ? [klass.primary_key] : klass.primary_key
-      selects = pks.each_with_object([]) { |pk, s| s << pk unless s.include?(pk) }
+      selects = klass._pk_as_array.each_with_object([]) { |pk, s| s << pk unless s.include?(pk) }
       # Get foreign keys for anything marked to be auto-preloaded, or a self-referencing JOIN
       klass_cols = klass.column_names
       reflect_on_all_associations.each do |a|
@@ -1740,52 +1749,6 @@ class Object
       built_model = Class.new(base_model) do |new_model_class|
         (schema_module || Object).const_set(chosen_name, new_model_class) unless is_generator
         @_brick_relation = relation
-        # Enable Elasticsearch for this one?
-        access = ::Brick.elasticsearch_models&.is_a?(Hash) ? ::Brick.elasticsearch_models[name] : ::Brick.elasticsearch_models
-        @_brick_es_crud ||= case access
-                            when String
-                              access
-                            when :all, :full
-                              'icrud' # Auto-create index, and full CRUD
-                            else
-                              ''
-                            end
-        unless @_brick_es_crud.blank?
-          include ::Elasticsearch::Model
-          code << "  include Elasticsearch::Model\n"
-          if @_brick_es_crud.index('i') # Enable auto-creation of indexes on import?
-            class << self
-              alias _original_import import
-              def import(options={}, &block)
-                self.__elasticsearch__.create_index! unless self.__elasticsearch__.index_exists?
-                _original_import(options={}, &block)
-              end
-            end
-          end
-          if @_brick_es_crud.index('c') || @_brick_es_crud.index('u') || @_brick_es_crud.index('d')
-            include ::Elasticsearch::Model::Callbacks
-            code << "  include Elasticsearch::Model::Callbacks\n"
-          end
-          if @_brick_es_crud.index('r')
-            # Customer.__elasticsearch__.search('taco').to_a
-          end
-          # # Need some mappings for text columns
-          # mappings do
-          #   indexes :company_name, type: 'text'
-          #   indexes :country, type: 'text'
-          # end
-          # def self.search(q)
-          #   s = self.__elasticsearch__.search(q)
-          #   binding.pry
-          #   s.to_a
-          # #   class Elasticsearch::Model::Response::Response
-          # #     def to_a
-          # #   end
-          # # rescue Elastic::Transport::Transport::Errors::NotFound => e
-          # #   self.create_index!
-          # #   self.__elasticsearch__.search(q)
-          # end
-        end
         if inheritable_name
           new_model_class.define_singleton_method :inherited do |subclass|
             super(subclass)
@@ -1858,6 +1821,59 @@ class Object
           end
         end
 
+        # Enable Elasticsearch based on the table name?
+        if (@_brick_es_crud = ::Brick.elasticsearch_models&.fetch(matching, nil))
+          include ::Elasticsearch::Model
+          if @_brick_es_crud.index('i') # Enable auto-creation of indexes on import?
+            class << self
+              alias _original_import import
+              def import(options={}, &block)
+                unless self.__elasticsearch__.index_exists?
+                  self.__elasticsearch__.create_index!
+                  ::Brick.elasticsearch_existings[self.table_name] = self.table_name.tr('.', '-').pluralize
+                end
+                _original_import(options={}, &block)
+              end
+            end
+          end
+          if ::Elasticsearch::Model.const_defined?('Callbacks') &&
+             @_brick_es_crud.index('c') || @_brick_es_crud.index('u') || @_brick_es_crud.index('d')
+            include ::Elasticsearch::Model::Callbacks
+            is_include_es_callbacks = true
+          end
+          # Create mappings for all text columns
+          mappings do
+            has_mappings = nil
+            new_model_class.columns.select { |col| [:string, :text].include?(col.type) }.each do |string_col|
+              unless has_mappings
+                code << "  include Elasticsearch::Model\n"
+                code << "  include Elasticsearch::Model::Callbacks\n" if is_include_es_callbacks
+                code << "  mappings do\n"
+                has_mappings = true
+              end
+              code << "    indexes :#{string_col.name}, type: 'text'\n"
+              indexes string_col.name.to_sym, type: 'text'
+            end
+            code << "  end\n" if has_mappings
+          end
+          if @_brick_es_crud.index('r')
+            class << self
+              # Search and hydrate records using only Elasticsearch data
+              define_method :search do |q|
+                self.__elasticsearch__.search(q).raw_response.body['hits']['hits'].map do |hit|
+                  obj = self.new(hit['_source'])
+                  obj.instance_variable_set(:@new_record, false) # Don't want to accidentally save a new one
+                  obj
+                end
+              rescue Elastic::Transport::Transport::Errors::NotFound => e
+                self.__elasticsearch__.create_index! if @_brick_es_crud.index('i')
+                ::Brick.elasticsearch_existings[self.table_name] = self.table_name.tr('.', '-').pluralize
+                []
+              end
+            end
+          end
+        end
+
         unless is_sti
           fks = relation[:fks] || {}
           # Do the bulk of the has_many / belongs_to processing, and store details about HMT so they can be done at the very last
@@ -2272,6 +2288,39 @@ class Object
             render json: { data: result } # [ver, result]
           end
 
+          self.define_method :search do
+            # TODO: Make sure at least one index is actually present which allows for reading before attempting
+            if (@qry = params['qry'] || params['_brick_es']) # Elasticsearch query?
+              @indexes = ::Brick.elasticsearch_existings&.keys
+              hits = Elasticsearch::Model.client.search({index: @indexes.join(','), q: @qry, size: 100})
+              model_infos = {}
+              # Number of indexes used:  hits.body['_shards']['total']
+              @count = hits.body['hits']['total']['value']
+              @results = hits.body['hits']['hits'].map do |x|
+                klass = ::Brick.relations[::Brick.elasticsearch_existings[x['_index']]][:class_name].constantize
+                model_info = model_infos[klass] ||= [
+                  klass.primary_key,
+                  klass.brick_parse_dsl(join_array = ::Brick::JoinArray.new, [], translations = {}, false, nil, true)
+                ]
+                obj = klass.new(x['_source'])
+                [
+                  klass.name,
+                  obj.send(model_info.first),
+                  obj.brick_descrip(
+                    model_info.last&.first&.map { |col2| obj.send(col2.last) },
+                    obj.send(klass.primary_key)
+                  ),
+                  send("#{klass._brick_index(:singular)}_path".to_sym, obj),
+                  x['_score']
+                ]
+              end
+              respond_to do |format|
+                format.js { render json: { result: @results } }
+                format.any {}
+              end
+            end
+          end
+
           return [new_controller_class, code + "end # BrickGem controller\n"]
         when 'BrickOpenapi'
           is_openapi = true
@@ -2584,7 +2633,26 @@ class Object
               render json: { result: ::Brick.unexclude_column(table_name, col) }
             elsif is_json && (q = params['_brick_es']) # Elasticsearch
               # Make sure that the index is actually present and we allow reading before attempting
-              es_result = model.__elasticsearch__.search(q).to_a if (es_perms = model.instance_variable_get(:@_brick_es_crud)).index('r')
+              if (es_perms = model.instance_variable_get(:@_brick_es_crud) ||
+                             # If a perms instance variable is missing for this model, get the perms ...
+                             (set = true && ::Brick.elasticsearch_models&.fetch(model.table_name, nil))
+                 ) && (
+                  # ... then set it on the model
+                  (set && model.instance_variable_set(:@_brick_es_crud, es_perms)) || es_perms
+                 )&.index('r')
+                es_result = begin
+                              model.__elasticsearch__.search(q)
+                            rescue Elastic::Transport::Transport::Errors::NotFound => e
+                              if @_brick_es_crud.index('i')
+                                self.__elasticsearch__.create_index!
+                                # model.import
+                                ::Brick.elasticsearch_existings[self.table_name] = self.table_name.tr('.', '-').pluralize
+                                model.__elasticsearch__.search(q)
+                              else
+                                []
+                              end
+                            end
+              end
               render json: { result: es_result }
             else
               real_model = model.real_model(params)
@@ -3254,7 +3322,7 @@ module Brick
         # Rails applies an _index suffix to that route when the resource name isn't something plural
         index << '_index' if mode != :singular && !not_path &&
                              index == (
-                                        index2 + [relation[:class_name][(relation&.fetch(:auto_prefixed_class, nil)&.length&.+ 2) || 0..-1]&.underscore&.tr('/', '_') || '_']
+                                        index2 + [relation[:class_name]&.[]((relation&.fetch(:auto_prefixed_class, nil)&.length&.+ 2) || 0..-1)&.underscore&.tr('/', '_') || '_']
                                       ).join(separator)
       end
       index

data/lib/brick/rails/engine.rb

@@ -671,10 +671,16 @@ window.addEventListener(\"popstate\", linkSchemas);
             def find_template(*args, **options)
               find_template_err = nil
               unless (model_name = @_brick_model&.name) ||
-                     (is_search = ::Brick.config.add_search && args[0..1] == ['search', ['brick_gem']]) ||
-                     (is_status = ::Brick.config.add_status && args[0..1] == ['status', ['brick_gem']]) ||
-                     (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']]) ||
-                     (is_crosstab = args[0..1] == ['crosstab', ['brick_gem']])
+                     (
+                      args[1].first == 'brick_gem' &&
+                      ((is_search = ::Brick.config.add_search && args[0] == 'search' &&
+                                    ::Brick.elasticsearch_existings&.length&.positive?
+                       ) ||
+                       (is_status = ::Brick.config.add_status && args[0] == 'status') ||
+                       (is_orphans = ::Brick.config.add_orphans && args[0] == 'orphans') ||
+                       (is_crosstab = args[0] == 'crosstab')
+                      )
+                     )
                 begin
                   if (possible_template = _brick_find_template(*args, **options))
                     return possible_template
@@ -792,7 +798,7 @@ window.addEventListener(\"popstate\", linkSchemas);
                                 b[0] = '' if b[0].is_a?(Symbol)
                                 a.first <=> b.first
                               end.each_with_object(+'') do |rel, s|
-                                next if rel.first.blank? || rel.last[:cols].empty? ||
+                                next if rel.first.is_a?(Symbol) || rel.first.blank? || rel.last[:cols].empty? ||
                                         ::Brick.config.exclude_tables.include?(rel.first)
 
                                 # %%% When table_name_prefixes are use then during rendering empty non-TNP
@@ -805,7 +811,7 @@ window.addEventListener(\"popstate\", linkSchemas);
                               end.html_safe
               # Options for special Brick pages
               prefix = "#{::Brick.config.path_prefix}/" if ::Brick.config.path_prefix
-              [['Search', ::Brick.config.add_search],
+              [['Search', is_search],
                ['Status', ::Brick.config.add_status],
                ['Orphans', is_orphans],
                ['Crosstab', is_crosstab]].each do |table_option, show_it|
@@ -1084,13 +1090,14 @@ end
 <% end
    # SEARCH BOX
    if @_brick_es&.index('r') # Must have at least Elasticsearch Read access %>
-  <input type=\"text\" id=\"esSearch\"><a href=\"\">S</a>
+  <input type=\"text\" id=\"esSearch\" class=\"dimmed\">
   <script>
-    var esSearch = document.getElementById(\"esSearch\")
+    var esSearch = document.getElementById(\"esSearch\");
+    var usedTerms = {};
     var isEsFiltered = false;
     esSearch.addEventListener(\"input\", function () {
       var gridTrs;
-      if (this.value.length > 2) { # At least 3 letters in the search term
+      if (this.value.length > 2 && usedTerms[this.value] !== null) { // At least 3 letters in the search term
         var es = doFetch(\"POST\", {_brick_es: this.value},
           function (p) {p.text().then(function (response) {
             var result = JSON.parse(response).result;
@@ -1111,13 +1118,16 @@ end
                 if (!isHit) row.style.display = \"none\";
               }
               isEsFiltered = true;
+              esSearch.className = \"\";
             } else {
               if (isEsFiltered) { // Show all rows and gray the search box
+                usedTerms[this.value] = null; // No results for this term
                 gridTrs = [... grid.querySelectorAll(\"tr\")];
                 for (var i = 1; i < gridTrs.length; ++i) {
                   gridTrs[i].style.display = \"table-row\";
                 }
               }
+              esSearch.className = \"dimmed\";
             }
           });}
         );
@@ -1127,6 +1137,7 @@ end
           for (var i = 1; i < gridTrs.length; ++i) {
             gridTrs[i].style.display = \"table-row\";
           }
+          esSearch.className = \"dimmed\";
         }
       }
     });
@@ -1211,21 +1222,28 @@ end
 +"#{css}
 <p class=\"flashNotice\"><%= notice if request.respond_to?(:flash) %></p>#{"
 #{schema_options}" if schema_options}
-<select id=\"tbl\">#{table_options}</select>
-<h1>Search</h1>
+<select id=\"tbl\">#{table_options}</select><br><br>
+<form method=\"get\">
+  <input type=\"text\" name=\"qry\"<%= \" value=\\\"#\{@qry}\\\"\".html_safe unless @qry.blank? %>><input type=\"submit\", value=\"Search\">
+</form>
+<% if @results.present? %>
+<div id=\"rowCount\"><b><%= @count %> results from: </b><%= @indexes.sort.join(', ') %></div>
+<% end %>
 <table id=\"resourceName\" class=\"shadow\"><thead><tr>
   <th>Resource</th>
   <th>Description</th>
-  <th>ID</th>
+  <th>Score</th>
 </tr></thead>
 <tbody>
-<% # @results.each do |r| %>
+<% @results&.each do |r| %>
   <tr>
-  <td><%= %></td>
-  <td<%=  %></td>
-  <td<%=  %></td>
+  <td><%= link_to (r[3]) do %><%= r[0] %><br>
+      <%= r[1] %><% end %>
+  </td>
+  <td><%= r[2] %></td>
+  <td><%= '%.3f' % r[4] %></td>
   </tr>
-<% # end %>
+<% end %>
 </tbody></table>
 #{script}"
                          end
@@ -1645,9 +1663,13 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
    # %%% Create a smart javascript routine which can do this client-side %>
 [... document.getElementsByTagName(\"TH\")].forEach(function (th) {
   th.addEventListener(\"click\", function (e) {
-    var xOrder;
-    if (xOrder = this.getAttribute(\"x-order\"))
+    var xOrder,
+        currentOrder;
+    if (xOrder = this.getAttribute(\"x-order\")) {
+      if ((currentOrder = changeout(location.href, \"_brick_order\")) === xOrder)
+        xOrder = \"-\" + xOrder;
       location.href = changeout(location.href, \"_brick_order\", xOrder);
+    }
   });
 });
 document.querySelectorAll(\"input, select\").forEach(function (inp) {

data/lib/brick/reflect_tables.rb

@@ -28,7 +28,8 @@ module Brick
             def method_missing(name, *args, &block)
               _original_method_missing(name, *args, &block)
             rescue Elastic::Transport::Transport::Errors::NotFound => e
-              if (missing_index = args.last&.fetch(:defined_params, nil)&.fetch(:index, nil))
+              if (missing_index = args.last&.fetch(:defined_params, nil)&.fetch(:index, nil)) &&
+                 ::Brick.elasticsearch_models&.fetch(missing_index, nil)&.include?('i')
                 self.indices.create({ index: missing_index,
                                       body: { settings: {}, mappings: { properties: {} } } })
                 puts "Auto-creating missing index \"#{missing_index}\""
@@ -47,34 +48,19 @@ module Brick
           begin
             cluster_info = client.info.body
             if (es_ver = cluster_info['version'])
-              ::Brick.elasticsearch_models = :all
               puts "Found Elasticsearch gem and #{'local ' unless es_uri}#{es_ver['distribution'].titleize} #{es_ver['number']} installation#{" at #{es_uri}" if es_uri}."
-              puts "Enable Elasticsearch support by either setting \"::Brick.elasticsearch_models = :all\" or by picking specific models by name."
-
-              # # Auto-create when trying to import and there is a missing index
-              # ::Elasticsearch::Model::Importing.class_exec do
-              # end
+              if ::Brick.elasticsearch_models.empty?
+                puts "Enable Elasticsearch support by either setting \"::Brick.elasticsearch_models = :all\" or by picking specific models by name."
+              end
+            else
+              ::Brick.elasticsearch_models = nil
             end
           rescue StandardError => e # Errno::ECONNREFUSED
+            ::Brick.elasticsearch_models = nil
             puts "Found Elasticsearch gem, but could not connect to #{'local ' unless es_uri}Elasticsearch/Opensearch server#{" at #{es_uri}" if es_uri}."
           end
-        # require 'net/http'
-        #   begin
-        #     es_uri = ENV['ELASTICSEARCH_URL']
-        #     binding.pry
-        #     cluster_info = JSON.parse(Net::HTTP.get(URI.parse(es_uri || 'http://localhost:9200')))
-        #     if (es_ver = cluster_info['version'])
-        #       ::Brick.elasticsearch_models = :all
-        #       puts "Found Elasticsearch gem and #{'local ' unless es_uri}#{es_ver['distribution'].titleize} #{es_ver['number']} installation#{" at #{es_uri}" if es_uri}."
-        #       puts "Enable Elasticsearch support by either setting \"::Brick.elasticsearch_models = :all\" or by picking specific models by name."
-        #     end
-        #   rescue StandardError => e
-        #   end
         end
       end
-      # client = Elasticsearch::Client.new(host: 'https://my-elasticsearch-host.example')
-      # client.ping
-      # client.search(q: 'test')
 
       # Overwrite SQLite's #begin_db_transaction so it opens in IMMEDIATE mode instead of
       # the default DEFERRED mode.
@@ -527,6 +513,52 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         end
       end
 
+      if ems = ::Brick.elasticsearch_models # ['comments']
+        access = case ems
+                 when Hash, String # Hash is a list of resource names and ES permissions such as 'r' or 'icr'
+                   ems
+                 when :all
+                   'crud' # All CRUD
+                 when :full
+                   'icrud' # Also able to auto-create indexes
+                 else
+                   ''
+                 end
+        # Rewriting this to have all valid indexes and their perms
+        ::Brick.elasticsearch_models = unless access.blank?
+          # Find all existing indexes
+          client = Elastic::Transport::Client.new
+          ::Brick.elasticsearch_existings = client.perform_request('GET', '_aliases').body.each_with_object({}) do |entry, s|
+            rel_name = entry.first.tr('-', '.')
+            s[entry.first] = rel_name if relations.include?(entry.first)
+            s[entry.first] = rel_name.singularize if relations.include?(rel_name.singularize)
+            entry.last.fetch('aliases', nil)&.each do |k, _v|
+              rel_name = k.tr('-', '.')
+              s[k] = rel_name if relations.include?(rel_name)
+              s[k] = rel_name.singularize if relations.include?(rel_name.singularize)
+            end
+          end
+          # Add this either if...
+          if access.is_a?(String) # ...they have permissions over absolutely anything,
+            relations.each_with_object({}) do |rel, s|
+              next if rel.first.is_a?(Symbol)
+
+              perms = rel.last.fetch(:isView, nil) ? access.tr('cud', '') : access
+              s[rel.first] = perms
+            end
+          else # or there are specific permissions for each resource, so find the matching indexes
+            client = Elastic::Transport::Client.new
+            ::Brick.elasticsearch_existings.each_with_object({}) do |index, s|
+              this_access = access.is_a?(String) ? access : access[index.first] || '' # Look up permissions from above
+              next unless (rel = relations.fetch(index.first, nil))
+
+              perms = rel&.fetch(:isView, nil) ? this_access.tr('cud', '') : this_access
+              s[index.first] = perms unless perms.blank?
+            end
+          end
+        end
+      end
+
       if orig_schema && (orig_schema = (orig_schema - ['pg_catalog', 'pg_toast', 'heroku_ext']).first)
         puts "Now switching back to \"#{orig_schema}\" schema."
         ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", orig_schema)

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 228
+    TINY = 230
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

data/lib/brick.rb

@@ -111,7 +111,7 @@ module Brick
                   :established_drf,
                   :is_oracle, :is_eager_loading, :auto_models, :initializer_loaded,
                   :table_name_lookup,
-                  :elasticsearch_models,
+                  :elasticsearch_models, :elasticsearch_existings,
                   :routes_done
     ::Brick.auto_models = []
 
@@ -292,6 +292,10 @@ to instead be this:
             s.first[bt_key] = [a.name, a.klass]
           end
         else # This gets all forms of has_many and has_one
+          if a.scope&.arity&.> 0
+            puts "Skipping HM column \"#{a.name}\" because it has a scope which requires #{a.scope.arity} #{'argument'.pluralize(a.scope.arity)}"
+            next
+          end
           if through # has_many :through or has_one :through
             is_invalid_source = nil
             begin