dynamoid 3.13.0 → 3.14.0

data/lib/dynamoid/transaction_read.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-require 'dynamoid/transaction_read/find'
-
-module Dynamoid
-  # The class +TransactionRead+ provides means to perform multiple reading
-  # operations in transaction, that is atomically, so that either all of them
-  # succeed, or all of them fail.
-  #
-  # The reading methods are supposed to be as close as possible to their
-  # non-transactional counterparts:
-  #
-  #   user_id = params[:user_id]
-  #   payment = params[:payment_id]
-  #
-  #   models = Dynamoid::TransactionRead.execute do |t|
-  #     t.find User, user_id
-  #     t.find Payment, payment_id
-  #   end
-  #
-  # The only difference is that the methods are called on a transaction
-  # instance and a model or a model class should be specified. So +User.find+
-  # becomes +t.find(user_id)+ and +Payment.find(payment_id)+ becomes +t.find
-  # Payment, payment_id+.
-  #
-  # A transaction can be used without a block. This way a transaction instance
-  # should be instantiated and committed manually with +#commit+ method:
-  #
-  #   t = Dynamoid::TransactionRead.new
-  #
-  #   t.find user_id
-  #   t.find payment_id
-  #
-  #   models = t.commit
-  #
-  #
-  # ### DynamoDB's transactions
-  #
-  # The main difference between DynamoDB transactions and a common interface is
-  # that DynamoDB's transactions are executed in batch. So in Dynamoid no
-  # data actually loaded when some transactional method (e.g+ `#find+) is
-  # called. All the changes are loaded at the end.
-  #
-  # A +TransactGetItems+ DynamoDB operation is used (see
-  # [documentation](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html)
-  # for details).
-  class TransactionRead
-    def self.execute
-      transaction = new
-
-      begin
-        yield transaction
-        transaction.commit
-      end
-    end
-
-    def initialize
-      @actions = []
-    end
-
-    # Load all the models.
-    #
-    #   transaction = Dynamoid::TransactionRead.new
-    #   # ...
-    #   transaction.commit
-    def commit
-      return [] if @actions.empty?
-
-      # some actions may produce multiple requests
-      action_request_groups = @actions.map(&:action_request).map do |action_request|
-        action_request.is_a?(Array) ? action_request : [action_request]
-      end
-      action_requests = action_request_groups.flatten(1)
-
-      return [] if action_requests.empty?
-
-      response = Dynamoid.adapter.transact_read_items(action_requests)
-
-      responses = response.responses.dup
-      @actions.zip(action_request_groups).map do |action, action_requests|
-        action_responses = responses.shift(action_requests.size)
-        action.process_responses(action_responses)
-      end.flatten
-    end
-
-    # Find one or many objects, specified by one id or an array of ids.
-    #
-    # By default it raises +RecordNotFound+ exception if at least one model
-    # isn't found. This behavior can be changed with +raise_error+ option. If
-    # specified +raise_error: false+ option then +find+ will not raise the
-    # exception.
-    #
-    # When a document schema includes range key it should always be specified
-    # in +find+ method call. In case it's missing +MissingRangeKey+ exception
-    # will be raised.
-    #
-    # Please note that there are the following differences between
-    # transactional and non-transactional +find+:
-    # - transactional +find+ preserves order of models in result when given multiple ids
-    # - transactional +find+ doesn't return results immediately, a single
-    #   collection with results of all the +find+ calls is returned instead
-    # - +:consistent_read+ option isn't supported
-    # - transactional +find+ is subject to limitations of the
-    #   [TransactGetItems](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html)
-    #   DynamoDB operation, e.g. the whole read transaction can load only up to 100 models.
-    #
-    # @param [Object|Array] ids a single primary key or an array of primary keys
-    # @param [Hash] options optional parameters of the operation
-    # @option options [Object] :range_key sort key of a model; required when a single partition key is given and a sort key is declared for a model
-    # @option options [true|false] :raise_error whether to raise a +RecordNotFound+ exception; specify explicitly +raise_error: false+ to suppress the exception; default is +true+
-    # @return [nil]
-    #
-    # @example Find by partition key
-    #   Dynamoid::TransactionRead.execute do |t|
-    #     t.find Document, 101
-    #   end
-    #
-    # @example Find by partition key and sort key
-    #   Dynamoid::TransactionRead.execute do |t|
-    #     t.find Document, 101, range_key: 'archived'
-    #   end
-    #
-    # @example Find several documents by partition key
-    #   Dynamoid::TransactionRead.execute do |t|
-    #     t.find Document, 101, 102, 103
-    #     t.find Document, [101, 102, 103]
-    #   end
-    #
-    # @example Find several documents by partition key and sort key
-    #   Dynamoid::TransactionRead.execute do |t|
-    #     t.find Document, [[101, 'archived'], [102, 'new'], [103, 'deleted']]
-    #   end
-    def find(model_class, *ids, **options)
-      action = Dynamoid::TransactionRead::Find.new(model_class, *ids, **options)
-      register_action action
-    end
-
-    private
-
-    def register_action(action)
-      @actions << action
-      action.on_registration
-      action.observable_by_user_result
-    end
-  end
-end

data/lib/dynamoid/transaction_write/base.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Dynamoid
-  class TransactionWrite
-    class Base
-      # Callback called at "initialization" or "registration" an action
-      # before changes are persisted. It's a proper place to validate
-      # a model or run callbacks
-      def on_registration
-        raise 'Not implemented'
-      end
-
-      # Callback called after changes are persisted.
-      # It's a proper place to mark changes in a model as applied.
-      def on_commit
-        raise 'Not implemented'
-      end
-
-      # Callback called when a transaction is rolled back.
-      # It's a proper place to undo changes made in after_... callbacks.
-      def on_rollback
-        raise 'Not implemented'
-      end
-
-      # Whether some callback aborted or canceled an action
-      def aborted?
-        raise 'Not implemented'
-      end
-
-      # Whether there are changes to persist, e.g. updating a model with no
-      # attribute changed is skipped.
-      def skipped?
-        raise 'Not implemented'
-      end
-
-      # Value returned to a user as an action result
-      def observable_by_user_result
-        raise 'Not implemented'
-      end
-
-      # Coresponding part of a final request body
-      def action_request
-        raise 'Not implemented'
-      end
-
-      # copied from aws_sdk_v3
-      def sanitize_item(attributes)
-        config_value = Dynamoid.config.store_attribute_with_nil_value
-        store_attribute_with_nil_value = config_value.nil? ? false : !!config_value
-
-        attributes.reject do |_, v|
-          !store_attribute_with_nil_value && v.nil?
-        end.transform_values do |v|
-          v.is_a?(Hash) ? v.stringify_keys : v
-        end
-      end
-    end
-  end
-end

data/lib/dynamoid/transaction_write/create.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module Dynamoid
-  class TransactionWrite
-    class Create < Base
-      def initialize(model_class, attributes = {}, **options, &block)
-        super()
-
-        @model = model_class.new(attributes)
-
-        if block
-          yield(@model)
-        end
-
-        @save_action = Save.new(@model, **options)
-      end
-
-      def on_registration
-        @save_action.on_registration
-      end
-
-      def on_commit
-        @save_action.on_commit
-      end
-
-      def on_rollback
-        @save_action.on_rollback
-      end
-
-      def aborted?
-        @save_action.aborted?
-      end
-
-      def skipped?
-        false
-      end
-
-      def observable_by_user_result
-        @model
-      end
-
-      def action_request
-        @save_action.action_request
-      end
-    end
-  end
-end

data/lib/dynamoid/transaction_write/delete_with_instance.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module Dynamoid
-  class TransactionWrite
-    class DeleteWithInstance < Base
-      def initialize(model)
-        super()
-
-        @model = model
-        @model_class = model.class
-      end
-
-      def on_registration
-        validate_model!
-      end
-
-      def on_commit
-        @model.destroyed = true
-      end
-
-      def on_rollback; end
-
-      def aborted?
-        false
-      end
-
-      def skipped?
-        false
-      end
-
-      def observable_by_user_result
-        @model
-      end
-
-      def action_request
-        key = { @model_class.hash_key => dump_attribute(@model_class.hash_key, @model.hash_key) }
-
-        if @model_class.range_key?
-          key[@model_class.range_key] = dump_attribute(@model_class.range_key, @model.range_value)
-        end
-
-        {
-          delete: {
-            key: key,
-            table_name: @model_class.table_name
-          }
-        }
-      end
-
-      private
-
-      def validate_model!
-        raise Dynamoid::Errors::MissingHashKey if @model.hash_key.nil?
-        raise Dynamoid::Errors::MissingRangeKey if @model_class.range_key? && @model.range_value.nil?
-      end
-
-      def dump_attribute(name, value)
-        options = @model_class.attributes[name]
-        Dumping.dump_field(value, options)
-      end
-    end
-  end
-end

data/lib/dynamoid/transaction_write/delete_with_primary_key.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module Dynamoid
-  class TransactionWrite
-    class DeleteWithPrimaryKey < Base
-      def initialize(model_class, hash_key, range_key)
-        super()
-
-        @model_class = model_class
-        @hash_key = hash_key
-        @range_key = range_key
-      end
-
-      def on_registration
-        validate_primary_key!
-      end
-
-      def on_commit; end
-
-      def on_rollback; end
-
-      def aborted?
-        false
-      end
-
-      def skipped?
-        false
-      end
-
-      def observable_by_user_result
-        nil
-      end
-
-      def action_request
-        key = { @model_class.hash_key => dump_attribute(@model_class.hash_key, @hash_key) }
-
-        if @model_class.range_key?
-          key[@model_class.range_key] = dump_attribute(@model_class.range_key, @range_key)
-        end
-
-        {
-          delete: {
-            key: key,
-            table_name: @model_class.table_name
-          }
-        }
-      end
-
-      private
-
-      def validate_primary_key!
-        raise Dynamoid::Errors::MissingHashKey if @hash_key.nil?
-        raise Dynamoid::Errors::MissingRangeKey if @model_class.range_key? && @range_key.nil?
-      end
-
-      def dump_attribute(name, value)
-        options = @model_class.attributes[name]
-        Dumping.dump_field(value, options)
-      end
-    end
-  end
-end

data/lib/dynamoid/transaction_write/destroy.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module Dynamoid
-  class TransactionWrite
-    class Destroy < Base
-      def initialize(model, **options)
-        super()
-
-        @model = model
-        @options = options
-        @model_class = model.class
-        @aborted = false
-      end
-
-      def on_registration
-        @aborted = true
-        @model.run_callbacks(:destroy) do
-          validate_primary_key!
-
-          @aborted = false
-          true
-        end
-
-        if @aborted && @options[:raise_error]
-          raise Dynamoid::Errors::RecordNotDestroyed, @model
-        end
-      end
-
-      def on_commit
-        return if @aborted
-
-        @model.destroyed = true
-        @model.run_callbacks(:commit)
-      end
-
-      def on_rollback
-        @model.run_callbacks(:rollback)
-      end
-
-      def aborted?
-        @aborted
-      end
-
-      def skipped?
-        false
-      end
-
-      def observable_by_user_result
-        return false if @aborted
-
-        @model
-      end
-
-      def action_request
-        key = { @model_class.hash_key => dump_attribute(@model_class.hash_key, @model.hash_key) }
-
-        if @model_class.range_key?
-          key[@model_class.range_key] = dump_attribute(@model_class.range_key, @model.range_value)
-        end
-
-        {
-          delete: {
-            key: key,
-            table_name: @model_class.table_name
-          }
-        }
-      end
-
-      private
-
-      def validate_primary_key!
-        raise Dynamoid::Errors::MissingHashKey if @model.hash_key.nil?
-        raise Dynamoid::Errors::MissingRangeKey if @model_class.range_key? && @model.range_value.nil?
-      end
-
-      def dump_attribute(name, value)
-        options = @model_class.attributes[name]
-        Dumping.dump_field(value, options)
-      end
-    end
-  end
-end

data/lib/dynamoid/transaction_write/item_updater.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Dynamoid
-  class TransactionWrite
-    class ItemUpdater
-      attr_reader :attributes_to_set, :attributes_to_add, :attributes_to_delete, :attributes_to_remove
-
-      def initialize(model_class)
-        @model_class = model_class
-
-        @attributes_to_set = {}
-        @attributes_to_add = {}
-        @attributes_to_delete = {}
-        @attributes_to_remove = []
-      end
-
-      def empty?
-        [@attributes_to_set, @attributes_to_add, @attributes_to_delete, @attributes_to_remove].all?(&:empty?)
-      end
-
-      def set(attributes)
-        validate_attribute_names!(attributes.keys)
-        if Dynamoid.config.store_attribute_with_nil_value
-          @attributes_to_set.merge!(attributes)
-        else
-          @attributes_to_set.merge!(attributes.reject { |_, v| v.nil? })
-          @attributes_to_remove += attributes.select { |_, v| v.nil? }.keys
-        end
-      end
-
-      # adds to array of fields for use in REMOVE update expression
-      def remove(*names)
-        validate_attribute_names!(names)
-        @attributes_to_remove += names
-      end
-
-      # increments a number or adds to a set, starts at 0 or [] if it doesn't yet exist
-      def add(attributes)
-        validate_attribute_names!(attributes.keys)
-        @attributes_to_add.merge!(attributes)
-      end
-
-      # deletes a value or values from a set
-      def delete(attributes)
-        validate_attribute_names!(attributes.keys)
-        @attributes_to_delete.merge!(attributes)
-      end
-
-      private
-
-      def validate_attribute_names!(names)
-        names.each do |name|
-          unless @model_class.attributes[name]
-            raise Dynamoid::Errors::UnknownAttribute.new(@model_class, name)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/dynamoid/transaction_write/save.rb

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module Dynamoid
-  class TransactionWrite
-    class Save < Base
-      def initialize(model, **options)
-        super()
-
-        @model = model
-        @model_class = model.class
-        @options = options
-
-        @aborted = false
-        @was_new_record = model.new_record?
-        @valid = nil
-      end
-
-      def on_registration
-        if @options[:validate] != false && !(@valid = @model.valid?)
-          if @options[:raise_error]
-            raise Dynamoid::Errors::DocumentNotValid, @model
-          else
-            @aborted = true
-            return
-          end
-        end
-
-        @aborted = true
-        callback_name = @was_new_record ? :create : :update
-
-        @model.run_callbacks(:save) do
-          @model.run_callbacks(callback_name) do
-            @model.run_callbacks(:validate) do
-              validate_primary_key!
-
-              @aborted = false
-              true
-            end
-          end
-        end
-
-        if @aborted && @options[:raise_error]
-          raise Dynamoid::Errors::RecordNotSaved, @model
-        end
-
-        if @was_new_record && @model.hash_key.nil?
-          @model.hash_key = SecureRandom.uuid
-        end
-      end
-
-      def on_commit
-        return if @aborted
-
-        @model.changes_applied
-
-        if @was_new_record
-          @model.new_record = false
-        end
-
-        @model.run_callbacks(:commit)
-      end
-
-      def on_rollback
-        @model.run_callbacks(:rollback)
-      end
-
-      def aborted?
-        @aborted
-      end
-
-      def skipped?
-        @model.persisted? && !@model.changed?
-      end
-
-      def observable_by_user_result
-        !@aborted
-      end
-
-      def action_request
-        if @was_new_record
-          action_request_to_create
-        else
-          action_request_to_update
-        end
-      end
-
-      private
-
-      def validate_primary_key!
-        raise Dynamoid::Errors::MissingHashKey if !@was_new_record && @model.hash_key.nil?
-        raise Dynamoid::Errors::MissingRangeKey if @model_class.range_key? && @model.range_value.nil?
-      end
-
-      def action_request_to_create
-        touch_model_timestamps(skip_created_at: false)
-
-        attributes_dumped = Dynamoid::Dumping.dump_attributes(@model.attributes, @model_class.attributes)
-        attributes_dumped = sanitize_item(attributes_dumped)
-
-        # require primary key not to exist yet
-        condition = "attribute_not_exists(#{@model_class.hash_key})"
-        if @model_class.range_key?
-          condition += " AND attribute_not_exists(#{@model_class.range_key})"
-        end
-
-        {
-          put: {
-            item: attributes_dumped,
-            table_name: @model_class.table_name,
-            condition_expression: condition
-          }
-        }
-      end
-
-      def action_request_to_update
-        touch_model_timestamps(skip_created_at: true)
-
-        # changed attributes to persist
-        changes = @model.attributes.slice(*@model.changed.map(&:to_sym))
-        changes_dumped = Dynamoid::Dumping.dump_attributes(changes, @model_class.attributes)
-
-        # primary key to look up an item to update
-        key = { @model_class.hash_key => dump_attribute(@model_class.hash_key, @model.hash_key) }
-        key[@model_class.range_key] = dump_attribute(@model_class.range_key, @model.range_value) if @model_class.range_key?
-
-        # Build UpdateExpression and keep names and values placeholders mapping
-        # in ExpressionAttributeNames and ExpressionAttributeValues.
-        set_expression_statements = []
-        remove_expression_statements = []
-        expression_attribute_names = {}
-        expression_attribute_values = {}
-
-        changes_dumped.each_with_index do |(name, value), i|
-          name_placeholder = "#_n#{i}"
-          value_placeholder = ":_s#{i}"
-
-          if value || Dynamoid.config.store_attribute_with_nil_value
-            set_expression_statements << "#{name_placeholder} = #{value_placeholder}"
-            expression_attribute_values[value_placeholder] = value
-          else
-            remove_expression_statements << name_placeholder
-          end
-          expression_attribute_names[name_placeholder] = name
-        end
-
-        update_expression = ''
-        update_expression += "SET #{set_expression_statements.join(', ')}" if set_expression_statements.any?
-        update_expression += " REMOVE #{remove_expression_statements.join(', ')}" if remove_expression_statements.any?
-
-        {
-          update: {
-            key: key,
-            table_name: @model_class.table_name,
-            update_expression: update_expression,
-            expression_attribute_names: expression_attribute_names,
-            expression_attribute_values: expression_attribute_values
-          }
-        }
-      end
-
-      def touch_model_timestamps(skip_created_at:)
-        return unless @model_class.timestamps_enabled?
-
-        timestamp = DateTime.now.in_time_zone(Time.zone)
-        @model.updated_at = timestamp unless @options[:touch] == false && !@was_new_record
-        @model.created_at ||= timestamp unless skip_created_at
-      end
-
-      def dump_attribute(name, value)
-        options = @model_class.attributes[name]
-        Dumping.dump_field(value, options)
-      end
-    end
-  end
-end