active_scaffold 3.7.0 → 3.7.1

data/lib/active_scaffold/bridges.rb

@@ -1,9 +1,6 @@
 module ActiveScaffold
   module Bridges
     ActiveScaffold.autoload_subdir('bridges', self)
-    module Shared
-      autoload :DateBridge, 'active_scaffold/bridges/shared/date_bridge'
-    end
 
     mattr_accessor :bridges
     mattr_accessor :bridges_run

data/lib/active_scaffold/constraints.rb

@@ -11,13 +11,27 @@ module ActiveScaffold
       @active_scaffold_constraints ||= active_scaffold_embedded_params[:constraints] || {}
     end
 
+    def register_constraint?(column_name, value)
+      if params_hash?(value)
+        false
+      elsif value.is_a?(Array)
+        column = active_scaffold_config.columns[column_name]
+        column && value.size > (column.association&.polymorphic? ? 2 : 1)
+      else
+        true
+      end
+    end
+
     # For each enabled action, adds the constrained columns to the ActionColumns object (if it exists).
     # This lets the ActionColumns object skip constrained columns.
     #
-    # If the constraint value is a Hash, then we assume the constraint is a multi-level association constraint (the reverse of a has_many :through) and we do NOT register the constraint column.
+    # If the constraint value is a Hash, then we assume the constraint is a multi-level association constraint
+    # (the reverse of a has_many :through) and we do NOT register the constraint column.
+    # If the constraint value is an Array, or Array with more than 2 items for polymorphic column,
+    # we do NOT register the constraint column, as records will have different values in the column.
     def register_constraints_with_action_columns(constrained_fields = nil)
       constrained_fields ||= []
-      constrained_fields |= active_scaffold_constraints.reject { |_, v| params_hash?(v) }.keys.collect(&:to_sym)
+      constrained_fields |= active_scaffold_constraints.select { |k, v| register_constraint?(k, v) }.keys.collect(&:to_sym)
       exclude_actions = []
       %i[list update].each do |action_name|
         if active_scaffold_config.actions.include? action_name
@@ -111,10 +125,10 @@ module ActiveScaffold
       value = association.klass.find(value).send(association.primary_key) if association.primary_key
 
       if association.polymorphic?
-        unless value.is_a?(Array) && value.size == 2
+        unless value.is_a?(Array) && value.size >= 2
           raise ActiveScaffold::MalformedConstraint, polymorphic_constraint_error(association), caller
         end
-        condition = {table => {association.foreign_type => value[0], field => value[1]}}
+        condition = {table => {association.foreign_type => value[0], field => value.size == 2 ? value[1] : value[1..-1]}}
       else
         condition = {table => {field.to_s => value}}
       end
@@ -149,11 +163,12 @@ module ActiveScaffold
           if column.association.collection?
             record.send(k.to_s).send(:<<, column.association.klass.find(v))
           elsif column.association.polymorphic?
-            unless v.is_a?(Array) && v.size == 2
+            unless v.is_a?(Array) && v.size >= 2
               raise ActiveScaffold::MalformedConstraint, polymorphic_constraint_error(column.association), caller
             end
-            record.send("#{k}=", v[0].constantize.find(v[1]))
-          elsif !column.association.source_reflection&.options&.include?(:through) # regular singular association, or one-level through association
+            record.send("#{k}=", v[0].constantize.find(v[1])) if v.size == 2
+          elsif !column.association.source_reflection&.options&.include?(:through) && # regular singular association, or one-level through association
+                !v.is_a?(Array)
             record.send("#{k}=", column.association.klass.find(v))
 
             # setting the belongs_to side of a has_one isn't safe. if the has_one was already

data/lib/active_scaffold/core.rb

@@ -257,6 +257,8 @@ module ActiveScaffold
     def self.column_type_cast(value, column)
       if defined?(ActiveRecord) && column.is_a?(ActiveRecord::ConnectionAdapters::Column)
         active_record_column_type_cast(value, column)
+      elsif defined?(ActiveModel) && column.is_a?(ActiveModel::Attribute)
+        active_record_column_type_cast(value, column.type)
       elsif defined?(Mongoid) && column.is_a?(Mongoid::Fields::Standard)
         mongoid_column_type_cast(value, column)
       else
@@ -269,9 +271,9 @@ module ActiveScaffold
       column.type.evolve value
     end
 
-    def self.active_record_column_type_cast(value, column)
-      return Time.zone.at(value.to_i) if value =~ /\A\d+\z/ && %i[time datetime].include?(column.type)
-      cast_type = ActiveRecord::Type.lookup column.type
+    def self.active_record_column_type_cast(value, column_or_type)
+      return Time.zone.at(value.to_i) if value =~ /\A\d+\z/ && %i[time datetime].include?(column_or_type.type)
+      cast_type = column_or_type.is_a?(ActiveRecord::ConnectionAdapters::Column) ? ActiveRecord::Type.lookup(column_or_type.type) : column_or_type
       cast_type ? cast_type.cast(value) : value
     end
   end

data/lib/active_scaffold/data_structures/column.rb

@@ -144,24 +144,58 @@ module ActiveScaffold::DataStructures
     # supported options:
     #   * for association columns
     #     * :select - displays a simple <select> or a collection of checkboxes to (dis)associate records
-    attr_accessor :form_ui
+    attr_reader :form_ui
 
-    attr_writer :list_ui
+    attr_reader :form_ui_options
+
+    # value must be a Symbol, or an Array of form_ui and options hash which will be used with form_ui only
+    def form_ui=(value)
+      check_valid_action_ui_params(value)
+      @form_ui, @form_ui_options = *value
+    end
+
+    # value must be a Symbol, or an Array of list_ui and options hash which will be used with list_ui only
+    def list_ui=(value)
+      check_valid_action_ui_params(value)
+      @list_ui, @list_ui_options = *value
+    end
 
     def list_ui
       @list_ui || form_ui
     end
 
-    attr_writer :show_ui
+    def list_ui_options
+      @list_ui ? @list_ui_options : form_ui_options
+    end
+
+    # value must be a Symbol, or an Array of show_ui and options hash which will be used with show_ui only
+    def show_ui=(value)
+      check_valid_action_ui_params(value)
+      @show_ui, @show_ui_options = *value
+    end
+
     def show_ui
       @show_ui || list_ui
     end
 
-    attr_writer :search_ui
+    def show_ui_options
+      @show_ui ? @show_ui_options : list_ui_options
+    end
+
+    # value must be a Symbol, or an Array of search_ui and options hash which will be used with search_ui only
+    def search_ui=(value)
+      check_valid_action_ui_params(value)
+      @search_ui, @search_ui_options = *value
+    end
+
     def search_ui
       @search_ui || @form_ui || (:select if association && !association.polymorphic?)
     end
 
+    def search_ui_options
+      @search_ui ? @search_ui_options : form_ui_options
+    end
+
     # a place to store dev's column specific options
     attr_writer :options
     def options
@@ -340,6 +374,9 @@ module ActiveScaffold::DataStructures
       @name = name.to_sym
       @active_record_class = active_record_class
       @column = _columns_hash[name.to_s]
+      if @column.nil? && active_record? && active_record_class._default_attributes.key?(name.to_s)
+        @column = active_record_class._default_attributes[name.to_s]
+      end
       @delegated_association = delegated_association
       @cache_key = [@active_record_class.name, name].compact.map(&:to_s).join('#')
       setup_association_info
@@ -356,22 +393,7 @@ module ActiveScaffold::DataStructures
 
       @text = @column.nil? || [:string, :text, :citext, String].include?(column_type)
       @number = false
-      if @column
-        if active_record_class.respond_to?(:defined_enums) && active_record_class.defined_enums[name.to_s]
-          @form_ui = :select
-          @options = {:options => active_record_class.send(name.to_s.pluralize).keys.map(&:to_sym)}
-        elsif column_number?
-          @number = true
-          @form_ui = :number
-          @options = {:format => :i18n_number}
-        else
-          @form_ui =
-            case @column.type
-            when :boolean then :checkbox
-            when :text then :textarea
-            end
-        end
-      end
+      setup_defaults_for_column if @column
       @allow_add_existing = true
       @form_ui = self.class.association_form_ui if @association && self.class.association_form_ui
 
@@ -396,7 +418,7 @@ module ActiveScaffold::DataStructures
     # just the field (not table.field)
     def field_name
       return nil if virtual?
-      @field_name ||= column ? quoted_field_name(column.name) : association.foreign_key
+      @field_name ||= column ? quoted_field_name(column.name) : quoted_field_name(association.foreign_key)
     end
 
     def <=>(other)
@@ -430,7 +452,22 @@ module ActiveScaffold::DataStructures
     end
 
     def default_for_empty_value
-      (column.null ? nil : column.default) if column
+      return nil unless column
+      if column.is_a?(ActiveModel::Attribute)
+        column.value
+      elsif active_record?
+        null? ? nil : column.default
+      elsif mongoid?
+        column.default_val
+      end
+    end
+
+    def null?
+      if active_record? && !column.is_a?(ActiveModel::Attribute)
+        column&.null
+      else
+        true
+      end
     end
 
     # the table.field name for this column, if applicable
@@ -438,6 +475,10 @@ module ActiveScaffold::DataStructures
       @field ||= quoted_field(field_name)
     end
 
+    def quoted_foreign_type
+      quoted_field(quoted_field_name(association.foreign_type))
+    end
+
     def type_for_attribute
       ActiveScaffold::OrmChecks.type_for_attribute active_record_class, name
     end
@@ -446,8 +487,39 @@ module ActiveScaffold::DataStructures
       ActiveScaffold::OrmChecks.column_type active_record_class, name
     end
 
+    def default_value
+      ActiveScaffold::OrmChecks.column_type active_record_class, name
+    end
+
+    def attributes=(opts)
+      opts.each do |setting, value|
+        send "#{setting}=", value
+      end
+    end
+
+    def cast(value)
+      ActiveScaffold::OrmChecks.cast active_record_class, name, value
+    end
+
     protected
 
+    def setup_defaults_for_column
+      if active_record_class.respond_to?(:defined_enums) && active_record_class.defined_enums[name.to_s]
+        @form_ui = :select
+        @options = {:options => active_record_class.send(name.to_s.pluralize).keys.map(&:to_sym)}
+      elsif column_number?
+        @number = true
+        @form_ui = :number
+        @options = {:format => :i18n_number}
+      else
+        @form_ui =
+          case column_type
+          when :boolean then null? ? :boolean : :checkbox
+          when :text then :textarea
+          end
+      end
+    end
+
     def setup_association_info
       assoc = active_record_class.reflect_on_association(name)
       @association =
@@ -506,7 +578,7 @@ module ActiveScaffold::DataStructures
     end
 
     def column_number?
-      return %i[float decimal integer].include? @column.type if active_record?
+      return %i[float decimal integer].include? column_type if active_record?
       return @column.type < Numeric if mongoid?
     end
 
@@ -560,5 +632,18 @@ module ActiveScaffold::DataStructures
         300
       end
     end
+
+    def check_valid_action_ui_params(value)
+      return true if valid_action_ui_params?(value)
+      raise ArgumentError, 'value must be a Symbol, or an array of Symbol and Hash'
+    end
+
+    def valid_action_ui_params?(value)
+      if value.is_a?(Array)
+        value.size <= 2 && value[0].is_a?(Symbol) && (value[1].nil? || value[1].is_a?(Hash))
+      else
+        value.nil? || value.is_a?(Symbol)
+      end
+    end
   end
 end

data/lib/active_scaffold/engine.rb

@@ -2,6 +2,9 @@ module ActiveScaffold
   class Engine < ::Rails::Engine
     initializer 'active_scaffold.action_controller' do
       ActiveSupport.on_load :action_controller do
+        require 'active_scaffold/extensions/action_controller_rescueing'
+        require 'active_scaffold/extensions/action_controller_rendering'
+        require 'active_scaffold/extensions/routing_mapper'
         include ActiveScaffold::Core
         include ActiveScaffold::RespondsToParent
         include ActiveScaffold::Helpers::ControllerHelpers
@@ -12,12 +15,17 @@ module ActiveScaffold
 
     initializer 'active_scaffold.action_view' do
       ActiveSupport.on_load :action_view do
+        require 'active_scaffold/extensions/action_view_rendering'
+        require 'active_scaffold/extensions/name_option_for_datetime'
         include ActiveScaffold::Helpers::ViewHelpers
       end
     end
 
     initializer 'active_scaffold.active_record' do
       ActiveSupport.on_load :active_record do
+        require 'active_scaffold/extensions/to_label'
+        require 'active_scaffold/extensions/unsaved_associated'
+        require 'active_scaffold/extensions/unsaved_record'
         include ActiveScaffold::ActiveRecordPermissions::ModelUserAccess::Model
         module ActiveRecord::Associations
           Association.send :include, ActiveScaffold::Tableless::Association
@@ -39,5 +47,12 @@ module ActiveScaffold
     initializer 'active_scaffold.assets' do
       config.assets.precompile << 'active_scaffold/indicator.gif'
     end
+
+    initializer 'active_scaffold.extensions' do
+      require 'active_scaffold/extensions/cow_proxy'
+      require 'active_scaffold/extensions/ice_nine'
+      require 'active_scaffold/extensions/localize'
+      require 'active_scaffold/extensions/paginator_extensions'
+    end
   end
 end

data/lib/active_scaffold/extensions/routing_mapper.rb

@@ -68,6 +68,7 @@ module ActiveScaffold
       end
     end
   end
+  ActiveSupport.run_load_hooks(:active_scaffold_routing, Routing)
 end
 
 module ActionDispatch

data/lib/active_scaffold/finder.rb

@@ -110,15 +110,42 @@ module ActiveScaffold
             end
           return nil unless sql
 
-          conditions = [column.search_sql.collect { |search_sql| sql % {:search_sql => search_sql} }.join(' OR ')]
-          conditions += values * column.search_sql.size if values.present?
-          conditions
+          where_values = []
+          sql_conditions = []
+          column.search_sql.each do |search_sql|
+            if search_sql.is_a?(Hash)
+              subquery_sql, *subquery_values = subquery_condition(column, sql, search_sql, values)
+              sql_conditions << subquery_sql
+              where_values.concat subquery_values
+            else
+              sql_conditions << sql % {:search_sql => search_sql}
+              where_values.concat values
+            end
+          end
+          [sql_conditions.join(' OR '), *where_values]
         rescue StandardError => e
           Rails.logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column :#{column.name}, search_ui = #{search_ui} in #{name}"
           raise e
         end
       end
 
+      def subquery_condition(column, sql, options, values)
+        relation, *columns = options[:subquery]
+        conditions = [columns.map { |search_sql| sql % {:search_sql => search_sql} }.join(' OR ')]
+        conditions += values * columns.size if values.present?
+        subquery = relation.where(conditions)
+        subquery = subquery.select(relation.primary_key) if subquery.select_values.blank?
+
+        conditions = [["#{options[:field] || column.field} IN (?)", options[:conditions]&.first].compact.join(' AND ')]
+        conditions << subquery
+        conditions.concat options[:conditions][1..-1] if options[:conditions]
+        if column.association&.polymorphic?
+          conditions[0] << " AND #{column.quoted_foreign_type} = ?"
+          conditions << relation.name
+        end
+        conditions
+      end
+
       def condition_for_search_ui(column, value, like_pattern, search_ui)
         case search_ui
         when :boolean, :checkbox
@@ -133,7 +160,7 @@ module ActiveScaffold
           condition_for_range(column, value, like_pattern)
         when :date, :time, :datetime, :timestamp
           condition_for_datetime(column, value)
-        when :select, :multi_select, :country, :usa_state, :chosen, :multi_chosen
+        when :select, :select_multiple, :draggable, :multi_select, :country, :usa_state, :chosen, :multi_chosen
           values = Array(value).select(&:present?)
           ['%<search_sql>s in (?)', values] if values.present?
         else
@@ -171,7 +198,10 @@ module ActiveScaffold
         elsif value[:from].blank?
           nil
         elsif ActiveScaffold::Finder::STRING_COMPARATORS.values.include?(value[:opt])
-          ["%<search_sql>s #{ActiveScaffold::Finder.like_operator} ?", value[:opt].sub('?', value[:from])]
+          [
+            "%<search_sql>s #{'NOT ' if value[:opt].start_with?('not_')}#{ActiveScaffold::Finder.like_operator} ?",
+            value[:opt].sub('not_', '').sub('?', value[:from])
+          ]
         elsif value[:opt] == 'BETWEEN'
           ['(%<search_sql>s BETWEEN ? AND ?)', value[:from], value[:to]]
         elsif ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(value[:opt])
@@ -241,14 +271,19 @@ module ActiveScaffold
         nil
       end
 
-      def parse_date_with_format(value, format_name)
-        format = I18n.t("date.formats.#{format_name || :default}")
-        format.gsub!(/%-d|%-m|%_m/) { |s| s.gsub(/[-_]/, '') } # strptime fails with %-d, %-m, %_m
-        en_value = I18n.locale == :en ? value : translate_days_and_months(value, format)
-        Date.strptime(en_value, format)
+      def format_for_date(column, value, format_name = column.options[:format])
+        if format_name
+          format = I18n.t("date.formats.#{format_name}")
+          format.gsub!(/%-d|%-m|%_m/) { |s| s.gsub(/[-_]/, '') } # strptime fails with %-d, %-m, %_m
+          en_value = I18n.locale == :en ? value : translate_days_and_months(value, format)
+        end
+        [en_value || value, format]
+      end
+
+      def parse_date_with_format(value, format)
+        Date.strptime(value, *format)
       rescue StandardError => e
-        message = "Error parsing date from #{en_value}"
-        message << " (#{value})" if en_value != value
+        message = "Error parsing date from #{value}"
         message << ", with format #{format}" if format
         Rails.logger.warn "#{message}:\n#{e.message}\n#{e.backtrace.join("\n")}"
         nil
@@ -280,7 +315,7 @@ module ActiveScaffold
             value.send(conversion)
           end
         elsif conversion == :to_date
-          parse_date_with_format(value, column.options[:format])
+          parse_date_with_format(*format_for_date(column, value))
         elsif value.include?('T')
           Time.zone.parse(value)
         else # datetime
@@ -292,7 +327,7 @@ module ActiveScaffold
       def condition_value_for_numeric(column, value)
         return value if value.nil?
         value = column.number_to_native(value) if column.options[:format] && column.search_ui != :number
-        case (column.search_ui || column.column.type)
+        case (column.search_ui || column.column_type)
         when :integer   then
           if value.is_a?(TrueClass) || value.is_a?(FalseClass)
             value ? 1 : 0
@@ -300,8 +335,7 @@ module ActiveScaffold
             value.to_i
           end
         when :float     then value.to_f
-        when :decimal
-          ::ActiveRecord::Type::Decimal.new.send(Rails.version < '5.0' ? :type_cast_from_user : :cast, value)
+        when :decimal   then ::ActiveRecord::Type::Decimal.new.cast(value)
         else
           value
         end
@@ -309,28 +343,102 @@ module ActiveScaffold
 
       def datetime_conversion_for_condition(column)
         if column.column
-          column.column.type == :date ? :to_date : :to_time
+          column.column_type == :date ? :to_date : :to_time
         else
           :to_time
         end
       end
 
       def condition_for_datetime(column, value, like_pattern = nil)
+        operator = ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(value['opt']) && value['opt'] != 'BETWEEN' ? value['opt'] : nil
+        from_value, to_value = datetime_from_to(column, value)
+
+        if column.search_sql.is_a? Proc
+          column.search_sql.call(from_value, to_value, operator)
+        elsif operator.nil?
+          ['%<search_sql>s BETWEEN ? AND ?', from_value, to_value] unless from_value.nil? || to_value.nil?
+        else
+          ["%<search_sql>s #{value['opt']} ?", from_value] unless from_value.nil?
+        end
+      end
+
+      def datetime_from_to(column, value)
         conversion = datetime_conversion_for_condition(column)
-        from_value = condition_value_for_datetime(column, value[:from], conversion)
-        to_value = condition_value_for_datetime(column, value[:to], conversion)
+        case value['opt']
+        when 'RANGE'
+          values = datetime_from_to_for_range(column, value)
+          # Avoid calling to_time, not needed and broken on rails >= 4, because return local time instead of UTC
+          values.collect!(&conversion) if conversion != :to_time
+          values
+        when 'PAST', 'FUTURE'
+          values = datetime_from_to_for_trend(column, value)
+          # Avoid calling to_time, not needed and broken on rails >= 4, because return local time instead of UTC
+          values.collect!(&conversion) if conversion != :to_time
+          values
+        else
+          %w[from to].collect { |field| condition_value_for_datetime(column, value[field], conversion) }
+        end
+      end
 
-        if from_value.nil? && to_value.nil?
-          nil
-        elsif !from_value
-          ['%<search_sql>s <= ?', to_value]
-        elsif !to_value
-          ['%<search_sql>s >= ?', from_value]
+      def datetime_now
+        Time.zone.now
+      end
+
+      def datetime_from_to_for_trend(column, value)
+        case value['opt']
+        when 'PAST'
+          trend_number = [value['number'].to_i, 1].max
+          now = datetime_now
+          if datetime_column_date?(column)
+            from = now.beginning_of_day.ago(trend_number.send(value['unit'].downcase.singularize.to_sym))
+            to = now.end_of_day
+          else
+            from = now.ago(trend_number.send(value['unit'].downcase.singularize.to_sym))
+            to = now
+          end
+          [from, to]
+        when 'FUTURE'
+          trend_number = [value['number'].to_i, 1].max
+          now = datetime_now
+          if datetime_column_date?(column)
+            from = now.beginning_of_day
+            to = now.end_of_day.in(trend_number.send(value['unit'].downcase.singularize.to_sym))
+          else
+            from = now
+            to = now.in(trend_number.send(value['unit'].downcase.singularize.to_sym))
+          end
+          [from, to]
+        end
+      end
+
+      def datetime_from_to_for_range(column, value)
+        case value['range']
+        when 'TODAY'
+          [datetime_now.beginning_of_day, datetime_now.end_of_day]
+        when 'YESTERDAY'
+          [datetime_now.ago(1.day).beginning_of_day, datetime_now.ago(1.day).end_of_day]
+        when 'TOMORROW'
+          [datetime_now.in(1.day).beginning_of_day, datetime_now.in(1.day).end_of_day]
         else
-          ['%<search_sql>s BETWEEN ? AND ?', from_value, to_value]
+          range_type, range = value['range'].downcase.split('_')
+          raise ArgumentError unless %w[week month year].include?(range)
+          case range_type
+          when 'this'
+            return datetime_now.send("beginning_of_#{range}".to_sym), datetime_now.send("end_of_#{range}")
+          when 'prev'
+            return datetime_now.ago(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), datetime_now.ago(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
+          when 'next'
+            return datetime_now.in(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), datetime_now.in(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
+          else
+            return nil, nil
+          end
         end
       end
 
+      def datetime_column_date?(column)
+        column.column&.type == :date
+      end
+
       def condition_for_record_select_type(column, value, like_pattern = nil)
         if value.is_a?(Array)
           ['%<search_sql>s IN (?)', value]
@@ -361,9 +469,16 @@ module ActiveScaffold
     STRING_COMPARATORS = {
       :contains    => '%?%',
       :begins_with => '?%',
-      :ends_with   => '%?'
+      :ends_with   => '%?',
+      :doesnt_contain    => 'not_%?%',
+      :doesnt_begin_with => 'not_?%',
+      :doesnt_end_with   => 'not_%?'
     }.freeze
     NULL_COMPARATORS = %w[null not_null].freeze
+    DATE_COMPARATORS = %w[PAST FUTURE RANGE].freeze
+    DATE_UNITS = %w[DAYS WEEKS MONTHS YEARS].freeze
+    TIME_UNITS = %w[SECONDS MINUTES HOURS].freeze
+    DATE_RANGES = %w[TODAY YESTERDAY TOMORROW THIS_WEEK PREV_WEEK NEXT_WEEK THIS_MONTH PREV_MONTH NEXT_MONTH THIS_YEAR PREV_YEAR NEXT_YEAR].freeze
 
     def self.included(klass)
       klass.extend ClassMethods

data/lib/active_scaffold/helpers/controller_helpers.rb

@@ -25,17 +25,22 @@ module ActiveScaffold
       end
 
       def generate_temporary_id(record = nil, generated_id = nil)
-        (generated_id || (Time.now.to_f * 1000).to_i.to_s).tap do |id|
-          cache_generated_id record, id
+        unless generated_id
+          temp_id = (Time.now.to_f * 1_000_000).to_i.to_s
+          temp_id.succ! while @temporary_ids&.dig(record.class.name)&.include?(temp_id)
+          generated_id = temp_id
         end
+        cache_generated_id record, generated_id
+        generated_id
       end
 
       def cache_generated_id(record, generated_id)
-        (@temporary_ids ||= {})[record.class.name] = generated_id if record && generated_id
+        # cache all generated ids for the same class, so generate_temporary_id can check and ensure ids are unique
+        ((@temporary_ids ||= {})[record.class.name] ||= []) << generated_id if record && generated_id
       end
 
       def generated_id(record)
-        @temporary_ids[record.class.name] if record && @temporary_ids
+        @temporary_ids[record.class.name]&.last if record && @temporary_ids
       end
 
       # These params should not propagate: