brick 1.0.71 → 1.0.73

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

@@ -87,9 +87,9 @@ module Brick
 
             def path_keys(hm_assoc, fk_name, obj_name, pk)
               keys = if fk_name.is_a?(Array) && pk.is_a?(Array) # Composite keys?
-                       fk_name.zip(pk.map { |pk_part| "#{obj_name}.#{pk_part}" })
+                       fk_name.zip(pk.map { |fk_part| "#{obj_name}.#{fk_part}" })
                      else
-                       pk = pk.each_with_object([]) { |pk_part, s| s << "#{obj_name}.#{pk_part}" }
+                       pk = pk.map { |pk_part| "#{obj_name}.#{pk_part}" }
                        [[fk_name, pk.length == 1 ? pk.first : pk.inspect]]
                      end
               keys << [hm_assoc.inverse_of.foreign_type, hm_assoc.active_record.name] if hm_assoc.options.key?(:as)
@@ -106,8 +106,8 @@ module Brick
                 return _brick_find_template(*args, **options)
               end
 
-            if @_brick_model
-                pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(model_name, nil))
+              if @_brick_model
+                pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(@_brick_model&.table_name, nil))
                 obj_name = model_name.split('::').last.underscore
                 path_obj_name = model_name.underscore.tr('/', '_')
                 table_name = obj_name.pluralize
@@ -159,7 +159,7 @@ module Brick
                     hms_columns << hm_entry
                   when 'show', 'new', 'update'
                     hm_stuff << if hm_fk_name
-                                  "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
+                                  "<%= link_to '#{assoc_name}', #{hm_assoc.klass._brick_index}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
                                 else # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
                                   assoc_name
                                 end
@@ -173,12 +173,13 @@ module Brick
               # environment or whatever, then get either the controllers or routes list instead
               apartment_default_schema = ::Brick.apartment_multitenant && Apartment.default_schema
               table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).each_with_object({}) do |tbl, s|
+                                binding.pry if tbl.is_a?(Symbol)
                                 if (tbl_parts = tbl.split('.')).first == apartment_default_schema
                                   tbl = tbl_parts.last
                                 end
                                 s[tbl] = nil
                               end.keys.sort.each_with_object(+'') do |v, s|
-                                s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>"
+                                s << "<option value=\"#{v.underscore.gsub('.', '/')}\">#{v}</option>"
                               end.html_safe
               table_options << '<option value="brick_status">(Status)</option>'.html_safe if ::Brick.config.add_status
               table_options << '<option value="brick_orphans">(Orphans)</option>'.html_safe if is_orphans
@@ -351,15 +352,39 @@ def hide_bcrypt(val, max_len = 200)
 end
 def display_value(col_type, val)
   case col_type
-  when 'geometry'
+  when 'geometry', 'geography'
     if Object.const_defined?('RGeo')
       @is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2' if @is_mysql.nil?
-      if @is_mysql
-        # MySQL's \"Internal Geometry Format\" is like WKB, but with an initial 4 bytes that indicates the SRID.
-        srid = val[0..3].unpack('I')
-        val = val[4..-1]
+      @is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer' if @is_mssql.nil?
+      val_err = nil
+      if @is_mysql || @is_mssql
+        # MySQL's \"Internal Geometry Format\" and MSSQL's Geography are like WKB, but with an initial 4 bytes that indicates the SRID.
+        if (srid = val&.[](0..3)&.unpack('I'))
+          val = val.force_encoding('BINARY')[4..-1].bytes
+
+          # MSSQL spatial bitwise flags, often 0C for a point:
+          # xxxx xxx1 = HasZValues
+          # xxxx xx1x = HasMValues
+          # xxxx x1xx = IsValid
+          # xxxx 1xxx = IsSinglePoint
+          # xxx1 xxxx = IsSingleLineSegment
+          # xx1x xxxx = IsWholeGlobe
+          # Convert Microsoft's unique geography binary to standard WKB
+          # (MSSQL point usually has two doubles, lng / lat, and can also have Z)
+          if @is_mssql
+            if val[0] == 1 && (val[1] & 8 > 0) && # Single point?
+              (val.length - 2) % 8 == 0 && val.length < 27 # And containing up to three 8-byte values?
+              idx = 2
+              new_val = [0, 0, 0, 0, 1]
+              new_val.concat(val[idx - 8...idx].reverse) while (idx += 8) <= val.length
+              val = new_val
+            else
+              val_err = '(Microsoft internal SQL geography type)'
+            end
+          end
+        end
       end
