cuprum-rails 0.1.0 → 0.2.0

data/lib/cuprum/rails/actions/update.rb

@@ -10,15 +10,10 @@ module Cuprum::Rails::Actions
   class Update < Cuprum::Rails::Actions::ResourceAction
     private
 
-    def assign_resource
-      primary_key = step { resource_id }
-      attributes  = step { resource_params }
-      entity      = step do
-        collection.find_one.call(primary_key: primary_key)
-      end
-      step do
-        collection.assign_one.call(attributes: attributes, entity: entity)
-      end
+    attr_reader :entity
+
+    def build_response
+      { resource.singular_name => entity }
     end
 
     def failed_validation?(result)
@@ -26,34 +21,87 @@ module Cuprum::Rails::Actions
         result.error.is_a?(Cuprum::Collections::Errors::FailedValidation)
     end
 
-    def process(request:)
-      super
+    def find_entity(primary_key:)
+      collection.find_one.call(primary_key: primary_key)
+    end
+
+    def find_required_entities
+      @entity = step { find_entity(primary_key: resource_id) }
+    end
 
-      entity, result = update_resource
+    def handle_failed_validation
+      result = yield
 
       return result unless failed_validation?(result)
 
       Cuprum::Result.new(
-        error:  result.error,
+        error:  scope_validation_errors(result.error),
         status: :failure,
-        value:  { singular_resource_name => entity }
+        value:  { resource.singular_name => entity }
       )
     end
 
-    def update_resource
-      entity = nil
+    def parameters_contract
+      return @parameters_contract if @parameters_contract
 
-      result = steps do
-        entity = assign_resource
+      resource_name         = resource.singular_name
+      parameters_constraint = require_parameters_constraint
 
-        step { collection.validate_one.call(entity: entity) }
+      @parameters_contract =
+        Cuprum::Rails::Constraints::ParametersContract.new do
+          key 'id',          Stannum::Constraints::Presence.new
+          key resource_name, parameters_constraint
+        end
+    end
 
-        step { collection.update_one.call(entity: entity) }
+    def perform_action
+      handle_failed_validation do
+        update_entity(attributes: resource_params)
+      end
+    end
+
+    def process(**)
+      @entity = nil
+
+      super
+    end
+
+    def require_parameters_constraint
+      Stannum::Contract.new do
+        constraint Stannum::Constraints::Presence.new, sanity: true
+        constraint Stannum::Constraints::Types::HashType.new
+      end
+    end
 
-        { singular_resource_name => entity }
+    def require_permitted_attributes?
+      true
+    end
+
+    def scope_validation_errors(error)
+      mapped_errors = Stannum::Errors.new
+
+      error.errors.each do |err|
+        mapped_errors
+          .dig(resource.singular_name, *err[:path].map(&:to_s))
+          .add(err[:type], message: err[:message], **err[:data])
       end
 
-      [entity, result]
+      Cuprum::Collections::Errors::FailedValidation.new(
+        entity_class: error.entity_class,
+        errors:       mapped_errors
+      )
+    end
+
+    def update_entity(attributes:)
+      steps do
+        step do
+          collection.assign_one.call(attributes: attributes, entity: entity)
+        end
+
+        step { collection.validate_one.call(entity: entity) }
+
+        step { collection.update_one.call(entity: entity) }
+      end
     end
   end
 end

data/lib/cuprum/rails/actions.rb

@@ -5,12 +5,16 @@ require 'cuprum/rails'
 module Cuprum::Rails
   # Namespace for defined resourceful actions.
   module Actions
-    autoload :Create,  'cuprum/rails/actions/create'
-    autoload :Destroy, 'cuprum/rails/actions/destroy'
-    autoload :Edit,    'cuprum/rails/actions/edit'
-    autoload :Index,   'cuprum/rails/actions/index'
-    autoload :New,     'cuprum/rails/actions/new'
-    autoload :Show,    'cuprum/rails/actions/show'
-    autoload :Update,  'cuprum/rails/actions/update'
+    autoload :Create,              'cuprum/rails/actions/create'
+    autoload :Destroy,             'cuprum/rails/actions/destroy'
+    autoload :Edit,                'cuprum/rails/actions/edit'
+    autoload :Index,               'cuprum/rails/actions/index'
+    autoload :Middleware,          'cuprum/rails/actions/middleware'
+    autoload :New,                 'cuprum/rails/actions/new'
+    autoload :ParameterValidation, 'cuprum/rails/actions/parameter_validation'
+    autoload :ResourceAction,      'cuprum/rails/actions/resource_action'
+    autoload :ResourceMethods,     'cuprum/rails/actions/resource_methods'
+    autoload :Show,                'cuprum/rails/actions/show'
+    autoload :Update,              'cuprum/rails/actions/update'
   end
 end

data/lib/cuprum/rails/collection.rb

@@ -1,42 +1,31 @@
 # frozen_string_literal: true
 
+require 'cuprum/collections/collection'
 require 'cuprum/command_factory'
 
 require 'cuprum/rails'
 
 module Cuprum::Rails
   # Wraps an ActiveRecord model as a Cuprum collection.
-  class Collection < Cuprum::CommandFactory
-    # @param collection_name [String, Symbol] The name of the collection.
-    # @param member_name [String] The name of a collection entity.
-    # @param options [Hash<Symbol>] Additional options for the command.
-    # @param record_class [Class] The ActiveRecord class for the collection.
-    def initialize(
-      record_class:,
-      collection_name: nil,
-      member_name:     nil,
-      **options
-    )
-      super()
-
-      @collection_name = resolve_collection_name(collection_name, record_class)
-      @member_name     = resolve_member_name(@collection_name, member_name)
-      @record_class    = record_class
-      @options         = options
+  class Collection < Cuprum::Collections::Collection
+    # @overload initialize(entity_class: nil, name: nil, qualified_name: nil, singular_name: nil, **options)
+    #   @param entity_class [Class, String] the class of entity represented by
+    #     the collection.
+    #   @param name [String] the name of the collection.
+    #   @param qualified_name [String] a scoped name for the collection.
+    #   @param singular_name [String] the name of an entity in the collection.
+    #   @param options [Hash] additional options for the collection.
+    #
+    #   @option options primary_key_name [String] the name of the primary key
+    #     attribute. Defaults to 'id'.
+    #   @option primary_key_type [Class, Stannum::Constraint] the type of
+    #     the primary key attribute. Defaults to Integer.
+    def initialize(**params)
+      params = disambiguate_keyword(params, :entity_class, :record_class)
+
+      super(**params)
     end
 
-    # @return [String] The name of the collection.
-    attr_reader :collection_name
-
-    # @return [String] the name of a collection entity.
-    attr_reader :member_name
-
-    # @return [Hash<Symbol>] additional options for the command.
-    attr_reader :options
-
-    # @return [Class] the ActiveRecord class for the collection.
-    attr_reader :record_class
-
     command_class :assign_one do
       Cuprum::Rails::Commands::AssignOne
         .subclass(**command_options)
@@ -86,30 +75,21 @@ module Cuprum::Rails
     #
     # @return [Cuprum::Rails::Query] the query.
     def query
-      Cuprum::Rails::Query.new(record_class)
-    end
-
-    private
-
-    def command_options
-      @command_options ||= {
-        collection_name: collection_name,
-        member_name:     member_name,
-        record_class:    record_class,
-        **options
-      }
+      Cuprum::Rails::Query.new(entity_class)
     end
 
-    def resolve_collection_name(collection_name, record_class)
-      return collection_name.to_s unless collection_name.nil?
+    # @return [Class] the class of entity represented by the collection.
+    def record_class
+      tools.core_tools.deprecate '#record_class method',
+        message: 'Use #entity_class instead'
 
-      record_class.name.underscore.pluralize
+      entity_class
     end
 
-    def resolve_member_name(collection_name, member_name)
-      return member_name.to_s unless member_name.nil?
+    private
 
-      collection_name.singularize
+    def command_options
+      super().merge(record_class: entity_class)
     end
   end
 end

data/lib/cuprum/rails/command.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'cuprum/collections'
+
 require 'cuprum/rails'
 
 module Cuprum::Rails
@@ -46,7 +48,7 @@ module Cuprum::Rails
 
     # @return [Symbol] the name of the primary key attribute.
     def primary_key_name
-      @primary_key_name ||= record_class.primary_key.intern
+      @primary_key_name ||= record_class.primary_key
     end
 
     # @return [Class] the type of the primary key attribute.

data/lib/cuprum/rails/commands/destroy_one.rb

@@ -25,6 +25,15 @@ module Cuprum::Rails::Commands
 
     private
 
+    def not_found_error(primary_key)
+      Cuprum::Collections::Errors::NotFound.new(
+        attribute_name:  primary_key_name,
+        attribute_value: primary_key,
+        collection_name: collection_name,
+        primary_key:     true
+      )
+    end
+
     def process(primary_key:)
       step { validate_primary_key(primary_key) }
 
@@ -32,12 +41,7 @@ module Cuprum::Rails::Commands
 
       entity.destroy
     rescue ActiveRecord::RecordNotFound
-      error = Cuprum::Collections::Errors::NotFound.new(
-        collection_name:    collection_name,
-        primary_key_name:   primary_key_name,
-        primary_key_values: [primary_key]
-      )
-      Cuprum::Result.new(error: error)
+      Cuprum::Result.new(error: not_found_error(primary_key))
     end
   end
 end

data/lib/cuprum/rails/commands/find_many.rb

@@ -6,13 +6,14 @@ require 'cuprum/collections/commands/abstract_find_many'
 
 require 'cuprum/rails/command'
 require 'cuprum/rails/commands'
+require 'cuprum/rails/errors/invalid_statement'
 
 module Cuprum::Rails::Commands
   # Command for finding multiple ActiveRecord records by primary key.
   class FindMany < Cuprum::Rails::Command
     include Cuprum::Collections::Commands::AbstractFindMany
 
-    # @!method call(primary_keys:, allow_partial: false, envelope: false, scope: nil) # rubocop:disable Layout/LineLength
+    # @!method call(primary_keys:, allow_partial: false, envelope: false, scope: nil)
     #   Queries the collection for the records with the given primary keys.
     #
     #   The command will find and return the entities with the given primary
@@ -46,6 +47,10 @@ module Cuprum::Rails::Commands
       Cuprum::Rails::Query.new(record_class)
     end
 
+    def invalid_statement_error(message)
+      Cuprum::Rails::Errors::InvalidStatement.new(message: message)
+    end
+
     def process(
       primary_keys:,
       allow_partial: false,
@@ -55,6 +60,8 @@ module Cuprum::Rails::Commands
       step { validate_primary_keys(primary_keys) }
 
       super
+    rescue ActiveRecord::StatementInvalid => exception
+      failure(invalid_statement_error(exception.message))
     end
   end
 end

data/lib/cuprum/rails/commands/find_matching.rb

@@ -12,7 +12,7 @@ module Cuprum::Rails::Commands
   class FindMatching < Cuprum::Rails::Command
     include Cuprum::Collections::Commands::AbstractFindMatching
 
-    # @!method call(envelope: false, limit: nil, offset: nil, order: nil, scope: nil, where: nil, &block) # rubocop:disable Layout/LineLength
+    # @!method call(envelope: false, limit: nil, offset: nil, order: nil, scope: nil, where: nil, &block)
     #   Queries the collection for records matching the given conditions.
     #
     #   @param envelope [Boolean] If true, wraps the result value in a Hash.

data/lib/cuprum/rails/commands/find_one.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require 'stannum/constraints/boolean'
+require 'stannum/errors'
 
 require 'cuprum/collections/commands/abstract_find_one'
 
 require 'cuprum/rails/command'
 require 'cuprum/rails/commands'
+require 'cuprum/rails/errors/invalid_statement'
 
 module Cuprum::Rails::Commands
   # Command for finding one ActiveRecord record by primary key.
@@ -41,10 +43,16 @@ module Cuprum::Rails::Commands
       Cuprum::Rails::Query.new(record_class)
     end
 
+    def invalid_statement_error(message)
+      Cuprum::Rails::Errors::InvalidStatement.new(message: message)
+    end
+
     def process(primary_key:, envelope: false, scope: nil)
       step { validate_primary_key(primary_key) }
 
       super
+    rescue ActiveRecord::StatementInvalid => exception
+      failure(invalid_statement_error(exception.message))
     end
   end
 end

data/lib/cuprum/rails/commands/insert_one.rb

@@ -4,6 +4,7 @@ require 'cuprum/collections/errors/already_exists'
 
 require 'cuprum/rails/command'
 require 'cuprum/rails/commands'
+require 'cuprum/rails/errors/invalid_statement'
 
 module Cuprum::Rails::Commands
   # Command for inserting an ActiveRecord record into the collection.
@@ -23,6 +24,19 @@ module Cuprum::Rails::Commands
 
     private
 
+    def already_exists_error(primary_key)
+      Cuprum::Collections::Errors::AlreadyExists.new(
+        attribute_name:  primary_key_name,
+        attribute_value: primary_key,
+        collection_name: collection_name,
+        primary_key:     true
+      )
+    end
+
+    def invalid_statement_error(message)
+      Cuprum::Rails::Errors::InvalidStatement.new(message: message)
+    end
+
     def process(entity:)
       step { validate_entity(entity) }
 
@@ -30,12 +44,9 @@ module Cuprum::Rails::Commands
 
       entity
     rescue ActiveRecord::RecordNotUnique
-      error = Cuprum::Collections::Errors::AlreadyExists.new(
-        collection_name:    collection_name,
-        primary_key_name:   primary_key_name,
-        primary_key_values: entity[primary_key_name]
-      )
-      failure(error)
+      failure(already_exists_error(entity[primary_key_name]))
+    rescue ActiveRecord::StatementInvalid => exception
+      failure(invalid_statement_error(exception.message))
     end
   end
 end

data/lib/cuprum/rails/commands/update_one.rb

@@ -4,6 +4,7 @@ require 'cuprum/collections/errors/not_found'
 
 require 'cuprum/rails/command'
 require 'cuprum/rails/commands'
+require 'cuprum/rails/errors/invalid_statement'
 
 module Cuprum::Rails::Commands
   # Command for updating an ActiveRecord record in the collection.
@@ -28,12 +29,20 @@ module Cuprum::Rails::Commands
 
       return if query.exists?
 
-      error = Cuprum::Collections::Errors::NotFound.new(
-        collection_name:    collection_name,
-        primary_key_name:   primary_key_name,
-        primary_key_values: primary_key
+      failure(not_found_error(primary_key))
+    end
+
+    def invalid_statement_error(message)
+      Cuprum::Rails::Errors::InvalidStatement.new(message: message)
+    end
+
+    def not_found_error(primary_key)
+      Cuprum::Collections::Errors::NotFound.new(
+        attribute_name:  primary_key_name,
+        attribute_value: primary_key,
+        collection_name: collection_name,
+        primary_key:     true
       )
-      failure(error)
     end
 
     def process(entity:)
@@ -44,6 +53,8 @@ module Cuprum::Rails::Commands
       entity.save
 
       entity
+    rescue ActiveRecord::StatementInvalid => exception
+      failure(invalid_statement_error(exception.message))
     end
   end
 end

data/lib/cuprum/rails/constraints/parameters_contract.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'stannum/contracts/indifferent_hash_contract'
+
+require 'cuprum/rails/constraints'
+
+module Cuprum::Rails::Constraints
+  # Contract for validating request parameters.
+  class ParametersContract < Stannum::Contracts::IndifferentHashContract
+    def initialize(**options)
+      super(allow_extra_keys: true, **options)
+    end
+  end
+end

data/lib/cuprum/rails/constraints.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'cuprum/rails'
+
+module Cuprum::Rails
+  # Namespace for Stannum constraints and contracts, which validate objects.
+  module Constraints
+    autoload :ParametersContract, 'cuprum/rails/constraints/parameters_contract'
+  end
+end

data/lib/cuprum/rails/controller.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require 'cuprum/rails'
-require 'cuprum/rails/controller_action'
+require 'cuprum/rails/controllers/class_methods/actions'
 require 'cuprum/rails/controllers/class_methods/configuration'
+require 'cuprum/rails/controllers/class_methods/middleware'
 require 'cuprum/rails/controllers/class_methods/validations'
 
 module Cuprum::Rails
@@ -21,7 +22,7 @@ module Cuprum::Rails
   #   class BooksController
   #     include Cuprum::Rails::Controller
   #
-  #     responder :html, Cuprum::Rails::Responders::Html::PluralResource
+  #     responder :html, Cuprum::Rails::Responders::Html::Resource
   #
   #     action :index,     Cuprum::Rails::Actions::Index
   #     action :show,      Cuprum::Rails::Actions::Show, member: true
@@ -43,8 +44,17 @@ module Cuprum::Rails
 
         other.extend(Cuprum::Rails::Controllers::ClassMethods::Actions)
         other.extend(Cuprum::Rails::Controllers::ClassMethods::Configuration)
+        other.extend(Cuprum::Rails::Controllers::ClassMethods::Middleware)
         other.extend(Cuprum::Rails::Controllers::ClassMethods::Validations)
       end
     end
+
+    # @api private
+    def action_options
+      {
+        repository: self.class.repository,
+        resource:   self.class.resource
+      }
+    end
   end
 end

data/lib/cuprum/rails/controllers/action.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require 'cuprum/middleware'
+
+require 'cuprum/rails/controllers'
+
+module Cuprum::Rails::Controllers
+  # @api private
+  #
+  # Implements a controller action.
+  #
+  # @note This class should not be initialized directly. Instead, use the
+  #   Cuprum::Rails::Controller.action class method to define an action.
+  class Action
+    extend Forwardable
+
+    # @param action_class [Class] the class of the action command. Must be
+    #   constructible with keyword :resource.
+    # @param action_name [String, Symbol] the name of the action.
+    # @param member_action [Boolean] true if the action acts on a collection
+    #   item, not on the collection as a whole.
+    def initialize(
+      action_class:,
+      action_name:,
+      member_action: false
+    )
+      @action_class    = action_class
+      @action_name     = action_name
+      @member_action   = !!member_action
+    end
+
+    # @return [Class] the class of the action command.
+    attr_reader :action_class
+
+    # @return [String, Symbol] the name of the action.
+    attr_reader :action_name
+
+    # Executes the controller action.
+    #
+    # 1. Initializes the action command with the resource.
+    # 2. Calls the command with the request.
+    # 3. Builds the responder with the resource and action metadata.
+    # 4. Calls the responder with the action result.
+    #
+    # @param controller [Cuprum::Rails::Controller] the controller instance
+    #   calling the request.
+    # @param request [Cuprum::Rails::Request] the request to process.
+    #
+    # @return [#call] the response object.
+    def call(controller, request)
+      responder  = build_responder(controller, request)
+      action     = apply_middleware(controller, action_class.new)
+      result     = action.call(request: request, **controller.action_options)
+
+      responder.call(result)
+    end
+
+    # @return [Boolean] true if the action acts on a collection item, not on the
+    #   collection as a whole.
+    def member_action?
+      @member_action
+    end
+
+    private
+
+    def apply_middleware(controller, command)
+      configuration = controller.class.configuration
+      middleware    =
+        configuration
+          .middleware_for(action_name)
+          .map { |config| build_middleware(config.command) }
+
+      Cuprum::Middleware.apply(
+        command:    command,
+        middleware: middleware
+      )
+    end
+
+    def build_middleware(command)
+      return command unless command.is_a?(Class)
+
+      command.new
+    end
+
+    def build_responder(controller, request)
+      configuration   = controller.class.configuration
+      responder_class = configuration.responder_for(request.format)
+
+      responder_class.new(
+        action_name:   action_name,
+        controller:    controller,
+        member_action: member_action?,
+        request:       request,
+        serializers:   configuration.serializers_for(request.format)
+      )
+    end
+  end
+end