brick 1.0.30 → 1.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad31136f451e04eabcc67ee09980d45d25aa8e35453aaf4c160ffc9aef3f774c
-  data.tar.gz: 5e3b705dfad389391b291d26bd3c0571cf0579abce3ed00c2840805fd5e05353
+  metadata.gz: 7bd78c8878b1ce8e8e58fb4d8463322269d2ac065c5ed12079dcc64360dc30d5
+  data.tar.gz: e6926fdc0ec59ad609be39361dbfe0ccea24c1b08a01ccf0a4ae8eb1aa9e2ba2
 SHA512:
-  metadata.gz: ac2403152cae57e54ae1840920aa47e5c64297ff7698f691c0a752ae063d824073f24d040aa66580ef0e5eddac0ec164cf720bc720ad73a09ef7862116608476
-  data.tar.gz: b529668cde573b3c371af30b7f141a1e313d477281bc2ef5453c9751a67abea39a4d8a57e3632f6ef8789ea04ab9d4e01170fb29f096fa6ab8772df77f60f564
+  metadata.gz: 5b6ac439519209c3097c2b2651ed66f319b9c04072d2cee7262aad6c4d9907d61b5b45ee1812c1f6cea1e5e1eed2082eb15953e4e3097c9c12b4f35a1f3af703
+  data.tar.gz: 5bb559ada7035abb062b0441578d5406e64f87b9f11fde1d5b3b880179098bafe9507a1a6cdd8e1af1cd1fb4defc1d339e0054896ca0e9c507ea831f24a0cb96

data/lib/brick/extensions.rb

@@ -86,7 +86,11 @@ module ActiveRecord
         descrip_col = (columns.map(&:name) - _brick_get_fks -
                       (::Brick.config.metadata_columns || []) -
                       [primary_key]).first
-        dsl = ::Brick.config.model_descrips[name] = "[#{descrip_col}]" if descrip_col
+        dsl = ::Brick.config.model_descrips[name] = if descrip_col
+                                                      "[#{descrip_col}]"
+                                                    elsif (pk_parts = self.primary_key.is_a?(Array) ? self.primary_key : [self.primary_key])
+                                                      "#{name} ##{pk_parts.map { |pk_part| "[#{pk_part}]" }.join(', ')}"
+                                                    end
       end
       dsl
     end
@@ -104,7 +108,8 @@ module ActiveRecord
             if ch == ']' # Time to process a bracketed thing?
               parts = bracket_name.split('.')
               first_parts = parts[0..-2].map do |part|
-                klass = klass.reflect_on_association(part_sym = part.to_sym).klass
+                klass = (orig_class = klass).reflect_on_association(part_sym = part.to_sym)&.klass
+                puts "Couldn't reference #{orig_class.name}##{part} that's part of the DSL \"#{dsl}\"." if klass.nil?
                 part_sym
               end
               parts = prefix + first_parts + [parts[-1]]
@@ -128,7 +133,7 @@ module ActiveRecord
         end
       else # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
         x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
-        x[prefix[-1]] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
+        x[prefix.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
       end
       members
     end
@@ -251,13 +256,12 @@ module ActiveRecord
           names << [piece.right._arel_table_type, (piece.right.table_alias || piece.right.name)]
         else # "Normal" setup, fed from a JoinSource which has an array of JOINs
           # The left side is the "JOIN" table
-          names += _recurse_arel(piece.left)
+          names += _recurse_arel(table = piece.left)
           # The expression on the right side is the "ON" clause
           # on = piece.right.expr
           # # Find the table which is not ourselves, and thus must be the "path" that led us here
           # parent = piece.left == on.left.relation ? on.right.relation : on.left.relation
           # binding.pry if piece.left.is_a?(Arel::Nodes::TableAlias)
-          table = piece.left
           if table.is_a?(Arel::Nodes::TableAlias)
             alias_name = table.right
             table = table.left
@@ -276,7 +280,8 @@ module ActiveRecord
         @_brick_chains = {}
         # The left side is the "FROM" table
         # names += _recurse_arel(piece.left)
-        names << [piece.left._arel_table_type, (piece.left.table_alias || piece.left.name)]
+        names << (this_name = [piece.left._arel_table_type, (piece.left.table_alias || piece.left.name)])
+        (_brick_chains[this_name.first] ||= []) << this_name.last
         # The right side is an array of all JOINs
         piece.right.each { |join| names << _recurse_arel(join) }
       end
@@ -348,6 +353,7 @@ module ActiveRecord
           next unless klass.reflect_on_association(assoc_name)&.klass&.column_names&.any?(ks.last)
 
           join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
+          distinct!
         end
         wheres[k] = v.split(',')
       end
@@ -397,6 +403,7 @@ module ActiveRecord
       hm_counts.each do |k, hm|
         associative = nil
         count_column = if hm.options[:through]
+          # binding.pry if associatives[hm.name].nil?
                          fk_col = (associative = associatives[hm.name]).foreign_key
                          hm.foreign_key
                        else
@@ -420,11 +427,13 @@ module ActiveRecord
           on_clause << "#{tbl_alias}.#{poly_type} = '#{name}'"
         end
         join_clause = "LEFT OUTER
-JOIN (SELECT #{selects.join(', ')}, COUNT(#{count_column}) AS _ct_ FROM #{associative&.table_name || hm.klass.table_name} GROUP BY #{(1..selects.length).to_a.join(', ')}) AS #{tbl_alias}"
+JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
+          }) AS _ct_ FROM #{associative&.table_name || hm.klass.table_name
+          } GROUP BY #{(1..selects.length).to_a.join(', ')}) AS #{tbl_alias}"
         joins!("#{join_clause} ON #{on_clause.join(' AND ')}")
       end
       where!(wheres) unless wheres.empty?
