brick 1.0.246 → 1.0.248

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
@@ -252,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 }
@@ -291,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
@@ -334,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
@@ -413,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;
@@ -480,7 +510,6 @@ module Brick::Rails::FormTags
     out << "  </tbody>
 </table>
 "
-
     out.html_safe
   end # brick_bezier
 
@@ -537,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
@@ -547,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
@@ -556,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) {
@@ -615,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
@@ -122,7 +122,7 @@ module ::Brick::Rails
       "<div id=\"mermaidErd\">
   <div id=\"mermaidDiagram\" class=\"mermaid\">
 erDiagram
-<% shown_classes = {}
+<%= shown_classes = {}
 
    def erd_sidelinks(shown_classes, klass)
      links = []
@@ -137,20 +137,20 @@ erDiagram
      links.join
    end
 
-   @_brick_bt_descrip&.each do |bt|
+   @_brick_bt_descrip&.each_with_object(+'') do |bt, s|
      bt_class = bt[1].first.first
      callbacks[bt_name = bt_class.name.split('::').last] = bt_class
      # Used to have:  &.inverse_of  before  &.macro
      is_has_one = ::#{model.name}.reflect_on_association(bt.first)&.macro == :has_one ||
                   ::Brick.config.has_ones&.fetch('#{model.name}', nil)&.key?(bt.first.to_s)
-    %>  <%= \"#{model_short_name} #\{is_has_one ? '||--o|' : '}o--||'} #\{bt_name} : \\\"#\{
+    s << \"  #{model_short_name} #\{is_has_one ? '||--o|' : '}o--||'} #\{bt_name} : \\\"#\{
         bt_underscored = bt[1].first.first.name.underscore.singularize
         bt.first unless bt.first.to_s == bt_underscored.split('/').last # Was:  bt_underscored.tr('/', '_')
-        }\\\"\".html_safe %>
-<%=  erd_sidelinks(shown_classes, bt_class).html_safe %>
-<% end
+        }\\\"\n\"
+     s << erd_sidelinks(shown_classes, bt_class)
+   end&.html_safe %><%=
    last_hm = nil
-   @_brick_hm_counts&.each do |hm|
+   @_brick_hm_counts&.each_with_object(+'') do |hm, s|
      # Skip showing self-referencing HM links since they would have already been drawn while evaluating the BT side
      next if (hm_class = hm.last&.klass) == ::#{model.name}
 
@@ -159,21 +159,21 @@ erDiagram
        through_name = (through_assoc = hm.last.source_reflection).active_record.name.split('::').last
        callbacks[through_name] = through_assoc.active_record
        if last_hm == through # Same HM, so no need to build it again, and for clarity just put in a blank line
-%><%=    \"\n\"
-%><%   else
-%>  <%= \"#{model_short_name} ||--o{ #\{through_name}\".html_safe %> : \"\"
-<%=      erd_sidelinks(shown_classes, through_assoc.active_record).html_safe %>
-<%       last_hm = through
+         s << \"\\n\"
+       else
+         s << \"  #{model_short_name} ||--o{ #\{through_name} : \\\"\\\"\\n\"
+         s << erd_sidelinks(shown_classes, through_assoc.active_record)
+         last_hm = through
        end
-%>    <%= \"#\{through_name} }o--|| #\{hm_name}\".html_safe %> : \"\"
-    <%= \"#{model_short_name} }o..o{ #\{hm_name} : \\\"#\{hm.first}\\\"\".html_safe %><%
+       s << \"    #\{through_name} }o--|| #\{hm_name} : \\\"\\\"\\n\"
+       s << \"#{model_short_name} }o..o{ #\{hm_name} : \\\"#\{hm.first}\\\"\\n\"
      else # has_many
-%>  <%= \"#{model_short_name} #\{hm.last.macro == :has_and_belongs_to_many ? '}o' : '||'}--o{ #\{hm_name} : \\\"#\{
+       s << \"  #{model_short_name} #\{hm.last.macro == :has_and_belongs_to_many ? '}o' : '||'}--o{ #\{hm_name} : \\\"#\{
             hm.first.to_s unless (last_hm = hm.first.to_s).downcase == hm_class.name.underscore.pluralize.tr('/', '_')
-          }\\\"\".html_safe %><%
-     end %>
-<%=  erd_sidelinks(shown_classes, hm_class).html_safe %>
-<% end
+          }\\\"\\n\"
+     end
+     s << erd_sidelinks(shown_classes, hm_class)
+   end&.html_safe %><%
    def dt_lookup(dt)
      { 'integer' => 'int', 'character varying' => 'varchar', 'double precision' => 'float',
        'timestamp without time zone' => 'timestamp',
@@ -186,26 +186,26 @@ erDiagram
      pkeys = cb_relation[:pkey]&.first&.last
      fkeys = cb_relation[:fks]&.values&.each_with_object([]) { |fk, s| s << fk[:fk] if fk.fetch(:is_bt, nil) }
      cols = cb_relation[:cols]
- %>  <%= cb_k %> {<%
-     pkeys&.each do |pk| %>
-    <%= \"#\{dt_lookup(cols[pk].first)} #\{pk} \\\"PK#\{' fk' if fkeys&.include?(pk)}\\\"\".html_safe %><%
-     end %><%
-     fkeys&.each do |fk|
+ %>  <%= cb_k %> {<%=
+     pkeys&.each_with_object(+'') do |pk, s|
+       s << \"#\{dt_lookup(cols[pk].first)} #\{pk} \\\"PK#\{' fk' if fkeys&.include?(pk)}\\\"\"
+     end&.html_safe %><%=
+     fkeys&.each_with_object(+'') do |fk, s|
        if fk.is_a?(Array)
-         fk.each do |fk_part| %>
-    <%= \"#\{dt_lookup(cols[fk_part].first)} #\{fk_part} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\".html_safe unless pkeys&.include?(fk_part) %><%
+         fk.each do |fk_part|
+           s << \"#\{dt_lookup(cols[fk_part].first)} #\{fk_part} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\" unless pkeys&.include?(fk_part)
          end
        else # %%% Does not yet accommodate polymorphic BTs
-    %>
-    <%= \"#\{dt_lookup(cols[fk]&.first)} #\{fk} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\".html_safe unless pkeys&.include?(fk) %><%
+         s << \"#\{dt_lookup(cols[fk]&.first)} #\{fk} \\\"&nbsp;&nbsp;&nbsp;&nbsp;fk\\\"\" unless pkeys&.include?(fk)
        end
-     end %><%
+     end&.html_safe %><%=
      if (erd_sc = Brick.config.erd_show_columns) == true || erd_sc&.include?(cb_class.name)
-       cols&.each do |col|
-         next if pkeys.include?(col.first) || fkeys.include?(col.first) %>
-    <%= \"#\{dt_lookup(col[1]&.first&.to_s)} #\{col.first}\".html_safe %><%
+       cols&.each_with_object(+'') do |col, s|
+         next if pkeys.include?(col.first) || fkeys.include?(col.first)
+
+         s << \"#\{dt_lookup(col[1]&.first&.to_s)} #\{col.first}\"
        end
-     end %>
+     end&.html_safe %>
   }
 <% end
  # callback < %= cb_k % > erdClick

data/lib/brick/reflect_tables.rb

@@ -100,7 +100,7 @@ module Brick
         is_postgres = nil
         is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer'
         case ActiveRecord::Base.connection.adapter_name
-        when 'PostgreSQL', 'SQLServer'
+        when 'PostgreSQL', 'PostGIS', 'SQLServer'
           is_postgres = !is_mssql
           db_schemas = if is_postgres
                          ActiveRecord::Base.execute_sql('SELECT nspname AS table_schema, MAX(oid) AS dt FROM pg_namespace GROUP BY 1 ORDER BY 1;')
@@ -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
@@ -177,8 +177,8 @@ module Brick
         measures = []
         ::Brick.is_oracle = true if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
         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'
+        when 'PostgreSQL', 'PostGIS', 'SQLite' # These bring back a hash for each row because the query uses column aliases
+          # schema ||= 'public' if ['PostgreSQL', 'PostGIS'].include?(ActiveRecord::Base.connection.adapter_name)
           retrieve_schema_and_tables(sql, is_postgres, is_mssql, schema).each do |r|
             # 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'.
@@ -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,11 +270,12 @@ 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
 
         # PostGIS adds three views which would confuse Rails if models were to be built for them.
-        if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+        if ['PostgreSQL', 'PostGIS'].include?(ActiveRecord::Base.connection.adapter_name)
           if relations.key?('geography_columns') && relations.key?('geometry_columns') && relations.key?('spatial_ref_sys')
             (::Brick.config.exclude_tables ||= []) << 'geography_columns'
             ::Brick.config.exclude_tables << 'geometry_columns'
@@ -282,7 +284,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         end
 
         # # Add unique OIDs
-        # if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+        # if ['PostgreSQL', 'PostGIS'].include?(ActiveRecord::Base.connection.adapter_name)
         #   ActiveRecord::Base.execute_sql(
         #     "SELECT c.oid, n.nspname, c.relname
         #     FROM pg_catalog.pg_namespace AS n
@@ -307,7 +309,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         kcus = nil
         entry_type = nil
         case ActiveRecord::Base.connection.adapter_name
-        when 'PostgreSQL', 'Mysql2', 'Trilogy', 'SQLServer'
+        when 'PostgreSQL', 'PostGIS', 'Mysql2', 'Trilogy', 'SQLServer'
           # Part 1 -- all KCUs
           sql = "SELECT CONSTRAINT_CATALOG, CONSTRAINT_SCHEMA, CONSTRAINT_NAME, ORDINAL_POSITION,
                         TABLE_NAME, COLUMN_NAME
@@ -367,7 +369,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
           fk_references = ActiveRecord::Base.execute_sql(sql)
         end
         ::Brick.is_oracle = true if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
-        # ::Brick.default_schema ||= schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+        # ::Brick.default_schema ||= schema ||= 'public' if ['PostgreSQL', 'PostGIS'].include?(ActiveRecord::Base.connection.adapter_name)
         ::Brick.default_schema ||= 'public' if is_postgres
         fk_references&.each do |fk|
           fk = fk.values unless fk.is_a?(Array)
@@ -443,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/util.rb

@@ -49,7 +49,7 @@ module Brick
           # then required in place of the original.
 
           Kernel.module_exec do
-            alias_method :orig_require, :require
+            alias_method :_orig_require, :require
             # To be most faithful to Ruby's normal behaviour, this should look like a public singleton
             define_method(:require) do |name|
               # %%% Can get a message such as "ActionDispatch::Routing is not missing constant RouteSet! (NameError)"
@@ -62,14 +62,14 @@ module Brick
                 else
                   is_replaced = false
                   if (replacement_path = ::Brick::Util._write_patched(folder_matcher, name, extension, ::Brick::Util._custom_require_dir, patched_filename, replacements))
-                    is_replaced = Kernel.send(:orig_require, replacement_path)
+                    is_replaced = _orig_require(replacement_path)
                   elsif replacement_path.nil?
                     puts "Couldn't find #{name} to require it!"
                   end
                   is_replaced
                 end
               else
-                Kernel.send(:orig_require, name)
+                _orig_require(name)
               end
             end
           end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -127,7 +127,7 @@ module Brick
     def set_db_schema(params = nil)
       # If Apartment::Tenant.current is not still the default (usually 'public') then an elevator has brought us into
       # a different tenant.  If so then don't allow schema navigation.
-      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' && apartment_multitenant
+      if ['PostgreSQL', 'PostGIS'].include?(ActiveRecord::Base.connection.adapter_name) && apartment_multitenant
         current_schema = (ActiveRecord::Base.execute_sql('SELECT current_schemas(true)')
                                             .first['current_schemas'][1..-2]
                                             .split(',') - ['pg_catalog', 'pg_toast', 'heroku_ext']).first
@@ -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
@@ -1547,8 +1547,8 @@ module ActiveRecord
 
     elsif private_instance_methods.include?(:select_association_list) # AR >= 6.1
       alias _brick_select_association_list select_association_list
-      def select_association_list(associations, stashed_joins = nil)
-        result = _brick_select_association_list(associations, stashed_joins)
+      def select_association_list(associations, stashed_joins = nil, &block)
+        result = _brick_select_association_list(associations, stashed_joins, &block)
         result.instance_variable_set(:@relation, self)
         result
       end
@@ -1686,11 +1686,11 @@ module ActiveRecord
             if (relation = child.instance_variable_get(:@assocs)&.instance_variable_get(:@relation))
               link_path = child.instance_variable_get(:@link_path)
               relation.brick_links(false)[link_path] = if child.table.is_a?(Arel::Nodes::TableAlias)
-                                                  child.table.right
-                                                else
-                                                  # Was:  result.first&.left&.table_alias || child.table_name
-                                                  child.table.table_alias || child.table_name
-                                                end
+                                                         child.table.right
+                                                       else
+                                                         # Was:  result.first&.left&.table_alias || child.table_name
+                                                         child.table.table_alias || child.table_name
+                                                       end
             end
             result
           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]