brick 1.0.229 → 1.0.230

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5484fa8f1c3c64e6d10340f54ca460668cfa176373b0d2322fe1ede86cfad8c
-  data.tar.gz: bda7b20486fb89f0b5775975957ea7f3b0de3b51a635e42e4a21dbec3b71478f
+  metadata.gz: 5230864d4450f23406da3efcab54e2c337ae9029c2b9fea3d1b8df1bb34583dd
+  data.tar.gz: b16f195b58d0df45611f8a2251e005ae6cc841970fb1c6eea17119af678d62a8
 SHA512:
-  metadata.gz: c6f01661b3423287dc4ce703790e04d292f902a14dc23e1e3b68a4891c9347adeb2083594717af1e0ca93404a6e7748e2f393885d4d37944b595757ee5a4b6b8
-  data.tar.gz: 6967a37c53be78011f1b0e7b5eb69ecf1a7779b1c0c312e2288a6ab701fdb1ab2724345957d178970df06ee26481bd1470e8fb5ede8d14e06d6ac0a4a6418248
+  metadata.gz: 55e9c658e0c258be349866a82f7c5a62234779aa27e7a5e04517979dbccdf9475948fecb2de8f78604daf773094e9a19f8a3c32b9d64ef5c8948cbd3fa4dffe2
+  data.tar.gz: a00b991cd2d4125e10baada1d070440d4b25a99994e462e543acafdcdcf4cf5a4703e7b0fc60dd2e6989e933828a9eb0355610f6901b9b2ca9d5a047a61260a3

data/lib/brick/extensions.rb

@@ -1749,57 +1749,6 @@ class Object
       built_model = Class.new(base_model) do |new_model_class|
         (schema_module || Object).const_set(chosen_name, new_model_class) unless is_generator
         @_brick_relation = relation
-        # Enable Elasticsearch based on the table name?
-        if (@_brick_es_crud = ::Brick.elasticsearch_models&.fetch(table_name, nil))
-          include ::Elasticsearch::Model
-          if @_brick_es_crud.index('i') # Enable auto-creation of indexes on import?
-            class << self
-              alias _original_import import
-              def import(options={}, &block)
-                unless self.__elasticsearch__.index_exists?
-                  self.__elasticsearch__.create_index!
-                  ::Brick.elasticsearch_existings << self.table_name
-                end
-                _original_import(options={}, &block)
-              end
-            end
-          end
-          if ::Elasticsearch::Model.const_defined?('Callbacks') &&
-             @_brick_es_crud.index('c') || @_brick_es_crud.index('u') || @_brick_es_crud.index('d')
-            include ::Elasticsearch::Model::Callbacks
-            is_include_es_callbacks = true
-          end
-          # Create mappings for all text columns
-          mappings do
-            has_mappings = nil
-            new_model_class.columns.select { |col| [:string, :text].include?(col.type) }.each do |string_col|
-              unless has_mappings
-                code << "  include Elasticsearch::Model\n"
-                code << "  include Elasticsearch::Model::Callbacks\n" if is_include_es_callbacks
-                code << "  mappings do\n"
-                has_mappings = true
-              end
-              code << "    indexes :#{string_col.name}, type: #{string_col.type.to_s.inspect}\n"
-              indexes string_col.name.to_sym, type: string_col.type.to_s
-            end
-            code << "  end\n" if has_mappings
-          end
-          if @_brick_es_crud.index('r')
-            class << self
-              # Search and hydrate records using only Elasticsearch data
-              define_method :search do |q|
-                self.__elasticsearch__.search(q).raw_response.body['hits']['hits'].map do |hit|
-                  obj = self.new(hit['_source'])
-                  obj.instance_variable_set(:@new_record, false) # Don't want to accidentally save a new one
-                  obj
-                end
-              rescue Elastic::Transport::Transport::Errors::NotFound => e
-                self.create_index! if @_brick_es_crud.index('i')
-                []
-              end
-            end
-          end
-        end
         if inheritable_name
           new_model_class.define_singleton_method :inherited do |subclass|
             super(subclass)
@@ -1872,6 +1821,59 @@ class Object
           end
         end
 
+        # Enable Elasticsearch based on the table name?
+        if (@_brick_es_crud = ::Brick.elasticsearch_models&.fetch(matching, nil))
+          include ::Elasticsearch::Model
+          if @_brick_es_crud.index('i') # Enable auto-creation of indexes on import?
+            class << self
+              alias _original_import import
+              def import(options={}, &block)
+                unless self.__elasticsearch__.index_exists?
+                  self.__elasticsearch__.create_index!
+                  ::Brick.elasticsearch_existings[self.table_name] = self.table_name.tr('.', '-').pluralize
+                end
+                _original_import(options={}, &block)
+              end
+            end
+          end
+          if ::Elasticsearch::Model.const_defined?('Callbacks') &&
+             @_brick_es_crud.index('c') || @_brick_es_crud.index('u') || @_brick_es_crud.index('d')
+            include ::Elasticsearch::Model::Callbacks
+            is_include_es_callbacks = true
+          end
+          # Create mappings for all text columns
+          mappings do
+            has_mappings = nil
+            new_model_class.columns.select { |col| [:string, :text].include?(col.type) }.each do |string_col|
+              unless has_mappings
+                code << "  include Elasticsearch::Model\n"
+                code << "  include Elasticsearch::Model::Callbacks\n" if is_include_es_callbacks
+                code << "  mappings do\n"
+                has_mappings = true
+              end
+              code << "    indexes :#{string_col.name}, type: 'text'\n"
+              indexes string_col.name.to_sym, type: 'text'
+            end
+            code << "  end\n" if has_mappings
+          end
+          if @_brick_es_crud.index('r')
+            class << self
+              # Search and hydrate records using only Elasticsearch data
+              define_method :search do |q|
+                self.__elasticsearch__.search(q).raw_response.body['hits']['hits'].map do |hit|
+                  obj = self.new(hit['_source'])
+                  obj.instance_variable_set(:@new_record, false) # Don't want to accidentally save a new one
+                  obj
+                end
+              rescue Elastic::Transport::Transport::Errors::NotFound => e
+                self.__elasticsearch__.create_index! if @_brick_es_crud.index('i')
+                ::Brick.elasticsearch_existings[self.table_name] = self.table_name.tr('.', '-').pluralize
+                []
+              end
+            end
+          end
+        end
+
         unless is_sti
           fks = relation[:fks] || {}
           # Do the bulk of the has_many / belongs_to processing, and store details about HMT so they can be done at the very last
@@ -2288,14 +2290,14 @@ class Object
 
           self.define_method :search do
             # TODO: Make sure at least one index is actually present which allows for reading before attempting
-            if (q = params['qry'] || params['_brick_es']) # Elasticsearch query?
-              @indexes = ::Brick.elasticsearch_existings
-              hits = Elasticsearch::Model.client.search({index: @indexes.join(','), q: q, size: 100})
+            if (@qry = params['qry'] || params['_brick_es']) # Elasticsearch query?
+              @indexes = ::Brick.elasticsearch_existings&.keys
+              hits = Elasticsearch::Model.client.search({index: @indexes.join(','), q: @qry, size: 100})
               model_infos = {}
               # Number of indexes used:  hits.body['_shards']['total']
               @count = hits.body['hits']['total']['value']
               @results = hits.body['hits']['hits'].map do |x|
-                klass = ::Brick.relations[x['_index']][:class_name].constantize
+                klass = ::Brick.relations[::Brick.elasticsearch_existings[x['_index']]][:class_name].constantize
                 model_info = model_infos[klass] ||= [
                   klass.primary_key,
                   klass.brick_parse_dsl(join_array = ::Brick::JoinArray.new, [], translations = {}, false, nil, true)
@@ -2644,7 +2646,7 @@ class Object
                               if @_brick_es_crud.index('i')
                                 self.__elasticsearch__.create_index!
                                 # model.import
-                                ::Brick.elasticsearch_existings << self.table_name
+                                ::Brick.elasticsearch_existings[self.table_name] = self.table_name.tr('.', '-').pluralize
                                 model.__elasticsearch__.search(q)
                               else
                                 []
@@ -3320,7 +3322,7 @@ module Brick
         # Rails applies an _index suffix to that route when the resource name isn't something plural
         index << '_index' if mode != :singular && !not_path &&
                              index == (
-                                        index2 + [relation[:class_name][(relation&.fetch(:auto_prefixed_class, nil)&.length&.+ 2) || 0..-1]&.underscore&.tr('/', '_') || '_']
+                                        index2 + [relation[:class_name]&.[]((relation&.fetch(:auto_prefixed_class, nil)&.length&.+ 2) || 0..-1)&.underscore&.tr('/', '_') || '_']
                                       ).join(separator)
       end
       index

data/lib/brick/rails/engine.rb

@@ -671,12 +671,16 @@ window.addEventListener(\"popstate\", linkSchemas);
             def find_template(*args, **options)
               find_template_err = nil
               unless (model_name = @_brick_model&.name) ||
-                     (is_search = ::Brick.config.add_search && args[0..1] == ['search', ['brick_gem']] &&
-                                  ::Brick.elasticsearch_existings&.length&.positive?
-                     ) ||
-                     (is_status = ::Brick.config.add_status && args[0..1] == ['status', ['brick_gem']]) ||
-                     (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']]) ||
-                     (is_crosstab = args[0..1] == ['crosstab', ['brick_gem']])
+                     (
+                      args[1].first == 'brick_gem' &&
+                      ((is_search = ::Brick.config.add_search && args[0] == 'search' &&
+                                    ::Brick.elasticsearch_existings&.length&.positive?
+                       ) ||
+                       (is_status = ::Brick.config.add_status && args[0] == 'status') ||
+                       (is_orphans = ::Brick.config.add_orphans && args[0] == 'orphans') ||
+                       (is_crosstab = args[0] == 'crosstab')
+                      )
+                     )
                 begin
                   if (possible_template = _brick_find_template(*args, **options))
                     return possible_template
@@ -1220,7 +1224,7 @@ end
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select><br><br>
 <form method=\"get\">
-  <input type=\"text\" name=\"qry\"><input type=\"submit\", value=\"Search\">
+  <input type=\"text\" name=\"qry\"<%= \" value=\\\"#\{@qry}\\\"\".html_safe unless @qry.blank? %>><input type=\"submit\", value=\"Search\">
 </form>
 <% if @results.present? %>
 <div id=\"rowCount\"><b><%= @count %> results from: </b><%= @indexes.sort.join(', ') %></div>

data/lib/brick/reflect_tables.rb

@@ -40,7 +40,7 @@ module Brick
             end
           end
         end
-        if ::Elasticsearch.const_defined?('Model') && ::Brick.elasticsearch_models
+        if ::Elasticsearch.const_defined?('Model')
           # By setting the environment variable ELASTICSEARCH_URL then you can specify an Elasticsearch/Opensearch host
           host = (client = ::Elasticsearch::Model.client).transport.hosts.first
           es_uri = URI.parse("#{host[:protocol]}://#{host[:host]}:#{host[:port]}")
@@ -528,18 +528,32 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         ::Brick.elasticsearch_models = unless access.blank?
           # Find all existing indexes
           client = Elastic::Transport::Client.new
-          ::Brick.elasticsearch_existings = client.perform_request('GET', '_aliases').body.each_with_object([]) do |entry, s|
-            s << entry.first if relations.include?(entry.first)
-            entry.last.fetch('aliases', nil)&.each { |k, _v| s << k if relations.include?(k) }
+          ::Brick.elasticsearch_existings = client.perform_request('GET', '_aliases').body.each_with_object({}) do |entry, s|
+            rel_name = entry.first.tr('-', '.')
+            s[entry.first] = rel_name if relations.include?(entry.first)
+            s[entry.first] = rel_name.singularize if relations.include?(rel_name.singularize)
+            entry.last.fetch('aliases', nil)&.each do |k, _v|
+              rel_name = k.tr('-', '.')
+              s[k] = rel_name if relations.include?(rel_name)
+              s[k] = rel_name.singularize if relations.include?(rel_name.singularize)
+            end
           end
           # Add this either if...
           if access.is_a?(String) # ...they have permissions over absolutely anything,
-            relations.each_with_object({}) { |rel, s| s[rel.first] = access unless rel.first.is_a?(Symbol) }
+            relations.each_with_object({}) do |rel, s|
+              next if rel.first.is_a?(Symbol)
+
+              perms = rel.last.fetch(:isView, nil) ? access.tr('cud', '') : access
+              s[rel.first] = perms
+            end
           else # or there are specific permissions for each resource, so find the matching indexes
             client = Elastic::Transport::Client.new
             ::Brick.elasticsearch_existings.each_with_object({}) do |index, s|
-              perms = access.is_a?(String) ? access : access[index] || '' # Look up permissions from above
-              s[index] = perms unless perms.blank?
+              this_access = access.is_a?(String) ? access : access[index.first] || '' # Look up permissions from above
+              next unless (rel = relations.fetch(index.first, nil))
+
+              perms = rel&.fetch(:isView, nil) ? this_access.tr('cud', '') : this_access
+              s[index.first] = perms unless perms.blank?
             end
           end
         end

data/lib/brick/version_number.rb

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

data/lib/generators/brick/airtable_api_caller.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Brick
+  class AirtableApiCaller
+    class << self
+      include FancyGets
+
+      def pick_tables(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:
+  data.records:read
+  data.recordComments:read"}
+  schema.bases:read
+
+Please provide your Airtable PAT:"
+        pat = gets_password
+        require 'net/http'
+        # Generate a list of bases that can be chosen
+        bases = https_get('https://api.airtable.com/v0/meta/bases', pat)
+        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
+        objects = https_get("https://api.airtable.com/v0/meta/bases/#{base.id}/tables", pat).fetch('tables', nil)
+        if objects.blank?
+          puts "No tables found in base #{base.name}."
+          return
+        end
+
+        tables = objects.map { |z| AirtableTable.new(z['id'], z['name'], z['primaryFieldId'], z['fields'], z['views'], base.id) }
+        chosen = gets_list(tables, tables.dup)
+        puts
+
+        # Build out a '::Brick.relations' hash that represents this Airtable schema
+        fks = []
+        associatives = {}
+        relations = chosen.each_with_object({}) do |table, s|
+                      tbl_name = sane_table_name(table.name)
+                      # Build out columns and foreign keys
+                      cols = {}
+                      table.fields.each do |col|
+                        col_name = sane_name(col['name'])
+                        # This is like a has_many or has_many through
+                        if col['type'] == 'multipleRecordLinks'
+                          # binding.pry if col['options']['isReversed']
+                          if (frn_tbl = sane_table_name(
+                                          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]
+                            else # N:M
+                              # Queue up to build associative table with two foreign keys
+                              camelized = (assoc_name = "#{tbl_name}_#{col_name}_#{frn_tbl}").camelize
+                              if associatives.keys.any? { |a| a.camelize == camelized }
+                                puts "Strangely have found two columns in \"#{table.name}\" with a name similar to \"#{col_name}\".  Skipping this to avoid a conflict."
+                                next
+
+                              end
+                              associatives[assoc_name] = [col_name, frn_tbl, tbl_name]
+                              fks << [assoc_name, frn_tbl, frn_tbl, col_name.underscore, tbl_name]
+                            end
+                          end
+                        else
+                          # puts col['type']
+                          dt = case col['type']
+                          when 'singleLineText', 'url', 'singleSelect'
+                            'string'
+                          when 'multilineText'
+                            'text'
+                          when 'number'
+                            'decimal'
+                          when 'checkbox'
+                            'boolean'
+                          when 'date'
+                            'date'
+                          when 'multipleSelects'
+                            # Sqlite3 can do json
+                            'json'
+                          when 'formula', 'count', 'rollup', 'multipleAttachments'
+                            next
+                          # else
+                          #   binding.pry
+                          end
+                          cols[col_name] = [dt, nil, true, false] # true is the col[:nillable]
+                        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']
+                      s[tbl_name] = {
+                        pkey: { "#{tbl_name}_pkey" => [sane_name(pkey)] },
+                        cols: cols,
+                        fks: {},
+                        airtable_table: table
+                      }
+                    end
+        associatives.each do |k, v|
+          pri_pk_col = relations[v[1]][:pkey]&.first&.last&.first
+          frn_pk_col = relations[v[2]][:pkey]&.first&.last&.first
+          pri_fk_name = "#{v[1]}_id"
+          frn_fk_name = (frn_fk_name == pri_fk_name) ?
+            "#{v[2]}_2_id" # Self-referencing N:M
+            : "#{v[2]}_id" # Standard N:M
+          relations[k] = {
+            pkey: { "#{k}_pkey" => ['id'] },
+            cols: { 'id' => ['integer', nil, false, false] }
+          }
+          fks << [v[1], pri_fk_name, k, pri_fk_name.underscore]
+          fks << [v[2], frn_fk_name, k, frn_fk_name.underscore]
+        end
+        fk_idx = 0
+        fks.each do |pri_tbl, fk_col, frn_tbl, airtable_col, assoc_tbl|
+          pri_pk_col = relations[pri_tbl][:pkey].first.last.first
+          # binding.pry unless relations.key?(frn_tbl) && relations[pri_tbl][:cols][pri_pk_col]
+          unless assoc_tbl # It's a 1:M -- make a FK column
+            relations[frn_tbl][:cols][fk_col] = [relations[pri_tbl][:cols][pri_pk_col][0], nil, true, false]
+          end
+          # And the actual relation
+          frn_fks = ((relations[frn_tbl] ||= {})[:fks] ||= {})
+          this_fk = frn_fks["fk_airtable_#{fk_idx += 1}"] = {
+            is_bt: !assoc_tbl, # Normal foreign key is true, and N:M is really a has_many, so false
+            fk: fk_col,
+            assoc_name: airtable_col,
+            inverse_table: pri_tbl
+          }
+          this_fk[:assoc_tbl] = assoc_tbl if assoc_tbl
+        end
+
+        relations
+      end
+
+      def https_get(uri, pat = nil)
+        uri = URI(uri) unless uri.is_a?(URI)
+        https = Net::HTTP.new(uri.host, uri.port)
+        request = Net::HTTP::Get.new("#{uri.path}?#{uri.query}")
+        request['Authorization'] = "Bearer #{@bearer ||= pat}"
+        response = Net::HTTP.start(uri.hostname, uri.port, { use_ssl: true }) do |http|
+          http.request(request)
+        end
+        # if response.code&.to_i > 299
+        # end
+        JSON.parse(response.body)
+      end
+
+      def sane_name(col_name)
+        sane_table_name(col_name.gsub('&', 'and').tr('()?', ''))
+      end
+
+      def sane_table_name(tbl_name)
+        tbl_name&.downcase&.tr(': -', '_')
+      end
+
+      class AirtableTable
+        attr_accessor :id, :name, :primary_key, :fields, :views, :base_id, :objects
+        def initialize(id, name,
+                       primary_key = nil, fields = nil, views = nil, base_id = nil)
+          self.id = id
+          self.name = name
+          self.primary_key = primary_key
+          self.fields = fields
+          self.views = views
+          self.base_id = base_id
+          self.objects = {}
+        end
+
+        def to_s
+          name
+        end
+      end
+    end
+  end
+end

data/lib/generators/brick/airtable_migrations_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'brick'
+require 'rails/generators'
+require 'rails/generators/active_record'
+require 'fancy_gets'
+require 'generators/brick/migrations_builder'
+require 'generators/brick/airtable_api_caller'
+
+module Brick
+  # Auto-generates Airtable migration files
+  class AirtableMigrationsGenerator < ::Rails::Generators::Base
+    desc 'Auto-generates migration files for an existing Airtable "base".'
+
+    def airtable_migrations
+      mig_path, is_insert_versions, is_delete_versions = ::Brick::MigrationsBuilder.check_folder
+      return unless mig_path &&
+                    (relations = ::Brick::AirtableApiCaller.pick_tables)
+
+      ::Brick::MigrationsBuilder.generate_migrations(relations.keys, mig_path, is_insert_versions, is_delete_versions, relations,
+                                                     do_fks_last: 'Separate', do_schema_migrations: false)
+    end
+  end
+end

data/lib/generators/brick/airtable_seeds_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'brick'
+require 'rails/generators'
+require 'rails/generators/active_record'
+require 'generators/brick/seeds_builder'
+require 'generators/brick/airtable_api_caller'
+
+module Brick
+  class AirtableSeedsGenerator < ::Rails::Generators::Base
+    desc 'Auto-generates a seeds file from existing data in an Airtable "base".'
+
+    def airtable_seeds
+      return unless (relations = ::Brick::AirtableApiCaller.pick_tables(:seeds))
+
+      ::Brick::SeedsBuilder.generate_seeds(relations)
+    end
+  end
+end

data/lib/generators/brick/{migration_builder.rb → migrations_builder.rb}

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Brick
-  module MigrationBuilder
+  module MigrationsBuilder
     # Many SQL types are the same as their migration data type name:
     #   text, integer, bigint, date, boolean, decimal, float
     # These however are not:
@@ -147,7 +149,7 @@ module Brick
                                         key_type, is_4x_rails, ar_version, do_fks_last, versions_to_create)
             after_fks.concat(add_fks) if do_fks_last
             current_mig_time[0] += 1.minute
-            versions_to_create << migration_file_write(mig_path, "create_#{::Brick._brick_index(tbl, nil, separator)}", current_mig_time, ar_version, mig)
+            versions_to_create << migration_file_write(mig_path, "create_#{::Brick._brick_index(tbl, nil, separator, relations[tbl])}", current_mig_time, ar_version, mig)
           end
           done.concat(fringe)
           chosen -= done
@@ -160,7 +162,9 @@ module Brick
                                         key_type, is_4x_rails, ar_version, do_fks_last, versions_to_create)
             after_fks.concat(add_fks)
             current_mig_time[0] += 1.minute
-            versions_to_create << migration_file_write(mig_path, "create_#{::Brick._brick_index(tbl, :migration, separator)}", current_mig_time, ar_version, mig)
+            versions_to_create << migration_file_write(mig_path, "create_#{
+              ::Brick._brick_index(tbl, :migration, separator, relations[tbl])
+            }", current_mig_time, ar_version, mig)
           end
           done.concat(chosen)
           chosen.clear

data/lib/generators/brick/migrations_generator.rb

@@ -4,12 +4,12 @@ require 'brick'
 require 'rails/generators'
 require 'rails/generators/active_record'
 require 'fancy_gets'
-require 'generators/brick/migration_builder'
+require 'generators/brick/migrations_builder'
 
 module Brick
   # Auto-generates migration files
   class MigrationsGenerator < ::Rails::Generators::Base
-    include ::Brick::MigrationBuilder
+    include ::Brick::MigrationsBuilder
     include FancyGets
 
     desc 'Auto-generates migration files for an existing database.'
@@ -25,13 +25,13 @@ module Brick
         return
       end
 
-      mig_path, is_insert_versions, is_delete_versions = ::Brick::MigrationBuilder.check_folder
+      mig_path, is_insert_versions, is_delete_versions = ::Brick::MigrationsBuilder.check_folder
       return unless mig_path
 
       # Generate a list of tables that can be chosen
       chosen = gets_list(list: tables, chosen: tables.dup)
 
-      ::Brick::MigrationBuilder.generate_migrations(chosen, mig_path, is_insert_versions, is_delete_versions)
+      ::Brick::MigrationsBuilder.generate_migrations(chosen, mig_path, is_insert_versions, is_delete_versions)
     end
   end
 end

data/lib/generators/brick/salesforce_migrations_generator.rb

@@ -3,7 +3,7 @@
 require 'brick'
 require 'rails/generators'
 require 'fancy_gets'
-require 'generators/brick/migration_builder'
+require 'generators/brick/migrations_builder'
 require 'generators/brick/salesforce_schema'
 
 module Brick
@@ -23,7 +23,7 @@ module Brick
       relations = nil
       end_document_proc = lambda do |salesforce_tables|
         # p [:end_document]
-        mig_path, is_insert_versions, is_delete_versions = ::Brick::MigrationBuilder.check_folder
+        mig_path, is_insert_versions, is_delete_versions = ::Brick::MigrationsBuilder.check_folder
         return unless mig_path
 
         # Generate a list of tables that can be chosen
@@ -73,7 +73,7 @@ module Brick
                       }
                     end
         # Build but do not have foreign keys established yet, and do not put version entries info the schema_migrations table
-        ::Brick::MigrationBuilder.generate_migrations(chosen, mig_path, is_insert_versions, is_delete_versions, relations,
+        ::Brick::MigrationsBuilder.generate_migrations(chosen, mig_path, is_insert_versions, is_delete_versions, relations,
                                                       do_fks_last: 'Separate', do_schema_migrations: false)
       end
       parser = Nokogiri::XML::SAX::Parser.new(::Brick::SalesforceSchema.new(end_document_proc))

data/lib/generators/brick/salesforce_schema.rb

@@ -2,7 +2,7 @@
 
 module Brick
   class SalesforceSchema < Nokogiri::XML::SAX::Document
-    include ::Brick::MigrationBuilder
+    include ::Brick::MigrationsBuilder
 
     attr_reader :end_document_proc
 

data/lib/generators/brick/seeds_builder.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+require 'fancy_gets'
+
+module Brick
+  class SeedsBuilder
+    class << self
+      include FancyGets
+
+      SeedModel = Struct.new(:table_name, :klass, :is_brick, :airtable_table)
+      SeedModel.define_method(:to_s) do
+        "#{klass.name}#{' (brick-generated)' if is_brick}"
+      end
+
+      def generate_seeds(relations = nil)
+        if File.exist?(seed_file_path = "#{::Rails.root}/db/seeds.rb")
+          puts "WARNING: seeds file #{seed_file_path} appears to already be present.\nOverwrite?"
+          return unless gets_list(list: ['No', 'Yes']) == 'Yes'
+
+          puts "\n"
+        end
+
+        if relations
+          is_airtable = true # So far the only thing that feeds us relations is Airtable
+          require 'generators/brick/airtable_api_caller'
+          # include ::Brick::MigrationsBuilder
+          chosen = relations.map { |k, v| SeedModel.new(k, nil, false, v[:airtable_table]) }
+        else
+          ::Brick.mode = :on
+          ActiveRecord::Base.establish_connection
+          relations = ::Brick.relations
+
+          # Load all models
+          ::Brick.eager_load_classes
+
+          # Generate a list of viable models that can be chosen
+          # First start with any existing models that have been defined ...
+          existing_models = ActiveRecord::Base.descendants.each_with_object({}) do |m, s|
+            s[m.table_name] = SeedModel.new(m.table_name, m, false) if !m.abstract_class? && !m.is_view? && m.table_exists?
+          end
+
+          models = (existing_models.values +
+                    # ... then add models which can be auto-built by Brick
+                    relations.reject do |k, v|
+                      k.is_a?(Symbol) || (v.key?(:isView) && v[:isView] == true) || existing_models.key?(k)
+                    end.map { |k, v| SeedModel.new(k, v[:class_name].constantize, true) }
+                   ).sort { |a, b| a.to_s <=> b.to_s }
+          if models.empty?
+            puts "No viable models found for database #{ActiveRecord::Base.connection.current_database}."
+            return
+          end
+
+          chosen = gets_list(list: models, chosen: models.dup)
+          schemas = chosen.each_with_object({}) do |v, s|
+            if (v_parts = v.table_name.split('.')).length > 1
+              s[v_parts.first] = nil unless [::Brick.default_schema, 'public'].include?(v_parts.first)
+            end
+          end
+        end
+
+        seeds = +'# Seeds file for '
+        if (arbc = ActiveRecord::Base.connection).respond_to?(:current_database) # SQLite3 can't do this!
+          seeds << "#{arbc.current_database}:\n"
+        elsif (filename = arbc.instance_variable_get(:@connection_parameters)&.fetch(:database, nil))
+          seeds << "#{filename}:\n"
+        end
+        done = []
+        fks = {}
+        stuck = {}
+        indexes = {} # Track index names to make sure things are unique
+        ar_base = Object.const_defined?(:ApplicationRecord) ? ApplicationRecord : Class.new(ActiveRecord::Base)
+        atrt_idx = 0    # ActionText::RichText unique index number
+        airtable_assoc_recids = Hash.new { |h, k| h[k] = [] }
+        @has_atrts = nil # Any ActionText::RichText present?
+        # Start by making entries for fringe models (those with no foreign keys).
+        # Continue layer by layer, creating entries for models that reference ones already done, until
+        # no more entries can be created.  (At that point hopefully all models are accounted for.)
+        while (fringe = chosen.reject do |seed_model|
+                          tbl = seed_model.table_name
+                          snag_fks = []
+                          snags = relations.fetch(tbl, nil)&.fetch(:fks, nil)&.select do |_k, v|
+                            # Skip any foreign keys which should be deferred ...
+                            !Brick.drfgs[tbl]&.any? do |drfg|
+                              drfg[0] == v.fetch(:fk, nil) && drfg[1] == v.fetch(:inverse_table, nil)
+                            end &&
+                            v[:is_bt] && !v[:polymorphic] && # ... and polymorphics ...
+                            tbl != v[:inverse_table] && # ... and self-referencing associations (stuff like "parent_id")
+                            !done.any? { |done_seed_model| done_seed_model.table_name == v[:inverse_table] } &&
+                            ::Brick.config.ignore_migration_fks.exclude?(snag_fk = "#{tbl}.#{v[:fk]}") &&
+                            snag_fks << snag_fk
+                          end
+                          if snags&.present?
+                            # puts snag_fks.inspect
+                            stuck[tbl] = snags
+                          end
+                        end
+              ).present?
+          seeds << "\n"
+          unless is_airtable
+            # Search through the fringe to see if we should bump special dependent classes forward to the next fringe.
+            # (Currently only ActiveStorage::Attachment if there's also an ActiveStorage::VariantRecord in the same
+            # fringe, and always have ActionText::EncryptedRichText at the very end.)
+            fringe_classes = fringe.map { |f| f.klass.name }
+            unless (asa_idx = fringe_classes.index('ActiveStorage::Attachment')).nil?
+              fringe.slice!(asa_idx) if fringe_classes.include?('ActiveStorage::VariantRecord')
+            end
+            unless (atert_idx = fringe_classes.index('ActionText::EncryptedRichText')).nil?
+              fringe.slice!(atert_idx) if fringe_classes.length > 1
+            end
+          end
+          fringe.each do |seed_model|
+            tbl = seed_model.table_name
+            next unless ::Brick.config.exclude_tables.exclude?(tbl) &&
+                        (relation = relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present? &&
+                        (is_airtable || (klass = seed_model.klass).table_exists?)
+
+            pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ar_base.primary_key].flatten.sort)
+            # In case things aren't as standard
+            if pkey_cols.empty?
+              pkey_cols = if rpk.empty? # && relation[:cols][arpk.first]&.first == key_type
+                            arpk
+                          elsif rpk.first
+                            rpk
+                          end
+            end
+            schema = if (tbl_parts = tbl.split('.')).length > 1
+                      if tbl_parts.first == (::Brick.default_schema || 'public')
+                        tbl_parts.shift
+                        nil
+                      else
+                        tbl_parts.first
+                      end
+                    end
+
+            # %%% For the moment we're skipping polymorphics
+            fkeys = if is_airtable
+              tbl = tbl.singularize
+              relation[:fks]&.values&.select { |assoc| assoc[:is_bt] && !assoc[:polymorphic] }
+            else
+              klass.reflect_on_all_associations.select { |a| a.belongs_to? && !a.polymorphic? }.map do |fk|
+                { fk: fk.foreign_key, assoc_name: fk.name.to_s, inverse_table: fk.table_name }
+              end
+            end
+            # Refer to this table name as a symbol or dotted string as appropriate
+            # tbl_code = tbl_parts.length == 1 ? ":#{tbl_parts.first}" : "'#{tbl}'"
+
+            has_rows = false
+            is_empty = true
+            klass_name = is_airtable ? ::Brick::AirtableApiCaller.sane_table_name(relation[:airtable_table]&.name)&.singularize&.camelize : klass.name
+            # Pull the records
+            collection = if is_airtable
+              if (airtable_table = relation[:airtable_table])
+                ::Brick::AirtableApiCaller.https_get("https://api.airtable.com/v0/#{airtable_table.base_id}/#{airtable_table.id}").fetch('records', nil)
+              end
+            else
+              klass.order(*pkey_cols)
+            end
+            collection&.each do |obj|
+              if is_airtable
+                fields = obj['fields'].each_with_object({}) do |field, s|
+                  if relation[:cols].keys.include?(col_name = ::Brick::AirtableApiCaller.sane_name(field.first))
+                    s[col_name] = obj['fields'][field.first]
+                  else # Consider N:M fks
+                    nm_fk = relation[:fks].find do |_k, fk1|
+                      relations[fk1[:assoc_tbl]]&.fetch(:fks, nil)&.find { |_k, fk2| fk2[:assoc_name] == col_name }
+                    end&.last
+                    if (t_table = nm_fk&.fetch(:inverse_table, nil))
+                      field.last.each do |nm_rec|
+                        nm_fk_col = nm_fk[:assoc_tbl]
+                        airtable_assoc_recids[t_table] << "#{nm_fk[:fk]}: #{nm_fk[:fk].singularize}_#{obj['id'][3..-1]}, " \
+                                                          "#{nm_fk_col}: #{nm_fk_col.singularize}_#{nm_rec[3..-1]}"
+                      end
+                    end
+                  end
+                end
+                objects = relation[:airtable_table].objects
+                obj = objects[airtable_id = obj['id']] = AirtableObject.new(seed_model, obj['fields'], obj['createdTime'])
+              end
+              unless has_rows
+                has_rows = true
+                seeds << "  puts 'Seeding: #{klass_name}'\n"
+              end
+              is_empty = false
+              # For Airtable, take off the "rec___" prefix
+              pk_val = is_airtable ? airtable_id[3..-1] : brick_escape(obj.attributes_before_type_cast[pkey_cols.first])
+              var_name = "#{tbl.gsub('.', '__')}_#{pk_val}"
+              fk_vals = []
+              data = []
+              updates = []
+              relation[:cols].each do |col, _col_type|
+                # Skip primary key columns, unless they are part of a foreign key.
+                # (But always add all columns if it's Airtable!)
+                next if !(fk = fkeys.find { |assoc| col == assoc[:fk] }) &&
+                        pkey_cols.include?(col) &&
+                        !is_airtable
+
+                # Used to be:  obj.send(col)
+                # (and with that it was possible to raise ActiveRecord::Encryption::Errors::Configuration...)
+                #  %%% should test further and see if that is possible with this code!)
+                if (val = obj.attributes_before_type_cast[col]) && (val.is_a?(Time) || val.is_a?(Date))
+                  val = val.to_s
+                end
+                if fk
+                  inv_tbl = fk[:inverse_table].gsub('.', '__')
+                  fk_val = if is_airtable
+                    # Used to be:  fk[:airtable_col]
+                    # Take off the "rec___" prefix
+                    obj.attributes_before_type_cast[fk[:assoc_name]]&.first&.[](3..-1)
+                  else
+                    brick_escape(val)
+                  end
+                  fk_vals << "#{fk[:assoc_name]}: #{inv_tbl}_#{fk_val}" if fk_val
+                else
+                  val = case val.class.name
+                        when 'ActiveStorage::Filename'
+                          val.to_s.inspect
+                        when 'ActionText::RichText'
+                          ensure_has_atrts(updates)
+                          atrt_var = "atrt#{atrt_idx += 1}"
+                          atrt_create = "(#{atrt_var} = #{val.class.name}.create(name: #{val.name.inspect}, body: #{val.to_trix_html.inspect
+                                        }, record_type: #{val.record_type.inspect}, record_id: #{var_name}.#{pkey_cols.first
+                                        }, created_at: DateTime.parse('#{val.created_at.inspect}'), updated_at: DateTime.parse('#{val.updated_at.inspect}')))"
+                          updates << "#{var_name}.update(#{col}: #{atrt_create})\n"
+                          # obj.send(col)&.embeds_blobs&.each do |blob|
+                            updates << "atrt_ids[[#{val.id}, '#{val.class.name}']] = #{atrt_var}.id\n"
+                          # end
+                          next
+                        else
+                          val.inspect
+                        end
+                  data << "#{col}: #{val}" unless val == 'nil'
+                end
+              end
+              case klass_name
+              when 'ActiveStorage::VariantRecord'
+                ensure_has_atrts(updates)
+                updates << "atrt_ids[[#{obj.id}, '#{klass_name}']] = #{var_name}.id\n"
+              end
+              # Make sure that ActiveStorage::Attachment and ActionText::EncryptedRichText get
+              # wired up to the proper record_id
+              if klass_name == 'ActiveStorage::Attachment' || klass_name == 'ActionText::EncryptedRichText'
+                record_class = data.find { |d| d.start_with?('record_type: ') }[14..-2]
+                record_id = data.find { |d| d.start_with?('record_id: ') }[11..-1]
+                data.reject! { |d| d.start_with?('record_id: ') || d.start_with?('created_at: ') || d.start_with?('updated_at: ') }
+                data << "record_id: atrt_ids[[#{record_id}, '#{record_class}']]"
+                seeds << "#{var_name} = #{klass_name}.find_or_create_by(#{(fk_vals + data).join(', ')}) do |asa|
+  asa.created_at = DateTime.parse('#{obj.created_at.inspect}')#{"
+  asa.updated_at = DateTime.parse('#{obj.updated_at.inspect}')" if obj.respond_to?(:updated_at)}
+end\n"
+              else
+                seeds << "#{var_name} = #{klass_name}.create(#{(fk_vals + data).join(', ')})\n"
+                unless is_airtable
+                  klass.attachment_reflections.each do |k, v|
+                    if (attached = obj.send(k))
+                      ensure_has_atrts(updates)
+                      updates << "atrt_ids[[#{obj.id}, '#{klass_name}']] = #{var_name}.id\n"
+                    end
+                  end if klass.respond_to?(:attachment_reflections)
+                end
+              end
+              updates.each { |update| seeds << update } # Anything that needs patching up after-the-fact
+            end
+            seeds << "  # (Skipping #{klass_name} as it has no rows)\n" unless has_rows
+          end
+          done.concat(fringe)
+          chosen -= done
+        end
+        airtable_assoc_recids.each do |k, v| # N:M links
+          v.each do |link|
+            seeds << "#{k.singularize.camelize}.create(#{link})\n"
+          end
+        end
+
+        File.open(seed_file_path, "w") { |f| f.write seeds }
+        stuck_counts = Hash.new { |h, k| h[k] = 0 }
+        chosen.each do |leftover|
+          puts "Can't do #{leftover.klass_name} because:\n  #{stuck[leftover.table_name].map do |snag|
+            stuck_counts[snag.last[:inverse_table]] += 1
+            snag.last[:assoc_name]
+          end.join(', ')}"
+        end
+        puts "\n*** Created seeds for #{done.length} models in db/seeds.rb ***"
+        if (stuck_sorted = stuck_counts.to_a.sort { |a, b| b.last <=> a.last }).length.positive?
+          puts "-----------------------------------------"
+          puts "Unable to create seeds for #{stuck_sorted.length} tables#{
+            ".  Here's the top 5 blockers" if stuck_sorted.length > 5
+          }:"
+          pp stuck_sorted[0..4]
+        end
+      end
+
+    private
+
+      def brick_escape(val)
+        val = val.to_s if val.is_a?(Date) || val.is_a?(Time) # Accommodate when for whatever reason a primary key is a date or time
+        case val
+        when String
+          ret = +''
+          val.each_char do |ch|
+            if ch < '0' || (ch > '9' && ch < 'A') || ch > 'Z'
+              ret << (ch == '_' ? ch : "x#{'K'.unpack('H*')[0]}")
+            else
+              ret << ch
+            end
+          end
+          ret
+        else
+          val
+        end
+      end
+
+      def ensure_has_atrts(array)
+        unless @has_atrts
+          array << "atrt_ids = {}\n"
+          @has_atrts = true
+        end
+      end
+
+      class AirtableObject
+        attr_accessor :table, :attributes_before_type_cast, :created_at
+        def initialize(table, attributes, created_at)
+          self.table = table
+          self.attributes_before_type_cast = attributes.each_with_object({}) { |a, s| s[::Brick::AirtableApiCaller.sane_name(a.first)] = a.last }
+          self.created_at = created_at
+        end
+      end
+    end
+  end
+end

data/lib/generators/brick/seeds_generator.rb

@@ -2,256 +2,16 @@
 
 require 'brick'
 require 'rails/generators'
-require 'fancy_gets'
+require 'generators/brick/seeds_builder'
 
 module Brick
   class SeedsGenerator < ::Rails::Generators::Base
-    include FancyGets
-
     desc 'Auto-generates a seeds file from existing data.'
 
-    SeedModel = Struct.new(:table_name, :klass, :is_brick)
-    SeedModel.define_method(:to_s) do
-      "#{klass.name}#{' (brick-generated)' if is_brick}"
-    end
-
     def brick_seeds
       # %%% If Apartment is active and there's no schema_to_analyse, ask which schema they want
 
-      ::Brick.mode = :on
-      ActiveRecord::Base.establish_connection
-
-      # Load all models
-      ::Brick.eager_load_classes
-
-      # Generate a list of viable models that can be chosen
-      # First start with any existing models that have been defined ...
-      existing_models = ActiveRecord::Base.descendants.each_with_object({}) do |m, s|
-        s[m.table_name] = SeedModel.new(m.table_name, m, false) if !m.abstract_class? && !m.is_view? && m.table_exists?
-      end
-      models = (existing_models.values +
-                # ... then add models which can be auto-built by Brick
-                ::Brick.relations.reject do |k, v|
-                  k.is_a?(Symbol) || (v.key?(:isView) && v[:isView] == true) || existing_models.key?(k)
-                end.map { |k, v| SeedModel.new(k, v[:class_name].constantize, true) }
-               ).sort { |a, b| a.to_s <=> b.to_s }
-      if models.empty?
-        puts "No viable models found for database #{ActiveRecord::Base.connection.current_database}."
-        return
-      end
-
-      if File.exist?(seed_file_path = "#{::Rails.root}/db/seeds.rb")
-        puts "WARNING: seeds file #{seed_file_path} appears to already be present.\nOverwrite?"
-        return unless gets_list(list: ['No', 'Yes']) == 'Yes'
-
-        puts "\n"
-      end
-
-      chosen = gets_list(list: models, chosen: models.dup)
-      schemas = chosen.each_with_object({}) do |v, s|
-        if (v_parts = v.table_name.split('.')).length > 1
-          s[v_parts.first] = nil unless [::Brick.default_schema, 'public'].include?(v_parts.first)
-        end
-      end
-      seeds = +'# Seeds file for '
-      if (arbc = ActiveRecord::Base.connection).respond_to?(:current_database) # SQLite3 can't do this!
-        seeds << "#{arbc.current_database}:\n"
-      elsif (filename = arbc.instance_variable_get(:@connection_parameters)&.fetch(:database, nil))
-        seeds << "#{filename}:\n"
-      end
-      done = []
-      fks = {}
-      stuck = {}
-      indexes = {} # Track index names to make sure things are unique
-      ar_base = Object.const_defined?(:ApplicationRecord) ? ApplicationRecord : Class.new(ActiveRecord::Base)
-      atrt_idx = 0    # ActionText::RichText unique index number
-      @has_atrts = nil # Any ActionText::RichText present?
-      # Start by making entries for fringe models (those with no foreign keys).
-      # Continue layer by layer, creating entries for models that reference ones already done, until
-      # no more entries can be created.  (At that point hopefully all models are accounted for.)
-      while (fringe = chosen.reject do |seed_model|
-                        tbl = seed_model.table_name
-                        snag_fks = []
-                        snags = ::Brick.relations.fetch(tbl, nil)&.fetch(:fks, nil)&.select do |_k, v|
-                          # Skip any foreign keys which should be deferred ...
-                          !Brick.drfgs[tbl]&.any? do |drfg|
-                            drfg[0] == v.fetch(:fk, nil) && drfg[1] == v.fetch(:inverse_table, nil)
-                          end &&
-                          v[:is_bt] && !v[:polymorphic] && # ... and polymorphics ...
-                          tbl != v[:inverse_table] && # ... and self-referencing associations (stuff like "parent_id")
-                          !done.any? { |done_seed_model| done_seed_model.table_name == v[:inverse_table] } &&
-                          ::Brick.config.ignore_migration_fks.exclude?(snag_fk = "#{tbl}.#{v[:fk]}") &&
-                          snag_fks << snag_fk
-                        end
-                        if snags&.present?
-                          # puts snag_fks.inspect
-                          stuck[tbl] = snags
-                        end
-                      end
-            ).present?
-        seeds << "\n"
-        # Search through the fringe to see if we should bump special dependent classes forward to the next fringe.
-        # (Currently only ActiveStorage::Attachment if there's also an ActiveStorage::VariantRecord in the same
-        # fringe, and always have ActionText::EncryptedRichText at the very end.)
-        fringe_classes = fringe.map { |f| f.klass.name }
-        unless (asa_idx = fringe_classes.index('ActiveStorage::Attachment')).nil?
-          fringe.slice!(asa_idx) if fringe_classes.include?('ActiveStorage::VariantRecord')
-        end
-        unless (atert_idx = fringe_classes.index('ActionText::EncryptedRichText')).nil?
-          fringe.slice!(atert_idx) if fringe_classes.length > 1
-        end
-        fringe.each do |seed_model|
-          tbl = seed_model.table_name
-          next unless ::Brick.config.exclude_tables.exclude?(tbl) &&
-                      (relation = ::Brick.relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present? &&
-                      (klass = seed_model.klass).table_exists?
-
-          pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ar_base.primary_key].flatten.sort)
-          # In case things aren't as standard
-          if pkey_cols.empty?
-            pkey_cols = if rpk.empty? # && relation[:cols][arpk.first]&.first == key_type
-                          arpk
-                        elsif rpk.first
-                          rpk
-                        end
-          end
-          schema = if (tbl_parts = tbl.split('.')).length > 1
-                     if tbl_parts.first == (::Brick.default_schema || 'public')
-                       tbl_parts.shift
-                       nil
-                     else
-                       tbl_parts.first
-                     end
-                   end
-
-          # %%% For the moment we're skipping polymorphics
-          fkeys = relation[:fks].values.select { |assoc| assoc[:is_bt] && !assoc[:polymorphic] }
-          # Refer to this table name as a symbol or dotted string as appropriate
-          # tbl_code = tbl_parts.length == 1 ? ":#{tbl_parts.first}" : "'#{tbl}'"
-
-          has_rows = false
-          is_empty = true
-          klass.order(*pkey_cols).each do |obj|
-            unless has_rows
-              has_rows = true
-              seeds << "  puts 'Seeding: #{klass.name}'\n"
-            end
-            is_empty = false
-            pk_val = obj.send(pkey_cols.first)
-            var_name = "#{tbl.gsub('.', '__')}_#{brick_escape(pk_val)}"
-            fk_vals = []
-            data = []
-            updates = []
-            relation[:cols].each do |col, _col_type|
-              next if !(fk = fkeys.find { |assoc| col == assoc[:fk] }) &&
-                      pkey_cols.include?(col)
-
-              begin
-                # Used to be:  obj.send(col)
-                if (val = obj.attributes_before_type_cast[col]) && (val.is_a?(Time) || val.is_a?(Date))
-                  val = val.to_s
-                end
-              rescue StandardError => e # ActiveRecord::Encryption::Errors::Configuration
-              end
-              if fk
-                inv_tbl = fk[:inverse_table].gsub('.', '__')
-                fk_vals << "#{fk[:assoc_name]}: #{inv_tbl}_#{brick_escape(val)}" if val
-              else
-                val = case val.class.name
-                      when 'ActiveStorage::Filename'
-                        val.to_s.inspect
-                      when 'ActionText::RichText'
-                        ensure_has_atrts(updates)
-                        atrt_var = "atrt#{atrt_idx += 1}"
-                        atrt_create = "(#{atrt_var} = #{val.class.name}.create(name: #{val.name.inspect}, body: #{val.to_trix_html.inspect
-                                      }, record_type: #{val.record_type.inspect}, record_id: #{var_name}.#{pkey_cols.first
-                                      }, created_at: DateTime.parse('#{val.created_at.inspect}'), updated_at: DateTime.parse('#{val.updated_at.inspect}')))"
-                        updates << "#{var_name}.update(#{col}: #{atrt_create})\n"
-                        # obj.send(col)&.embeds_blobs&.each do |blob|
-                          updates << "atrt_ids[[#{val.id}, '#{val.class.name}']] = #{atrt_var}.id\n"
-                        # end
-                        next
-                      else
-                        val.inspect
-                      end
-                data << "#{col}: #{val}" unless val == 'nil'
-              end
-            end
-            case klass.name
-            when 'ActiveStorage::VariantRecord'
-              ensure_has_atrts(updates)
-              updates << "atrt_ids[[#{obj.id}, '#{klass.name}']] = #{var_name}.id\n"
-            end
-            # Make sure that ActiveStorage::Attachment and ActionText::EncryptedRichText get
-            # wired up to the proper record_id
-            if klass.name == 'ActiveStorage::Attachment' || klass.name == 'ActionText::EncryptedRichText'
-              record_class = data.find { |d| d.start_with?('record_type: ') }[14..-2]
-              record_id = data.find { |d| d.start_with?('record_id: ') }[11..-1]
-              data.reject! { |d| d.start_with?('record_id: ') || d.start_with?('created_at: ') || d.start_with?('updated_at: ') }
-              data << "record_id: atrt_ids[[#{record_id}, '#{record_class}']]"
-              seeds << "#{var_name} = #{klass.name}.find_or_create_by(#{(fk_vals + data).join(', ')}) do |asa|
-  asa.created_at = DateTime.parse('#{obj.created_at.inspect}')#{"
-  asa.updated_at = DateTime.parse('#{obj.updated_at.inspect}')" if obj.respond_to?(:updated_at)}
-end\n"
-            else
-              seeds << "#{var_name} = #{seed_model.klass.name}.create(#{(fk_vals + data).join(', ')})\n"
-              klass.attachment_reflections.each do |k, v|
-                if (attached = obj.send(k))
-                  ensure_has_atrts(updates)
-                  updates << "atrt_ids[[#{obj.id}, '#{klass.name}']] = #{var_name}.id\n"
-                end
-              end if klass.respond_to?(:attachment_reflections)
-            end
-            updates.each { |update| seeds << update } # Anything that needs patching up after-the-fact
-          end
-          seeds << "  # (Skipping #{seed_model.klass.name} as it has no rows)\n" unless has_rows
-          File.open(seed_file_path, "w") { |f| f.write seeds }
-        end
-        done.concat(fringe)
-        chosen -= done
-      end
-      stuck_counts = Hash.new { |h, k| h[k] = 0 }
-      chosen.each do |leftover|
-        puts "Can't do #{leftover.klass.name} because:\n  #{stuck[leftover.table_name].map do |snag|
-          stuck_counts[snag.last[:inverse_table]] += 1
-          snag.last[:assoc_name]
-        end.join(', ')}"
-      end
-      puts "\n*** Created seeds for #{done.length} models in db/seeds.rb ***"
-      if (stuck_sorted = stuck_counts.to_a.sort { |a, b| b.last <=> a.last }).length.positive?
-        puts "-----------------------------------------"
-        puts "Unable to create seeds for #{stuck_sorted.length} tables#{
-          ".  Here's the top 5 blockers" if stuck_sorted.length > 5
-        }:"
-        pp stuck_sorted[0..4]
-      end
-    end
-
-  private
-
-    def brick_escape(val)
-      val = val.to_s if val.is_a?(Date) || val.is_a?(Time) # Accommodate when for whatever reason a primary key is a date or time
-      case val
-      when String
-        ret = +''
-        val.each_char do |ch|
-          if ch < '0' || (ch > '9' && ch < 'A') || ch > 'Z'
-            ret << (ch == '_' ? ch : "x#{'K'.unpack('H*')[0]}")
-          else
-            ret << ch
-          end
-        end
-        ret
-      else
-        val
-      end
-    end
-
-    def ensure_has_atrts(array)
-      unless @has_atrts
-        array << "atrt_ids = {}\n"
-        @has_atrts = true
-      end
+      ::Brick::SeedsBuilder.generate_seeds
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.229
+  version: 1.0.230
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-04 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -228,13 +228,17 @@ files:
 - lib/brick/util.rb
 - lib/brick/version_number.rb
 - lib/generators/brick/USAGE
+- lib/generators/brick/airtable_api_caller.rb
+- lib/generators/brick/airtable_migrations_generator.rb
+- lib/generators/brick/airtable_seeds_generator.rb
 - lib/generators/brick/controllers_generator.rb
 - lib/generators/brick/install_generator.rb
-- lib/generators/brick/migration_builder.rb
+- lib/generators/brick/migrations_builder.rb
 - lib/generators/brick/migrations_generator.rb
 - lib/generators/brick/models_generator.rb
 - lib/generators/brick/salesforce_migrations_generator.rb
 - lib/generators/brick/salesforce_schema.rb
+- lib/generators/brick/seeds_builder.rb
 - lib/generators/brick/seeds_generator.rb
 - lib/generators/brick/templates/add_object_changes_to_versions.rb.erb
 - lib/generators/brick/templates/create_versions.rb.erb