cuprum-rails 0.1.0 → 0.2.0

data/lib/cuprum/rails/action.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'forwardable'
+
 require 'cuprum/command'
 
 require 'cuprum/rails'
@@ -7,37 +9,51 @@ require 'cuprum/rails'
 module Cuprum::Rails
   # Abstract command that implement a controller action.
   class Action < Cuprum::Command
-    # @param resource [Cuprum::Rails::Resource] The controller resource.
-    def initialize(resource:)
-      super()
-
-      @resource = resource
-    end
+    extend Forwardable
 
-    # @!method call(request:)
+    # @!method call(request:, repository: nil, **options)
     #   Performs the controller action.
     #
     #   Subclasses should implement a #process method with the :request keyword,
     #   which accepts an ActionDispatch::Request instance.
     #
-    #   @param request [ActionDispatch::Request] The Rails request.
+    #   @param request [ActionDispatch::Request] the Rails request.
+    #   @param repository [Cuprum::Collections::Repository] the repository
+    #     containing the data collections for the application or scope.
+    #   @param options [Hash<Symbol, Object>] additional options for the action.
     #
     #   @return [Cuprum::Result] the result of the action.
 
-    # @return [Cuprum::Rails::Resource] the controller resource.
-    attr_reader :resource
+    # @!method params
+    #   @return [Hash<String, Object>] the request parameters.
+    def_delegators :@request, :params
 
-    private
+    # @return [Hash<Symbol, Object>] additional options for the action.
+    attr_reader :options
 
+    # @return [Cuprum::Collections::Repository] the repository containing the
+    #   data collections for the application or scope.
+    attr_reader :repository
+
+    # @return [Cuprum::Rails::Request] the formatted request.
     attr_reader :request
 
-    def params
-      @params ||= ActionController::Parameters.new(request.params)
+    private
+
+    def build_result(error: nil, metadata: nil, status: nil, value: nil)
+      Cuprum::Rails::Result.new(
+        error:    error,
+        metadata: metadata,
+        status:   status,
+        value:    value
+      )
     end
 
-    def process(request:)
-      @params  = nil
-      @request = request
+    def process(request:, repository: nil, **options)
+      @params     = nil
+      @repository = repository
+      @request    = request
+      @options    = options
 
       nil
     end

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

@@ -10,21 +10,20 @@ module Cuprum::Rails::Actions
   class Create < Cuprum::Rails::Actions::ResourceAction
     private
 
-    def create_resource
-      entity = nil
+    attr_reader :entity
 
-      result = steps do
-        attributes = step { resource_params }
-        entity     = step { collection.build_one.call(attributes: attributes) }
+    def build_response
+      { resource.singular_name => entity }
+    end
+
+    def create_entity(attributes:)
+      steps do
+        @entity = step { collection.build_one.call(attributes: attributes) }
 
         step { collection.validate_one.call(entity: entity) }
 
         step { collection.insert_one.call(entity: entity) }
-
-        { singular_resource_name => entity }
       end
-
-      [entity, result]
     end
 
     def failed_validation?(result)
@@ -32,17 +31,65 @@ module Cuprum::Rails::Actions
         result.error.is_a?(Cuprum::Collections::Errors::FailedValidation)
     end
 
-    def process(request:)
-      super
-
-      entity, result = create_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 parameters_contract
+      return @parameters_contract if @parameters_contract
+
+      resource_name         = resource.singular_name
+      parameters_constraint = require_parameters_constraint
+
+      @parameters_contract =
+        Cuprum::Rails::Constraints::ParametersContract.new do
+          key resource_name, parameters_constraint
+        end
+    end
+
+    def perform_action
+      handle_failed_validation do
+        create_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
+
+    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
+
+      Cuprum::Collections::Errors::FailedValidation.new(
+        entity_class: error.entity_class,
+        errors:       mapped_errors
       )
     end
   end

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

@@ -8,15 +8,31 @@ module Cuprum::Rails::Actions
   class Destroy < Cuprum::Rails::Actions::ResourceAction
     private
 
-    def process(request:)
-      super
+    attr_reader :entity
+
+    def build_response
+      { resource.singular_name => entity }
+    end
+
+    def destroy_entity(primary_key:)
+      collection.destroy_one.call(primary_key: primary_key)
+    end
 
