brick 1.0.189 → 1.0.191

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 382e04c6f26509410cbd0660360620ad0ada6f40492babff8c65af9e53e41b02
-  data.tar.gz: 4a6cb0143dce1953a601cf26e7217d3723fc36c8ab2ba45750ce21761d931e14
+  metadata.gz: 193982ca353a787d619e46d02b5d7a671c2b05936a2bf96c7f4c92fbba2b467c
+  data.tar.gz: 065f9abdc32f6d6413caf955ab7f01cd2a300b24532f215471aadf82ec9bdc93
 SHA512:
-  metadata.gz: 45cb41aa504aa8171387e3de188437d6a210b7c8769770c161e58cb566c850e2a557fc7a102538df42bfefb4a35c8f6d5d43e5b65b16920a1adcd2cf5b18068c
-  data.tar.gz: e67fcd671d56691628e2164d266c16d014aa78882d43a2e555b65816b347df8dc61c92df1986e716cd613b25dae7a35160b7e3995dd9a842a41e73a75d75540d
+  metadata.gz: 363c321fac7e13b4ccbe4bd9ed8b10f1a525641c0da3db0c5ee2bc49f6b1a7b0b0254c11fdb9d42c4ab2ab2c9c7e673a4f6c25e063315bcafcede48cc3096692
+  data.tar.gz: 9f27685f8621482b2130a66d5c7d149d41b108dc73f800d060f26ab757f09f06bb3c675b22db0dc37e666a55cdcd0b5ead274232913893d48881809cbf58e72e

data/lib/brick/config.rb

@@ -399,6 +399,14 @@ module Brick
       @mutex.synchronize { @not_nullables = columns }
     end
 
+    def omit_empty_tables_in_dropdown
+      @mutex.synchronize { @omit_empty_tables_in_dropdown }
+    end
+
+    def omit_empty_tables_in_dropdown=(field_set)
+      @mutex.synchronize { @omit_empty_tables_in_dropdown = field_set }
+    end
+
     def always_load_fields
       @mutex.synchronize { @always_load_fields || {} }
     end

data/lib/brick/extensions.rb

@@ -98,6 +98,7 @@ module ActiveRecord
       end
 
       def _br_quoted_name(name)
+        name = name.join('.') if name.is_a?(Array)
         if name == '*'
           name
         elsif is_mysql
@@ -328,27 +329,10 @@ module ActiveRecord
     end
 
     # Providing a relation object allows auto-modules built from table name prefixes to work
-    def self._brick_index(mode = nil, separator = '_', relation = nil)
+    def self._brick_index(mode = nil, separator = nil, relation = nil)
       return if abstract_class?
 
-      tbl_parts = ((mode == :singular) ? table_name.singularize : table_name).split('.')
-      tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == ::Brick.apartment_default_tenant
-      if (aps = relation&.fetch(:auto_prefixed_schema, nil)) && tbl_parts.last.start_with?(aps)
-        last_part = tbl_parts.last[aps.length..-1]
-        aps = aps[0..-2] if aps[-1] == '_'
-        tbl_parts[-1] = aps
-        tbl_parts << last_part
-      end
-      path_prefix = []
-      if ::Brick.config.path_prefix
-        tbl_parts.unshift(::Brick.config.path_prefix)
-        path_prefix << ::Brick.config.path_prefix
-      end
-      index = tbl_parts.map(&:underscore).join(separator)
-      # Rails applies an _index suffix to that route when the resource name isn't something plural
-      index << '_index' if mode != :singular && separator == '_' &&
-                           index == (path_prefix + [name&.underscore&.tr('/', '_') || '_']).join(separator)
-      index
+      ::Brick._brick_index(table_name, mode, separator, relation)
     end
 
     def self.brick_import_template
@@ -685,7 +669,7 @@ module ActiveRecord
       (cust_col_override || klass._br_cust_cols).each do |k, cc|
         if rel_dupe.respond_to?(k) # Name already taken?
           # %%% Use ensure_unique here in this kind of fashion:
-          # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
+          # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", nil, bts, hms)
           # binding.pry
           next
         end
@@ -805,6 +789,7 @@ module ActiveRecord
 
       # Add derived table JOIN for the has_many counts
       nix = []
+      previous = []
       klass._br_hm_counts.each do |k, hm|
         count_column = if hm.options[:through]
                          # Build the chain of JOINs going to the final destination HMT table
@@ -831,7 +816,7 @@ module ActiveRecord
                            through_sources.push(this_hm = src_ref.active_record.reflect_on_association(thr))
                          end
                          through_sources.push(src_ref) unless src_ref.belongs_to?
-                         from_clause = +"#{through_sources.first.table_name} br_t0"
+                         from_clause = +"#{_br_quoted_name(through_sources.first.table_name)} br_t0"
                          fk_col = through_sources.shift.foreign_key
 
                          idx = 0
@@ -899,7 +884,7 @@ module ActiveRecord
           next
         end
 
-        tbl_alias = "b_r_#{hm.name}"
+        tbl_alias = unique63("b_r_#{hm.name}", previous)
         on_clause = []
         hm_selects = if fk_col.is_a?(Array) # Composite key?
                        fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl.table_name}.#{pri_key[idx]}" }
@@ -1104,6 +1089,19 @@ Might want to add this in your brick.rb:
     def shift_or_first(ary)
       ary.length > 1 ? ary.shift : ary.first
     end
+
+    def unique63(name, previous)
+      name = name[0..62] if name.length > 63
+      unique_num = 1
+      loop do
+        break unless previous.include?(name)
+
+        unique_suffix = "_#{unique_num += 1}"
+        name = "#{name[0..name.length - unique_suffix.length - 1]}#{unique_suffix}"
+      end
+      previous << name
+      name
+    end
   end
 
   module Inheritance
@@ -1714,7 +1712,8 @@ class Object
               # options[:class_name] = hm.first[:inverse_table].singularize.camelize
               # options[:foreign_key] = hm.first[:fk].to_sym
               far_assoc = relations[hm.first[:inverse_table]][:fks].find { |_k, v| v[:assoc_name] == hm[1] }
-              options[:class_name] = ::Brick.namify(far_assoc.last[:inverse_table], :underscore).camelize
+              # Was:  ::Brick.namify(far_assoc.last[:inverse_table], :underscore).camelize
+              options[:class_name] = relations[far_assoc.last[:inverse_table]][:class_name]
               options[:foreign_key] = far_assoc.last[:fk].to_sym
             end
             options[:source] ||= hm[1].to_sym unless hmt_name.singularize == hm[1]
@@ -1801,9 +1800,9 @@ class Object
          ::Brick.config.schema_behavior[:multitenant] && singular_table_parts.first == 'public'
         singular_table_parts.shift
       end
-      options[:class_name] = "::#{assoc[:primary_class]&.name ||
-                                  singular_table_parts.map { |p| ::Brick.namify(p, :underscore).camelize}.join('::')
-                                 }" if need_class_name
+      if need_class_name
+        options[:class_name] = "::#{assoc[:primary_class]&.name || ::Brick.relations[inverse_table][:class_name]}"
+      end
       if need_fk # Funky foreign key?
         options_fk_key = :foreign_key
         if assoc[:fk].is_a?(Array)
@@ -2558,6 +2557,8 @@ class Object
                                     assoc_name = assoc_parts.join('.')
                                   else
                                     class_name_parts = ::Brick.namify(hm_assoc[:inverse_table], :underscore).split('.')
+                                    last_idx = class_name_parts.length - 1
+                                    class_name_parts[last_idx] = class_name_parts[last_idx].singularize
                                     real_name = class_name_parts.map(&:camelize).join('::')
                                     needs_class = (real_name != hm_assoc[:inverse_table].camelize)
                                   end
@@ -2895,24 +2896,32 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       #   end
       # end
       # schema = ::Brick.default_schema # Reset back for this next round of fun
+      kcus = nil
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'Mysql2', 'Trilogy', 'SQLServer'
-        sql = "SELECT kcu1.CONSTRAINT_SCHEMA, kcu1.TABLE_NAME, kcu1.COLUMN_NAME,
-            kcu2.CONSTRAINT_SCHEMA AS primary_schema, kcu2.TABLE_NAME AS primary_table, kcu1.CONSTRAINT_NAME AS CONSTRAINT_SCHEMA_FK
+        # All KCUs -- use this to virtually JOIN against fk_references in Ruby code
+        sql = "SELECT CONSTRAINT_CATALOG, CONSTRAINT_SCHEMA, CONSTRAINT_NAME, ORDINAL_POSITION,
+                      TABLE_NAME, COLUMN_NAME
+              FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE#{"
+              WHERE CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }"
+        kcus = ActiveRecord::Base.execute_sql(sql).each_with_object({}) do |v, s|
+                 key = "#{v.fetch('constraint_name', v[2])}.#{v.fetch('constraint_schema', v[1])}.#{v.fetch('constraint_catalog', v[0])}.#{v.fetch('ordinal_position', v[3])}"
+                 key << ".#{v.fetch('table_name', v[4])}.#{v.fetch('column_name', v[5])}" unless is_postgres || is_mssql
+                 s[key] = [v.fetch('constraint_schema', v[1]), v.fetch('table_name', v[4])]
+               end
+
+        sql = "SELECT kcu.CONSTRAINT_SCHEMA, kcu.TABLE_NAME, kcu.COLUMN_NAME,
+            #{# These will get filled in with real values (effectively doing the JOIN in Ruby)
+              is_postgres || is_mssql ? 'NULL as primary_schema, NULL as primary_table' :
+                                        'kcu.REFERENCED_TABLE_NAME, kcu.REFERENCED_COLUMN_NAME'},
+            kcu.CONSTRAINT_NAME AS CONSTRAINT_SCHEMA_FK,
+            rc.UNIQUE_CONSTRAINT_NAME, rc.UNIQUE_CONSTRAINT_SCHEMA, rc.UNIQUE_CONSTRAINT_CATALOG, kcu.ORDINAL_POSITION
           FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
-            INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu1
-              ON kcu1.CONSTRAINT_CATALOG = rc.CONSTRAINT_CATALOG
-              AND kcu1.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
-              AND kcu1.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
-            INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu2
-              ON kcu2.CONSTRAINT_CATALOG = rc.UNIQUE_CONSTRAINT_CATALOG
-              AND kcu2.CONSTRAINT_SCHEMA = rc.UNIQUE_CONSTRAINT_SCHEMA
-              AND kcu2.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME#{"
-              AND kcu2.TABLE_NAME = kcu1.REFERENCED_TABLE_NAME
-              AND kcu2.COLUMN_NAME = kcu1.REFERENCED_COLUMN_NAME" unless is_postgres || is_mssql }
-              AND kcu2.ORDINAL_POSITION = kcu1.ORDINAL_POSITION#{"
-          WHERE kcu1.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }"
-          # AND kcu2.TABLE_NAME = ?;", Apartment::Tenant.current, table_name
+            INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu
+              ON kcu.CONSTRAINT_CATALOG = rc.CONSTRAINT_CATALOG
+              AND kcu.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
+              AND kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME#{"
+          WHERE kcu.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }"
         fk_references = ActiveRecord::Base.execute_sql(sql)
       when 'SQLite'
         sql = "SELECT NULL AS constraint_schema, m.name, fkl.\"from\", NULL AS primary_schema, fkl.\"table\", m.name || '_' || fkl.\"from\" AS constraint_name
@@ -2940,9 +2949,14 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       end
       ::Brick.is_oracle = true if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
       # ::Brick.default_schema ||= schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-      ::Brick.default_schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+      ::Brick.default_schema ||= 'public' if is_postgres
       fk_references&.each do |fk|
         fk = fk.values unless fk.is_a?(Array)
+        # Virtually JOIN against fk_references in order to change out the primary schema and primary table
+        if (kcu = kcus&.fetch("#{fk[6]}.#{fk[7]}.#{fk[8]}.#{fk[9]}", nil))
+          fk[3] = kcu[0]
+          fk[4] = kcu[1]
+        end
         # Multitenancy makes things a little more general overall, except for non-tenanted tables
         if ::Brick.is_apartment_excluded_table(::Brick.namify(fk[1]))
           fk[0] = ::Brick.apartment_default_tenant
@@ -2967,6 +2981,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         end
         ::Brick._add_bt_and_hm(fk, relations)
       end
+      kcus = nil # Allow this large item to be garbage collected
     end
 
     table_name_lookup = (::Brick.table_name_lookup ||= {})
@@ -2985,18 +3000,71 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
                                     &.find { |k1, _v1| singular.start_with?(k1) && singular.length > k1.length }
                       ).present?
                      v[:auto_prefixed_schema] = tnp.first
-                     v[:resource] = rel_name.last[(tnp_length = tnp.first.length)..-1]
-                     [tnp.last, singular[tnp_length..-1]]
+                     # v[:resource] = rel_name.last[tnp.first.length..-1]
+                     [tnp.last, singular[tnp.first.length..-1]]
                    else
-                     v[:resource] = rel_name.last
+                     # v[:resource] = rel_name.last
                      [singular]
                    end
-      v[:class_name] = (schema_names + name_parts).map { |p| ::Brick.namify(p, :underscore).camelize }.join('::')
+      proposed_name_parts = (schema_names + name_parts).map { |p| ::Brick.namify(p, :underscore).camelize }
+      # Find out if the proposed name leads to a module or class that already exists and is not an AR class
+      colliding_thing = nil
+      loop do
+        klass = Object
+        proposed_name_parts.each do |part|
+          if klass.const_defined?(part)
+            klass = klass.const_get(part)
+          else
+            klass = nil
+            break
+          end
+        end
+        break if !klass || (klass < ActiveRecord::Base) # Break if all good -- no conflicts
+
+        # Find a unique name since there's already something that's non-AR with that same name
+        last_idx = proposed_name_parts.length - 1
+        proposed_name_parts[last_idx] = ::Brick.ensure_unique(proposed_name_parts[last_idx], 'X')
+        colliding_thing ||= klass
+      end
+      v[:class_name] = proposed_name_parts.join('::')
+      # Was:  v[:resource] = v[:class_name].underscore.tr('/', '.').pluralize
+      v[:resource] = proposed_name_parts.last.underscore.pluralize
+      if colliding_thing
+        message_start = if colliding_thing.is_a?(Module) && Object.const_defined?(:Rails) &&
+                           colliding_thing.constants.find { |c| colliding_thing.const_get(c) < Rails::Application }
+                          "The module for the Rails application itself, \"#{colliding_thing.name}\","
+                        else
+                          "Non-AR #{colliding_thing.class.name.downcase} \"#{colliding_thing.name}\""
+                        end
+        puts "WARNING:  #{message_start} already exists.\n  Will set up to auto-create model #{v[:class_name]} for table #{k}."
+      end
       # Track anything that's out-of-the-ordinary
       table_name_lookup[v[:class_name]] = k unless v[:class_name].underscore.pluralize == k
     end
     ::Brick.load_additional_references if ::Brick.initializer_loaded
 
+    if is_postgres
+      ActiveRecord::Base.execute_sql("-- inherited and partitioned tables counts
+      SELECT parent.relname,
+        ((SUM(child.reltuples::float) / greatest(SUM(child.relpages), 1))) *
+        (SUM(pg_relation_size(child.oid))::float / (current_setting('block_size')::float))::integer AS rowcount
+      FROM pg_inherits
+        INNER JOIN pg_class parent ON pg_inherits.inhparent = parent.oid
+        INNER JOIN pg_class child ON pg_inherits.inhrelid = child.oid
+      GROUP BY parent.relname, child.reltuples, child.relpages, child.oid
+
+      UNION ALL
+
+      -- table count
+      SELECT relname,
+        (reltuples::float / greatest(relpages, 1)) *
+          (pg_relation_size(pg_class.oid)::float / (current_setting('block_size')::float))::integer AS rowcount
+      FROM pg_class
+      GROUP BY relname, reltuples, relpages, oid").each do |tblcount|
+        relations.fetch(tblcount['relname'], nil)&.[]=(:rowcount, tblcount['rowcount'].round)
+      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)
@@ -3136,7 +3204,7 @@ module Brick
         # For any appended references (those that come from config), arrive upon a definitely unique constraint name
         pri_tbl = is_class ? fk[4][:class].underscore : pri_tbl
         pri_tbl = "#{bt_assoc_name}_#{pri_tbl}" if pri_tbl&.singularize != bt_assoc_name
-        cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
+        cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", nil, bts, hms)
         missing = []
         missing << fk[1] unless relations.key?(fk[1])
         missing << primary_table unless is_class || relations.key?(primary_table)
@@ -3270,15 +3338,17 @@ module Brick
       end
     end
 
-    def ensure_unique(name, *sources)
+    def ensure_unique(name, delimiter, *sources)
       base = name