-      RGeo::WKRep::WKBParser.new.parse(val)
+      val_err || (val ? RGeo::WKRep::WKBParser.new.parse(val.pack('c*')) : nil)
     else
       '(Add RGeo gem to parse geometry detail)'
     end
@@ -448,7 +473,7 @@ function changeout(href, param, value, trimAfter) {
   var params = hrefParts.length > 1 ? hrefParts[1].split(\"&\") : [];
   if (param === undefined || param === null || param === -1) {
     hrefParts = hrefParts[0].split(\"://\");
-    var pathParts = hrefParts[hrefParts.length - 1].split(\"/\");
+    var pathParts = hrefParts[hrefParts.length - 1].split(\"/\").filter(function (pp) {return pp !== \"\";});
     if (value === undefined)
       // A couple possibilities if it's namespaced, starting with two parts in the path -- and then try just one
       return [pathParts.slice(1, 3).join('/'), pathParts.slice(1, 2)[0]];
@@ -562,7 +587,7 @@ erDiagram
     <%= \"#\{model_short_name} }o..o{ #\{hm_name} : \\\"#\{hm.first}\\\"\".html_safe %><%
      else # has_many
 %>  <%= \"#\{model_short_name} ||--o{ #\{hm_name} : \\\"#\{
-            hm_name unless hm.first.to_s == hm_class.name.underscore.pluralize.tr('/', '_')
+            hm.first.to_s unless hm.first.to_s.downcase == hm_class.name.underscore.pluralize.tr('/', '_')
           }\\\"\".html_safe %><%
      end %>
 <% end
@@ -604,7 +629,7 @@ erDiagram
                                   end
                          if Object.const_defined?('DutyFree')
                            template_link = "
-  <%= link_to 'CSV', #{table_name}_path(format: :csv) %> &nbsp; <a href=\"#\" id=\"sheetsLink\">Sheets</a>
+  <%= link_to 'CSV', #{@_brick_model._brick_index}_path(format: :csv) %> &nbsp; <a href=\"#\" id=\"sheetsLink\">Sheets</a>
   <div id=\"dropper\" contenteditable=\"true\"></div>
   <input type=\"button\" id=\"btnImport\" value=\"Import\">
 
@@ -667,7 +692,7 @@ erDiagram
         console.log(\"x1\", sheetUrl);
 
         // Get JSON data
-        fetch(changeout(<%= #{table_name}_path(format: :js).inspect.html_safe %>, \"_brick_schema\", brickSchema)).then(function (response) {
+        fetch(changeout(<%= #{@_brick_model._brick_index}_path(format: :js).inspect.html_safe %>, \"_brick_schema\", brickSchema)).then(function (response) {
           response.json().then(function (data) {
             gapi.client.sheets.spreadsheets.values.append({
               spreadsheetId: spreadsheetId,
@@ -698,7 +723,7 @@ erDiagram
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
 <table id=\"resourceName\"><tr>
-  <td><h1>#{model_plural = model_name.pluralize}</h1></td>
+  <td><h1>#{model_name}</h1></td>
   <td id=\"imgErd\" title=\"Show ERD\"></td>
 </tr></table>#{template_link}<%
    if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
@@ -712,10 +737,10 @@ erDiagram
        origin = (key_parts = k.split('.')).length == 1 ? #{model_name} : #{model_name}.reflect_on_association(key_parts.first).klass
        if (destination_fk = Brick.relations[origin.table_name][:fks].values.find { |fk| fk[:fk] == key_parts.last }) &&
           (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><%
+         <h3>for <%= link_to \"#{"#\{obj.brick_descrip\} (#\{destination.name\})\""}, send(\"#\{destination._brick_index\}_path\".to_sym, id) %></h3><%
        end
      end %>
-  (<%= link_to 'See all #{model_plural.split('::').last}', #{path_obj_name.pluralize}_path %>)
+  (<%= link_to 'See all #{model_name.split('::').last.pluralize}', #{@_brick_model._brick_index}_path %>)
 <% end
    # COLUMN EXCLUSIONS
    if @_brick_excl&.present? %>
@@ -768,7 +793,7 @@ erDiagram
               end
        elsif col # HM column
          s << \"<th#\{' x-order=\"' + col_name + '\"' if true}>#\{col[2]} \"
-         s << (col.first ? \"#\{col[3]}\" : \"#\{link_to(col[3], send(\"#\{col[1].name.underscore.tr('/', '_').pluralize}_path\"))}\")
+         s << (col.first ? \"#\{col[3]}\" : \"#\{link_to(col[3], send(\"#\{col[1]._brick_index}_path\"))}\")
        else # Bad column name!
          s << \"<th title=\\\"<< Unknown column >>\\\">#\{col_name}\"
        end
@@ -776,7 +801,11 @@ erDiagram
      end.html_safe
   %></tr></thead>
   <tbody>
-  <% @#{table_name}.each do |#{obj_name}|
+  <% # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
+     #     ActiveRecord::StatementTimeout in Warehouse::ColdRoomTemperatures_Archive#index
+     #     TinyTds::Error: Adaptive Server connection timed out
+     #     (After restarting the server it worked fine again.)
+     @#{table_name}.each do |#{obj_name}|
        hms_cols = {#{hms_columns.join(', ')}} %>
   <tr>#{"
     <td><%= link_to '⇛', #{path_obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
@@ -811,10 +840,11 @@ erDiagram
                    else
                      \"#\{hms_col[1] || 'View'\} #\{hms_col.first}\"
                    end %>
-         <%= link_to txt, send(\"#\{klass.name.underscore.tr('/', '_').pluralize}_path\".to_sym, hms_col[2]) unless hms_col[1]&.zero? %>
+         <%= link_to txt, send(\"#\{klass._brick_index}_path\".to_sym, hms_col[2]) unless hms_col[1]&.zero? %>
         <% end
          elsif (col = cols[col_name])
-    %><%=  display_value(col&.type || col&.sql_type, val) %><%
+           col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
+    %><%=  display_value(col_type || col&.sql_type, val) %><%
          else # Bad column name!
       %>?<%
          end
@@ -908,7 +938,7 @@ erDiagram
 if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
   description %><br><%
 end
-%><%= link_to '(See all #{obj_name.pluralize})', #{path_obj_name.pluralize}_path %>
+%><%= link_to '(See all #{obj_name.pluralize})', #{@_brick_model._brick_index}_path %>
 #{erd_markup}
 <% if obj %>
   <br><br>
@@ -974,7 +1004,8 @@ end
             \"<span class=\\\"orphan\\\">Orphaned ID: #\{val}</span>\".html_safe
           end %>
     <% else
-      case (col_type = col.type || col.sql_type)
+      col_type = col.sql_type == 'geography' ? col.sql_type : col.type
+      case (col_type ||= col.sql_type)
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly?
              is_revert = false %>
@@ -1008,8 +1039,8 @@ end
       <% when :binary, :primary_key
            is_revert = false %>
       <% else %>
-        <%= display_value(col_type, val)
-           is_revert = false %>
+        <%= is_revert = false
+           display_value(col_type, val) %>
       <% end
        end
        if is_revert
@@ -1077,7 +1108,7 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
   var imgErd = document.getElementById(\"imgErd\");
   var mermaidErd = document.getElementById(\"mermaidErd\");
   var mermaidCode;
-  var cbs = {<%= callbacks.map { |k, v| \"#\{k}: \\\"#\{v.name.underscore.pluralize}\\\"\" }.join(', ').html_safe %>};
+  var cbs = {<%= callbacks.map { |k, v| \"#\{k}: \\\"#\{send(\"#\{v._brick_index}_path\".to_sym)}\\\"\" }.join(', ').html_safe %>};
   if (imgErd) imgErd.addEventListener(\"click\", showErd);
   function showErd() {
     imgErd.style.display = \"none\";
@@ -1101,7 +1132,7 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
               function (evt) {
                 location.href = changeout(changeout(
                   changeout(location.href, '_brick_order', null), // Remove any ordering
-                -1, cbs[this.id]), \"_brick_erd\", \"1\");
+                -1, cbs[this.id].replace(/^[\/]+/, \"\")), \"_brick_erd\", \"1\");
               }
             );
           }

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -125,8 +125,8 @@ module Brick
   class << self
     attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle
 
-    def set_db_schema(params)
-      schema = params['_brick_schema'] || 'public'
+    def set_db_schema(params = nil)
+      schema = (params ? params['_brick_schema'] : ::Brick.default_schema) || 'public'
       if schema && ::Brick.db_schemas&.include?(schema)
         ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
         schema
@@ -152,16 +152,19 @@ module Brick
     end
 
     # Convert spaces to underscores if the second character and onwards is mixed case
-    def namify(name)
+    def namify(name, action = nil)
+      has_uppers = name =~ /[A-Z]+/
+      has_lowers = name =~ /[a-z]+/
+      name.downcase! if has_uppers && action == :downcase
       if name.include?(' ')
         # All uppers or all lowers?
-        if name[1..-1] =~ /^[A-Z0-9_]+$/ || name[1..-1] =~ /^[a-z0-9_]+$/
+        if !has_uppers || !has_lowers
           name.titleize.tr(' ', '_')
         else # Mixed uppers and lowers -- just remove existing spaces
           name.tr(' ', '')
         end
       else
-        name
+        action == :underscore ? name.underscore : name
       end
     end
 
@@ -265,6 +268,26 @@ module Brick
       !!Brick.config.enable_routes
     end
 
+    # @api public
+    def enable_api=(path)
+      Brick.config.enable_api = path
+    end
+
+    # @api public
+    def enable_api
+      Brick.config.enable_api
+    end
+
+    # @api public
+    def api_root=(path)
+      Brick.config.api_root = path
+    end
+
+    # @api public
+    def api_root
+      Brick.config.api_root
+    end
+
     # @api public
     def skip_database_views=(value)
       Brick.config.skip_database_views = value
@@ -483,7 +506,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
         # %%% TODO: If no auto-controllers then enumerate the controllers folder in order to build matching routes
         # If auto-controllers and auto-models are both enabled then this makes sense:
         ::Brick.relations.each do |rel_name, v|
-          rel_name = rel_name.split('.').map { |x| ::Brick.namify(x).underscore }
+          rel_name = rel_name.split('.').map { |rel_part| ::Brick.namify(rel_part, :underscore) }
           schema_names = rel_name[0..-2]
           schema_names.shift if ::Brick.apartment_multitenant && schema_names.first == Apartment.default_schema
           # %%% If more than one schema has the same table name, will need to add a schema name prefix to have uniqueness
@@ -493,10 +516,12 @@ In config/initializers/brick.rb appropriate entries would look something like:
             options[:only] = [:index, :show] if v.key?(:isView)
             if schema_names.present? # && !Object.const_defined('Apartment')
               send(:namespace, schema_names.first) do
-                send(:resources, controller_name.to_sym, **options)
+                send(:resources, k.to_sym, **options)
               end
+              send(:get, "/api/v1/#{schema_names.first}/#{k}", { to: "#{schema_names.first}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
             else
-              send(:resources, controller_name.to_sym, **options)
+              send(:resources, k.to_sym, **options)
+              send(:get, "/api/v1/#{k}", { to: "#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
             end
           end
           if ::Brick.config.add_status && instance_variable_get(:@set).named_routes.names.exclude?(:brick_status)
@@ -506,7 +531,11 @@ In config/initializers/brick.rb appropriate entries would look something like:
             get('/brick_orphans', to: 'brick_gem#orphans', as: 'brick_orphans')
           end
         end
-        send(:get, '/api-docs/v1/swagger.json', { to: 'brick_swagger#index' }) if Object.const_defined?('Rswag::Ui')
+        if Object.const_defined?('Rswag::Ui') && doc_endpoint = Rswag::Ui.config.config_object[:urls].last
+          # Serves JSON swagger info from a path such as  '/api-docs/v1/swagger.json'
+          puts "Mounting swagger info endpoint for \"#{doc_endpoint[:name]}\" on #{doc_endpoint[:url]}"
+          send(:get, doc_endpoint[:url], { to: 'brick_swagger#index' })
+        end
       end
       super
     end
@@ -726,6 +755,63 @@ ActiveSupport.on_load(:active_record) do
         end
       end
     end
+
+    # Migration stuff
+    module ConnectionAdapters
+      # Override the downcasing implementation from the OracleEnhanced gem as it has bad regex
+      if const_defined?(:OracleEnhanced)
+        module OracleEnhanced::Quoting
+          private
+
+          def oracle_downcase(column_name)
+            return nil if column_name.nil?
+
+            /^[A-Za-z0-9_]+$/ =~ column_name ? column_name.downcase : column_name
+          end
+        end
+      end
+      if const_defined?(:SQLServerAdapter)
+        class SQLServer::TableDefinition
+          alias _brick_new_column_definition new_column_definition
+          def new_column_definition(name, type, **options)
+            case type
+            when :serial
+              type = :integer
+              options[:is_identity] = true
+            when :bigserial
+              type = :bigint
+              options[:is_identity] = true
+            end
+            _brick_new_column_definition(name, type, **options)
+          end
+          def serial(*args)
+            options = args.extract_options!
+            options[:is_identity] = true
+            args.each { |name| column(name, 'integer', options) }
+          end
+          def bigserial(*args)
+            options = args.extract_options!
+            options[:is_identity] = true
+            args.each { |name| column(name, 'bigint', options) }
+          end
+          # Seems that geography gets used a fair bit in MSSQL
+          def geography(*args)
+            options = args.extract_options!
+            # options[:precision] ||= 8
+            # options[:scale] ||= 2
+            args.each { |name| column(name, 'geography', options) }
+          end
+        end
+        class SQLServerAdapter
+          unless respond_to?(:schema_exists?)
+            def schema_exists?(schema)
+              schema_sql = 'SELECT 1 FROM sys.schemas WHERE name = ?'
+              ActiveRecord::Base.execute_sql(schema_sql, schema).present?
+            end
+          end
+        end
+      end
+    end
   end
   # rubocop:enable Lint/ConstantDefinitionInBlock
 

data/lib/generators/brick/install_generator.rb

@@ -147,6 +147,8 @@ module Brick
 # Brick.enable_controllers = true # Setting this to \"false\" will disable controllers in development
 # Brick.enable_views = true # Setting this to \"false\" will disable views in development
 
+# Brick.api_root = '/api/v1/' # Path from which to serve out API resources when the RSwag gem is present
+
 # # By default models are auto-created for database views, and set to be read-only.  This can be skipped.
 # Brick.skip_database_views = true
 

data/lib/generators/brick/migrations_generator.rb

@@ -23,6 +23,21 @@ module Brick
                   'time with time zone' => 'time',
                   'double precision' => 'float',
                   'smallint' => 'integer', # %%% Need to put in "limit: 2"
+                  # # Oracle data types
+                  'VARCHAR2' => 'string',
+                  'CHAR' => 'string',
+                  ['NUMBER', 22] => 'integer',
+                  /^INTERVAL / => 'string', # Time interval stuff like INTERVAL YEAR(2) TO MONTH, INTERVAL '999' DAY(3), etc
+                  'XMLTYPE' => 'xml',
+                  'RAW' => 'binary',
+                  'SDO_GEOMETRY' => 'geometry',
+                  # MSSQL data types
+                  'int' => 'integer',
+                  'nvarchar' => 'string',
+                  'nchar' => 'string',
+                  'datetime2' => 'timestamp',
+                  'bit' => 'boolean',
+                  'varbinary' => 'binary',
                   # Sqlite data types
                   'TEXT' => 'text',
                   '' => 'string',
@@ -122,7 +137,7 @@ module Brick
         fringe.each do |tbl|
           next unless (relation = ::Brick.relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present?
 
-          pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ActiveRecord::Base.primary_key].flatten)
+          pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ApplicationRecord.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
@@ -141,7 +156,7 @@ module Brick
                    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}", current_mig_time += 1.minute, ar_version, mig)
+            migration_file_write(mig_path, "create_db_schema_#{schema.underscore}", current_mig_time += 1.minute, ar_version, mig)
             built_schemas[schema] = nil
           end
 
@@ -151,11 +166,16 @@ module Brick
           # 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)
+          # 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 = relation[:cols][pkey_cols&.first]&.first) &&
-                             (pkey_col_first = SQL_TYPES[pkey_col_first] || pkey_col_first) != key_type)
+                      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'
@@ -164,9 +184,14 @@ module Brick
                         else
                           ", id: :#{pkey_col_first}" # Something like:  id: :integer, primary_key: :businessentityid
                         end +
-                          (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '') +
-                          (!is_4x_rails && (comment = relation&.fetch(:description, nil))&.present? ? ", comment: #{comment.inspect}" : '')
+                          (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
@@ -187,18 +212,24 @@ module Brick
           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] || col_type.first
-            suffix = col_type[3] ? +', null: false' : +''
+            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' : +''
             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] }
+            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 << "      t.#{sql_type} :#{column}#{suffix}\n"
+                mig << emit_column(sql_type, column, suffix)
                 add_fks << [to_table, column, ::Brick.relations[fk[:inverse_table]]]
               else
                 suffix << ", type: :#{sql_type}" unless sql_type == key_type

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.71
+  version: 1.0.73
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-16 00:00:00.000000000 Z
+date: 2022-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord