activeitem 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11aa0780a8b4e5d41d3010603fff7f4e86f2dd6226e443d1c969d461f115d9a5
-  data.tar.gz: fa289cbbd0677836e4933cb57392ca7027821e12df1f3eb1cacd8fb87b130ddc
+  metadata.gz: 8c3c7d26fc3228203838e82ee2819b5bfe3be9269429e5e4fa0f9fc0f895dca1
+  data.tar.gz: 3972d267e94e926212ecfd8dac239daa4b1043cf6a1f567da8c45fcc8ff38403
 SHA512:
-  metadata.gz: 8f04eda18abbbf4bf4ab2aae97ff933406dad0692157acb3a3d22b8ca2b4caec99c750489c719f194ddda05e07ee42a310a3bc387ae173364a696809cea87546
-  data.tar.gz: 48b5015fc97d6137b33ca2b3b92c308f3e9f993d8a6c083bc0255fbac5af6da5c9bba9998801450da6192e2c8b2d4d35c1e67f3ead284d1c8608e745c2be2bc8
+  metadata.gz: 02ab351109c3b188a103114e8b051e8f073771aa75769ee315f05f12d4fd0162ec4584113b3e2982f59fdbc6b71bb96a7a8d58ec2e01ae256bb1fc24ee7b014e
+  data.tar.gz: d6649e5310e72e084504eca05b61253dde0eb8722149031acd1dfa1d2ba63a9191d70c10cc7f375de06cadfafd991c5b5e1204b6b17dc379159f8bf35bf1c86d

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.0.3
+
+### Changed
+
+- Replace custom `validates_length_of`, `validates_numericality_of`, `validates_format_of` with ActiveModel built-ins
+- Replace hand-rolled dirty tracking (`@pending_changes`/`@previously_changed`) with `ActiveModel::Dirty`
+- Replace manual `ActiveSupport::Callbacks` DSL with `ActiveModel::Callbacks` + `define_model_callbacks`
+
+### Improved
+
+- Add `limit` to `UniquenessValidator` queries (limit 2 when excluding self, `.first` for new records)
+- `execute_count_query` now respects `limit_value` and short-circuits pagination
+- `check_dependent_associations` uses `limit(1).any?` for restrict checks
+
 ## 0.0.2
 
 ### Security

data/lib/active_item/associations.rb

@@ -20,25 +20,22 @@ module ActiveItem
       self.class._associations.each do |name, config|
         next unless config[:type] == :has_many && config[:dependent]
 
-        associated_records = send(name)
-        has_records = associated_records.respond_to?(:any?) ? associated_records.any? : false
-
-        next unless has_records
-
         case config[:dependent]
         when :restrict_with_exception
-          raise DeleteRestrictionError, name
+          raise DeleteRestrictionError, name if send(name).limit(1).any?
         when :restrict_with_error
-          error_message = config[:message] || "Cannot delete #{self.class.name} because dependent #{name} exist"
-          errors.add(:base, error_message)
-          throw(:abort)
+          if send(name).limit(1).any?
+            error_message = config[:message] || "Cannot delete #{self.class.name} because dependent #{name} exist"
+            errors.add(:base, error_message)
+            throw(:abort)
+          end
         when :destroy
-          associated_records.each(&:destroy)
+          send(name).each(&:destroy)
         when :delete_all
-          associated_records.each(&:delete)
+          send(name).each(&:delete)
         when :nullify
           foreign_key = config[:foreign_key]
-          associated_records.each { |record| record.update(foreign_key => nil) }
+          send(name).each { |record| record.update(foreign_key => nil) }
         end
       end
     end

data/lib/active_item/base.rb

@@ -4,8 +4,6 @@ require 'aws-sdk-dynamodb'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/array/extract_options'
-require 'active_support/callbacks'
-require 'active_support/concern'
 require 'active_model'
 require 'securerandom'
 
@@ -15,10 +13,13 @@ module ActiveItem
   # DynamoDB tables.
   class Base
     include ActiveModel::Validations
-    include ActiveSupport::Callbacks
+    include ActiveModel::Dirty
+    extend ActiveModel::Callbacks
     include Associations
     include Logging
 
+    define_model_callbacks :save, :create, :update, :destroy, :initialize, :validation
+
     def self.const_missing(name)
       ActiveItem.const_defined?(name) ? ActiveItem.const_get(name) : super
     end
@@ -29,9 +30,6 @@ module ActiveItem
     extend QueryHelpers
     extend Validations
 
-    define_callbacks :save, :create, :update, :destroy, :validation
-    define_model_callbacks :initialize, only: :after
-
     attr_reader :id
     attr_accessor :created_at, :updated_at, :dbrecord
 
@@ -39,13 +37,11 @@ module ActiveItem
       @id = (value.to_s.strip.empty? ? nil : value)
     end
 
-    set_callback :create, :before, :generate_primary_key
-    set_callback :create, :before, :assign_created_timestamp
-    set_callback :destroy, :before, :check_dependent_associations
+    before_create :generate_primary_key
+    before_create :assign_created_timestamp
+    before_destroy :check_dependent_associations
 
     def initialize(attributes = {})
-      @previously_changed = {}
-      @pending_changes = {}
       @_preloaded_counts = {}
       @_preloaded_associations = {}
       @new_record = true
@@ -56,6 +52,8 @@ module ActiveItem
         setter = "#{key}="
         send(setter, value) if respond_to?(setter)
       end
+
+      clear_changes_information
     end
 
     def _preloaded_counts
@@ -99,19 +97,18 @@ module ActiveItem
         attrs.each do |attr|
           attr_name = attr.to_s
 
+          define_attribute_methods attr_name
+
           define_method(attr_name) do
             instance_variable_get("@#{attr_name}")
           end
 
           define_method("#{attr_name}=") do |value|
             old_value = instance_variable_get("@#{attr_name}")
+            if old_value != value
+              send("#{attr_name}_will_change!") unless changed_attributes.key?(attr_name)
+            end
             instance_variable_set("@#{attr_name}", value)
-
-            return unless old_value != value && instance_variable_defined?(:@pending_changes)
-
-            @pending_changes ||= {}
-            @pending_changes[attr_name] ||= [old_value, nil]
-            @pending_changes[attr_name][1] = value
           end
         end
       end
@@ -181,9 +178,9 @@ module ActiveItem
         record.instance_variable_set(:@id, normalized_item[primary_key])
         record.send(:populate_attributes_from_item, normalized_item)
         record.instance_variable_set(:@new_record, false)
-        record.instance_variable_set(:@previously_changed, {})
-        record.instance_variable_set(:@pending_changes, {})
+        record.instance_variable_set(:@mutations_from_database, nil)
         record.instance_variable_set(:@dbrecord, normalized_item)
+        record.send(:clear_changes_information)
         record
       end
 
@@ -210,7 +207,7 @@ module ActiveItem
         record
       end
 
-      # Callback DSL
+      # Callback DSL — :on option routes before_save/after_save to create/update
       def before_save(*args, &)
         options = args.extract_options!
         if options[:on]
@@ -237,15 +234,6 @@ module ActiveItem
         end
       end
 
-      def before_create(...) = set_callback(:create, :before, ...)
-      def after_create(...) = set_callback(:create, :after, ...)
-      def before_update(...) = set_callback(:update, :before, ...)
-      def after_update(...) = set_callback(:update, :after, ...)
-      def before_validation(...) = set_callback(:validation, :before, ...)
-      def after_validation(...) = set_callback(:validation, :after, ...)
-      def before_destroy(...) = set_callback(:destroy, :before, ...)
-      def after_destroy(...) = set_callback(:destroy, :after, ...)
-
       def scope(name, body)
         raise ArgumentError, 'scope body must be callable (Proc/Lambda)' unless body.respond_to?(:call)
 
@@ -298,13 +286,12 @@ module ActiveItem
       @created_at = fresh_record.created_at
       @updated_at = fresh_record.updated_at
       @dbrecord = fresh_record.dbrecord
-      @pending_changes = {}
-      @previously_changed = {}
+      clear_changes_information
       self
     end
 
     def has_changes_to_save?
-      changes.any?
+      changed?
     end
 
     def to_h
@@ -375,6 +362,7 @@ module ActiveItem
       return false if result == false
 
       changes_applied
+      @new_record = false
       true
     rescue StandardError => e
       dynamo_logger.error("Failed to save #{self.class.name}: #{e.message}")
@@ -445,34 +433,16 @@ module ActiveItem
     def assign_attributes(attributes)
       attributes.each do |key, value|
         setter = "#{key}="
-        next unless respond_to?(setter)
-
-        old_value = send(key)
-        @pending_changes[key.to_s] = [old_value, value] if old_value != value
-        send(setter, value)
+        send(setter, value) if respond_to?(setter)
       end
     end
 
     def attribute_changed?(attr_name)
-      @pending_changes.key?(attr_name.to_s)
+      super(attr_name.to_s)
     end
 
     def attribute_was(attr_name)
-      @pending_changes.dig(attr_name.to_s, 0)
-    end
-
-    def changes
-      @pending_changes
-    end
-
-    def previous_changes
-      @previously_changed
-    end
-
-    def changes_applied
-      @previously_changed = @pending_changes.dup
-      @pending_changes = {}
-      @new_record = false
+      attribute_in_database(attr_name.to_s)
     end
 
     def valid?(context = nil)

data/lib/active_item/relation.rb

@@ -765,6 +765,7 @@ module ActiveItem
                    build_count_scan_params(normalized_conditions)
                  end
         params[:exclusive_start_key] = exclusive_start_key if exclusive_start_key
+        params[:limit] = limit_value if limit_value
 
         response = if effective_index && normalized_conditions.any?
                      resolved_model.dynamodb.query(params)
@@ -775,9 +776,10 @@ module ActiveItem
         total += response.count
         exclusive_start_key = response.last_evaluated_key
         break unless exclusive_start_key
+        break if limit_value && total >= limit_value
       end
 
-      total
+      limit_value ? [total, limit_value].min : total
     rescue Aws::DynamoDB::Errors::AccessDeniedException => e
       raise ActiveItem::AccessDeniedError.new(model_name: resolved_model.name, table: resolved_model.table_name,
                                               operation: 'Count', original_error: e)

data/lib/active_item/validations.rb

@@ -16,72 +16,32 @@ module ActiveItem
         end
       end
 
-      existing = record.class.where(**conditions)
-      existing = existing.reject { |r| r.id == record.id } if record.id
-      existing = existing.select { |r| options[:conditions].call(r) } if options[:conditions]
+      relation = record.class.where(**conditions)
+
+      if options[:conditions]
+        # Custom conditions require loading records for Ruby-side filtering
+        existing = relation.to_a
+        existing = existing.reject { |r| r.id == record.id } if record.id
+        existing = existing.select { |r| options[:conditions].call(r) }
+        taken = existing.any?
+      elsif record.id
+        # Need to exclude current record — fetch up to 2 (current + one other)
+        existing = relation.limit(2).to_a
+        taken = existing.any? { |r| r.id != record.id }
+      else
+        # New record — just check if any match exists
+        taken = !relation.first.nil?
+      end
 
-      record.errors.add(attribute, options[:message] || 'has already been taken') if existing.any?
+      record.errors.add(attribute, options[:message] || 'has already been taken') if taken
     end
   end
 
-  # Convenience validation macros (uniqueness, length, numericality, format)
-  # that extend ActiveModel::Validations for DynamoDB-backed models.
+  # Convenience validation macro for uniqueness (DynamoDB-specific).
+  # Length, numericality, and format validations are provided by ActiveModel.
   module Validations
     def validates_uniqueness_of(*attributes, **options)
       validates(*attributes, uniqueness: options.empty? || options)
     end
-
-    def validates_length_of(*attributes, **options)
-      attributes.each do |attribute|
-        validate do
-          value = send(attribute)
-          next if value.nil?
-
-          length = value.to_s.length
-
-          errors.add(attribute, options[:message] || "is too short (minimum is #{options[:minimum]} characters)") if options[:minimum] && length < options[:minimum]
-          errors.add(attribute, options[:message] || "is too long (maximum is #{options[:maximum]} characters)") if options[:maximum] && length > options[:maximum]
-          if options[:in] && !options[:in].include?(length)
-            errors.add(attribute, options[:message] || "length must be between #{options[:in].min} and #{options[:in].max} characters")
-          end
-          errors.add(attribute, options[:message] || "must be exactly #{options[:is]} characters") if options[:is] && length != options[:is]
-        end
-      end
-    end
-
-    def validates_numericality_of(*attributes, **options)
-      attributes.each do |attribute|
-        validate do
-          value = send(attribute)
-          next if value.nil?
-
-          unless value.is_a?(Numeric) || value.to_s.match?(/\A-?\d+(\.\d+)?\z/)
-            errors.add(attribute, options[:message] || 'is not a number')
-            next
-          end
-
-          num_value = value.to_f
-
-          if options[:only_integer] && num_value != num_value.to_i
-            errors.add(attribute, options[:message] || 'must be an integer')
-            next
-          end
-
-          errors.add(attribute, options[:message] || "must be greater than #{options[:greater_than]}") if options[:greater_than] && num_value <= options[:greater_than]
-          if options[:greater_than_or_equal_to] && num_value < options[:greater_than_or_equal_to]
-            errors.add(attribute, options[:message] || "must be greater than or equal to #{options[:greater_than_or_equal_to]}")
-          end
-          errors.add(attribute, options[:message] || "must be less than #{options[:less_than]}") if options[:less_than] && num_value >= options[:less_than]
-          if options[:less_than_or_equal_to] && num_value > options[:less_than_or_equal_to]
-            errors.add(attribute, options[:message] || "must be less than or equal to #{options[:less_than_or_equal_to]}")
-          end
-          errors.add(attribute, options[:message] || "must be equal to #{options[:equal_to]}") if options[:equal_to] && num_value != options[:equal_to]
-        end
-      end
-    end
-
-    def validates_format_of(*attributes, **options)
-      attributes.each { |attribute| validates attribute, format: options }
-    end
   end
 end

data/lib/active_item/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveItem
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeitem
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Andy Davis
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-22 00:00:00.000000000 Z
+date: 2026-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -73,14 +73,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement