brick 1.0.245 → 1.0.247

data/lib/brick/rails/form_builder.rb

@@ -9,18 +9,19 @@ module Brick::Rails::FormBuilder
   def brick_field(method, html_options = {}, val = nil, col = nil,
                   bt = nil, bt_class = nil, bt_name = nil, bt_pair = nil)
     model = self.object.class
-    col ||= model.columns_hash[method]
+    col ||= model.columns_hash[method.to_s]
     out = +'<table><tr><td>'
     html_options[:class] = 'dimmed' unless val
     is_revert = true
     template = instance_variable_get(:@template)
+    method_sym = method.to_sym
     if bt
       bt_class ||= bt[1].first.first
       bt_name ||= bt[1].map { |x| x.first.name }.join('/')
       bt_pair ||= bt[1].first
 
       html_options[:prompt] = "Select #{bt_name}"
-      out << self.select(method.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options)
+      out << self.select(method_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options)
       bt_obj = nil
       begin
         bt_obj = bt_class&.find_by(bt_pair[1] => val)
@@ -38,8 +39,8 @@ module Brick::Rails::FormBuilder
                   "<span class=\"orphan\">Orphaned ID: #{val}</span>".html_safe
                 end
       out << bt_link if bt_link
-    elsif model._brick_monetized_attributes&.include?(method)
-      out << self.text_field(method.to_sym, html_options.merge({ value: Money.new(val.to_i).format }))
+    elsif model._brick_monetized_attributes&.include?(method.to_s)
+      out << self.text_field(method_sym, html_options.merge({ value: Money.new(val.to_i).format }))
     else
       col_type = if model.json_column?(col) || val.is_a?(Array)
                    :json
@@ -61,40 +62,40 @@ module Brick::Rails::FormBuilder
             out << "<img src=\"#{url}\" title=\"#{val}\">"
           elsif model.respond_to?(:enumerized_attributes) && (opts = (attr = model.enumerized_attributes[method])&.options).present?
             enum_html_options = attr.kind_of?(Enumerize::Multiple) ? html_options.merge({ multiple: true, size: opts.length + 1 }) : html_options
-            out << self.select(method.to_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, enum_html_options)
+            out << self.select(method_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, enum_html_options)
           else
             spit_out_text_field = true
           end
         elsif col_type == :enum
           if col.respond_to?(:limit) && col.limit.present?
-            out << self.select(method.to_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + col.limit, { value: val.to_s || '^^^brick_NULL^^^' }, html_options)
+            out << self.select(method_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + col.limit, { value: val.to_s || '^^^brick_NULL^^^' }, html_options)
           else
             spit_out_text_field = true
           end
         else
           template.instance_variable_set(:@_text_fields_present, true)
-          out << self.hidden_field(method.to_sym, html_options)
+          out << self.hidden_field(method_sym, html_options)
           out << "<trix-editor input=\"#{self.field_id(method)}\"></trix-editor>"
         end
         if spit_out_text_field
           # %%% Need to update the max-width with javascript when page width is adjusted?
           html_options.merge!(style: 'min-width: 154px;field-sizing: content;') # max-width: auto;
-          out << self.text_field(method.to_sym, html_options)
+          out << self.text_field(method_sym, html_options)
         end
         when :boolean
-        out << self.check_box(method.to_sym)
+        out << self.check_box(method_sym)
       when :integer, :decimal, :float
-        if model.respond_to?(:attribute_types) && (enum_type = model.attribute_types[method]).is_a?(ActiveRecord::Enum::EnumType)
+        if model.respond_to?(:attribute_types) && (enum_type = model.attribute_types[method.to_s]).is_a?(ActiveRecord::Enum::EnumType)
           opts = enum_type.send(:mapping)&.each_with_object([]) { |v, s| s << [v.first, v.first] } || []
-          out << self.select(method.to_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, options)
+          out << self.select(method_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, options)
         else
           digit_pattern = col_type == :integer ? '(?:-|)\d*' : '(?:-|)\d*(?:\.\d*|)'
-          # Used to do this for float / decimal:  self.number_field method.to_sym
-          out << self.text_field(method.to_sym, { pattern: digit_pattern, class: 'check-validity' })
+          # Used to do this for float / decimal:  self.number_field method_sym
+          out << self.text_field(method_sym, { pattern: digit_pattern, class: 'check-validity' })
         end
       when *DT_PICKERS.keys
         template.instance_variable_set(:@_date_fields_present, true)
-        out << self.text_field(method.to_sym, { class: DT_PICKERS[col_type] })
+        out << self.text_field(method_sym, { class: DT_PICKERS[col_type] })
       when :uuid
         is_revert = false
         # Postgres naturally uses the +uuid_generate_v4()+ function from the uuid-ossp extension
@@ -146,7 +147,7 @@ module Brick::Rails::FormBuilder
         end
         out << self.hidden_field("_brick_attached_#{method}", value: existing.join(',')) unless existing.blank?
         # Render a "Choose File(s)" input element
-        args = [method.to_sym]
+        args = [method_sym]
         args << { multiple: true } if col&.type == :files
         out << self.file_field(*args)
       when :primary_key
@@ -163,7 +164,7 @@ module Brick::Rails::FormBuilder
         end
         # Because there are so danged many quotes in JSON, escape them specially by converting to backticks.
         # (and previous to this, escape backticks with our own goofy code of ^^br_btick__ )
-        out << (json_field = self.hidden_field(method.to_sym, { class: 'jsonpicker', value: val_str&.gsub('`', '^^br_btick__')&.tr('\"', '`')&.html_safe }))
+        out << (json_field = self.hidden_field(method_sym, { class: 'jsonpicker', value: val_str&.gsub('`', '^^br_btick__')&.tr('\"', '`')&.html_safe }))
         out << "<div id=\"_br_json_#{self.field_id(method)}\"></div>"
       else
         is_revert = false
@@ -177,6 +178,7 @@ module Brick::Rails::FormBuilder
     end
     out << "</td></tr></table>
 "
+    @_brick&.fetch(:fields_rendered, nil)&.<< method.to_s # Track that we've rendered this one
     out.html_safe
   end # brick_field
 end

data/lib/brick/rails/form_tags.rb

@@ -30,7 +30,7 @@ module Brick::Rails::FormTags
     col_keys = relation.columns.each_with_object([]) do |col, s|
       col_name = col.name
       next if inclusions&.exclude?(col_name) ||
-              (pk.include?(col_name) && [:integer, :uuid].include?(col.type) && !bts&.key?(col_name)) ||
+              (pk.include?(col_name) && ([:string, :text].exclude?(col.type) || col_name == 'airtable_id') && !bts&.key?(col_name)) ||
               ::Brick.config.metadata_columns.include?(col_name) || poly_cols&.include?(col_name)
 
       s << col_name
@@ -112,7 +112,7 @@ module Brick::Rails::FormTags
       next unless klass.table_exists?
 
       rid = pk.map { |pk_part| obj.send(pk_part.to_sym) }
-      out << "<tr x-id=\"#{rid.join('/')}\">\n"
+      out << "<tr x-id=\"#{slashed_rid = rid.join('/')}\">\n"
       out << "<td class=\"col-sticky alternating-gray\">#{link_to('⇛', send("#{klass._brick_index(:singular)}_path".to_sym, rid),
                                                                   { class: 'big-arrow' })}</td>\n" if pk.present?
       ac = obj.instance_variable_get(:@association_cache) || obj.instance_variable_set(:@association_cache, {})
@@ -134,8 +134,14 @@ module Brick::Rails::FormTags
           if bt[2] && obj.respond_to?(poly_id_col = "#{bt.first}_id") # Polymorphic?
             if (poly_id = obj.send(poly_id_col))
               bt_class = obj.send(klass.brick_foreign_type(bt.first))
-              base_class_underscored = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class._brick_index(:singular)
-              out << link_to("#{bt_class} ##{poly_id}", send("#{base_class_underscored}_path".to_sym, poly_id))
+              root_class_name = (::Brick.existing_stis[bt_class] || bt_class)
+              begin
+                base_class_underscored = root_class_name.constantize.base_class._brick_index(:singular)
+                out << link_to("#{bt_class} ##{poly_id}", send("#{base_class_underscored}_path".to_sym, poly_id))
+              rescue NameError => ee
+                puts "WARNING:  While searching for a polymorphically associated #{bt.first} for the #{klass.name} with ID #{slashed_rid}, was unable to locate a model called \"#{root_class_name}\".  This model might have been deleted, thereby orphaning rows in the #{klass.table_name} table."
+                out << "<span class=\"orphan\">&lt;&lt; Orphaned \"#{root_class_name}\" with ID: #{slashed_rid} >></span>"
+              end
             end
           else # BT or HOT
             bt_class = bt[1].first.first
@@ -151,11 +157,17 @@ module Brick::Rails::FormTags
             end
             br_descrip_args = [obj]
             br_descrip_args += [bt_class._brick_deserialized_value(obj, descrips[0..-2]), bt_id_col] if descrips
-            bt_txt = bt_class.brick_descrip(*br_descrip_args)
-            bt_txt = ::Brick::Rails.display_binary(bt_txt).html_safe if bt_txt&.encoding&.name == 'ASCII-8BIT'
-            bt_txt ||= "<span class=\"orphan\">&lt;&lt; Orphaned ID: #{val} >></span>" if val
-            bt_id = bt_class._brick_deserialized_id(obj, bt_id_col)
-            out << (bt_id&.first ? link_to(bt_txt, send("#{bt_class.base_class._brick_index(:singular)}_path".to_sym, bt_id)) : bt_txt || '')
+            out << if bt_id_col.blank? && bt[1].first[1] # Is this a BT which references a table with no primary key?
+                     # Although we have no way to directly reference this record via a show action, we can at least create a link like this:
+                     #   http://localhost:3000/brick/local_authority_postcode?__value=PA2Y+5LQ
+                     link_to(val, send("#{bt_class.base_class._brick_index(:singular)}_path".to_sym, '__the_id__')).gsub('__the_id__', "?__#{bt[1].first[1]}=#{CGI.escape(val)}")
+                   else # Normal BT or HOT
+                     bt_txt = bt_class.brick_descrip(*br_descrip_args)
+                     bt_txt = ::Brick::Rails.display_binary(bt_txt).html_safe if bt_txt&.encoding&.name == 'ASCII-8BIT'
+                     bt_txt ||= "<span class=\"orphan\">&lt;&lt; Orphaned ID: #{val} >></span>" if val
+                     bt_id = bt_class._brick_deserialized_id(obj, bt_id_col)
+                     (bt_id&.first ? link_to(bt_txt, send("#{bt_class.base_class._brick_index(:singular)}_path".to_sym, bt_id)) : bt_txt || '')
+                   end
           end
         elsif (hms_col = hms_cols[col_name])
           if hms_col.length == 1
@@ -165,15 +177,14 @@ module Brick::Rails::FormTags
             if col[2] == 'HO'
               descrips = bt_descrip[col_name.to_sym][hm_klass]
               if (descrip_parts = hm_klass._brick_deserialized_value(obj, descrips[0..-2]))&.first
+                ho_id = hm_klass._brick_deserialized_id(obj, ho_id_col = descrips.last)
                 ho_txt = if hm_klass.name == 'ActiveStorage::Attachment'
                            begin
                              ::Brick::Rails.display_binary(obj.send(col[3])&.blob&.download)&.html_safe
                            rescue
+                             # Attachment is missing for some reason ... default to showing just a description.
                            end
-                         else
-                           hm_klass.brick_descrip(obj, descrip_parts, ho_id_col = descrips.last)
-                         end
-                ho_id = hm_klass._brick_deserialized_id(obj, ho_id_col)
+                         end || hm_klass.brick_descrip(obj, descrip_parts, ho_id_col)
                 out << link_to(ho_txt, send("#{hm_klass.base_class._brick_index(:singular)}_path".to_sym, ho_id))
               end
             elsif obj.respond_to?(ct_col = hms_col[1].to_sym) && (ct = obj.send(ct_col)&.to_i)&.positive?
@@ -241,25 +252,52 @@ module Brick::Rails::FormTags
 
   # -----------------------------
   # Our mega show/new/update form
-  def brick_form_for(obj, options = {}, model = obj.class, bts = {}, pk = (obj.class.primary_key || []))
+  def brick_form_with(**options, &block)
+    obj = options.delete(:model) || instance_variable_get("@#{obj_name = controller_name.singularize}".to_sym)
+    unless obj
+      puts "WARNING:  Could not find #{obj_name} object"
+      return
+    end
+
+    model = obj.class
+    bts = options.delete(:bts) || {}
+    pk = options.delete(:pk) || model.primary_key || []
     pk = [pk] unless pk.is_a?(Array)
     pk.map!(&:to_s)
+    brick_stuff = { fields_rendered: (fields_rendered = []), bts: bts, pk: pk }
+
+    # options[:model] = obj.becomes(model.base_class) unless options.include?(:model)
+    unless options.include?(:url)
+      options[:url] = if obj.new_record?
+                        link_to_brick(obj.class, path_only: true) # Properly supports STI, but only works for :new
+                      else
+                        path_helper = obj.new_record? ? model._brick_index : model._brick_index(:singular)
+                        send("#{path_helper}_path".to_sym, obj) if ::Brick.config.path_prefix || (path_helper != obj.class.table_name)
+                      end
+    end
+
+    # We call into the older #form_for in order to have compatibility with Rails < 5.1
     form_for(obj.becomes(model.base_class), options) do |f|
-      out = +'<table class="shadow">'
-      has_fields = false
+      out = +''
+      out << '<table class="shadow">'
+      f.instance_variable_set(:@_brick, brick_stuff)
+      has_fields = has_updatable_fields = nil
       # If it's a new record, set any default polymorphic types
-      bts&.each do |_k, v|
+      bts.each do |_k, v|
         if v[2]
           obj.send("#{model.brick_foreign_type(v.first)}=", v[1].first&.first&.name)
         end
       end if obj.new_record?
       hoa, hma, rtans = model._activestorage_actiontext_fields
-      (model.column_names + hoa + hma + rtans.keys).each do |k|
+
+      block.call(f) if block_given?
+
+      ((model.column_names + hoa + hma + rtans.keys) - fields_rendered).each do |k|
         pk_pos = (pk.index(k)&.+ 1)
-        next if (pk_pos && pk.length == 1 && !bts.key?(k)) ||
+        col = model.columns_hash[k]
+        next if (pk_pos && pk.length == 1 && !bts.key?(k) && [:string, :text].exclude?(col.type)) ||
                 ::Brick.config.metadata_columns.include?(k)
 
-        col = model.columns_hash[k]
         if !col
           kwargs = if hoa.include?(k) # has_one_attached
                      { sql_type: 'binary', type: :file }
@@ -280,7 +318,7 @@ module Brick::Rails::FormTags
         val = obj.attributes[k]
         out << "
   <tr>
-    <th class=\"show-field\"#{" title=\"#{col&.comment}\"".html_safe if col&.respond_to?(:comment) && !col&.comment.blank?}>"
+    <th class=\"show-field\"#{" title=\"#{col&.comment}\"" if col&.respond_to?(:comment) && !col&.comment.blank?}>"
         has_fields = true
         if (bt = bts[k])
           # Add a final member in this array with descriptive options to be used in <select> drop-downs
@@ -323,35 +361,38 @@ module Brick::Rails::FormTags
         else
           out << model.human_attribute_name(k, { default: k })
         end
-        out << " (PK #{pk_pos})" if pk_pos
+        out << " (PK&nbsp;#{pk_pos})" if pk_pos
         out << "
     </th>
     <td>
         "
-        if pk_pos
+        if pk_pos &&
+           # Allow new records to have a text-based primary key to be entered
+           (!obj.new_record? || [:string, :text].exclude?(col.type))
           out << val.to_s
         else
+          has_updatable_fields = true
           out << f.brick_field(k, html_options = {}, val, col, bt, bt_class, bt_name, bt_pair)
         end
         out << "
     </td>
   </tr>"
       end
-      if has_fields
+      if has_updatable_fields
         out << "<tr><td colspan=\"2\">#{f.submit({ class: 'update' })}</td></tr>"
-      else
+      elsif !has_fields
         out << '<tr><td colspan="2">(No displayable fields)</td></tr>'
       end
       out << '</table>'
       if model.name == 'ActiveStorage::Attachment'
         begin
-          out << ::Brick::Rails.display_binary(obj&.blob&.download, 500_000)&.html_safe
+          out << ::Brick::Rails.display_binary(obj&.blob&.download, 500_000)
         rescue
         end
       end
-      out.html_safe
-    end
-  end # brick_form_for
+      output_buffer << out.html_safe
+    end # form_for
+  end # brick_form_with
 
   # ------------------------------------------
   # Our cool N:M checkbox constellation editor
@@ -402,7 +443,7 @@ module Brick::Rails::FormTags
     end
     out << "  </tbody>
 </table>
-<script<%= @_request.env['_brick_nonce'] %>>
+<script#{@_request.env['_brick_nonce']}>
   var constellation = document.getElementById(\"#{table_name}\");
   var nextSib,
       _this;
@@ -469,7 +510,6 @@ module Brick::Rails::FormTags
     out << "  </tbody>
 </table>
 "
-
     out.html_safe
   end # brick_bezier
 
@@ -526,7 +566,7 @@ module Brick::Rails::FormTags
   </div>
 </div>
 "
-    out
+    out.html_safe
   end # brick_header
 
   # All the standard CSS with teal colouration for use with Brick
@@ -536,6 +576,8 @@ module Brick::Rails::FormTags
 
   # -----------------------------------------------------------------------------------------------
   def set_grid_javascript(klass, pk, show_new_button = nil, row_count = nil, total_row_count = nil)
+    camel_name = klass.name.split('::').last
+    camel_name[0].downcase!
     table_name = klass.table_name.split('.').last
 
     # Javascript for brick_grid and brick_constellation
@@ -545,13 +587,13 @@ module Brick::Rails::FormTags
 // Plunk the row count in now that we know it
 var rowCount = document.getElementById(\"rowCount\");
 if (rowCount) rowCount.innerHTML = \"#{pluralize(row_count, "row")}#{total_row_count} &nbsp;\";
-var #{table_name}HtColumns;
+var #{camel_name}HtColumns;
 " unless row_count.nil?
 
     grid_scripts << "
 // Snag first TR for sticky header
 var grid = document.getElementById(\"#{table_name}\");
-#{table_name}HtColumns = grid && [grid.getElementsByTagName(\"TR\")[0]];
+#{camel_name}HtColumns = grid && [grid.getElementsByTagName(\"TR\")[0]];
 var headerTop = document.getElementById(\"headerTop\");
 var headerCols;
 if (grid) {
@@ -604,8 +646,8 @@ function setHeaderSizes() {
 
   // Set up proper sizings of sticky column header
   var node;
-  for (var j = 0; j < #{table_name}HtColumns.length; ++j) {
-    var row = #{table_name}HtColumns[j];
+  for (var j = 0; j < #{camel_name}HtColumns.length; ++j) {
+    var row = #{camel_name}HtColumns[j];
     var tr = isEmpty ? document.createElement(\"TR\") : headerTop.childNodes[j];
     tr.innerHTML = row.innerHTML.trim();
     var curLeft = 0.0;

data/lib/brick/rails.rb

@@ -6,7 +6,7 @@ require 'brick/rails/engine'
 module ::Brick::Rails
   class << self
     # Low-level way to render read-only data for a field based on its data type.
-    # Used by both brick_grid and brick_form_for (which gets down to this low-level
+    # Used by both brick_grid and brick_form_with (which gets down to this low-level
     # implementation from brick_field).
     def display_value(col_type, val, lat_lng = nil)
       is_mssql_geography = nil
@@ -179,7 +179,7 @@ erDiagram
        'timestamp without time zone' => 'timestamp',
        'timestamp with time zone' => 'timestamp',
        'time without time zone' => 'time',
-       'time with time zone' => 'time' }[dt] || dt&.tr(' (', '_').tr(')', '') || 'int'
+       'time with time zone' => 'time' }[dt] || dt&.tr(' (', '_')&.tr(')', '') || 'int'
    end
    callbacks.merge({#{model_short_name.inspect} => ::#{model.name}}).each do |cb_k, cb_class|
      cb_relation = ::Brick.relations[cb_class.table_name]

data/lib/brick/reflect_tables.rb

@@ -143,7 +143,7 @@ module Brick
               ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
             else
               puts "*** In the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to schema(s) called #{possible_schemas.map { |s| "\"#{s}\"" }.join(', ')}.  No mentioned schema exists. ***"
-              if ::Brick.db_schemas.key?(::Brick.apartment_default_tenant)
+              if Object.const_defined?('Apartment') && ::Brick.db_schemas.key?(::Brick.apartment_default_tenant)
                 ::Brick.default_schema = schema = ::Brick.apartment_default_tenant
               end
             end
@@ -214,6 +214,7 @@ module Brick
             cols[col_name] = [r['data_type'], r['max_length'], measures&.include?(col_name), r['is_nullable'] == 'NO']
             # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
             relation[:col_descrips][col_name] = r['column_description'] if r['column_description']
+            relation[:col_order] << col_name
           end
         else # MySQL2, OracleEnhanced, and MSSQL act a little differently, bringing back an array for each row
           schema_and_tables = case ActiveRecord::Base.connection.adapter_name
@@ -269,6 +270,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
             # 'data_type', 'max_length', measure, 'is_nullable'
             cols[col_name] = [r[4], r[5], measures&.include?(col_name), r[8] == 'NO']
             # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
+            relation[:col_order] << col_name
           end
         end
 
@@ -425,8 +427,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
                                       end
                         )&.present?
                        if tnp.last&.start_with?('::') # TNP that points to an exact class?
-                         # Had considered:  [tnp.last[2..-1]]
-                         [singular]
+                         tnp.last[2..-1].split('::')
                        elsif tnp.last
                          v[:auto_prefixed_schema], v[:auto_prefixed_class] = tnp
                          # v[:resource] = rel_name.last[tnp.first.length..-1]
@@ -444,14 +445,18 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         loop do
           klass = Object
           proposed_name_parts.each do |part|
-            if klass.const_defined?(part) && klass.name != part
-              begin
+            begin
+              if klass.const_defined?(part) && klass.name != part
                 klass = klass.const_get(part)
-              rescue NoMethodError => e
+              else
                 klass = nil
                 break
               end
-            else
+            rescue NoMethodError => e
+              klass = nil
+              break
+            rescue NameError => e
+              puts "WARNING:  Unable to automatically generate a class for the table named #{part}.\n  In the brick.rb initializer file you can add the line \"::Brick.table_name_prefixes = { '#{part}' => '::YourModelName' }\" in order to specify a usable class name for this object."
               klass = nil
               break
             end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -162,7 +162,7 @@ module Brick
                                   (existing = @relations.find { |_k, v| v.fetch(:db_name, nil) == db_name })
                                  existing.last
                                else
-                                 Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } }.tap do |h|
+                                 Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = (k == :col_order ? [] : {}) } }.tap do |h|
                                    h[:db_name] = db_name if db_name
                                  end
                                end

data/lib/generators/brick/airtable_api_caller.rb

@@ -5,7 +5,7 @@ module Brick
     class << self
       include FancyGets
 
-      def pick_tables(usage = :migrations)
+      def pick_tables(is_airtable_id, usage = :migrations)
         puts "In order to reference Airtable data you will need a Personal Access Token (PAT) which can be generated by referencing this URL:
   https://airtable.com/create/tokens
 You need only #{usage == :migrations ? 'this scope:' : "these three scopes:
@@ -19,6 +19,10 @@ Please provide your Airtable PAT:"
         require 'net/http'
         # Generate a list of bases that can be chosen
         bases = https_get('https://api.airtable.com/v0/meta/bases', pat)
+        if (error = bases.fetch('error', nil))
+          puts error.fetch('message', nil) || 'Error'
+          return
+        end
         base = gets_list(bases.fetch('bases', nil)&.map { |z| AirtableTable.new(z['id'], z['name']) })
         puts
         # Generate a list of tables that can be chosen
@@ -35,10 +39,11 @@ Please provide your Airtable PAT:"
         # Build out a '::Brick.relations' hash that represents this Airtable schema
         fks = []
         associatives = {}
-        relations = chosen.each_with_object({}) do |table, s|
+        relations = chosen.each_with_object({base_name: base.name}) do |table, s|
                       tbl_name = sane_table_name(table.name)
                       # Build out columns and foreign keys
                       cols = {}
+                      col_order = []
                       table.fields.each do |col|
                         col_name = sane_name(col['name'])
                         # This is like a has_many or has_many through
@@ -48,7 +53,8 @@ Please provide your Airtable PAT:"
                                           chosen.find { |t| t.id == col['options']['linkedTableId'] }&.name
                                         ))
                             if col['options']['prefersSingleRecordLink'] # 1:M
-                              fks << [frn_tbl, "#{col_name}_id", tbl_name, col_name]
+                              fks << [frn_tbl, (fk_col_name = "#{col_name}_id"), tbl_name, col_name]
+                              col_order << fk_col_name
                             else # N:M
                               # Queue up to build associative table with two foreign keys
                               camelized = (assoc_name = "#{tbl_name}_#{col_name}_#{frn_tbl}").camelize
@@ -64,17 +70,17 @@ Please provide your Airtable PAT:"
                         else
                           # puts col['type']
                           dt = case col['type']
-                          when 'singleLineText', 'url', 'email', 'singleSelect'
+                          when 'singleLineText', 'url', 'email', 'singleSelect', 'phoneNumber'
                             'string'
                           when 'multilineText'
                             'text'
                           when 'number', 'currency'
-                            'decimal'
+                            col['options']['precision'] == 0 ? 'integer' : 'decimal'
                           when 'checkbox'
                             'boolean'
                           when 'date'
                             'date'
-                          when 'multipleSelects'
+                          when 'multipleSelects', 'singleCollaborator'
                             # Sqlite3 can do json
                             'json'
                           when 'formula', 'count', 'rollup', 'multipleAttachments'
@@ -83,13 +89,21 @@ Please provide your Airtable PAT:"
                           #   binding.pry
                           end
                           cols[col_name] = [dt, nil, true, false] # true is the col[:nillable]