-      if (added_num = name.slice!(/_(\d+)$/))
+      delimiter ||= '_'
+      # By default ends up building this regex:  /_(\d+)$/
+      if (added_num = name.slice!(Regexp.new("#{delimiter}(\d+)$")))
         added_num = added_num[1..-1].to_i
       else
         added_num = 1
       end
       while (
-        name = "#{base}_#{added_num += 1}"
+        name = "#{base}#{delimiter}#{added_num += 1}"
         sources.each_with_object(nil) do |v, s|
           s || case v
                when Hash
@@ -3356,6 +3426,33 @@ module Brick
       end
     end
 
+    def _brick_index(tbl_name, mode = nil, separator = nil, relation = nil)
+      separator ||= '_'
+      res_name = (tbl_name_parts = tbl_name.split('.'))[0..-2].first
+      res_name << '.' if res_name
+      (res_name ||= +'') << (relation || ::Brick.relations.fetch(tbl_name, nil)&.fetch(:resource, nil) || tbl_name_parts.last)
+
+      res_parts = ((mode == :singular) ? res_name.singularize : res_name).split('.')
+      res_parts.shift if ::Brick.apartment_multitenant && res_parts.length > 1 && res_parts.first == ::Brick.apartment_default_tenant
+      if (aps = relation&.fetch(:auto_prefixed_schema, nil)) && res_parts.last.start_with?(aps)
+        last_part = res_parts.last[aps.length..-1]
+        aps = aps[0..-2] if aps[-1] == '_'
+        res_parts[-1] = aps
+        res_parts << last_part
+      end
+      path_prefix = []
+      if ::Brick.config.path_prefix
+        res_parts.unshift(::Brick.config.path_prefix)
+        path_prefix << ::Brick.config.path_prefix
+      end
+      index = res_parts.map(&:underscore).join(separator)
+      index = index.tr('_', 'x') if separator == 'x'
+      # Rails applies an _index suffix to that route when the resource name isn't something plural
+      index << '_index' if mode != :singular && separator == '_' &&
+                           index == (path_prefix + [name&.underscore&.tr('/', '_') || '_']).join(separator)
+      index
+    end
+
     def find_col_renaming(api_ver_path, relation_name)
       ::Brick.config.api_column_renaming&.fetch(
         api_ver_path,

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

@@ -738,8 +738,11 @@ window.addEventListener(\"popstate\", linkSchemas);
                       hms_columns << hm_entry
                     end
                   when 'show', 'new', 'update'
+                    predicates = nil
                     hm_stuff << if hm_fk_name
-                                  if hm_assoc.klass.column_names.include?(hm_fk_name.to_s) ||
+                                  if (hm_fk_name.is_a?(Array) && # Composite key?
+                                      hm_fk_name.all? { |hm_fk_part| hm_assoc.klass.column_names.include?(hm_fk_part) }) ||
+                                     hm_assoc.klass.column_names.include?(hm_fk_name.to_s) ||
                                      (hm_fk_name.is_a?(String) && hm_fk_name.include?('.')) # HMT?  (Could do a better check for this)
                                     predicates = path_keys(hm_assoc, hm_fk_name, pk).map do |k, v|
                                                    if v == '[sti_type]'
@@ -771,9 +774,18 @@ window.addEventListener(\"popstate\", linkSchemas);
               end
               # %%% If we are not auto-creating controllers (or routes) then omit by default, and if enabled anyway, such as in a development
               # environment or whatever, then get either the controllers or routes list instead
-              prefix = "#{::Brick.config.path_prefix}/" if ::Brick.config.path_prefix
-              table_options = ::Brick.relations.each_with_object({}) do |rel, s|
-                                next if rel.first.is_a?(Symbol) || ::Brick.config.exclude_tables.include?(rel.first)
+              table_rels = if ::Brick.config.omit_empty_tables_in_dropdown
+                             ::Brick.relations.reject { |k, v| k.is_a?(Symbol) || v[:rowcount] == 0 }
+                           else
+                             ::Brick.relations
+                           end
+              table_options = table_rels.sort do |a, b|
+                                a[0] = '' if a[0].is_a?(Symbol)
+                                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? ||
+                                        ::Brick.config.exclude_tables.include?(rel.first)
 
                                 tbl_parts = rel.first.split('.')
                                 if (aps = rel.last.fetch(:auto_prefixed_schema, nil))
@@ -781,16 +793,16 @@ window.addEventListener(\"popstate\", linkSchemas);
                                   aps = aps[0..-2] if aps[-1] == '_'
                                   tbl_parts[-2] = aps
                                 end
-                                if tbl_parts.first == apartment_default_schema
-                                  tbl_parts.shift
-                                end
+                                tbl_parts.shift if tbl_parts.first == apartment_default_schema
                                 # %%% When table_name_prefixes are use then during rendering empty non-TNP
                                 # entries get added at some point when an attempt is made to find the table.
                                 # Will have to hunt that down at some point.
-                                s[tbl_parts.join('.')] = nil unless rel.last[:cols].empty?
-                              end.keys.sort.each_with_object(+'') do |v, s|
-                                s << "<option value=\"#{prefix}#{v.underscore.gsub('.', '/')}\">#{v}</option>"
+                                if (rowcount = rel.last.fetch(:rowcount, nil))
+                                  rowcount = rowcount > 0 ? " (#{rowcount})" : nil
+                                end
+                                s << "<option value=\"#{::Brick._brick_index(rel.first, nil, '/')}\">#{rel.first}#{rowcount}</option>"
                               end.html_safe
+              prefix = "#{::Brick.config.path_prefix}/" if ::Brick.config.path_prefix
               table_options << "<option value=\"#{prefix}brick_status\">(Status)</option>".html_safe if ::Brick.config.add_status
               table_options << "<option value=\"#{prefix}brick_orphans\">(Orphans)</option>".html_safe if is_orphans
               table_options << "<option value=\"#{prefix}brick_crosstab\">(Crosstab)</option>".html_safe if is_crosstab
@@ -1473,7 +1485,7 @@ end
   %>
   <tr>
   <td><%= begin
-            kls = Object.const_get(::Brick.relations.fetch(r[0], nil)&.fetch(:class_name, nil))
+            kls = Object.const_get((rel = ::Brick.relations.fetch(r[0], nil))&.fetch(:class_name, nil))
           rescue
           end
           if kls.is_a?(Class) && (path_helper = respond_to?(bi_path = \"#\{kls._brick_index}_path\".to_sym) ? bi_path : nil)
@@ -1486,7 +1498,10 @@ end
          else
            ' class=\"dimmed\"'
          end&.html_safe %>><%= # Table
-          r[1] %></td>
+         if (rowcount = rel&.fetch(:rowcount, nil))
+           rowcount = (rowcount > 0 ? \" (#\{rowcount})\" : nil)
+         end
+         \"#\{r[1]}#\{rowcount}\" %></td>
   <td<%= lines = r[2]&.map { |line| \"#\{line.first}:#\{line.last}\" }
          ' class=\"dimmed\"'.html_safe unless r[2] %>><%= # Migration
           lines&.join('<br>')&.html_safe %></td>
@@ -1638,7 +1653,7 @@ end
                  end
       s << "<table id=\"#{hm_name}\" class=\"shadow\">
         <tr><th>#{hm[1]}#{' poly' if hm[0].options[:as]} #{hm[3]}
-          <% if respond_to?(:new_#{partial_new_path_name = hm.first.klass._brick_index(:singular)}_path) %>
+          <% if predicates && respond_to?(:new_#{partial_new_path_name = hm.first.klass._brick_index(:singular)}_path) %>
           <span class = \"add-hm-related\"><%=
             pk_val = (obj_pk = model.primary_key).is_a?(String) ? obj.send(obj_pk) : obj_pk.map { |pk_part| obj.send(pk_part) }
             pk_val_arr = [pk_val] unless pk_val.is_a?(Array)

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

@@ -151,7 +151,7 @@ module Brick::Rails::FormTags
     #     ActiveRecord::StatementTimeout in Warehouse::ColdRoomTemperatures_Archive#index
     #     TinyTds::Error: Adaptive Server connection timed out
     #     (After restarting the server it worked fine again.)
-    rowCount = 0
+    row_count = 0
     relation.each do |obj|
       out << "<tr>\n"
       out << "<td class=\"col-sticky\">#{link_to('⇛', send("#{klass._brick_index(:singular)}_path".to_sym,
@@ -252,13 +252,16 @@ module Brick::Rails::FormTags
         out << '</td>'
       end
       out << '</tr>'
-      rowCount += 1
+      row_count += 1
+    end
+    if (total_row_count = ::Brick.relations[table_name].fetch(:rowcount, nil))
+      total_row_count = total_row_count > row_count ? " (out of #{total_row_count})" : nil
     end
     out << "  </tbody>
 </table>
 <script>
   var rowCount = document.getElementById(\"rowCount\");
-  if (rowCount) rowCount.innerHTML = \"#{pluralize(rowCount, "row")} &nbsp;\";
+  if (rowCount) rowCount.innerHTML = \"#{pluralize(row_count, "row")}#{total_row_count} &nbsp;\";
 </script>
 "
 

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -619,6 +619,10 @@ module Brick
       Brick.config.license = key
     end
 
+    def omit_empty_tables_in_dropdown=(setting)
+      Brick.config.omit_empty_tables_in_dropdown = setting
+    end
+
     def always_load_fields=(field_set)
       Brick.config.always_load_fields = field_set
     end
@@ -948,13 +952,14 @@ In config/initializers/brick.rb appropriate entries would look something like:
         object_name = k.split('.').last # Take off any first schema part
 
         full_schema_prefix = if (full_aps = aps = v.fetch(:auto_prefixed_schema, nil))
-                                aps = aps[0..-2] if aps[-1] == '_'
-                                (schema_prefix&.dup || +'') << "#{aps}."
-                              else
-                                schema_prefix
-                              end
+                               aps = aps[0..-2] if aps[-1] == '_'
+                               (schema_prefix&.dup || +'') << "#{aps}."
+                             else
+                               schema_prefix
+                             end
 
         # Track routes being built
+        resource_name = v.fetch(:resource, nil) || k
         if (class_name = v.fetch(:class_name, nil))
           if v.key?(:isView)
             view_class_length = class_name.length if class_name.length > view_class_length
@@ -962,7 +967,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
           else
             table_class_length = class_name.length if class_name.length > table_class_length
             tables
-          end << [class_name, aps, k.tr('.', '/')[full_aps&.length || 0 .. -1]]
+          end << [class_name, aps, resource_name.tr('.', '/')[full_aps&.length || 0 .. -1]]
         end
 
         options = {}
@@ -973,7 +978,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
         prefixes << [aps, v[:class_name]&.split('::')[-2]&.underscore] if aps
         prefixes << schema_name if schema_name
         prefixes << path_prefix if path_prefix
-        brick_namespace_create.call(prefixes, v[:resource], options)
+        brick_namespace_create.call(prefixes, resource_name, options)
         sti_subclasses.fetch(class_name, nil)&.each do |sc| # Add any STI subclass routes for this relation
           brick_namespace_create.call(prefixes, sc.underscore.tr('/', '_').pluralize, options)
         end

data/lib/generators/brick/migration_builder.rb

@@ -89,7 +89,13 @@ module Brick
         [mig_path, is_insert_versions, is_delete_versions]
       end
 
-      def generate_migrations(chosen, mig_path, is_insert_versions, is_delete_versions, relations = ::Brick.relations)
+      def generate_migrations(chosen, mig_path, is_insert_versions, is_delete_versions,
+                              relations = ::Brick.relations, do_fks_last: nil, do_schema_migrations: true)
+        if do_fks_last.nil?
+          puts 'Would you like for the foreign keys to be built inline inside of each migration file, or as a final migration?'
+          do_fks_last = (gets_list(list: ['Inline', 'Separate final migration for all FKs']).start_with?('Separate'))
+        end
+
         is_sqlite = ActiveRecord::Base.connection.adapter_name == 'SQLite'
         key_type = ((is_sqlite || ActiveRecord.version < ::Gem::Version.new('5.1')) ? 'integer' : 'bigint')
         is_4x_rails = ActiveRecord.version < ::Gem::Version.new('5.0')
@@ -112,6 +118,7 @@ module Brick
         # Start by making migrations for fringe tables (those with no foreign keys).
         # Continue layer by layer, creating migrations for tables that reference ones already done, until
         # no more migrations can be created.  (At that point hopefully all tables are accounted for.)
+        after_fks = [] # Track foreign keys to add after table creation
         while (fringe = chosen.reject do |tbl|
                           snag_fks = []
                           snags = relations.fetch(tbl, nil)&.fetch(:fks, nil)&.select do |_k, v|
@@ -131,166 +138,58 @@ module Brick
                           end
                         end).present?
           fringe.each do |tbl|
-            next unless (relation = relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present?
+            mig = gen_migration_columns(relations, tbl, (tbl_parts = tbl.split('.')), (add_fks = []),
+                                        key_type, is_4x_rails, ar_version, do_fks_last)
+            after_fks.concat(add_fks) if do_fks_last
+            versions_to_create << migration_file_write(mig_path, ::Brick._brick_index("create_#{tbl}", nil, 'x'), current_mig_time += 1.minute, ar_version, mig)
+          end
+          done.concat(fringe)
+          chosen -= done
+        end
 
-            pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [::Brick.ar_base.primary_key].flatten.sort)
-            # In case things aren't as standard
-            if pkey_cols.empty?
-              pkey_cols = if rpk.empty? && relation[:cols][arpk.first]&.first == key_type
-                            arpk
-                          elsif rpk.first
-                            rpk
-                          end
-            end
-            schema = if (tbl_parts = tbl.split('.')).length > 1
-                      if tbl_parts.first == (::Brick.default_schema || 'public')
-                        tbl_parts.shift
-                        nil
-                      else
-                        tbl_parts.first
-                      end
-                    end
-            unless schema.blank? || built_schemas.key?(schema)
-              mig = +"  def change\n    create_schema(:#{schema}) unless schema_exists?(:#{schema})\n  end\n"
-              migration_file_write(mig_path, "create_db_schema_#{schema.underscore}", current_mig_time += 1.minute, ar_version, mig)
-              built_schemas[schema] = nil
-            end
+        if do_fks_last
+          # Write out any more tables that haven't been done yet
+          chosen.each do |tbl|
+            mig = gen_migration_columns(relations, tbl, (tbl_parts = tbl.split('.')), (add_fks = []),
+                                        key_type, is_4x_rails, ar_version, do_fks_last)
+            after_fks.concat(add_fks)
+            migration_file_write(mig_path, ::Brick._brick_index("create_#{tbl}", nil, 'x'), current_mig_time += 1.minute, ar_version, mig)
+          end
+          done.concat(chosen)
+          chosen.clear
 
-            # %%% For the moment we're skipping polymorphics
-            fkey_cols = relation[:fks].values.select { |assoc| assoc[:is_bt] && !assoc[:polymorphic] }
-            # If the primary key is also used as a foreign key, will need to do  id: false  and then build out
-            # a column definition which includes :primary_key -- %%% also using a data type of bigserial or serial
-            # if this one has come in as bigint or integer.
-            pk_is_also_fk = fkey_cols.any? { |assoc| pkey_cols&.first == assoc[:fk] } ? pkey_cols&.first : nil
-            # Support missing primary key (by adding:  , id: false)
-            id_option = if pk_is_also_fk || !pkey_cols&.present?
-                          needs_serial_col = true
-                          +', id: false'
-                        elsif ((pkey_col_first = (col_def = relation[:cols][pkey_cols&.first])&.first) &&
-                              (pkey_col_first = SQL_TYPES[pkey_col_first] || SQL_TYPES[col_def&.[](0..1)] ||
-                                                SQL_TYPES.find { |r| r.first.is_a?(Regexp) && pkey_col_first =~ r.first }&.last ||
-                                                pkey_col_first
-                              ) != key_type
-                              )
-                          case pkey_col_first
-                          when 'integer'
-                            +', id: :serial'
-                          when 'bigint'
-                            +', id: :bigserial'
-                          else
-                            +", id: :#{pkey_col_first}" # Something like:  id: :integer, primary_key: :businessentityid
-                          end +
-                            (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '')
-                        end
-            if !id_option && pkey_cols.sort != arpk
-              id_option = +", primary_key: :#{pkey_cols.first}"
-            end
-            if !is_4x_rails && (comment = relation&.fetch(:description, nil))&.present?
-              (id_option ||= +'') << ", comment: #{comment.inspect}"
-            end
-            # Find the ActiveRecord class in order to see if the columns have comments
-            unless is_4x_rails
-              klass = begin
-                        tbl.tr('.', '/').singularize.camelize.constantize
-                      rescue StandardError
-                      end
-              if klass
-                unless ActiveRecord::Migration.table_exists?(klass.table_name)
-                  puts "WARNING: Unable to locate table #{klass.table_name} (for #{klass.name})."
-                  klass = nil
-                end
-              end
-            end
-            # Refer to this table name as a symbol or dotted string as appropriate
-            tbl_code = tbl_parts.length == 1 ? ":#{tbl_parts.first}" : "'#{tbl}'"
-            mig = +"  def change\n    return unless reverting? || !table_exists?(#{tbl_code})\n\n"
-            mig << "    create_table #{tbl_code}#{id_option} do |t|\n"
-            possible_ts = [] # Track possible generic timestamps
-            add_fks = [] # Track foreign keys to add after table creation
-            relation[:cols].each do |col, col_type|
-              sql_type = SQL_TYPES[col_type.first] || SQL_TYPES[col_type[0..1]] ||
-                        SQL_TYPES.find { |r| r.first.is_a?(Regexp) && col_type.first =~ r.first }&.last ||
-                        col_type.first
-              suffix = col_type[3] || pkey_cols&.include?(col) ? +', null: false' : +''
-              suffix << ', array: true' if (col_type.first == 'ARRAY')
-              if !is_4x_rails && klass && (comment = klass.columns_hash.fetch(col, nil)&.comment)&.present?
-                suffix << ", comment: #{comment.inspect}"
-              end
-              # Determine if this column is used as part of a foreign key
-              if (fk = fkey_cols.find { |assoc| col == assoc[:fk] })
-                to_table = fk[:inverse_table].split('.')
-                to_table = to_table.length == 1 ? ":#{to_table.first}" : "'#{fk[:inverse_table]}'"
-                if needs_serial_col && pkey_cols&.include?(col) && (new_serial_type = {'integer' => 'serial', 'bigint' => 'bigserial'}[sql_type])
-                  sql_type = new_serial_type
-                  needs_serial_col = false
-                end
-                if fk[:fk] != "#{fk[:assoc_name].singularize}_id" # Need to do our own foreign_key tricks, not use references?
-                  column = fk[:fk]
-                  mig << emit_column(sql_type, column, suffix)
-                  add_fks << [to_table, column, relations[fk[:inverse_table]]]
-                else
-                  suffix << ", type: :#{sql_type}" unless sql_type == key_type
-                  # Will the resulting default index name be longer than what Postgres allows?  (63 characters)
-                  if (idx_name = ActiveRecord::Base.connection.index_name(tbl, {column: col})).length > 63
-                    # Try to find a shorter name that hasn't been used yet
-                    unless indexes.key?(shorter = idx_name[0..62]) ||
-                          indexes.key?(shorter = idx_name.tr('_', '')[0..62]) ||
-                          indexes.key?(shorter = idx_name.tr('aeio', '')[0..62])
-                      puts "Unable to easily find unique name for index #{idx_name} that is shorter than 64 characters,"
-                      puts "so have resorted to this GUID-based identifier: #{shorter = "#{tbl[0..25]}_#{::SecureRandom.uuid}"}."
-                    end
-                    suffix << ", index: { name: '#{shorter || idx_name}' }"
-                    indexes[shorter || idx_name] = nil
-                  end
-                  primary_key = nil
-                  begin
-                    primary_key = relations[fk[:inverse_table]][:class_name]&.constantize&.primary_key
-                  rescue NameError => e
-                    primary_key = ::Brick.ar_base.primary_key
-                  end
-                  mig << "      t.references :#{fk[:assoc_name]}#{suffix}, foreign_key: { to_table: #{to_table}#{", primary_key: :#{primary_key}" if primary_key != ::Brick.ar_base.primary_key} }\n"
-                end
-              else
-                next if !id_option&.end_with?('id: false') && pkey_cols&.include?(col)
+          # Add a final migration to create all the foreign keys
+          mig = +"  def change\n"
+          after_fks.each do |add_fk|
+            next unless add_fk[2] # add_fk[2] holds the inverse relation
 
-                # See if there are generic timestamps
-                if sql_type == 'timestamp' && ['created_at','updated_at'].include?(col)
-                  possible_ts << [col, !col_type[3]]
-                else
-                  mig << emit_column(sql_type, col, suffix)
-                end
-              end
-            end
-            if possible_ts.length == 2 && # Both created_at and updated_at
-              # Rails 5 and later timestamps default to NOT NULL
-              (possible_ts.first.last == is_4x_rails && possible_ts.last.last == is_4x_rails)
-              mig << "\n      t.timestamps\n"
-            else # Just one or the other, or a nullability mismatch
-              possible_ts.each { |ts| emit_column('timestamp', ts.first, nil) }
+            unless (pk = add_fk[2][:pkey].values.flatten&.first)
+              # No official PK, but if coincidentally there's a column of the same name, take a chance on it
+              pk = (add_fk[2][:cols].key?(add_fk[1]) && add_fk[1]) || '???'
             end
-            mig << "    end\n"
-            if pk_is_also_fk
-              mig << "    reversible do |dir|\n"
-              mig << "      dir.up { execute('ALTER TABLE #{tbl} ADD PRIMARY KEY (#{pk_is_also_fk})') }\n"
-              mig << "    end\n"
-            end
-            add_fks.each do |add_fk|
-              is_commented = false
-              # add_fk[2] holds the inverse relation
-              unless (pk = add_fk[2][:pkey].values.flatten&.first)
-                is_commented = true
-                mig << "    # (Unable to create relationship because primary key is missing on table #{add_fk[0]})\n"
-                # No official PK, but if coincidentally there's a column of the same name, take a chance on it
-                pk = (add_fk[2][:cols].key?(add_fk[1]) && add_fk[1]) || '???'
-              end
-              #                                                                 to_table               column
-              mig << "    #{'# ' if is_commented}add_foreign_key #{tbl_code}, #{add_fk[0]}, column: :#{add_fk[1]}, primary_key: :#{pk}\n"
-            end
-            mig << "  end\n"
-            versions_to_create << migration_file_write(mig_path, "create_#{tbl_parts.map(&:underscore).join('_')}", current_mig_time += 1.minute, ar_version, mig)
+            mig << "    add_foreign_key #{add_fk[3]}, " # The tbl_code
+            #         to_table               column
+            mig << "#{add_fk[0]}, column: :#{add_fk[1]}, primary_key: :#{pk}\n"
           end
-          done.concat(fringe)
-          chosen -= done
+          if after_fks.length > 500
+            minutes = (after_fks.length + 1000) / 1500
+            mig << "    if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'\n"
+            mig << "      puts 'NOTE:  It could take around #{minutes} #{'minute'.pluralize(minutes)} on a FAST machine for Postgres to do all the final processing for these foreign keys.  Please be patient!'\n"
+
+            mig << "      # Vacuum takes only about ten seconds when all the tables are empty,
+      # and about 2 minutes when the tables are fairly full.
+      execute('COMMIT')
+      execute('VACUUM FULL')
+      execute('BEGIN TRANSACTION')
+    end\n"
+          end
+
+          mig << +"  end\n"
+          migration_file_write(mig_path, 'create_brick_fks.rbx', current_mig_time += 1.minute, ar_version, mig)
+          puts "Have written out a final migration called 'create_brick_fks.rbx' which creates #{after_fks.length} foreign keys.
+  This file extension (.rbx) will cause it not to run yet when you do a 'rails db:migrate'.
+  The idea here is to do all data loading first, and then rename that migration file back
+  into having a .rb extension, and run a final db:migrate to put the foreign keys in place."
         end
 
         stuck_counts = Hash.new { |h, k| h[k] = 0 }
@@ -310,7 +209,7 @@ module Brick
             ".  Here's the top 5 blockers" if stuck_sorted.length > 5
           }:"
           pp stuck_sorted[0..4]
-        else # Successful, and now we can update the schema_migrations table accordingly
+        elsif do_schema_migrations # Successful, and now we can update the schema_migrations table accordingly
           unless ActiveRecord::Migration.table_exists?(ActiveRecord::Base.schema_migrations_table_name)
             ActiveRecord::SchemaMigration.create_table
           end
@@ -333,13 +232,178 @@ module Brick
 
     private
 
+      def gen_migration_columns(relations, tbl, tbl_parts, add_fks,
+                                key_type, is_4x_rails, ar_version, do_fks_last)
+        return unless (relation = relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present?
+
+        mig = +''
+        pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [::Brick.ar_base.primary_key].flatten.sort)
+        # In case things aren't as standard
+        if pkey_cols.empty?
+          pkey_cols = if rpk.empty? && relation[:cols][arpk.first]&.first == key_type
+                        arpk
+                      elsif rpk.first
+                        rpk
+                      end
+        end
+        schema = if tbl_parts.length > 1
+                   if tbl_parts.first == (::Brick.default_schema || 'public')
+                     tbl_parts.shift
+                     nil
+                   else
+                     tbl_parts.first
+                   end
+                 end
+        unless schema.blank? || built_schemas.key?(schema)
+          mig = +"  def change\n    create_schema(:#{schema}) unless schema_exists?(:#{schema})\n  end\n"
+          migration_file_write(mig_path, "create_db_schema_#{schema.underscore}", current_mig_time += 1.minute, ar_version, mig)
+          built_schemas[schema] = nil
+        end
+
+        # %%% For the moment we're skipping polymorphics
+        fkey_cols = relation[:fks].values.select { |assoc| assoc[:is_bt] && !assoc[:polymorphic] }
+        # If the primary key is also used as a foreign key, will need to do  id: false  and then build out
+        # a column definition which includes :primary_key -- %%% also using a data type of bigserial or serial
+        # if this one has come in as bigint or integer.
+        pk_is_also_fk = fkey_cols.any? { |assoc| pkey_cols&.first == assoc[:fk] } ? pkey_cols&.first : nil
+        id_option = if pk_is_also_fk || !pkey_cols&.present?
+                      needs_serial_col = true
+                      +', id: false' # Support missing primary key (by adding:  , id: false)
+                    elsif ((pkey_col_first = (col_def = relation[:cols][pkey_cols&.first])&.first) &&
+                          (pkey_col_first = SQL_TYPES[pkey_col_first] || SQL_TYPES[col_def&.[](0..1)] ||
+                                            SQL_TYPES.find { |r| r.first.is_a?(Regexp) && pkey_col_first =~ r.first }&.last ||
+                                            pkey_col_first
+                          ) != key_type
+                          )
+                      case pkey_col_first
+                      when 'integer'
+                        +', id: :serial'
+                      when 'bigint'
+                        +', id: :bigserial'
+                      else
+                        +", id: :#{pkey_col_first}" # Something like:  id: :integer, primary_key: :businessentityid
+                      end +
+                        (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '')
+                    end
+        if !id_option && pkey_cols.sort != arpk
+          id_option = +", primary_key: :#{pkey_cols.first}"
+        end
+        if !is_4x_rails && (comment = relation&.fetch(:description, nil))&.present?
+          (id_option ||= +'') << ", comment: #{comment.inspect}"
+        end
+        # Find the ActiveRecord class in order to see if the columns have comments
+        unless is_4x_rails
+          klass = begin
+                    tbl.tr('.', '/').singularize.camelize.constantize
+                  rescue StandardError
+                  end
+          if klass
+            unless ActiveRecord::Migration.table_exists?(klass.table_name)
+              puts "WARNING: Unable to locate table #{klass.table_name} (for #{klass.name})."
+              klass = nil
+            end
+          end
+        end
+        # Refer to this table name as a symbol or dotted string as appropriate
+        tbl_code = tbl_parts.length == 1 ? ":#{tbl_parts.first}" : "'#{tbl}'"
+        mig = +"  def change\n    return unless reverting? || !table_exists?(#{tbl_code})\n\n"
+        mig << "    create_table #{tbl_code}#{id_option} do |t|\n"
+        possible_ts = [] # Track possible generic timestamps
+        relation[:cols].each do |col, col_type|
+          sql_type = SQL_TYPES[col_type.first] || SQL_TYPES[col_type[0..1]] ||
+                     SQL_TYPES.find { |r| r.first.is_a?(Regexp) && col_type.first =~ r.first }&.last ||
+                     col_type.first
+          suffix = col_type[3] || pkey_cols&.include?(col) ? +', null: false' : +''
+          suffix << ', array: true' if (col_type.first == 'ARRAY')
+          if !is_4x_rails && klass && (comment = klass.columns_hash.fetch(col, nil)&.comment)&.present?
+            suffix << ", comment: #{comment.inspect}"
+          end
+          # Determine if this column is used as part of a foreign key
+          if (fk = fkey_cols.find { |assoc| col == assoc[:fk] })
+            to_table = fk[:inverse_table].split('.')
+            to_table = to_table.length == 1 ? ":#{to_table.first}" : "'#{fk[:inverse_table]}'"
+            if needs_serial_col && pkey_cols&.include?(col) && (new_serial_type = {'integer' => 'serial', 'bigint' => 'bigserial'}[sql_type])
+              sql_type = new_serial_type
+              needs_serial_col = false
+            end
+            if do_fks_last || (fk[:fk] != "#{fk[:assoc_name].singularize}_id") # Need to do our own foreign_key tricks, not use references?
+              column = fk[:fk]
+              mig << emit_column(sql_type, column, suffix)
+              add_fks << [to_table, column, relations[fk[:inverse_table]], tbl_code]
+            else
+              suffix << ", type: :#{sql_type}" unless sql_type == key_type
+              # Will the resulting default index name be longer than what Postgres allows?  (63 characters)
+              if (idx_name = ActiveRecord::Base.connection.index_name(tbl, {column: col})).length > 63
+                # Try to find a shorter name that hasn't been used yet
+                unless indexes.key?(shorter = idx_name[0..62]) ||
+                      indexes.key?(shorter = idx_name.tr('_', '')[0..62]) ||
+                      indexes.key?(shorter = idx_name.tr('aeio', '')[0..62])
+                  puts "Unable to easily find unique name for index #{idx_name} that is shorter than 64 characters,"
+                  puts "so have resorted to this GUID-based identifier: #{shorter = "#{tbl[0..25]}_#{::SecureRandom.uuid}"}."
+                end
+                suffix << ", index: { name: '#{shorter || idx_name}' }"
+                indexes[shorter || idx_name] = nil
+              end
+              next if do_fks_last
+
+              primary_key = nil
+              begin
+                primary_key = relations[fk[:inverse_table]][:class_name]&.constantize&.primary_key
+              rescue NameError => e
+                primary_key = ::Brick.ar_base.primary_key
+              end
+              fk_stuff = ", foreign_key: { to_table: #{to_table}#{", primary_key: :#{primary_key}" if primary_key != ::Brick.ar_base.primary_key} }"
+              mig << "      t.references :#{fk[:assoc_name]}#{suffix}#{fk_stuff}\n"
+            end
+          else
+            next if !id_option&.end_with?('id: false') && pkey_cols&.include?(col)
+
+            # See if there are generic timestamps
+            if sql_type == 'timestamp' && ['created_at','updated_at'].include?(col)
+              possible_ts << [col, !col_type[3]]
+            else
+              mig << emit_column(sql_type, col, suffix)
+            end
+          end
+        end
+        if possible_ts.length == 2 && # Both created_at and updated_at
+          # Rails 5 and later timestamps default to NOT NULL
+          (possible_ts.first.last == is_4x_rails && possible_ts.last.last == is_4x_rails)
+          mig << "\n      t.timestamps\n"
+        else # Just one or the other, or a nullability mismatch
+          possible_ts.each { |ts| emit_column('timestamp', ts.first, nil) }
+        end
+        mig << "    end\n"
+        if pk_is_also_fk
+          mig << "    reversible do |dir|\n"
+          mig << "      dir.up { execute('ALTER TABLE #{tbl} ADD PRIMARY KEY (#{pk_is_also_fk})') }\n"
+          mig << "    end\n"
+        end
+        add_fks.each do |add_fk|
+          next unless add_fk[2]
+
+          is_commented = false
+          # add_fk[2] holds the inverse relation
+          unless (pk = add_fk[2][:pkey]&.values&.flatten&.first)
+            is_commented = true
+            mig << "    # (Unable to create relationship because primary key is missing on table #{add_fk[0]})\n"
+            # No official PK, but if coincidentally there's a column of the same name, take a chance on it
+            pk = (add_fk[2][:cols].key?(add_fk[1]) && add_fk[1]) || '???'
+          end
+          mig << "    #{'# ' if do_fks_last}#{'# ' if is_commented}add_foreign_key #{tbl_code}, "
+          #         to_table               column
+          mig << "#{add_fk[0]}, column: :#{add_fk[1]}, primary_key: :#{pk}\n"
+        end
+        mig << "  end\n"
+      end
+
       def emit_column(type, name, suffix)
         "      t.#{type.start_with?('numeric') ? 'decimal' : type} :#{name}#{suffix}\n"
       end
 
       def migration_file_write(mig_path, name, current_mig_time, ar_version, mig)
-        File.open("#{mig_path}/#{version = current_mig_time.strftime('%Y%m%d%H%M00')}_#{name}.rb", "w") do |f|
-          f.write "class #{name.camelize} < ActiveRecord::Migration#{ar_version}\n"
+        File.open("#{mig_path}/#{version = current_mig_time.strftime('%Y%m%d%H%M00')}_#{name}#{'.rb' unless name.index('.')}", "w") do |f|
+          f.write "class #{name.split('.').first.camelize} < ActiveRecord::Migration#{ar_version}\n"
           f.write mig
           f.write "end\n"
         end

data/lib/generators/brick/migrations_generator.rb

@@ -26,6 +26,7 @@ module Brick
       end
 
       mig_path, is_insert_versions, is_delete_versions = ::Brick::MigrationBuilder.check_folder
+      return unless mig_path
 
       # Generate a list of tables that can be chosen
       chosen = gets_list(list: tables, chosen: tables.dup)

data/lib/generators/brick/salesforce_migrations_generator.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'brick'
+require 'rails/generators'
+require 'fancy_gets'
+require 'generators/brick/migration_builder'
+require 'generators/brick/salesforce_schema'
+
+module Brick
+  # Auto-generates migration files
+  class SalesforceMigrationsGenerator < ::Rails::Generators::Base
+    include FancyGets
+    desc 'Auto-generates migration files for a set of Salesforce tables and columns.'
+
+    argument :wsdl_file, type: :string, default: ''
+
+    def brick_salesforce_migrations
+      ::Brick.apply_double_underscore_patch
+      # ::Brick.mode = :on
+      # ActiveRecord::Base.establish_connection
+
+      # Runs at the end of parsing Salesforce WSDL, and uses the discovered tables and columns to create migrations
+      relations = nil
+      end_document_proc = lambda do |salesforce_tables|
+        # p [:end_document]
+        mig_path, is_insert_versions, is_delete_versions = ::Brick::MigrationBuilder.check_folder
+        return unless mig_path
+
+        # Generate a list of tables that can be chosen
+        table_names = salesforce_tables.keys
+        chosen = gets_list(list: table_names, chosen: table_names.dup)
+
+        soap_data_types = {
+          'tns:ID' => 'string',
+          'xsd:string' => 'string',
+          'xsd:dateTime' => 'datetime',
+          'xsd:boolean' => 'boolean',
+          'xsd:double' => 'float',
+          'xsd:int' => 'integer',
+          'xsd:date' => 'date',
+          'xsd:anyType' => 'string', # Don't fully know on this
+          'xsd:long' => 'bigint',
+          'xsd:base64Binary' => 'bytea',
+          'xsd:time' => 'time'
+        }
+        fk_idx = 0
+        # Build out a '::Brick.relations' hash that represents this Salesforce schema
+        relations = chosen.each_with_object({}) do |tbl_name, s|
+                      tbl = salesforce_tables[tbl_name]
+                      # Build out columns and foreign keys
+                      cols = { 'id'=>['string', nil, false, true] }
+                      fks = {}
+                      tbl[:cols].each do |col|
+                        next if col[:name] == 'Id'
+
+                        dt = soap_data_types[col[:data_type]] || 'string'
+                        cols[col[:name]] = [dt, nil, col[:nillable], false]
+                        if (ref_to = col[:fk_reference_to])
+                          fk_hash = {
+                            is_bt: true,
+                            fk: col[:name],
+                            assoc_name: "#{col[:name]}_bt",
+                            inverse_table: ref_to
+                          }
+                          fks["fk_salesforce_#{fk_idx += 1}"] = fk_hash
+                        end
+                      end
+                      # Put it all into a relation entry, named the same as the table
+                      s[tbl_name] = {
+                        pkey: { "#{tbl_name}_pkey" => ['id'] },
+                        cols: cols,
+                        fks: fks
+                      }
+                    end
+        # Build but do not have foreign keys established yet, and do not put version entries info the schema_migrations table
+        ::Brick::MigrationBuilder.generate_migrations(chosen, mig_path, is_insert_versions, is_delete_versions, relations,
+                                                      do_fks_last: true, do_schema_migrations: false)
+      end
+      parser = Nokogiri::XML::SAX::Parser.new(::Brick::SalesforceSchema.new(end_document_proc))
+      # The WSDL file must have a .xml extension, and can be in any folder in the project
+      # Alternatively the user can supply this option on the command line
+      @wsdl_file = nil if @wsdl_file == ''
+      loop do
+        break if (@wsdl_file ||= gets_list(Dir['**/*.xml'] + ['* Cancel *'])) == '* Cancel *'
+
+        parser.parse(File.read(@wsdl_file))
+
+        if relations.length > 300
+          puts "A Salesforce installation generally has hundreds to a few thousand tables, and many are empty.
+In order to more easily navigate just those tables that have content, you might want to add this
+to brick.rb:
+  ::Brick.omit_empty_tables_in_dropdown = true"
+        end
+        break
+      rescue Errno::ENOENT
+        puts "File \"#{@wsdl_file}\" is not found."
+        @wsdl_file = nil
+      end
+    end
+  end
+end

data/lib/generators/brick/salesforce_schema.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Brick
+  class SalesforceSchema < Nokogiri::XML::SAX::Document
+    include ::Brick::MigrationBuilder
+
+    attr_reader :end_document_proc
+
+    def initialize(end_doc_proc)
+      @end_document_proc = end_doc_proc
+    end
+
+    def start_document
+      # p [:start_document]
+      @salesforce_tables = {}
+      @text_stack = []
+      @all_extends = {}
+      puts 'Each dot is a table:'
+    end
+
+    def end_document
+      puts
+      end_document_proc&.call(@salesforce_tables)
+    end
+
+    def start_element_namespace(name, attrs = [], prefix = nil, uri = nil, ns = [])
+      # p [:start_element, name, attrs, prefix, uri, ns]
+      case name
+      when 'complexType' # Table
+        @last_table = attrs.find { |a| a.localname == 'name' }&.value
+        @fks = {}
+        # if attrs.first&.value&.end_with?('__c') # Starts as a string
+      when 'extension'
+        @last_extension = attrs.find { |a| a.localname == 'base' }.value
+      when 'element' # Column
+        # Extremely rarely this is nil!
+        data_type = attrs.find { |a| a.localname == 'type' }&.value
+        return if !@last_table || data_type.nil? || data_type == 'tns:QueryResult'
+
+        # Promoted to a real SalesforceTable object
+        if @last_table.is_a?(String)
+          @last_table = @salesforce_tables[@last_table] = { extend: @salesforce_tables[@last_extension] }
+        end
+
+        col_name = attrs.find { |a| a.localname == 'name' }&.value
+
+        # Foreign key reference?
+        if data_type&.start_with?('ens:')
+          foreign_table = data_type[4..]
+          if col_name.end_with?('__r')
+            @fks["#{col_name[0..-2]}c"] = foreign_table
+          else # if col_name.end_with?('Id')
+            @fks["#{col_name}Id"] = foreign_table
+          end
+          return
+        end
+
+        # Rarely this is nil
+        nillable = attrs.find { |a| a.localname == 'nillable' }&.value == 'true'
+        min_occurs = attrs.find { |a| a.localname == 'minOccurs' }&.value || -2
+        min_occurs = -1 if min_occurs == 'unbounded'
+        max_occurs = attrs.find { |a| a.localname == 'maxOccurs' }&.value || -2
+        max_occurs = -1 if max_occurs == 'unbounded'
+        col_options = { name: col_name, data_type: :data_type, nillable: :nillable, min_occurs: :min_occurs, max_occurs: :max_occurs }
+
+        (@last_table[:cols] ||= []) << col_options
+      end
+      @text_stack.push +''
+    end
+
+    def end_element_namespace(name, prefix = nil, uri = nil)
+      # p [:end_element, name, prefix, uri]
+      texts = @text_stack.pop
+      case name
+      when 'extension'
+        @last_extension = nil
+      when 'complexType'
+        if @last_table && !@last_table.is_a?(String)
+          # Do up any foreign keys
+          @fks.each do |k, v|
+            # Only a few records set up like this, going to sObject
+            if 
+              # (k.downcase.end_with?('recordid') &&
+              #   (fk_col = @last_table[:cols].find { |t| t[:name] == "#{k[0..-9]}Id" })
+              #  ) ||
+               (fk_col = @last_table[:cols].find { |t| t[:name] == k })
+              fk_col[:fk_reference_to] = v
+              # puts "Skipping #{@last_table[:name]} / #{k}"
+            end
+          end
+        end
+        print '.'
+        @last_table = nil
+      end
+      # p [:end_element_texts, name, texts]
+    end
+
+    def characters(string)
+      # p [:characters, string]
+      @text_stack.each do |text|
+        text << string
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.189
+  version: 1.0.191
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-17 00:00:00.000000000 Z
+date: 2023-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -258,6 +258,8 @@ files:
 - lib/generators/brick/migration_builder.rb
 - lib/generators/brick/migrations_generator.rb
 - lib/generators/brick/models_generator.rb
+- lib/generators/brick/salesforce_migrations_generator.rb
+- lib/generators/brick/salesforce_schema.rb
 - lib/generators/brick/seeds_generator.rb
 - lib/generators/brick/templates/add_object_changes_to_versions.rb.erb
 - lib/generators/brick/templates/create_versions.rb.erb