-      primary_key = step { resource_id }
-      entity      = step do
-        collection.destroy_one.call(primary_key: primary_key)
-      end
+    def parameters_contract
+      @parameters_contract ||=
+        Cuprum::Rails::Constraints::ParametersContract.new do
+          key 'id', Stannum::Constraints::Presence.new
+        end
+    end
+
+    def perform_action
+      @entity = step { destroy_entity(primary_key: resource_id) }
+    end
 
-      { singular_resource_name => entity }
+    def process(**)
+      @entity = nil
+
+      super
     end
   end
 end

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

@@ -8,15 +8,31 @@ module Cuprum::Rails::Actions
   class Edit < Cuprum::Rails::Actions::ResourceAction
     private
 
-    def process(request:)
-      super
+    attr_reader :entity
+
+    def build_response
+      { resource.singular_name => entity }
+    end
+
+    def find_entity(primary_key:)
+      collection.find_one.call(primary_key: primary_key)
+    end
 
-      primary_key = step { resource_id }
-      entity      = step do
-        collection.find_one.call(primary_key: primary_key)
-      end
+    def parameters_contract
+      @parameters_contract ||=
+        Cuprum::Rails::Constraints::ParametersContract.new do
+          key 'id', Stannum::Constraints::Presence.new
+        end
+    end
+
+    def perform_action
+      @entity = step { find_entity(primary_key: resource_id) }
+    end
 
-      { singular_resource_name => entity }
+    def process(**)
+      @entity = nil
+
+      super
     end
   end
 end

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

@@ -11,12 +11,27 @@ module Cuprum::Rails::Actions
 
     private
 
+    attr_reader :entities
+
+    def build_response
+      { resource.name => entities.to_a }
+    end
+
     # @note Overload this method to change how the filtering params are defined,
     #   or override the #limit, #offset, #order, #where methods directly.
     def filter_params
       tools.hash_tools.convert_keys_to_strings(request.params)
     end
 
+    def find_entities(limit:, offset:, order:, &block)
+      collection.find_matching.call(
+        limit:  limit,
+        offset: offset,
+        order:  order,
+        &block
+      )
+    end
+
     def limit
       filter_params['limit']
     end
@@ -29,19 +44,24 @@ module Cuprum::Rails::Actions
       filter_params.fetch('order', default_order.presence)
     end
 
-    def process(request:)
-      super
-
+    def perform_action
       filters = where
       block   = where.present? ? -> { filters } : nil
 
-      collection.find_matching.call(
-        envelope: true,
-        limit:    limit,
-        offset:   offset,
-        order:    order,
-        &block
-      )
+      @entities = step do
+        find_entities(
+          limit:  limit,
+          offset: offset,
+          order:  order,
+          &block
+        )
+      end
+    end
+
+    def process(**)
+      @entities = nil
+
+      super
     end
 
     def tools

data/lib/cuprum/rails/actions/middleware/associations/cache.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'cuprum/rails/actions/middleware/associations'
+
+module Cuprum::Rails::Actions::Middleware::Associations
+  # Pre-warm the association cache for a resource.
+  class Cache < Cuprum::Command
+    # Strategy for caching an association value on an ActiveRecord model.
+    ACTIVE_RECORD_STRATEGY = lambda do |entity:, name:, value:|
+      entity.send(:association_instance_set, name, value)
+
+      entity
+    end
+
+    # Generic strategy for caching an association value.
+    DEFAULT_STRATEGY = lambda do |entity:, name:, value:|
+      entity[name] = value
+
+      entity
+    end
+
+    STRATEGIES = {
+      Object             => DEFAULT_STRATEGY,
+      ActiveRecord::Base => ACTIVE_RECORD_STRATEGY
+    }.freeze
+    private_constant :STRATEGIES
+
+    class << self
+      # Defines a strategy for caching an association value.
+      #
+      # @param klass [Class] the base class or module for matching entities.
+      #
+      # @yield the strategy for caching the association value.
+      #
+      # @yieldparam entity [Object] the base entity.
+      # @yieldparam name [String] the name of the association.
+      # @yieldparam value [Object] the associated entity to cache.
+      #
+      # @yieldreturn [Object] the entity with cached assocation value.
+      def define_strategy(klass, &block)
+        (@strategies ||= STRATEGIES.dup)[klass] = block
+      end
+
+      # @return [Proc] the defined strategies for caching association values.
+      def strategies
+        (@strategies ||= STRATEGIES.dup).reverse_each
+      end
+    end
+
+    # @param association [Cuprum::Associations::Association] the association
+    #   to cache.
+    # @param resource [Cuprum::Rails::Resource] the resource to cache.
+    def initialize(association:, resource:)
+      super()
+
+      @association = association
+      @resource    = resource
+    end
+
+    # @return [Cuprum::Associations::Association] the association to cache.
+    attr_reader :association
+
+    # @return [Cuprum::Rails::Resource] the resource to cache.
+    attr_reader :resource
+
+    private
+
+    def cache_association(entity:, value:)
+      value    = value.first if association.singular?
+      strategy =
+        self.class.strategies.find { |klass, _| entity.is_a?(klass) }.last
+
+      strategy.call(
+        entity: entity,
+        name:   association.name,
+        value:  value
+      )
+    end
+
+    def convert_to_array(value)
+      return [] if value.nil?
+
+      return value if value.is_a?(Array)
+
+      [value]
+    end
+
+    def index_values(values:)
+      key_name = association.with_inverse(resource).query_key_name
+
+      values
+        .each
+        .with_object(Hash.new { |hsh, key| hsh[key] = [] }) do |value, hsh|
+          hsh[value[key_name]] << value
+
+          hsh
+        end
+    end
+
+    def process(entities:, values:)
+      indexed = index_values(values: convert_to_array(values))
+      cached  = convert_to_array(entities).map do |entity|
+        cache_association(
+          entity: entity,
+          value:  indexed[entity[association.inverse_key_name]]
+        )
+      end
+
+      entities.is_a?(Array) ? cached : cached.first
+    end
+  end
+end

data/lib/cuprum/rails/actions/middleware/associations/find.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'cuprum/rails/actions/middleware/associations'
+require 'cuprum/rails/actions/middleware/associations/query'
+
+module Cuprum::Rails::Actions::Middleware::Associations
+  # Middleware for querying an association from the action results.
+  class Find < Cuprum::Rails::Actions::Middleware::Associations::Query
+    private
+
+    def process(next_command, repository:, request:, resource:, **rest)
+      super
+
+      return result unless result.success?
+
+      values   = step { perform_query }
+      entities = entities_from(result: result)
+      entities = step { cache_association(entities: entities, values: values) }
+
+      merge_result(entities: entities, result: result, values: values)
+    end
+  end
+end

data/lib/cuprum/rails/actions/middleware/associations/parent.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/commands/associations/require_many'
+
+require 'cuprum/rails/actions/middleware/associations'
+require 'cuprum/rails/actions/middleware/associations/query'
+require 'cuprum/rails/errors/missing_parameter'
+
+module Cuprum::Rails::Actions::Middleware::Associations
+  # Middleware for querying a parent association from a parameter.
+  class Parent < Cuprum::Rails::Actions::Middleware::Associations::Query
+    # @param association_params [Hash] parameters to pass to the association.
+    def initialize(**association_params)
+      super(
+        association_type: :belongs_to,
+        **association_params
+      )
+    end
+
+    private
+
+    def cache_entities(result:, values:)
+      return unless result.success?
+
+      entities = entities_from(result: result)
+
+      cache_association(entities: entities, values: values)
+    end
+
+    def process(next_command, repository:, request:, resource:, **rest)
+      @repository = repository
+      @request    = request
+      @resource   = resource
+
+      primary_key = step { query_keys }
+      values      = step { require_parent(primary_key: primary_key) }
+      result      = super
+      entities    = step { cache_entities(result: result, values: values) }
+
+      merge_result(entities: entities, result: result, values: values)
+    end
+
+    def query_command
+      Cuprum::Collections::Commands::Associations::RequireMany.new(
+        association: association,
+        repository:  repository,
+        resource:    resource
+      )
+    end
+
+    def query_keys
+      key   = "#{association.singular_name}_id"
+      value = request.params[key]
+
+      return value if value.present?
+
+      error = Cuprum::Rails::Errors::MissingParameter.new(
+        parameter_name: key,
+        parameters:     request.params
+      )
+      failure(error)
+    end
+
+    def require_parent(primary_key:)
+      values = step { perform_query(keys: primary_key) }
+
+      values.is_a?(Array) ? values.first : values
+    end
+  end
+end

data/lib/cuprum/rails/actions/middleware/associations/query.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/associations/belongs_to'
+require 'cuprum/collections/commands/associations/find_many'
+
+require 'cuprum/rails/actions/middleware/associations'
+require 'cuprum/rails/actions/middleware/associations/cache'
+require 'cuprum/rails/result'
+
+module Cuprum::Rails::Actions::Middleware::Associations
+  # Abstract middleware for performing an association query.
+  class Query < Cuprum::Rails::Action
+    include Cuprum::Middleware
+
+    # @param association_type [String, Symbol] the type of association.
+    # @param association_params [Hash] parameters to pass to the association.
+    def initialize(association_type: nil, **association_params)
+      super()
+
+      @association_type = association_type&.intern
+      @association      = build_association(**association_params)
+    end
+
+    # @return [Cuprum::Collections::Association] the association.
+    attr_reader :association
+
+    # @return [String, Symbol] the type of association.
+    attr_reader :association_type
+
+    private
+
+    attr_reader :repository
+
+    attr_reader :request
+
+    attr_reader :resource
+
+    attr_reader :result
+
+    def association_class
+      case association_type
+      when :belongs_to
+        Cuprum::Collections::Associations::BelongsTo
+      else
+        Cuprum::Collections::Association
+      end
+    end
+
+    def build_association(**params)
+      association_class.new(**params)
+    end
+
+    def cache_association(entities:, values:)
+      Cuprum::Rails::Actions::Middleware::Associations::Cache
+        .new(association: association, resource: resource)
+        .call(entities: entities, values: values)
+    end
+
+    def entities_from(result:)
+      return unless result.value.is_a?(Hash)
+
+      if result.value.key?(resource.singular_name)
+        return result.value[resource.singular_name]
+      end
+
+      result.value[resource.name]
+    end
+
+    def merge_result(entities:, result:, values:)
+      return result unless result.value.is_a?(Hash)
+
+      Cuprum::Rails::Result.new(
+        **result.properties,
+        value: merge_values(
+          entities: entities,
+          value:    result.value,
+          values:   values
+        )
+      )
+    end
+
+    def merge_values(entities:, value:, values:)
+      if entities.present?
+        key   = pluralize_name(resource: resource, values: entities)
+        value = value.merge(key => entities)
+      end
+
+      if values.present?
+        key   = pluralize_name(resource: association, values: values)
+        value = value.merge(key => values)
+      end
+
+      value
+    end
+
+    def pluralize_name(resource:, values:)
+      values.is_a?(Array) ? resource.plural_name : resource.singular_name
+    end
+
+    def process(next_command, repository:, request:, resource:, **rest)
+      @repository = repository
+      @request    = request
+      @resource   = resource
+      @result     = next_command.call(
+        repository: repository,
+        request:    request,
+        resource:   resource,
+        **rest
+      )
+    end
+
+    def perform_query(keys: nil)
+      keys ||= step { query_keys }
+
+      if keys.is_a?(Array)
+        query_command.call(keys: keys)
+      else
+        query_command.call(key: keys)
+      end
+    end
+
+    def query_command
+      Cuprum::Collections::Commands::Associations::FindMany.new(
+        association: association,
+        repository:  repository,
+        resource:    resource
+      )
+    end
+
+    def query_keys
+      entities = entities_from(result: result)
+
+      if entities.is_a?(Array)
+        association.map_entities_to_keys(*entities)
+      else
+        association.map_entities_to_keys(entities).first
+      end
+    end
+  end
+end

data/lib/cuprum/rails/actions/middleware/associations.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'cuprum/rails/actions/middleware'
+
+module Cuprum::Rails::Actions::Middleware
+  # Namespace for association middleware.
+  module Associations
+    autoload :Cache,  'cuprum/rails/actions/middleware/associations/cache'
+    autoload :Parent, 'cuprum/rails/actions/middleware/associations/parent'
+    autoload :Query,  'cuprum/rails/actions/middleware/associations/query'
+  end
+end