+                          col_order << col_name
                         end
                       end
                       # Put it all into a relation entry, named the same as the table
-                      pkey = table.fields.find { |f| f['id'] == table.primary_key }['name']
+                      pkey = if is_airtable_id
+                               cols['airtable_id'] = ['string', nil, true, false]
+                               'airtable_id'
+                             else
+                               table.fields.find { |f| f['id'] == table.primary_key }['name']
+                             end
+
                       s[tbl_name] = {
                         pkey: { "#{tbl_name}_pkey" => [sane_name(pkey)] },
                         cols: cols,
+                        col_order: col_order,
                         fks: {},
                         airtable_table: table
                       }

data/lib/generators/brick/airtable_migrations_generator.rb

@@ -15,9 +15,10 @@ module Brick
     def airtable_migrations
       mig_path, is_insert_versions, is_delete_versions = ::Brick::MigrationsBuilder.check_folder
       return unless mig_path &&
-                    (relations = ::Brick::AirtableApiCaller.pick_tables)
+                    (relations = ::Brick::AirtableApiCaller.pick_tables(!ENV['OMIT_AIRTABLE_ID']))
 
-      ::Brick::MigrationsBuilder.generate_migrations(relations.keys, mig_path, is_insert_versions, is_delete_versions, relations,
+      chosen = relations.keys.reject { |k| k.is_a?(Symbol) }
+      ::Brick::MigrationsBuilder.generate_migrations(chosen, mig_path, is_insert_versions, is_delete_versions, relations,
                                                      do_fks_last: 'Separate', do_schema_migrations: false)
     end
   end

data/lib/generators/brick/airtable_seeds_generator.rb

@@ -11,7 +11,7 @@ module Brick
     desc 'Auto-generates a seeds file from existing data in an Airtable "base".'
 
     def airtable_seeds
-      return unless (relations = ::Brick::AirtableApiCaller.pick_tables(:seeds))
+      return unless (relations = ::Brick::AirtableApiCaller.pick_tables(!ENV['OMIT_AIRTABLE_ID'], :seeds))
 
       ::Brick::SeedsBuilder.generate_seeds(relations)
     end

data/lib/generators/brick/install_generator.rb

@@ -43,7 +43,7 @@ module Brick
           relation.last[:cols].each do |col, type|
             col_down = col.downcase
 
-            if (is_possible_poly = ['character varying', 'text'].include?(type.first))
+            if (is_possible_poly = ['character varying', 'varchar', 'text', 'VARCHAR2'].include?(type.first))
               if col_down.end_with?('_type')
                 poly_type_cut_length = -6
                 col_down = col_down[0..-6]