activeitem 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a08a2b03026d0380bc6232ad035c49ca911bb5ee96c8e7d55de3dd23ebc3dcba
-  data.tar.gz: 1778c6afe64631e5f40ef13b69a761109475befffdea301cb4144a5ea0abc7bb
+  metadata.gz: 8c3c7d26fc3228203838e82ee2819b5bfe3be9269429e5e4fa0f9fc0f895dca1
+  data.tar.gz: 3972d267e94e926212ecfd8dac239daa4b1043cf6a1f567da8c45fcc8ff38403
 SHA512:
-  metadata.gz: c03b044f31d8a843fd37f066a6f5ae25a406165db25541a717e547bee044f20f09f45399dc4beaa133fb696611d86ee0938d09d9e67d3cdb50616e9493005c8b
-  data.tar.gz: 024f823d6e9d76a4e7f9b9a77ac1e9212d213a549e9fc735051e7fdc2c5ac507f28c894aa9d2d209b589a772f5db534063c3e33d7f8db64cc8eefeea02b8955d
+  metadata.gz: 02ab351109c3b188a103114e8b051e8f073771aa75769ee315f05f12d4fd0162ec4584113b3e2982f59fdbc6b71bb96a7a8d58ec2e01ae256bb1fc24ee7b014e
+  data.tar.gz: d6649e5310e72e084504eca05b61253dde0eb8722149031acd1dfa1d2ba63a9191d70c10cc7f375de06cadfafd991c5b5e1204b6b17dc379159f8bf35bf1c86d

data/CHANGELOG.md

@@ -1,5 +1,41 @@
 # 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
+
+- **[Critical]** Pagination cursor validation — decoded JSON is now validated to only contain flat key/value pairs with alphanumeric keys and string/numeric values. Prevents partition traversal via crafted cursors.
+- **[Critical]** Remove arbitrary file require from `model_loader.rb` — `safe_constantize_model` now uses `safe_constantize` with class name format validation instead of requiring files from disk.
+- **[Medium]** Add jitter to exponential backoff in batch operations to prevent thundering herd.
+- **[Low]** Replace `Object.const_get` with `safe_constantize` in `composed_of` to prevent constant hierarchy traversal.
+
+### Fixed
+
+- Fix `set_created_timestamp` callback not setting `@created_at`, causing DynamoDB `Invalid attribute value type` errors on create
+- Fix duplicate `id=` method definition (Lint/DuplicateMethods) by using `attr_reader :id` with a custom setter
+- Fix duplicate `last` method definition in QueryHelpers
+- Fix duplicate branch in Relation `includes` case statement (Lint/DuplicateBranch)
+- Use `Comparable#clamp` in Pagination and Relation (Style/ComparableClamp)
+
+### Added
+
+- Documentation comments for all public modules and classes (Style/Documentation)
+- `--workdir` option to CI DynamoDB service for `act` compatibility
+
 ## 0.0.1
 
 - Initial release

data/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Andy Davis
+Copyright (c) 2026 Stowzilla Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/active_item/associations.rb

@@ -5,6 +5,9 @@ require 'active_support/inflector'
 require_relative 'model_loader'
 
 module ActiveItem
+  # Provides has_many and belongs_to association macros with lazy loading,
+  # preloading support, and dependent record handling (destroy, nullify,
+  # restrict).
   module Associations
     extend ActiveSupport::Concern
     include ModelLoader
@@ -17,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.new(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
@@ -87,9 +87,7 @@ module ActiveItem
         )
 
         foreign_key_sym = foreign_key.to_sym
-        unless method_defined?(foreign_key_sym) || private_method_defined?(foreign_key_sym)
-          attr_accessor foreign_key_sym
-        end
+        attr_accessor foreign_key_sym unless method_defined?(foreign_key_sym) || private_method_defined?(foreign_key_sym)
 
         validates foreign_key_sym, presence: true unless optional
 
@@ -98,10 +96,10 @@ module ActiveItem
         define_method("#{association_name}=") { |record| set_belongs_to_association(association_name, record) }
 
         default_foreign_key = "#{association_name}_id"
-        if foreign_key.to_s != default_foreign_key
-          define_method(default_foreign_key) { send(foreign_key) }
-          define_method("#{default_foreign_key}=") { |value| send("#{foreign_key}=", value) }
-        end
+        return unless foreign_key.to_s != default_foreign_key
+
+        define_method(default_foreign_key) { send(foreign_key) }
+        define_method("#{default_foreign_key}=") { |value| send("#{foreign_key}=", value) }
       end
     end
 
@@ -111,19 +109,17 @@ module ActiveItem
       config = self.class._associations[name]
       return Relation.new(Object, conditions: { _empty: true }) unless config
 
-      if _preloaded_associations.key?(name)
-        return Relation.new(nil, preloaded_records: _preloaded_associations[name], class_name: config[:class_name])
-      end
+      return Relation.new(nil, preloaded_records: _preloaded_associations[name], class_name: config[:class_name]) if _preloaded_associations.key?(name)
 
       local_key_value = send(config[:primary_key])
       return Relation.new(nil, conditions: { _empty: true }, class_name: config[:class_name]) if local_key_value.nil?
 
       conditions = { config[:foreign_key].to_sym => local_key_value }
       relation = Relation.new(nil, conditions: conditions, index_name: config[:index],
-                              class_name: config[:class_name], owner: self)
+                                   class_name: config[:class_name], owner: self)
 
       if config[:scope]
-        if config[:scope].arity == 0
+        if config[:scope].arity.zero?
           relation.instance_exec(&config[:scope]) || relation
         else
           config[:scope].call(relation)
@@ -149,6 +145,7 @@ module ActiveItem
         record = klass.find(foreign_key_value)
       rescue ActiveItem::RecordNotFound
         raise unless config[:optional]
+
         record = nil
       end
       instance_variable_set(cache_var, record)

data/lib/active_item/base.rb

@@ -4,18 +4,22 @@ 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'
 
 module ActiveItem
+  # Base class for all ActiveItem models. Provides persistence, callbacks,
+  # validations, dirty tracking, and an ActiveRecord-like interface for
+  # 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
@@ -26,32 +30,30 @@ module ActiveItem
     extend QueryHelpers
     extend Validations
 
-    define_callbacks :save, :create, :update, :destroy, :validation
-    define_model_callbacks :initialize, only: :after
-
-    attr_accessor :id, :created_at, :updated_at, :dbrecord
+    attr_reader :id
+    attr_accessor :created_at, :updated_at, :dbrecord
 
     def id=(value)
       @id = (value.to_s.strip.empty? ? nil : value)
     end
 
-    set_callback :create, :before, :generate_primary_key
-    set_callback :create, :before, :set_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
 
-      if attributes.is_a?(Hash)
-        attributes.each do |key, value|
-          setter = "#{key}="
-          send(setter, value) if respond_to?(setter)
-        end
+      return unless attributes.is_a?(Hash)
+
+      attributes.each do |key, value|
+        setter = "#{key}="
+        send(setter, value) if respond_to?(setter)
       end
+
+      clear_changes_information
     end
 
     def _preloaded_counts
@@ -63,9 +65,7 @@ module ActiveItem
     end
 
     def self.attribute_names
-      @attribute_names ||= begin
-        instance_methods.grep(/\A[a-z_][a-z0-9_]*=\z/).map { |m| m.to_s.chomp('=') }.sort
-      end
+      @attribute_names ||= instance_methods.grep(/\A[a-z_][a-z0-9_]*=\z/).map { |m| m.to_s.chomp('=') }.sort
     end
 
     def populate_attributes_from_item(item)
@@ -75,11 +75,11 @@ module ActiveItem
         value = nil
         found = false
         self.class.dynamo_key_variants(attr_name).each do |key|
-          if item.key?(key)
-            value = item[key]
-            found = true
-            break
-          end
+          next unless item.key?(key)
+
+          value = item[key]
+          found = true
+          break
         end
 
         instance_variable_set("@#{attr_name}", value) if found
@@ -97,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}")
-            instance_variable_set("@#{attr_name}", value)
-
-            if old_value != value && instance_variable_defined?(:@pending_changes)
-              @pending_changes ||= {}
-              @pending_changes[attr_name] ||= [old_value, nil]
-              @pending_changes[attr_name][1] = value
+            if old_value != value
+              send("#{attr_name}_will_change!") unless changed_attributes.key?(attr_name)
             end
+            instance_variable_set("@#{attr_name}", value)
           end
         end
       end
@@ -120,12 +119,12 @@ module ActiveItem
 
       def primary_key=(value)
         remove_method primary_key.to_sym
-        remove_method "#{primary_key}=".to_sym
+        remove_method :"#{primary_key}="
 
         @primary_key = value.to_s
 
         alias_method primary_key.to_sym, :id
-        alias_method "#{primary_key}=".to_sym, :id=
+        alias_method :"#{primary_key}=", :id=
       end
 
       def table_name
@@ -140,9 +139,7 @@ module ActiveItem
         @dynamodb ||= Aws::DynamoDB::Client.new(http_wire_trace: false)
       end
 
-      def dynamodb=(client)
-        @dynamodb = client
-      end
+      attr_writer :dynamodb
 
       def dynamo_attribute_map(mappings = nil)
         if mappings
@@ -155,6 +152,7 @@ module ActiveItem
       def to_dynamo_key(attr_name)
         attr_str = attr_name.to_s
         return dynamo_attribute_map[attr_str] if dynamo_attribute_map.key?(attr_str)
+
         attr_str.camelize(:lower)
       end
 
@@ -162,6 +160,7 @@ module ActiveItem
         key_str = dynamo_key.to_s
         reverse_map = dynamo_attribute_map.invert
         return reverse_map[key_str] if reverse_map.key?(key_str)
+
         key_str.underscore
       end
 
@@ -176,12 +175,12 @@ module ActiveItem
         normalized_item = normalize_dynamodb_values(item)
 
         record = allocate
-        record.instance_variable_set(:@id, normalized_item[self.primary_key])
+        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
 
@@ -208,44 +207,36 @@ module ActiveItem
         record
       end
 
-      # Callback DSL
-      def before_save(*args, &block)
+      # Callback DSL — :on option routes before_save/after_save to create/update
+      def before_save(*args, &)
         options = args.extract_options!
         if options[:on]
           case options[:on].to_sym
-          when :create then set_callback(:create, :before, *args, &block)
-          when :update then set_callback(:update, :before, *args, &block)
+          when :create then set_callback(:create, :before, *args, &)
+          when :update then set_callback(:update, :before, *args, &)
           else raise ArgumentError, "Invalid on: option '#{options[:on]}'. Must be :create or :update"
           end
         else
-          set_callback(:save, :before, *args, &block)
+          set_callback(:save, :before, *args, &)
         end
       end
 
-      def after_save(*args, &block)
+      def after_save(*args, &)
         options = args.extract_options!
         if options[:on]
           case options[:on].to_sym
-          when :create then set_callback(:create, :after, *args, &block)
-          when :update then set_callback(:update, :after, *args, &block)
+          when :create then set_callback(:create, :after, *args, &)
+          when :update then set_callback(:update, :after, *args, &)
           else raise ArgumentError, "Invalid on: option '#{options[:on]}'. Must be :create or :update"
           end
         else
-          set_callback(:save, :after, *args, &block)
+          set_callback(:save, :after, *args, &)
         end
       end
 
-      def before_create(*args, &block) = set_callback(:create, :before, *args, &block)
-      def after_create(*args, &block) = set_callback(:create, :after, *args, &block)
-      def before_update(*args, &block) = set_callback(:update, :before, *args, &block)
-      def after_update(*args, &block) = set_callback(:update, :after, *args, &block)
-      def before_validation(*args, &block) = set_callback(:validation, :before, *args, &block)
-      def after_validation(*args, &block) = set_callback(:validation, :after, *args, &block)
-      def before_destroy(*args, &block) = set_callback(:destroy, :before, *args, &block)
-      def after_destroy(*args, &block) = set_callback(:destroy, :after, *args, &block)
-
       def scope(name, body)
-        raise ArgumentError, "scope body must be callable (Proc/Lambda)" unless body.respond_to?(:call)
+        raise ArgumentError, 'scope body must be callable (Proc/Lambda)' unless body.respond_to?(:call)
+
         _scopes[name.to_sym] = body
         define_singleton_method(name) { all.instance_exec(&body) }
       end
@@ -257,7 +248,8 @@ module ActiveItem
       private
 
       def default_table_name
-        raise "Cannot generate table name for anonymous class" unless name
+        raise 'Cannot generate table name for anonymous class' unless name
+
         ActiveItem.configuration.table_name_for(name)
       end
 
@@ -265,7 +257,7 @@ module ActiveItem
         super
         subclass.class_eval do
           alias_method primary_key.to_sym, :id
-          alias_method "#{primary_key}=".to_sym, :id=
+          alias_method :"#{primary_key}=", :id=
         end
       end
     end
@@ -279,12 +271,14 @@ module ActiveItem
     end
 
     def reload
-      raise "Cannot reload a new record" if new_record?
+      raise 'Cannot reload a new record' if new_record?
+
       fresh_record = self.class.find(id)
       raise "Record not found: #{self.class.name} with id #{id}" unless fresh_record
 
       self.class.attribute_names.each do |attr_name|
         next if attr_name == 'dbrecord'
+
         value = fresh_record.instance_variable_get("@#{attr_name}")
         instance_variable_set("@#{attr_name}", value)
       end
@@ -292,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
@@ -308,12 +301,17 @@ module ActiveItem
     def attributes
       attrs = {}
       pk_name = self.class.primary_key
-      pk_value = send(pk_name) rescue instance_variable_get("@#{pk_name}")
+      pk_value = begin
+        send(pk_name)
+      rescue StandardError
+        instance_variable_get("@#{pk_name}")
+      end
       attrs['id'] = pk_value
       attrs[pk_name] = pk_value
 
       self.class.attribute_names.each do |attr_name|
         next if attr_name == 'dbrecord'
+
         value = instance_variable_get("@#{attr_name}")
         attrs[attr_name] = value unless value.nil?
       end
@@ -324,11 +322,17 @@ module ActiveItem
     end
 
     def inspect
-      pk_value = send(self.class.primary_key) rescue id
+      begin
+        send(self.class.primary_key)
+      rescue StandardError
+        id
+      end
       attr_strs = self.class.attribute_names.filter_map do |attr|
         next if attr == 'dbrecord'
+
         value = instance_variable_get("@#{attr}")
         next if value.nil?
+
         "#{attr}: #{value.inspect}"
       end
       "#<#{self.class.name} #{attr_strs.join(', ')}>"
@@ -356,9 +360,11 @@ module ActiveItem
       end
 
       return false if result == false
+
       changes_applied
+      @new_record = false
       true
-    rescue => e
+    rescue StandardError => e
       dynamo_logger.error("Failed to save #{self.class.name}: #{e.message}")
       raise e
     end
@@ -406,10 +412,11 @@ module ActiveItem
     def destroy
       result = run_callbacks(:destroy) { perform_destroy }
       return false if result == false
+
       true
     rescue DeleteRestrictionError
       false
-    rescue => e
+    rescue StandardError => e
       dynamo_logger.error("Failed to destroy #{self.class.name}: #{e.message}")
       errors.add(:base, e.message)
       false
@@ -418,7 +425,7 @@ module ActiveItem
     def delete
       perform_destroy
       true
-    rescue => e
+    rescue StandardError => e
       dynamo_logger.error("Failed to delete #{self.class.name}: #{e.message}")
       false
     end
@@ -426,38 +433,20 @@ module ActiveItem
     def assign_attributes(attributes)
       attributes.each do |key, value|
         setter = "#{key}="
-        if respond_to?(setter)
-          old_value = send(key)
-          @pending_changes[key.to_s] = [old_value, value] if old_value != value
-          send(setter, value)
-        end
+        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)
-      return super(context) if defined?(@running_validations) && @running_validations
+      return super if defined?(@running_validations) && @running_validations
 
       @running_validations = true
       begin
@@ -477,8 +466,8 @@ module ActiveItem
       instance_variable_set("@#{pk}", @id) if pk != 'id'
     end
 
-    def set_created_timestamp
-      @created_at ||= Time.now.utc.iso8601
+    def assign_created_timestamp
+      @created_at ||= Time.now.utc.iso8601 # rubocop:disable Naming/MemoizedInstanceVariableName
     end
 
     def dynamodb
@@ -508,11 +497,11 @@ module ActiveItem
 
       dynamo_logger.info("#{self.class.name} created (#{self.class.primary_key}: #{id})")
     rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException
-      errors.add(:id, "already exists")
+      errors.add(:id, 'already exists')
       false
     rescue Aws::DynamoDB::Errors::AccessDeniedException => e
       raise ActiveItem::AccessDeniedError.new(model_name: self.class.name, table: table_name,
-                                                operation: 'PutItem', original_error: e)
+                                              operation: 'PutItem', original_error: e)
     end
 
     def build_dynamodb_item
@@ -521,6 +510,7 @@ module ActiveItem
       dynamodb_attributes.each do |attr|
         value = instance_variable_get("@#{attr}")
         next if value.nil?
+
         dynamo_key = self.class.to_dynamo_key(attr)
         item[dynamo_key] = value
       end
@@ -559,7 +549,7 @@ module ActiveItem
         end
       end
 
-      update_parts << "updatedAt = :updatedAt"
+      update_parts << 'updatedAt = :updatedAt'
       attr_values[':updatedAt'] = Time.now.utc.iso8601
 
       update_expression = "SET #{update_parts.join(', ')}"
@@ -576,7 +566,7 @@ module ActiveItem
       dynamodb.update_item(params)
     rescue Aws::DynamoDB::Errors::AccessDeniedException => e
       raise ActiveItem::AccessDeniedError.new(model_name: self.class.name, table: table_name,
-                                                operation: 'UpdateItem', original_error: e)
+                                              operation: 'UpdateItem', original_error: e)
     end
 
     def perform_destroy
@@ -585,7 +575,7 @@ module ActiveItem
       dynamo_logger.info("#{self.class.name} deleted (#{key}: #{send(key)})")
     rescue Aws::DynamoDB::Errors::AccessDeniedException => e
       raise ActiveItem::AccessDeniedError.new(model_name: self.class.name, table: table_name,
-                                                operation: 'DeleteItem', original_error: e)
+                                              operation: 'DeleteItem', original_error: e)
     end
   end
 end