-      limit(1000) # Don't want to get too carried away just yet
+      limit!(1000) # Don't want to get too carried away just yet
       wheres unless wheres.empty? # Return the specific parameters that we did use
     end
 
@@ -485,7 +494,9 @@ if ActiveSupport::Dependencies.respond_to?(:autoload_module!) # %%% Only works w
       alias _brick_autoload_module! autoload_module!
       def autoload_module!(*args)
         into, const_name, qualified_name, path_suffix = args
-        if (base_class = ::Brick.config.sti_namespace_prefixes&.fetch("::#{into.name}::", nil)&.constantize)
+        base_class_name = ::Brick.config.sti_namespace_prefixes&.fetch("::#{into.name}::", nil)
+        base_class_name = "::#{base_class_name}" unless base_class_name.start_with?('::')
+        if (base_class = base_class_name&.constantize)
           ::Brick.sti_models[qualified_name] = { base: base_class }
           # Build subclass and place it into the specially STI-namespaced module
           into.const_set(const_name.to_sym, klass = Class.new(base_class))
@@ -506,8 +517,13 @@ end
 Module.class_exec do
   alias _brick_const_missing const_missing
   def const_missing(*args)
-    if (self.const_defined?(args.first) && (possible = self.const_get(args.first)) != self) ||
-       (self != Object && Object.const_defined?(args.first) && (possible = Object.const_get(args.first)) != self)
+    if (self.const_defined?(args.first) && (possible = self.const_get(args.first)) && possible != self) ||
+       (self != Object && Object.const_defined?(args.first) &&
+         (
+           (possible = Object.const_get(args.first)) &&
+           (possible != self || (possible == self && possible.is_a?(Class)))
+         )
+       )
       return possible
     end
     class_name = args.first.to_s
@@ -533,22 +549,23 @@ Module.class_exec do
     result = if ::Brick.enable_controllers? && class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
                # Otherwise now it's up to us to fill in the gaps
                # (Go over to underscores for a moment so that if we have something come in like VABCsController then the model name ends up as
-               # VAbc instead of VABC)
+               # Vabc instead of VABC)
                full_class_name = +''
                full_class_name << "::#{self.name}" unless self == Object
                full_class_name << "::#{plural_class_name.underscore.singularize.camelize}"
-               if (model = self.const_get(full_class_name))
+               if (plural_class_name == 'BrickSwagger' || model = self.const_get(full_class_name))
                  # 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
              elsif (::Brick.enable_models? || ::Brick.enable_controllers?) && # Schema match?
                    self == 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),
-                                  (table_name = singular_table_name.pluralize),
-                                  class_name,
-                                  (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas.include?(s) }
+                   (schema_name = [(singular_table_name = class_name.underscore),
+                                   (table_name = singular_table_name.pluralize),
+                                   class_name,
+                                   (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas.include?(s) }&.camelize ||
+                                  (::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}::") && class_name))
                # Build out a module for the schema if it's namespaced
-               schema_name = schema_name.camelize
+               # schema_name = schema_name.camelize
                self.const_set(schema_name.to_sym, (built_module = Module.new))
 
                [built_module, "module #{schema_name}; end\n"]
@@ -557,27 +574,37 @@ Module.class_exec do
                # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
                # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
 
-               unless self == Object # Are we in some namespace?
+               if self != Object || # Are we in some namespace? ...
+                  (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{name}::", nil)&.constantize) # ... or part of an auto-STI namespace?
                  schema_name = [(singular_schema_name = name.underscore),
                                 (schema_name = singular_schema_name.pluralize),
                                 name,
                                 name.pluralize].find { |s| Brick.db_schemas.include?(s) }
                end
-
                plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
                # If it's namespaced then we turn the first part into what would be a schema name
-               singular_table_name = ActiveSupport::Inflector.underscore(model_name).gsub('::', '.')
-
-               # Adjust for STI if we know of a base model for the requested model name
-               table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ::Brick.existing_stis[model_name]&.constantize)
-                              base_model.table_name
-                            else
-                              ActiveSupport::Inflector.pluralize(singular_table_name)
-                            end
-
-               # Maybe, just maybe there's a database table that will satisfy this need
-               if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(schema_name ? "#{schema_name}.#{m}" : m) })
-                 Object.send(:build_model, schema_name, model_name, singular_table_name, table_name, relations, matching)
+               singular_table_name = ActiveSupport::Inflector.underscore(model_name).gsub('/', '.')
+
+               if base_model
+                 schema_name = name.underscore # For the auto-STI namespace models
+                 table_name = base_model.table_name
+                 Object.send(:build_model, self, model_name, singular_table_name, table_name, relations, table_name)
+               else
+                 # Adjust for STI if we know of a base model for the requested model name
+                 # %%% Does not yet work with namespaced model names.  Perhaps prefix with plural_class_name when doing the lookups here.
+                 table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ::Brick.existing_stis[model_name]&.constantize)
+                                base_model.table_name
+                              else
+                                ActiveSupport::Inflector.pluralize(singular_table_name)
+                              end
+                 if ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') &&
+                    Apartment.excluded_models.include?(table_name.singularize.camelize)
+                   schema_name = Apartment.default_schema
+                 end
+                 # Maybe, just maybe there's a database table that will satisfy this need
+                 if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(schema_name ? "#{schema_name}.#{m}" : m) })
+                   Object.send(:build_model, schema_name, model_name, singular_table_name, table_name, relations, matching)
+                 end
                end
              end
     if result
@@ -593,7 +620,7 @@ Module.class_exec do
     elsif self != Object
       module_parent.const_missing(*args)
     else
-      puts "MISSING! mod #{self.name} #{args.inspect} #{table_name}"
+      puts "MISSING! #{self.name} #{args.inspect} #{table_name}"
       self._brick_const_missing(*args)
     end
   end
@@ -601,117 +628,31 @@ end
 
 class Object
   class << self
-#     alias _brick_const_missing const_missing
-#     def const_missing(*args)
-#       # return self.const_get(args.first) if self.const_defined?(args.first)
-#       # return Object.const_get(args.first) if Object.const_defined?(args.first) unless self == Object
-#       if self.const_defined?(args.first) && (possible = self.const_get(args.first)) != self
-#         return possible
-#       end
-#       if self != Object && Object.const_defined?(args.first) && (possible = Object.const_get(args.first)) != self
-#         return possible
-#       end
-  
-#       class_name = args.first.to_s
-#       # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
-#       # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
-#       # that is, checking #qualified_name_for with:  from_mod, const_name
-#       # If we want to support namespacing in the future, might have to utilise something like this:
-#       # path_suffix = ActiveSupport::Dependencies.qualified_name_for(Object, args.first).underscore
-#       # return self._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(path_suffix)
-#       # If the file really exists, go and snag it:
-#       if !(is_found = ActiveSupport::Dependencies.search_for_file(class_name.underscore)) && (filepath = (self.name || class_name)&.split('::'))
-#         filepath = (filepath[0..-2] + [class_name]).join('/').underscore + '.rb'
-#       end
-#       if is_found
-#         return self._brick_const_missing(*args)
-#       elsif ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
-#         my_const = parent.const_missing(class_name) # ends up having:  MyModule::MyClass
-#         return my_const
-#       end
-#       relations = ::Brick.instance_variable_get(:@relations)[ActiveRecord::Base.connection_pool.object_id] || {}
-#       result = if ::Brick.enable_controllers? && class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
-#                  # Otherwise now it's up to us to fill in the gaps
-#                  # (Go over to underscores for a moment so that if we have something come in like VABCsController then the model name ends up as
-#                  # VAbc instead of VABC)
-#                  if (model = Object.const_get(plural_class_name.underscore.singularize.camelize))
-#                    # 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.
-#                    build_controller(nil, class_name, plural_class_name, model, relations)
-#                  end
-#                elsif (::Brick.enable_models? || ::Brick.enable_controllers?) && # Schema match?
-#                      db_schema_name = [(singular_table_name = class_name.underscore),
-#                                       (table_name = singular_table_name.pluralize),
-#                                       class_name,
-#                                       (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas.include?(s) }
-#                  # Build out a module for the schema if it's namespaced
-#                  schema_name = db_schema_name.camelize
-#                  unless Object.const_defined?(schema_name.to_sym)
-#                    Object.const_set(schema_name.to_sym, (built_module = Module.new))
-#                    Brick.db_schemas[db_schema_name] = built_module
-#                    [built_module, "module #{schema_name}; end\n"]
-#                  end
-#                  #  # %%% Perhaps an option to use the first module just as schema, and additional modules as namespace with a table name prefix applied
-#                  #  schema_name, model_name = 
-#                  #  code = +''
-#                  #  mod_tree = +''
-#                  #  model_name.split('::')[0..-2].each do |mod_name|
-#                  #    mod_tree << "::#{mod_name}"
-#                  #    Module.new(mod_tree)
-#                  #    code << "module #{mod_tree}; end\n"
-#                  #  end
-#                elsif ::Brick.enable_models?
-#                  # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
-#                  # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
-#                  plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
-#                  singular_table_name = ActiveSupport::Inflector.underscore(model_name)
-
-#                  # Adjust for STI if we know of a base model for the requested model name
-#                  table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ::Brick.existing_stis[model_name]&.constantize)
-#                                 base_model.table_name
-#                               else
-#                                 ActiveSupport::Inflector.pluralize(singular_table_name)
-#                               end
-
-#                  # Maybe, just maybe there's a database table that will satisfy this need
-#                  if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(m) })
-#                    build_model(nil, model_name, singular_table_name, table_name, relations, matching)
-#                  end
-#                end
-#       if result
-#         built_class, code = result
-#         puts "\n#{code}"
-#         built_class
-#       elsif ::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}") && !schema_name
-# #         module_prefixes = type_name.split('::')
-# #         path = self.name.split('::')[0..-2] + []
-# #         module_prefixes.unshift('') unless module_prefixes.first.blank?
-# #         candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb')
-#         self._brick_const_missing(*args)
-#       elsif self != Object
-#         module_parent.const_missing(*args)
-#       else
-#         puts "MISSING! obj #{self.name}/#{schema_name}  #{args.inspect} #{table_name}"
-#         self._brick_const_missing(*args)
-#       end
-#     end
 
   private
 
     def build_model(schema_name, model_name, singular_table_name, table_name, relations, matching)
-      full_name = if schema_name.blank?
+      full_name = if (::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') && schema_name == Apartment.default_schema)
+                    relation = relations["#{schema_name}.#{matching}"]
+                    model_name
+                  elsif schema_name.blank?
                     model_name
                   else # Prefix the schema to the table name + prefix the schema namespace to the class name
-                    schema_module = (Brick.db_schemas[schema_name] ||= self.const_get(schema_name.singularize.camelize))
-                    matching = "#{schema_name}.#{matching}"
+                    schema_module = if schema_name.instance_of?(Module) # from an auto-STI namespace?
+                                      schema_name
+                                    else
+                                      matching = "#{schema_name}.#{matching}"
+                                      (Brick.db_schemas[schema_name] ||= self.const_get(schema_name.singularize.camelize))
+                                    end
                     "#{schema_module&.name}::#{model_name}"
                   end
 
-      return if ((is_view = (relation = relations[matching]).key?(:isView)) && ::Brick.config.skip_database_views) ||
+      return if ((is_view = (relation ||= relations[matching]).key?(:isView)) && ::Brick.config.skip_database_views) ||
                 ::Brick.config.exclude_tables.include?(matching)
 
       # Are they trying to use a pluralised class name such as "Employees" instead of "Employee"?
       if table_name == singular_table_name && !ActiveSupport::Inflector.inflections.uncountable.include?(table_name)
-        unless ::Brick.config.sti_namespace_prefixes&.key?("::#{singular_table_name.titleize}::")
+        unless ::Brick.config.sti_namespace_prefixes&.key?("::#{singular_table_name.camelize}::")
           puts "Warning: Class name for a model that references table \"#{matching}\" should be \"#{ActiveSupport::Inflector.singularize(model_name)}\"."
         end
         return
@@ -755,6 +696,9 @@ class Object
             code << "  self.primary_key = #{pk_sym.inspect}\n"
           end
           _brick_primary_key(relation) # Set the newly-found PK in the instance variable
+        elsif (possible_pk = ActiveRecord::Base.get_primary_key(base_class.name)) && relation[:cols][possible_pk]
+          new_model_class.primary_key = (possible_pk = possible_pk.to_sym)
+          code << "  self.primary_key = #{possible_pk.inspect}\n"
         else
           code << "  # Could not identify any column(s) to use as a primary key\n" unless is_view
         end
@@ -792,10 +736,11 @@ class Object
       end # class definition
       # Having this separate -- will this now work out better?
         built_model.class_exec do
-          hmts.each do |hmt_fk, fks|
+          hmts&.each do |hmt_fk, fks|
             hmt_fk = hmt_fk.tr('.', '_')
             fks.each do |fk|
-              through = fk.first[:assoc_name]
+              # %%% Will not work with custom has_many name
+              through = ::Brick.config.schema_behavior[:multitenant] ? fk.first[:assoc_name] : fk.first[:inverse_table].tr('.', '_').pluralize
               hmt_name = if fks.length > 1
                            if fks[0].first[:inverse][:assoc_name] == fks[1].first[:inverse][:assoc_name] # Same BT names pointing back to us? (Most common scenario)
                              "#{hmt_fk}_through_#{fk.first[:assoc_name]}"
@@ -807,10 +752,15 @@ class Object
                          else
                            hmt_fk
                          end
-              source = fk.last unless hmt_name.singularize == fk.last
-              code << "  has_many :#{hmt_name}, through: #{(assoc_name = through.to_sym).to_sym.inspect}#{", source: :#{source}" if source}\n"
-              options = { through: assoc_name }
-              options[:source] = source.to_sym if source
+              options = { through: through.to_sym }
+              if relation[:fks].any? { |k, v| v[:assoc_name] == hmt_name }
+                hmt_name = "#{hmt_name.singularize}_#{fk.first[:assoc_name]}"
+                # binding.pry if relation[:fks].any? { |k, v| v[:assoc_name] == hmt_name }
+                options[:class_name] = fk.first[:inverse_table].singularize.camelize
+                options[:foreign_key] = fk.first[:fk].to_sym
+              end
+              options[:source] = fk.last.to_sym unless hmt_name.singularize == fk.last
+              code << "  has_many :#{hmt_name}#{options.map { |opt| ", #{opt.first}: #{opt.last.inspect}" }.join}\n"
               self.send(:has_many, hmt_name.to_sym, **options)
             end
           end
@@ -832,6 +782,7 @@ class Object
                              else
                                assoc[:assoc_name]
                              end
+                options[:optional] = true if assoc.key?(:optional)
                 if assoc.key?(:polymorphic)
                   options[:polymorphic] = true
                 else
@@ -875,7 +826,11 @@ class Object
               end
       # Figure out if we need to specially call out the class_name and/or foreign key
       # (and if either of those then definitely also a specific inverse_of)
-      options[:class_name] = "::#{assoc[:primary_class]&.name || singular_table_name.split('.').map(&:camelize).join('::')}" if need_class_name
+      if (singular_table_parts = singular_table_name.split('.')).length > 1 &&
+         ::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(&:camelize).join('::')}" if need_class_name
       # Work around a bug in CPK where self-referencing belongs_to associations double up their foreign keys
       if need_fk # Funky foreign key?
         options[:foreign_key] = if assoc[:fk].is_a?(Array)
@@ -889,7 +844,6 @@ class Object
 
       # Prepare a list of entries for "has_many :through"
       if macro == :has_many
-        puts [inverse_table, relations[inverse_table].length].inspect
         relations[inverse_table][:hmt_fks].each do |k, hmt_fk|
           next if k == assoc[:fk]
 
@@ -905,19 +859,70 @@ class Object
     def build_controller(namespace, class_name, plural_class_name, model, relations)
       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))
+      pk = model&._brick_primary_key(relations.fetch(table_name, nil))
 
       namespace_name = "#{namespace.name}::" if namespace
       code = +"class #{namespace_name}#{class_name} < ApplicationController\n"
       built_controller = Class.new(ActionController::Base) do |new_controller_class|
         (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
-        code << "  def index\n"
-        code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{pk.inspect})" : '.all'}\n"
-        code << "    @#{table_name}.brick_select(params)\n"
-        code << "  end\n"
+        unless (is_swagger = plural_class_name == 'BrickSwagger') # && request.format == :json)
+          code << "  def index\n"
+          code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{pk.inspect})" : '.all'}\n"
+          code << "    @#{table_name}.brick_select(params)\n"
+          code << "  end\n"
+        end
         self.protect_from_forgery unless: -> { self.request.format.js? }
         self.define_method :index do
+          if is_swagger
+            json = { 'openapi': '3.0.1', 'info': { 'title': 'API V1', 'version': 'v1' },
+                     'servers': [
+                       { 'url': 'https://{defaultHost}', 'variables': { 'defaultHost': { 'default': 'www.example.com' } } }
+                     ]
+                   }
+            json['paths'] = relations.each_with_object({}) do |v, s|
+              # next if v.last[:is_view]
+
+              s["/api/v1/#{v.first}"] = {
+                'get': {
+                  'summary': 'list #{v.first}',
+                  'parameters': v.last[:cols].map { |k, v| { 'name' => k, 'schema': { 'type': v.first } } },
+                  'responses': { '200': { 'description': 'successful' } }
+                }
+              }
+              s["/api/v1/#{v.first}/{id}"] = {
+                'patch': {
+                  'summary': 'update a #{v.first.singularize}',
+                  'parameters': v.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
+                    { 'name' => k, 'schema': { 'type': v.first } }
+                  end,
+                  'responses': { '200': { 'description': 'successful' } }
+                }
+                # "/api/v1/books/{id}": {
+                #   "parameters": [
+                #     {
+                #       "name": "id",
+                #       "in": "path",
+                #       "description": "id",
+                #       "required": true,
+                #       "schema": {
+                #         "type": "string"
+                #       }
+                #     },
+                #     {
+                #       "name": "Authorization",
+                #       "in": "header",
+                #       "schema": {
+                #         "type": "string"
+                #       }
+                #     }
+                #   ],
+              }
+            end
+            # binding.pry
+            render inline: json.to_json, content_type: request.format
+            return
+          end
           ::Brick.set_db_schema(params)
           if request.format == :csv # Asking for a template?
             require 'csv'
@@ -946,7 +951,7 @@ class Object
           @_brick_join_array = join_array
         end
 
-        if model.primary_key
+        if model&.primary_key
           code << "  def show\n"
           code << (find_by_id = "    id = params[:id]&.split(/[\\/,_]/)
     id = id.first if id.is_a?(Array) && id.length == 1
@@ -961,7 +966,7 @@ class Object
         end
 
         # By default, views get marked as read-only
-        unless false # model.readonly # (relation = relations[model.table_name]).key?(:isView)
+        unless is_swagger # model.readonly # (relation = relations[model.table_name]).key?(:isView)
           code << "  # (Define :new, :create)\n"
 
           if model.primary_key
@@ -993,7 +998,9 @@ class Object
               #   return
               end
 
-              instance_variable_set("@#{singular_table_name}".to_sym, (obj = model.find(params[:id].split(','))))
+              id = params[:id]&.split(/[\/,_]/)
+              id = id.first if id.is_a?(Array) && id.length == 1
+              instance_variable_set("@#{singular_table_name}".to_sym, (obj = model.find(id)))
               obj = obj.first if obj.is_a?(Array)
               obj.send(:update, send(params_name = params_name.to_sym))
             end
@@ -1018,10 +1025,23 @@ class Object
 
     def _brick_get_hm_assoc_name(relation, hm_assoc)
       if relation[:hm_counts][hm_assoc[:assoc_name]]&.> 1
+        # binding.pry if (same_name = relation[:fks].find { |x| x.last[:assoc_name] == hm_assoc[:assoc_name] && x.last != hm_assoc }) #&&
+                                    # x.last[:alternate_name] == hm_assoc[:alternate_name] })
+        # relation[:fks].any? { |k, v| v[:assoc_name] == new_alt_name }
         plural = ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])
-        [hm_assoc[:alternate_name] == name.underscore ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural, true]
+        # binding.pry if hm_assoc[:assoc_name] == 'issue_issue_duplicates'
+        new_alt_name = (hm_assoc[:alternate_name] == name.underscore) ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural
+        # uniq = 1
+        # while same_name = relation[:fks].find { |x| x.last[:assoc_name] == hm_assoc[:assoc_name] && x.last != hm_assoc }
+        #   hm_assoc[:assoc_name] = "#{hm_assoc_name}_#{uniq += 1}"
+        # end
+        # puts new_alt_name
+        # binding.pry if new_alt_name == 'issue_duplicates'
+        # hm_assoc[:assoc_name] = new_alt_name
+        [new_alt_name, true]
       else
         assoc_name = hm_assoc[:inverse_table].pluralize
+        # hm_assoc[:assoc_name] = assoc_name
         [assoc_name, assoc_name.include?('.')]
       end
     end
@@ -1040,16 +1060,30 @@ module ActiveRecord::ConnectionHandling
     conn
   end
 
+  # This is done separately so that during testing it can be called right after a migration
+  # in order to make sure everything is good.
   def _brick_reflect_tables
+    initializer_loaded = false
     if (relations = ::Brick.relations).empty?
-      load Rails.root.join('config/initializers/brick.rb') # Hopefully our initializer is named exactly this!
+      # If there's schema things configured then we only expect our initializer to be named exactly this
+      if File.exist?(brick_initializer = Rails.root.join('config/initializers/brick.rb'))
+        initializer_loaded = load brick_initializer
+      end
+      # Load the initializer for the Apartment gem a little early so that if .excluded_models and
+      # .default_schema are specified then we can work with non-tenanted models more appropriately
+      if Object.const_defined?('Apartment') && File.exist?(apartment_initializer = Rails.root.join('config/initializers/apartment.rb'))
+        load apartment_initializer
+        apartment_excluded = Apartment.excluded_models
+      end
       # Only for Postgres?  (Doesn't work in sqlite3)
       # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
       schema_sql = 'SELECT NULL AS table_schema;'
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL'
-        if (::Brick.default_schema = schema = ::Brick.config.schema_behavior&.[](:multitenant)&.[](:schema_to_analyse))
+        if (is_multitenant = (multitenancy = ::Brick.config.schema_behavior[:multitenant]) &&
+           (sta = multitenancy[:schema_to_analyse]) != 'public')
+          ::Brick.default_schema = schema = sta
           ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
         end
         schema_sql = 'SELECT DISTINCT table_schema FROM INFORMATION_SCHEMA.tables;'
@@ -1067,6 +1101,28 @@ module ActiveRecord::ConnectionHandling
         puts "Unfamiliar with connection adapter #{ActiveRecord::Base.connection.adapter_name}"
       end
 
+      unless (db_schemas = ActiveRecord::Base.execute_sql(schema_sql)).is_a?(Array)
+        db_schemas = db_schemas.to_a
+      end
+      unless db_schemas.empty?
+        ::Brick.db_schemas = db_schemas.each_with_object({}) do |row, s|
+          row = row.is_a?(String) ? row : row['table_schema']
+          # Remove any system schemas
+          s[row] = nil unless ['information_schema', 'pg_catalog'].include?(row)
+        end
+      end
+
+      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+        if (possible_schema = ::Brick.config.schema_behavior&.[](:multitenant)&.[](:schema_to_analyse))
+          if ::Brick.db_schemas.key?(possible_schema)
+            ::Brick.default_schema = schema = possible_schema
+            ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
+          else
+            puts "*** In the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to a schema called \"#{possible_schema}\".  This schema does not exist. ***"
+          end
+        end
+      end
+
       sql ||= "SELECT t.table_schema AS schema, t.table_name AS relation_name, t.table_type,
           c.column_name, c.data_type,
           COALESCE(c.character_maximum_length, c.numeric_precision) AS max_length,
@@ -1093,14 +1149,16 @@ module ActiveRecord::ConnectionHandling
       measures = []
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'SQLite' # These bring back a hash for each row because the query uses column aliases
-        schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+        # schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
         ActiveRecord::Base.execute_sql(sql).each do |r|
-          # next if internal_views.include?(r['relation_name']) # Skip internal views such as v_all_assessments
-          relation_name = if r['schema'] != schema
-                            "#{schema_name = r['schema']}.#{r['relation_name']}"
-                          else
-                            r['relation_name']
-                          end
+          # If Apartment gem lists the table as being associated with a non-tenanted model then use whatever it thinks
+          # is the default schema, usually 'public'.
+          schema_name = if ::Brick.config.schema_behavior[:multitenant]
+                          Apartment.default_schema if apartment_excluded&.include?(r['relation_name'].singularize.camelize)
+                        elsif ![schema, 'public'].include?(r['schema'])
+                          r['schema']
+                        end
+          relation_name = schema_name ? "#{schema_name}.#{r['relation_name']}" : r['relation_name']
           relation = relations[relation_name]
           relation[:isView] = true if r['table_type'] == 'VIEW'
           col_name = r['column_name']
@@ -1119,7 +1177,6 @@ module ActiveRecord::ConnectionHandling
         end
       else # MySQL2 acts a little differently, bringing back an array for each row
         ActiveRecord::Base.execute_sql(sql).each do |r|
-          # next if internal_views.include?(r['relation_name']) # Skip internal views such as v_all_assessments
           relation = relations[(relation_name = r[0])] # here relation represents a table or view from the database
           relation[:isView] = true if r[1] == 'VIEW' # table_type
           col_name = r[2]
@@ -1158,7 +1215,7 @@ module ActiveRecord::ConnectionHandling
       #     end
       #   end
       # end
-      schema = ::Brick.default_schema # Reset back for this next round of fun
+      # schema = ::Brick.default_schema # Reset back for this next round of fun
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'Mysql2'
         sql = "SELECT kcu1.CONSTRAINT_SCHEMA, kcu1.TABLE_NAME, kcu1.COLUMN_NAME,
@@ -1173,7 +1230,7 @@ module ActiveRecord::ConnectionHandling
               AND kcu2.CONSTRAINT_SCHEMA = rc.UNIQUE_CONSTRAINT_SCHEMA
               AND kcu2.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
               AND kcu2.ORDINAL_POSITION = kcu1.ORDINAL_POSITION#{"
-            WHERE kcu1.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if schema }"
+          WHERE kcu1.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if schema }"
           # AND kcu2.TABLE_NAME = ?;", Apartment::Tenant.current, table_name
       when 'SQLite'
         sql = "SELECT m.name, fkl.\"from\", fkl.\"table\", m.name || '_' || fkl.\"from\" AS constraint_name
@@ -1183,19 +1240,20 @@ module ActiveRecord::ConnectionHandling
       else
       end
       if sql
-        ::Brick.default_schema ||= schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-        unless (db_schemas = ActiveRecord::Base.execute_sql(schema_sql)).is_a?(Array)
-          db_schemas = db_schemas.to_a
-        end
-        unless db_schemas.empty?
-          ::Brick.db_schemas = db_schemas.each_with_object({}) do |row, s|
-            row = row.is_a?(String) ? row : row['table_schema']
-            # Remove whatever default schema we're using and other system schemas
-            s[row] = nil unless ['information_schema', 'pg_catalog', schema].include?(row)
-          end
-        end
+        # ::Brick.default_schema ||= schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
         ActiveRecord::Base.execute_sql(sql).each do |fk|
           fk = fk.values unless fk.is_a?(Array)
+          # Multitenancy makes things a little more general overall, except for non-tenanted tables
+          if apartment_excluded&.include?(fk[1].singularize.camelize)
+            fk[0] = Apartment.default_schema
+          elsif fk[0] == 'public' || (is_multitenant && fk[0] == schema)
+            fk[0] = nil
+          end
+          if apartment_excluded&.include?(fk[4].singularize.camelize)
+            fk[3] = Apartment.default_schema
+          elsif fk[3] == 'public' || (is_multitenant && fk[3] == schema)
+            fk[3] = nil
+          end
           ::Brick._add_bt_and_hm(fk, relations)
         end
       end
@@ -1208,11 +1266,7 @@ module ActiveRecord::ConnectionHandling
       views.keys.each { |k| puts ActiveSupport::Inflector.singularize(k).camelize }
     end
 
-    # Try to load the initializer pretty danged early
-    if File.exist?(brick_initialiser = Rails.root.join('config/initializers/brick.rb'))
-      load brick_initialiser
-      ::Brick.load_additional_references
-    end
+    ::Brick.load_additional_references if initializer_loaded
   end
 end
 
@@ -1239,31 +1293,51 @@ module Brick
   # rubocop:enable Style/CommentedKeyword
 
   class << self
-    def _add_bt_and_hm(fk, relations, is_polymorphic = false)
-      if (bt_assoc_name = fk[2].underscore).end_with?('_id')
-        bt_assoc_name = bt_assoc_name[0..-4]
-      elsif bt_assoc_name.end_with?('id') && bt_assoc_name.exclude?('_') # Make the bold assumption that we can just peel off the final ID part
-        bt_assoc_name = bt_assoc_name[0..-3]
-      else
-        bt_assoc_name = "#{bt_assoc_name}_bt"
+    def _add_bt_and_hm(fk, relations, is_polymorphic = false, is_optional = false)
+      bt_assoc_name = fk[2]
+      unless is_polymorphic
+        bt_assoc_name = if bt_assoc_name.underscore.end_with?('_id')
+                          bt_assoc_name[0..-4]
+                        elsif bt_assoc_name.downcase.end_with?('id') && bt_assoc_name.exclude?('_')
+                          bt_assoc_name[0..-3] # Make the bold assumption that we can just peel off any final ID part
+                        else
+                          "#{bt_assoc_name}_bt"
+                        end
       end
       # %%% Temporary schema patch
-      fk[1] = "#{fk[0]}.#{for_tbl = fk[1]}" if fk[0] && fk[0] != ::Brick.default_schema
-      for_tbl << '_' if for_tbl
+      for_tbl = fk[1]
+      fk[0] = Apartment.default_schema if Object.const_defined?('Apartment') && Apartment.excluded_models.include?(for_tbl.singularize.camelize)
+      fk[1] = "#{fk[0]}.#{fk[1]}" if fk[0] # && fk[0] != ::Brick.default_schema
       bts = (relation = relations.fetch(fk[1], nil))&.fetch(:fks) { relation[:fks] = {} }
+
       # %%% Do we miss out on has_many :through or even HM based on constantizing this model early?
       # Maybe it's already gotten this info because we got as far as to say there was a unique class
       primary_table = if (is_class = fk[4].is_a?(Hash) && fk[4].key?(:class))
                         pri_tbl = (primary_class = fk[4][:class].constantize).table_name
+                        if (pri_tbl_parts = pri_tbl.split('.')).length > 1
+                          fk[3] = pri_tbl_parts.first
+                        end
                       else
+                        is_schema = if ::Brick.config.schema_behavior[:multitenant]
+                                      # If Apartment gem lists the primary table as being associated with a non-tenanted model
+                                      # then use 'public' schema for the primary table
+                                      if Object.const_defined?('Apartment') && Apartment.excluded_models.include?(fk[4].singularize.camelize)
+                                        fk[3] = Apartment.default_schema
+                                        true
+                                      end
+                                    else
+                                      fk[3] && fk[3] != ::Brick.default_schema && fk[3] != 'public'
+                                    end
                         pri_tbl = fk[4]
-                        (fk[3] && fk[3] != ::Brick.default_schema) ? "#{fk[3]}.#{pri_tbl}" : pri_tbl
+                        is_schema ? "#{fk[3]}.#{pri_tbl}" : pri_tbl
                       end
       hms = (relation = relations.fetch(primary_table, nil))&.fetch(:fks) { relation[:fks] = {} } unless is_class
 
       unless (cnstr_name = fk[5])
         # For any appended references (those that come from config), arrive upon a definitely unique constraint name
-        cnstr_base = cnstr_name = "(brick) #{for_tbl}#{is_class ? fk[4][:class].underscore : pri_tbl}"
+        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_base = cnstr_name = "(brick) #{for_tbl}_#{pri_tbl}"
         cnstr_added_num = 1
         cnstr_name = "#{cnstr_base}_#{cnstr_added_num += 1}" while bts&.key?(cnstr_name) || hms&.key?(cnstr_name)
         missing = []
@@ -1303,6 +1377,7 @@ module Brick
       else
         inverse_table = [primary_table] if is_polymorphic
         assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[2], assoc_name: bt_assoc_name, inverse_table: inverse_table || primary_table }
+        assoc_bt[:optional] = true if is_optional
         assoc_bt[:polymorphic] = true if is_polymorphic
       end
       if is_class
@@ -1323,7 +1398,14 @@ module Brick
         assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
         assoc_hm[:inverse] = assoc_bt
       else
-        assoc_hm = hms[hm_cnstr_name] = { is_bt: false, fk: fk[2], assoc_name: fk[1].tr('.', '_').pluralize, alternate_name: bt_assoc_name, inverse_table: fk[1], inverse: assoc_bt }
+        inv_tbl = if ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') && fk[0] == Apartment.default_schema
+                    for_tbl
+                  else
+                    fk[1]
+                  end
+                  # binding.pry if inv_tbl == 'issue_issue_duplicates' # inverse_table goofed?
+        assoc_hm = hms[hm_cnstr_name] = { is_bt: false, fk: fk[2], assoc_name: for_tbl.pluralize, alternate_name: bt_assoc_name,
+                                          inverse_table: inv_tbl, inverse: assoc_bt }
         assoc_hm[:polymorphic] = true if is_polymorphic
         hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
         hm_counts[fk[1]] = hm_counts.fetch(fk[1]) { 0 } + 1

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

@@ -222,7 +222,7 @@ end %>"
               if ['index', 'show', 'update'].include?(args.first)
                 poly_cols = []
                 css << "<% bts = { #{
-                  bts.each_with_object([]) do |v, s|
+                  bt_items = bts.each_with_object([]) do |v, s|
                     foreign_models = if v.last[2] # Polymorphic?
                                        poly_cols << @_brick_model.reflect_on_association(v[1].first).foreign_type
                                        v.last[1].each_with_object([]) { |x, s| s << "[#{x.name}, #{x.primary_key.inspect}]" }.join(', ')
@@ -230,7 +230,10 @@ end %>"
                                        "[#{v.last[1].name}, #{v.last[1].primary_key.inspect}]"
                                      end
                     s << "#{v.first.inspect} => [#{v.last.first.inspect}, [#{foreign_models}], #{v.last[2].inspect}]"
-                  end.join(', ')
+                  end
+                  # # %%% Need to fix poly going to an STI class
+                  # binding.pry unless poly_cols.empty?
+                  bt_items.join(', ')
                 } }
                 poly_cols = #{poly_cols.inspect} %>"
               end
@@ -404,7 +407,7 @@ function changeout(href, param, value) {
        origin = (key_parts = k.split('.')).length == 1 ? #{model_name} : #{model_name}.reflect_on_association(key_parts.first).klass
       #  binding.pry
        if (destination_fk = Brick.relations[origin.table_name][:fks].values.find { |fk| puts fk.inspect; fk[:fk] == key_parts.last }) &&
-         (obj = (destination = origin.reflect_on_association(destination_fk[:assoc_name])&.klass)&.find(id)) %>
+          (obj = (destination = origin.reflect_on_association(destination_fk[:assoc_name])&.klass)&.find(id)) %>
          <h3>for <%= link_to \"#{"#\{obj.brick_descrip\} (#\{destination.name\})\""}, send(\"#\{destination.name.underscore.tr('/', '_')\}_path\".to_sym, id) %></h3><%
        end
      end %>

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -93,16 +93,19 @@ module Brick
     attr_accessor :default_schema, :db_schemas
 
     def set_db_schema(params)
-      schema = params['_brick_schema']
+      schema = params['_brick_schema'] || 'public'
       ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema) if schema && ::Brick.db_schemas&.include?(schema)
     end
 
     # All tables and views (what Postgres calls "relations" including column and foreign key info)
     def relations
-      connections = Brick.instance_variable_get(:@relations) ||
-        Brick.instance_variable_set(:@relations, (connections = {}))
       # Key our list of relations for this connection off of the connection pool's object_id
-      (connections[ActiveRecord::Base.connection_pool.object_id] ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } })
+      (@relations ||= {})[ActiveRecord::Base.connection_pool.object_id] ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } }
+    end
+
+    # If multitenancy is enabled, a list of non-tenanted "global" models
+    def non_tenanted_models
+      @pending_models ||= {}
     end
 
     def get_bts_and_hms(model)
@@ -129,6 +132,7 @@ module Brick
       associatives = hms.each_with_object({}) do |hmt, s|
         if (through = hmt.last.options[:through])
           skip_hms[through] = nil
+          # binding.pry if hmt.first == :issue_issues
           s[hmt.first] = hms[through] # End up with a hash of HMT names pointing to join-table associations
         elsif hmt.last.inverse_of.nil?
           puts "SKIPPING #{hmt.last.name.inspect}"
@@ -314,7 +318,7 @@ module Brick
         if ars
           ars.each do |ar|
             fk = ar.length < 5 ? [nil, +ar[0], ar[1], nil, +ar[2]] : [ar[0], +ar[1], ar[2], ar[3], +ar[4], ar[5]]
-            ::Brick._add_bt_and_hm(fk, relations)
+            ::Brick._add_bt_and_hm(fk, relations, false, true)
           end
         end
         if (polys = ::Brick.config.polymorphics)
@@ -327,7 +331,7 @@ module Brick
             v ||= ActiveRecord::Base.execute_sql("SELECT DISTINCT #{poly}_type AS typ FROM #{table_name}").each_with_object([]) { |result, s| s << result['typ'] if result['typ'] }
             v.each do |type|
               if relations.key?(primary_table = type.underscore.pluralize)
-                ::Brick._add_bt_and_hm([nil, table_name, poly, nil, primary_table, "(brick) #{table_name}_#{poly}"], relations, true)
+                ::Brick._add_bt_and_hm([nil, table_name, poly, nil, primary_table, "(brick) #{table_name}_#{poly}"], relations, true, true)
               else
                 missing_stis[primary_table] = type unless ::Brick.existing_stis.key?(type)
               end
@@ -406,6 +410,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
         ::Brick.relations.each do |rel_name, v|
           rel_name = rel_name.split('.').map(&:underscore)
           schema_names = rel_name[0..-2]
+          schema_names.shift if ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') && schema_names.first == Apartment.default_schema
           k = rel_name.last
           unless existing_controllers.key?(controller_name = k.pluralize)
             options = {}
@@ -419,6 +424,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
             end
           end
         end
+        send(:get, '/api-docs/v1/swagger.json', { to: 'brick_swagger#index' }) if Object.const_defined?('Rswag::Ui')
       end
       super
     end

data/lib/generators/brick/install_generator.rb

@@ -28,7 +28,7 @@ module Brick
             col_down = col.downcase
 
             if (is_possible_poly = ['character varying', 'text'].include?(type.first))
-              if col_down.end_with?('_type') &&
+              if col_down.end_with?('_type')
                 poly_type_cut_length = -6
                 col_down = col_down[0..-6]
               elsif col_down.end_with?('type')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.30
+  version: 1.0.33
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-29 00:00:00.000000000 Z
+date: 2022-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord