activeitem 0.0.16 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6460db8a74ca7bcb5d28c0bfdb7c4a6c1eba5c5d68318245612dad78d1d1d282
-  data.tar.gz: 9fe2d9707efa0a41b74fa1c07c5c24453605baa5d24e3f1880c248c92c5a03b0
+  metadata.gz: 89a17fbb7cce2459ac2ab8c4edf9e981e12193571b273c149b3d2d74511dba9e
+  data.tar.gz: 1cb5a9301704de43df7fd601c841183bbfdb5b140bac9e2f7ff2b4e729b77f70
 SHA512:
-  metadata.gz: 61ad96dc3dd1a28bda5a9af288bd17e1eef4f11b450f08efae26c1ea8f8060819727dde8d855d562e0fbbf2e6012096e159952d44c0d22255abc2384d85d80a9
-  data.tar.gz: 741d0e3a257199f62373c16960bea2d90fe26e37e9f4dcb8516cfb049170caac8a237c90ef1ba17dde88b356218b12f7e5e7d5f4a9d96abee7f64225639762f8
+  metadata.gz: 4e7ac3bb2d79938a0aec2d860fc1cd106472e8d24b27166dc0afccaba2fac740faed88d2753e664f96f3149937e6b0209c35d316bfa84b7c020e45e601fa8ab2
+  data.tar.gz: 9c9c2bac36a241539eab5ebc44dd428d3b91b2780b18dd1660e5b3a997fc151669ea46df521b29e5636e26e6f444063a4bf49d059940bf0d03f3bc5bfeb5928c

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.0.18
+
+### Added
+
+- **Transactional saves** — `save`, `save!`, `destroy`, and `destroy!` now automatically enroll in the current transaction when called inside a `Model.transaction` block. This enables an ActiveRecord-style implicit API:
+
+  ```ruby
+  Model.transaction do
+    record1.save!
+    record2.save!
+    record3.destroy!
+  end
+  ```
+
+  All operations are committed atomically at block end. The explicit API (`txn.put(record)`) continues to work for backwards compatibility.
+
+- **RecordInvalid exception** — `save!` now raises `ActiveItem::RecordInvalid` with the record attached, instead of a generic `StandardError`. This matches ActiveRecord behavior.
+
+- **Transaction.active?** — class method to check if code is executing inside a transaction block.
+
 ## 0.0.13
 
 ### Changed

data/lib/active_item/associations.rb

@@ -143,9 +143,13 @@ module ActiveItem
                        "#{association_name.to_s.camelize}Index"
                      end
 
+        # Store partition key in DynamoDB format (camelCase) for consistency
+        # with RECENT_INDEX and explicit index definitions
+        dynamo_key = to_dynamo_key(foreign_key)
+
         @_belongs_to_indexes ||= {}
         @_belongs_to_indexes = @_belongs_to_indexes.merge(
-          index_name => { partition_key: foreign_key }
+          index_name => { partition_key: dynamo_key }
         )
       end
     end

data/lib/active_item/base.rb

@@ -349,6 +349,9 @@ module ActiveItem
     def save(validate: true)
       return false if validate && !run_validations
 
+      # If inside a transaction block, enroll this save in the transaction
+      return enroll_in_transaction if Transaction.active?
+
       result = run_callbacks :save do
         if new_record?
           run_callbacks(:create) { perform_create }
@@ -368,7 +371,9 @@ module ActiveItem
     end
 
     def save!
-      raise StandardError, "Validation failed: #{errors.full_messages.join(', ')}" unless save
+      raise RecordInvalid.new(self), "Validation failed: #{errors.full_messages.join(', ')}" unless save
+
+      true
     end
 
     def self.create(attributes = {})
@@ -383,10 +388,39 @@ module ActiveItem
       obj
     end
 
+    # Execute a block within a transaction context.
+    #
+    # Supports two usage patterns:
+    #
+    # 1. Explicit API (block receives transaction):
+    #      Model.transaction do |txn|
+    #        txn.put(record1)
+    #        txn.update(record2)
+    #      end
+    #
+    # 2. Implicit API (transactional saves):
+    #      Model.transaction do
+    #        record1.save!
+    #        record2.save!
+    #        record3.destroy!
+    #      end
+    #
+    # In the implicit API, save/destroy calls are automatically enrolled.
+    # The transaction is committed when the block completes successfully.
+    # If an exception is raised, no changes are committed (all-or-nothing).
+    #
+    # @yield [Transaction] the transaction object (optional)
+    # @raise [TransactionError] if the transaction fails
     def self.transaction
       txn = Transaction.new
-      yield txn
-      txn.execute!
+      Transaction.current = txn
+      begin
+        # Support both explicit (yield txn) and implicit (no block param) APIs
+        yield txn if block_given?
+        txn.execute!
+      ensure
+        Transaction.current = nil
+      end
     end
 
     def self.transaction_find(items)
@@ -408,6 +442,9 @@ module ActiveItem
     end
 
     def destroy
+      # If inside a transaction block, enroll this destroy in the transaction
+      return enroll_destroy_in_transaction if Transaction.active?
+
       result = run_callbacks(:destroy) { perform_destroy }
       return false if result == false
 
@@ -421,7 +458,9 @@ module ActiveItem
     end
 
     def destroy!
-      destroy || raise(RecordNotDestroyed.new(nil, self))
+      raise RecordNotDestroyed.new(nil, self) unless destroy
+
+      true
     end
 
     def delete
@@ -460,6 +499,37 @@ module ActiveItem
 
     private
 
+    # Enroll this record's save operation in the current transaction.
+    # Called when save is invoked inside a transaction block.
+    def enroll_in_transaction
+      txn = Transaction.current
+
+      result = run_callbacks :save do
+        if new_record?
+          run_callbacks(:create) { txn.put(self) }
+        else
+          run_callbacks(:update) { txn.update(self) }
+        end
+      end
+
+      return false if result == false
+
+      # Mark changes as applied (will be committed when transaction executes)
+      # Note: @new_record stays true until transaction.execute! completes
+      true
+    end
+
+    # Enroll this record's destroy operation in the current transaction.
+    # Called when destroy is invoked inside a transaction block.
+    def enroll_destroy_in_transaction
+      txn = Transaction.current
+
+      result = run_callbacks(:destroy) { txn.delete(self) }
+      return false if result == false
+
+      true
+    end
+
     def generate_primary_key
       @id = nil if @id.to_s.strip.empty?
       @id ||= SecureRandom.uuid

data/lib/active_item/errors.rb

@@ -4,6 +4,17 @@ module ActiveItem
   class RecordNotFound < StandardError; end
   class TransactionError < StandardError; end
 
+  # Raised by save! when validations fail.
+  class RecordInvalid < StandardError
+    attr_reader :record
+
+    def initialize(record = nil)
+      @record = record
+      message = record ? "Validation failed: #{record.errors.full_messages.join(', ')}" : 'Validation failed'
+      super(message)
+    end
+  end
+
   # Raised when an IAM policy denies a DynamoDB operation on a table.
   class AccessDeniedError < StandardError
     attr_reader :model_name, :table, :operation, :original_error

data/lib/active_item/relation.rb

@@ -547,8 +547,7 @@ module ActiveItem
       if effective_index && normalized_conditions.any? && normalized_conditions.values.first.is_a?(Array)
         index_config = resolved_model.indexes[effective_index] || {}
         ruby_partition_key = normalized_conditions.keys.first.to_s
-        raw_pk = index_config[:partition_key]&.to_s || ruby_partition_key
-        dynamo_partition_key = resolved_model.to_dynamo_key(raw_pk)
+        dynamo_partition_key = index_config[:partition_key]&.to_s || resolved_model.to_dynamo_key(ruby_partition_key)
         return fanout_paginated_query(effective_index, normalized_conditions, index_config, dynamo_partition_key,
                                       normalized_conditions.values.first, cursor, per_page)
       end
@@ -613,8 +612,7 @@ module ActiveItem
       partition_value = normalized_conditions.values.first
 
       index_config = resolved_model.indexes[idx_name] || {}
-      raw_pk = index_config[:partition_key]&.to_s || ruby_partition_key
-      dynamo_partition_key = resolved_model.to_dynamo_key(raw_pk)
+      dynamo_partition_key = index_config[:partition_key]&.to_s || resolved_model.to_dynamo_key(ruby_partition_key)
 
       params = {
         table_name: resolved_model.table_name,
@@ -863,8 +861,7 @@ module ActiveItem
       partition_value = normalized_conditions.values.first
 
       index_config = resolved_model.indexes[idx_name] || {}
-      raw_partition_key = index_config[:partition_key]&.to_s || ruby_partition_key
-      dynamo_partition_key = resolved_model.to_dynamo_key(raw_partition_key)
+      dynamo_partition_key = index_config[:partition_key]&.to_s || resolved_model.to_dynamo_key(ruby_partition_key)
 
       params = {
         table_name: resolved_model.table_name,
@@ -980,8 +977,7 @@ module ActiveItem
       partition_value = normalized_conditions.values.first
 
       index_config = resolved_model.indexes[idx_name] || {}
-      raw_pk = index_config[:partition_key]&.to_s || ruby_partition_key
-      dynamo_partition_key = resolved_model.to_dynamo_key(raw_pk)
+      dynamo_partition_key = index_config[:partition_key]&.to_s || resolved_model.to_dynamo_key(ruby_partition_key)
 
       params = {
         table_name: resolved_model.table_name,
@@ -1139,9 +1135,8 @@ module ActiveItem
       # Get the actual DynamoDB partition key name from the index definition
       # The index definition stores the DynamoDB key name (which may be camelCase)
       index_config = resolved_model.indexes[idx_name] || {}
-      raw_partition_key = index_config[:partition_key]&.to_s || ruby_partition_key
       # Always convert to DynamoDB key format (camelCase) for the expression
-      dynamo_partition_key = resolved_model.to_dynamo_key(raw_partition_key)
+      dynamo_partition_key = index_config[:partition_key]&.to_s || resolved_model.to_dynamo_key(ruby_partition_key)
 
       return fanout_query(idx_name, normalized_conditions, index_config, dynamo_partition_key, partition_value) if partition_value.is_a?(Array)
 

data/lib/active_item/transaction.rb

@@ -3,15 +3,49 @@
 module ActiveItem
   # Wraps DynamoDB TransactWriteItems, allowing multiple put, update, and
   # delete operations to be committed atomically (up to 100 items).
+  #
+  # Supports two usage patterns:
+  #
+  # 1. Explicit API (original):
+  #      Model.transaction do |txn|
+  #        txn.put(record1)
+  #        txn.update(record2)
+  #      end
+  #
+  # 2. Implicit API (transactional saves):
+  #      Model.transaction do
+  #        record1.save!
+  #        record2.save!
+  #        record3.destroy!
+  #      end
+  #
+  # In the implicit API, save/destroy calls inside the block are automatically
+  # enrolled in the transaction and committed atomically at block end.
   class Transaction
     MAX_ITEMS = 100
 
     attr_reader :operations
 
+    class << self
+      # Thread-local storage for the current transaction context
+      def current
+        Thread.current[:activeitem_current_transaction]
+      end
+
+      def current=(txn)
+        Thread.current[:activeitem_current_transaction] = txn
+      end
+    end
+
     def initialize
       @operations = []
     end
 
+    # Check if we're inside a transaction block
+    def self.active?
+      !current.nil?
+    end
+
     def put(record, condition: nil)
       record.instance_variable_set(:@id, SecureRandom.uuid) unless record.id
       pk = record.class.primary_key

data/lib/active_item/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeitem
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.18
 platform: ruby
 authors:
 - Andy Davis
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-04 00:00:00.000000000 Z
+date: 2026-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel