api_maker 0.0.1 → 0.0.2

data/app/services/api_maker/update_command.rb

@@ -1,42 +1,26 @@
 class ApiMaker::UpdateCommand < ApiMaker::BaseCommand
-  attr_reader :command, :model, :params, :serializer
+  attr_reader :serializer
 
   def execute!
-    each_command do |command|
-      @command = command
-      @model = command.model
-      @params = command.args || {}
+    ApiMaker::Configuration.profile(-> { "UpdateCommand: #{model_class.name}" }) do
       @serializer = serialized_resource(model)
+      sanitized_parameters = sanitize_parameters
 
-      if command.model.update(sanitize_parameters)
+      if command.model.update(sanitized_parameters)
         success_response
       else
-        failure_response
+        failure_save_response(model: model, params: sanitized_parameters)
       end
     end
-
-    ServicePattern::Response.new(success: true)
-  end
-
-  def failure_response
-    command.fail(
-      model: serializer.result,
-      success: false,
-      errors: model.errors.full_messages
-    )
   end
 
   def sanitize_parameters
-    serializer.resource_instance.permitted_params(ApiMaker::PermittedParamsArgument.new(command: command, model: model))
-  end
-
-  def serialized_resource(model)
-    ApiMaker::Serializer.new(ability: current_ability, args: api_maker_args, model: model)
+    serializer.resource_instance.permitted_params(ApiMaker::PermittedParamsArgument.new(command: self, model: model))
   end
 
   def success_response
-    command.result(
-      model: serializer.result,
+    succeed!(
+      model: serialized_model(model),
       success: true
     )
   end

data/app/services/api_maker/update_command_service.rb

@@ -1,14 +1,14 @@
 class ApiMaker::UpdateCommandService < ApiMaker::CommandService
-  def execute
+  def perform
     ApiMaker::UpdateCommand.execute_in_thread!(
       ability: ability,
-      args: args,
+      api_maker_args: api_maker_args,
       collection: collection,
       commands: commands,
       command_response: command_response,
       controller: controller
     )
-    ServicePattern::Response.new(success: true)
+    succeed!
   end
 
   def collection

data/app/services/api_maker/valid_command.rb

@@ -1,11 +1,8 @@
 class ApiMaker::ValidCommand < ApiMaker::BaseCommand
-  attr_reader :command, :model, :params, :serializer
+  attr_reader :serializer
 
   def execute!
-    each_command do |command|
-      @command = command
-      @params = command.args || {}
-
+    ApiMaker::Configuration.profile(-> { "ValidCommand: #{model_class.name}" }) do
       if command.model_id.present?
         model = resource_instance_class.find(command.model_id)
       else
@@ -15,10 +12,8 @@ class ApiMaker::ValidCommand < ApiMaker::BaseCommand
       serializer = serialized_resource(model)
       model.assign_attributes(sanitize_parameters(serializer))
 
-      command.result(valid: model.valid?, errors: model.errors.full_messages)
+      succeed!(valid: model.valid?, errors: model.errors.full_messages)
     end
-
-    ServicePattern::Response.new(success: true)
   end
 
   def resource_instance_class
@@ -26,10 +21,6 @@ class ApiMaker::ValidCommand < ApiMaker::BaseCommand
   end
 
   def sanitize_parameters(serializer)
-    serializer.resource_instance.permitted_params(ApiMaker::PermittedParamsArgument.new(command: command, model: serializer.model))
-  end
-
-  def serialized_resource(model)
-    ApiMaker::Serializer.new(ability: current_ability, args: api_maker_args, model: model)
+    serializer.resource_instance.permitted_params(ApiMaker::PermittedParamsArgument.new(command: self, model: serializer.model))
   end
 end

data/app/services/api_maker/valid_command_service.rb

@@ -1,14 +1,14 @@
 class ApiMaker::ValidCommandService < ApiMaker::CommandService
-  def execute
+  def perform
     ApiMaker::ValidCommand.execute_in_thread!(
       ability: ability,
-      args: args,
+      api_maker_args: api_maker_args,
       collection: collection,
       commands: commands,
       command_response: command_response,
       controller: controller
     )
-    ServicePattern::Response.new(success: true)
+    succeed!
   end
 
   def collection

data/app/services/api_maker/validation_errors_generator_service.rb

@@ -0,0 +1,146 @@
+class ApiMaker::ValidationErrorsGeneratorService < ApiMaker::ApplicationService
+  attr_reader :model, :params, :result
+
+  def initialize(model:, params:)
+    @model = model
+    @params = params
+    @result = []
+  end
+
+  def perform
+    path = [model.model_name.singular]
+
+    inspect_model(model, path)
+    inspect_params(model, params, path)
+    ServicePattern::Response.new(result: result)
+  end
+
+  def inspect_model(model, path)
+    return if model.errors.empty?
+
+    model.errors.details.each do |attribute_name, _errors|
+      attribute_type = attribute_type(model, attribute_name)
+      next unless attribute_type
+
+      attribute_path = path + [attribute_name]
+      input_name = path_to_attribute_name(attribute_path)
+
+      error_data = {
+        attribute_name: attribute_name,
+        attribute_type: attribute_type,
+        id: model.id,
+        model_name: model.model_name.param_key,
+        error_messages: model.errors.messages.fetch(attribute_name).to_a,
+        error_types: model.errors.details.fetch(attribute_name).map do |error|
+          error = error.fetch(:error)
+
+          if error.is_a?(Symbol)
+            error
+          else
+            :custom_error
+          end
+        end
+      }
+
+      error_data[:input_name] = input_name unless attribute_type == :base
+
+      result << error_data
+    end
+  end
+
+  def attribute_type(model, attribute_name)
+    if model.attribute_names.include?(attribute_name.to_s)
+      :attribute
+    elsif model.class.const_defined?(:ADDITIONAL_ATTRIBUTES_FOR_VALIDATION_ERRORS) &&
+        model.class.const_get(:ADDITIONAL_ATTRIBUTES_FOR_VALIDATION_ERRORS).include?(attribute_name)
+      :additional_attribute_for_validation
+    elsif model._reflections.key?(attribute_name.to_s)
+      :reflection
+    elsif model.class.try(:monetized_attributes)&.include?(attribute_name.to_s)
+      :monetized_attribute
+    elsif attribute_name == :base
+      :base
+    end
+  end
+
+  def error_type(attribute_type, error)
+    if attribute_type == :base
+      :base
+    else
+      error.fetch(:error)
+    end
+  end
+
+  def inspect_params(model, params, path)
+    params.each do |attribute_name, attribute_value|
+      match = attribute_name.match(/\A(.+)_attributes\Z/)
+      next unless match
+
+      association_name = match[1].to_sym
+      association = model.association(association_name)
+
+      path << attribute_name
+
+      if attribute_value.is_a?(Array)
+        check_nested_many_models_for_validation_errors_on_array(association.target, attribute_value, path)
+      elsif all_keys_numeric?(attribute_value)
+        # This is a has-many relationship where keys are mapped to attributes
+        check_nested_many_models_for_validation_errors(association.target, attribute_value, path)
+      else
+        inspect_model(association.target, path)
+        inspect_params(association.target, attribute_value, path)
+      end
+
+      path.pop
+    end
+  end
+
+  def all_keys_numeric?(hash)
+    hash.keys.all? { |key| key.to_s.match?(/\A\d+\Z/) }
+  end
+
+  def check_nested_many_models_for_validation_errors(models_up_next, attribute_value, path)
+    if models_up_next.length != attribute_value.keys.length
+      raise "Expected same length on targets and attribute values: #{models_up_next.length}, #{attribute_value.keys.length}"
+    end
+
+    count = 0
+    attribute_value.each do |unique_key, model_attribute_values|
+      model_up_next = models_up_next.fetch(count)
+      count += 1
+
+      path << unique_key
+      inspect_model(model_up_next, path)
+      inspect_params(model_up_next, model_attribute_values, path)
+      path.pop
+    end
+  end
+
+  def check_nested_many_models_for_validation_errors_on_array(models_up_next, attribute_value, path)
+    if models_up_next.length != attribute_value.length
+      raise "Expected same length on targets and attribute values: #{models_up_next.length}, #{attribute_value.length}"
+    end
+
+    count = 0
+    attribute_value.each_with_index do |model_attribute_values, unique_key|
+      model_up_next = models_up_next.fetch(count)
+      count += 1
+
+      path << unique_key
+      inspect_model(model_up_next, path)
+      inspect_params(model_up_next, model_attribute_values, path)
+      path.pop
+    end
+  end
+
+  def path_to_attribute_name(original_attribute_path)
+    attribute_path = original_attribute_path.dup
+    path_string = attribute_path.shift.dup
+
+    attribute_path.each do |path_part|
+      path_string << "[#{path_part}]"
+    end
+
+    path_string
+  end
+end

data/app/views/api_maker/_data.html.erb

@@ -1,15 +1,21 @@
-<div class="api-maker-data"<%
+<script type="text/javascript">
+  if (!window.apiMakerDeviseCurrent) {
+    window.apiMakerDeviseCurrent = {}
+  }
 
-Devise.mappings.each do |scope|
-  model = __send__("current_#{scope[0]}")
-  next unless model
+  <%
+    Devise.mappings.each do |scope|
+      model = __send__("current_#{scope[0]}")
+      next unless model
 
-  resource_class = ApiMaker::Serializer.resource_for(model.class)
-  next unless resource_class
+      resource_class = ApiMaker::Serializer.resource_for(model.class)
+      next unless resource_class
 
-  serializer = ApiMaker::Serializer.new(ability: current_ability, args: api_maker_args, model: model) if model
+      serializer = ApiMaker::Serializer.new(ability: current_ability, api_maker_args: api_maker_args, model: model) if model
 
-  %> data-current-<%= scope[0].to_s.dasherize %>="<%= model ? serializer.to_json : null %>"<%
-end
-
-%>></div>
+      %>
+        window.apiMakerDeviseCurrent["<%= scope[0] %>"] = <%= model ? serializer.to_json(result_parser: true).html_safe : null %>
+      <%
+    end
+  %>
+</script>

data/config/routes.rb

@@ -1,7 +1,5 @@
 ApiMaker::Engine.routes.draw do
   post "commands" => "commands#create"
-  post "devise/do_sign_in" => "devise#do_sign_in"
-  post "devise/do_sign_out" => "devise#do_sign_out"
 
   resources :session_statuses, only: :create
 end

data/lib/api_maker/ability.rb

@@ -3,9 +3,10 @@ class ApiMaker::Ability
 
   attr_reader :loader
 
-  def initialize(args: nil)
-    @args = args
-    @loader = ApiMaker::AbilityLoader.new(ability: self, args: args)
+  def initialize(api_maker_args: nil, locals: nil)
+    @api_maker_args = api_maker_args || {}
+    @locals = locals || api_maker_args&.dig(:locals) || {}
+    @loader = ApiMaker::AbilityLoader.new(ability: self, locals: locals, api_maker_args: api_maker_args)
   end
 
   # Override methods from CanCan::Ability to first load abilities from the given resource
@@ -13,6 +14,16 @@ class ApiMaker::Ability
     subject = args.second
     load_abilities(subject)
     super
+  rescue ActiveModel::MissingAttributeError => e
+    if subject.is_a?(ActiveRecord::Base)
+      # Add subject / model class name to the error message
+      new_error = ActiveModel::MissingAttributeError.new("Error on #{subject.class.name}: #{e.message}")
+      new_error.set_backtrace(e.backtrace)
+
+      raise new_error
+    end
+
+    raise e
   end
 
   def model_adapter(*args)
@@ -24,15 +35,19 @@ class ApiMaker::Ability
   def load_abilities(subject)
     return unless active_record?(subject)
 
-    if subject.class == Class
-      loader.load_model_class(subject)
+    if subject.class == Class # rubocop:disable Style/ClassEqualityComparison
+      ApiMaker::Configuration.profile(-> { "Loading abilities for #{subject.name}" }) do
+        loader.load_model_class(subject)
+      end
     elsif subject.class != Class
-      loader.load_model_class(subject.class)
+      ApiMaker::Configuration.profile(-> { "Loading abilities for #{subject.class.name}" }) do
+        loader.load_model_class(subject.class)
+      end
     end
   end
 
   def active_record?(subject)
-    return subject < ActiveRecord::Base if subject.class == Class
+    return subject < ActiveRecord::Base if subject.class == Class # rubocop:disable Style/ClassEqualityComparison
 
     subject.is_a?(ActiveRecord::Base)
   end

data/lib/api_maker/ability_loader.rb

@@ -1,21 +1,24 @@
 class ApiMaker::AbilityLoader
-  def initialize(ability:, args:)
+  attr_reader :ability, :api_maker_args, :loaded, :locals, :loaded_model_names
+
+  def initialize(ability:, api_maker_args:, locals:)
     @ability = ability
-    @args = args
+    @api_maker_args = api_maker_args
+    @locals = locals
     @loaded_model_names = {}
   end
 
   def load_model_class(model_class)
-    return if @loaded_model_names.key?(model_class.name)
+    return if loaded_model_names.key?(model_class.name)
 
     resource = ApiMaker::MemoryStorage.current.resource_for_model(model_class)
     load_resource(resource)
   end
 
   def load_resource(resource)
-    return if @loaded_model_names.key?(resource.model_class_name)
+    return if loaded_model_names.key?(resource.model_class_name)
 
-    resource.new(ability: @ability, args: @args, model: nil).abilities
-    @loaded_model_names[resource.model_class_name] = true
+    resource.new(ability: ability, api_maker_args: api_maker_args, locals: locals, model: nil).abilities
+    loaded_model_names[resource.model_class_name] = true
   end
 end

data/lib/api_maker/base_collection_instance.rb

@@ -0,0 +1,15 @@
+class ApiMaker::BaseCollectionInstance
+  ApiMaker::IncludeHelpers.execute!(klass: self)
+
+  attr_accessor :collection
+  attr_reader :api_maker_args, :commands, :command_response, :controller, :current_ability
+
+  def initialize(ability:, api_maker_args:, collection:, commands:, command_response:, controller:)
+    @api_maker_args = api_maker_args
+    @current_ability = ability
+    @collection = collection
+    @commands = commands
+    @command_response = command_response
+    @controller = controller
+  end
+end

data/lib/api_maker/base_resource.rb

@@ -1,13 +1,23 @@
 class ApiMaker::BaseResource
-  attr_reader :ability, :args, :model
+  ApiMaker::IncludeHelpers.execute!(klass: self)
 
-  delegate :can, to: :ability
+  attr_reader :ability, :api_maker_args, :locals, :model
 
-  CRUD = [:create, :read, :update, :destroy].freeze
+  delegate :can, :can?, allow_nil: true, to: :ability
+
+  CRUD = [:create, :create_events, :read, :update, :update_events, :destroy, :destroy_events].freeze
+  READ = [:create_events, :destroy_events, :read, :update_events].freeze
+
+  def self.attribute(attribute_name, **args)
+    # Automatically add a columns argument if the attribute name matches a column name on the models table
+    args[:requires_columns] = [attribute_name] if !args.key?(:requires_columns) && column_exists_on_model?(model_class, attribute_name)
+
+    ApiMaker::MemoryStorage.current.add(self, :attributes, attribute_name, args)
+  end
 
   def self.attributes(*attributes, **args)
-    attributes.each do |attribute|
-      ApiMaker::MemoryStorage.current.add(self, :attributes, attribute, args)
+    attributes.each do |attribute_name|
+      attribute(attribute_name, args)
     end
   end
 
@@ -15,12 +25,29 @@ class ApiMaker::BaseResource
     ApiMaker::MemoryStorage.current.storage_for(self, :attributes)
   end
 
+  def self._attributes_with_string_keys
+    @_attributes_with_string_keys ||= begin
+      result = {}
+      _attributes.each do |key, value|
+        result[key.to_s] = value
+      end
+      result
+    end
+  end
+
   def self.collection_commands(*list)
     list.each do |collection_command|
       ApiMaker::MemoryStorage.current.add(self, :collection_commands, collection_command)
     end
   end
 
+  def self.column_exists_on_model?(model_class, column_name)
+    model_class.column_names.include?(column_name.to_s)
+  rescue ActiveRecord::StatementInvalid
+    # This happens if the table or column doesn't exist - like if we are running during a migration
+    false
+  end
+
   def self.member_commands(*list)
     list.each do |member_command|
       ApiMaker::MemoryStorage.current.add(self, :member_commands, member_command)
@@ -39,7 +66,7 @@ class ApiMaker::BaseResource
   end
 
   def self.model_class_name
-    @model_class_name ||= name.gsub(/Resource$/, "").gsub(/^Resources::/, "")
+    @model_class_name ||= short_name
   end
 
   def self.relationships(*relationships)
@@ -53,7 +80,7 @@ class ApiMaker::BaseResource
   end
 
   def self.collection_name
-    @collection_name ||= plural_name.underscore.dasherize
+    @collection_name ||= plural_name.underscore
   end
 
   def self.default_select
@@ -66,13 +93,112 @@ class ApiMaker::BaseResource
     @plural_name ||= short_name.pluralize
   end
 
+  def self.require_name
+    @require_name ||= collection_name.singularize
+  end
+
   def self.short_name
     @short_name ||= name.match(/\AResources::(.+)Resource\Z/)[1]
   end
 
-  def initialize(ability: nil, args: {}, model:)
+  def self.underscore_name
+    @underscore_name ||= plural_name.underscore
+  end
+
+  def initialize(ability: nil, api_maker_args: {}, locals:, model:)
     @ability = ability
-    @args = args
+    @api_maker_args = api_maker_args
+    @locals = locals || api_maker_args&.dig(:locals) || {}
     @model = model
   end
+
+  def can_access_through(ability:, relationship:)
+    reflection = model_class.reflections.fetch(relationship.to_s)
+    target_model_class = reflection.klass
+    self.ability.load_abilities(target_model_class)
+    relevant_rules = self.ability.__send__(:relevant_rules, ability, target_model_class)
+
+    relevant_rules.each do |relevant_rule|
+      if relevant_rule.conditions.empty?
+        handle_empty_conditions(
+          model_class: model_class,
+          reflection: reflection,
+          relationship: relationship,
+          target_model_class: target_model_class
+        )
+      elsif relevant_rule.conditions.is_a?(Array)
+        handle_array_condition_rule(
+          ability: ability,
+          model_class: model_class,
+          reflection: reflection,
+          relevant_rule: relevant_rule
+        )
+      else
+        can ability, model_class, {
+          reflection.name => relevant_rule.conditions
+        }
+      end
+    end
+  end
+
+  def inspect
+    "#<#{self.class.name}:#{__id__}>"
+  end
+
+  def model_class
+    self.class.model_class
+  end
+
+private
+
+  def handle_empty_conditions(model_class:, reflection:, relationship:, target_model_class:)
+    lookup_query = target_model_class
+      .where("#{target_model_class.table_name}.#{reflection.foreign_key} = #{model_class.table_name}.#{model_class.primary_key}")
+
+    exists_sql = "EXISTS (#{lookup_query.to_sql})"
+
+    can ability, model_class, [exists_sql] do |model|
+      model.__send__(relationship).any?
+    end
+  end
+
+  def handle_array_condition_rule(ability:, model_class:, reflection:, relevant_rule:)
+    if raw_supported_macro?(reflection.macro)
+      nested_sql = nested_raw_sql(
+        model_class: model_class,
+        relevant_rule: relevant_rule,
+        reflection: reflection
+      )
+
+      can ability, model_class, [nested_sql] do |model|
+        model_class.where(nested_sql).exists?(id: model.id)
+      end
+    else
+      raise "No support for macro: #{reflection.macro}"
+    end
+  end
+
+  def raw_supported_macro?(macro)
+    macro == :belongs_to || macro == :has_many || macro == :has_one
+  end
+
+  def nested_raw_sql(model_class:, reflection:, relevant_rule:)
+    # The conditions are given as raw SQL so we nest the original sub-query under a new one that filters on the ID of the current table as well
+    relationship_sql = relevant_rule.conditions.first
+    "EXISTS (" \
+      "SELECT 1 " \
+      "FROM #{reflection.klass.table_name} " \
+      "WHERE " \
+        "#{nested_raw_sql_condition(model_class: model_class, reflection: reflection)} AND " \
+        "(#{relationship_sql})" \
+    ")"
+  end
+
+  def nested_raw_sql_condition(model_class:, reflection:)
+    if reflection.macro == :belongs_to
+      "#{reflection.klass.table_name}.#{reflection.join_primary_key} = #{model_class.table_name}.#{reflection.foreign_key}"
+    else
+      "#{reflection.klass.table_name}.#{reflection.foreign_key} = #{model_class.table_name}.#{model_class.primary_key}"
+    end
+  end
 end

data/lib/api_maker/base_service.rb

@@ -0,0 +1,14 @@
+class ApiMaker::BaseService < ServicePattern::Service
+  ApiMaker::IncludeHelpers.execute!(klass: self)
+
+  attr_reader :args, :api_maker_args, :controller, :current_ability
+
+  delegate :request, allow_nil: true, to: :controller
+
+  def initialize(ability: nil, args: {}, api_maker_args: {}, controller: nil)
+    @args = args
+    @api_maker_args = api_maker_args
+    @controller = controller
+    @current_ability = ability
+  end
+end