api_maker 0.0.1 → 0.0.2

data/app/services/api_maker/collection_command_service.rb

@@ -1,24 +1,38 @@
 class ApiMaker::CollectionCommandService < ApiMaker::CommandService
-  def execute
-    authorize!
+  def perform
+    ApiMaker::Configuration.profile(-> { "CollectionCommand: #{namespace}::#{command_name}" }) do
+      if authorized?
+        constant.execute_in_thread!(
+          ability: ability,
+          api_maker_args: api_maker_args,
+          collection: nil,
+          commands: commands,
+          command_response: command_response,
+          controller: controller
+        )
+      else
+        fail_with_no_access
+      end
 
-    constant.execute_in_thread!(
-      ability: ability,
-      args: args,
-      collection: nil,
-      commands: commands,
-      command_response: command_response,
-      controller: controller
-    )
-
-    ServicePattern::Response.new(success: true)
+      succeed!
+    end
   end
 
-  def authorize!
-    raise CanCan::AccessDenied, "No access to '#{@command_name}' on '#{model_class.name}'" unless @ability.can?(@command_name.to_sym, model_class)
+  def authorized?
+    ability.can?(command_name.to_sym, model_class)
   end
 
   def constant
-    @constant ||= "Commands::#{namespace}::#{@command_name.camelize}".constantize
+    @constant ||= "Commands::#{namespace}::#{command_name.camelize}".constantize
+  end
+
+  def fail_with_no_access
+    commands.each_key do |command_id|
+      command_response.error_for_command(
+        command_id,
+        success: false,
+        errors: ["No access to '#{command_name}' on '#{model_class.name}'"]
+      )
+    end
   end
 end

data/app/services/api_maker/collection_loader.rb

@@ -0,0 +1,124 @@
+class ApiMaker::CollectionLoader < ApiMaker::ApplicationService
+  attr_reader :ability, :api_maker_args, :collection, :locals, :params
+
+  def initialize(ability:, api_maker_args:, collection:, locals: nil, params: {})
+    @ability = ability
+    @api_maker_args = api_maker_args
+    @collection = collection
+    @locals = locals || api_maker_args&.dig(:locals) || {}
+    @params = params
+  end
+
+  def perform
+    set_query
+
+    if params[:count]
+      count = @query.count
+      count = count.length if count.is_a?(Hash)
+
+      succeed!(count: count)
+    else
+      collection = collection_from_query(@query)
+      response = collection.as_json
+      include_pagination_data(response, @query)
+
+      succeed!(response)
+    end
+  end
+
+  def filter_custom_accessible_by(collection)
+    return collection if params[:accessible_by].blank?
+
+    collection.accessible_by(ability, params[:accessible_by].to_sym)
+  end
+
+  def collection_from_query(collection)
+    ApiMaker::CollectionSerializer.new(
+      ability: ability,
+      api_maker_args: api_maker_args,
+      collection: collection,
+      locals: locals,
+      query_params: params
+    ).result
+  end
+
+  def distinct_query
+    @query = @query.distinct if params[:distinct]
+  end
+
+  def group_query
+    return if params[:group_by].blank?
+
+    params[:group_by].each do |group_by|
+      if group_by.is_a?(Array)
+        raise "Expected table and column but array length was wrong: #{group_by.length}" unless group_by.length == 2
+
+        resource_class = group_by[0]
+        column_name = group_by[1]
+        model_class = resource_class.model_class
+        raise "Not a valid column name: #{column_name}" unless model_class.column_names.include?(column_name)
+
+        arel_column = model_class.arel_table[column_name]
+      else
+        arel_column = collection.klass.arel_table[group_by]
+        raise "Not a valid column name: #{group_by}" unless collection.klass.column_names.include?(group_by)
+      end
+
+      @query = @query.group(arel_column)
+    end
+  end
+
+  def limit_query
+    @query = @query.limit(params[:limit]) if params[:limit].present?
+  end
+
+  def include_pagination_data(response, collection)
+    return if params[:page].blank?
+
+    countable_collection = collection.except(:distinct).except(:group).except(:select).except(:order)
+
+    Rails.logger.debug { "API maker: CollectionLoader total pages for #{model_class.name}" }
+    total_pages = countable_collection.total_pages
+
+    Rails.logger.debug { "API maker: CollectionLoader total count for #{model_class.name}" }
+    total_count = countable_collection.try(:total_count) || countable_collection.total_entries
+
+    response[:meta] = {
+      currentPage: collection.current_page,
+      perPage: collection.try(:per_page) || collection.limit_value,
+      totalCount: total_count,
+      totalPages: total_pages
+    }
+  end
+
+  def manage_through_relationship
+    return if params[:through].blank?
+
+    through_model_class = params[:through][:model].safe_constantize
+    through_model = through_model_class.accessible_by(ability).find_by(through_model_class.primary_key => params[:through][:id])
+
+    return if through_model.nil?
+
+    association = ActiveRecord::Associations::Association.new(through_model, through_model_class.reflections.fetch(params[:through][:reflection]))
+
+    query_through = association.scope
+    query_through = query_through.accessible_by(ability)
+
+    filter_custom_accessible_by(query_through)
+  end
+
+  def model_class
+    @model_class ||= collection.klass
+  end
+
+  def set_query
+    @query = manage_through_relationship || collection
+    group_query
+    distinct_query
+    @query = @query.ransack(params[:q]).result
+    limit_query
+    @query = @query.page(params[:page]) if params[:page].present?
+    @query = @query.per_page(params[:per]) if params[:per].present?
+    @query = filter_custom_accessible_by(@query)
+  end
+end

data/app/services/api_maker/command_failed_error.rb

@@ -0,0 +1,3 @@
+class ApiMaker::CommandFailedError < RuntimeError
+  attr_accessor :api_maker_args, :api_maker_block
+end

data/app/services/api_maker/command_response.rb

@@ -47,21 +47,32 @@ class ApiMaker::CommandResponse
 
 private
 
-  def spawn_thread
+  def spawn_thread(&blk)
+    parent_thread = Thread.current
+
     @threads << Thread.new do
+      child_thread = Thread.current
+
       Rails.application.executor.wrap do
-        I18n.with_locale(locale) do
-          yield
+        ApiMaker::Configuration.current.on_thread_callbacks&.each do |on_thread_callback|
+          on_thread_callback.call(parent_thread: parent_thread, child_thread: child_thread)
         end
+
+        I18n.with_locale(locale, &blk)
       end
     rescue => e # rubocop:disable Style/RescueStandardError
       puts e.inspect
-      puts e.backtrace
+      puts Rails.backtrace_cleaner.clean(e.backtrace)
 
       Rails.logger.error e.message
-      Rails.logger.error e.backtrace.join("\n")
+      Rails.logger.error Rails.backtrace_cleaner.clean(e.backtrace).join("\n")
 
-      ApiMaker::Configuration.current.report_error(controller: controller, error: e)
+      ApiMaker::Configuration.current.report_error(
+        command: nil,
+        controller: controller,
+        error: e,
+        response: nil
+      )
     end
   end
 end

data/app/services/api_maker/command_service.rb

@@ -1,9 +1,9 @@
 class ApiMaker::CommandService < ApiMaker::ApplicationService
-  attr_reader :ability, :args, :commands, :command_name, :command_response, :controller, :resource_name
+  attr_reader :ability, :api_maker_args, :commands, :command_name, :command_response, :controller, :resource_name
 
-  def initialize(ability:, args:, commands:, command_name:, command_response:, controller:, resource_name:)
+  def initialize(ability:, api_maker_args:, commands:, command_name:, command_response:, controller:, resource_name:)
     @ability = ability
-    @args = args
+    @api_maker_args = api_maker_args
     @command_name = command_name
     @command_response = command_response
     @commands = commands

data/app/services/api_maker/create_command.rb

@@ -1,38 +1,27 @@
 class ApiMaker::CreateCommand < ApiMaker::BaseCommand
-  attr_reader :command, :model, :params, :serializer
+  attr_reader :model, :serializer
 
   def execute!
-    each_command do |command|
-      @command = command
+    ApiMaker::Configuration.profile(-> { "CreateCommand: #{model_class.name}" }) do
       @model = collection.klass.new
-      @params = command.args || {}
       @serializer = serialized_resource(model)
-      @model.assign_attributes(sanitize_parameters)
+      sanitized_parameters = sanitize_parameters
+      @model.assign_attributes(sanitized_parameters)
 
-      if !current_ability.can?(:create, @model)
-        failure_response(["No access to create that resource"])
-      elsif @model.save
+      if !current_ability.can?(:create, model)
+        failure_response(errors: ["No access to create that resource"])
+      elsif model.save
         success_response
       else
-        failure_response(model.errors.full_messages)
+        failure_save_response(model: model, params: sanitized_parameters)
       end
     end
-
-    ServicePattern::Response.new(success: true)
   end
 
   def api_maker_resource_class
     @api_maker_resource_class ||= "Resources::#{collection.klass.name}Resource".constantize
   end
 
-  def failure_response(errors)
-    command.fail(
-      model: serializer.result,
-      success: false,
-      errors: errors
-    )
-  end
-
   def resource_instance_class_name
     @resource_instance_class_name ||= self.class.name.split("::").last.gsub(/Controller$/, "").singularize
   end
@@ -46,16 +35,12 @@ class ApiMaker::CreateCommand < ApiMaker::BaseCommand
   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/create_command_service.rb

@@ -1,15 +1,15 @@
 class ApiMaker::CreateCommandService < ApiMaker::CommandService
-  def execute
+  def perform
     ApiMaker::CreateCommand.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/database_type.rb

@@ -0,0 +1,9 @@
+class ApiMaker::DatabaseType
+  def self.postgres?
+    adapter_name == :postgresql
+  end
+
+  def self.adapter_name
+    @adapter_name ||= ApplicationRecord.connection.adapter_name.downcase.to_sym
+  end
+end

data/app/services/api_maker/deep_merge_params.rb

@@ -0,0 +1,26 @@
+class ApiMaker::DeepMergeParams < ApiMaker::ApplicationService
+  attr_reader :hash1, :hash2
+
+  def initialize(hash1, hash2)
+    @hash1 = hash1
+    @hash2 = hash2
+  end
+
+  def perform
+    merged_hash = hash1.deep_merge(hash2) do |_key, this_val, other_val|
+      if this_val.is_a?(Array) && other_val.is_a?(Array) && this_val.length == other_val.length
+        this_val.zip(other_val).collect do |a, b|
+          if a.is_a?(Hash) && b.is_a?(Hash)
+            a.deep_merge(b)
+          else
+            other_val
+          end
+        end
+      else
+        other_val
+      end
+    end
+
+    succeed! merged_hash
+  end
+end

data/app/services/api_maker/deserializer.rb

@@ -0,0 +1,35 @@
+class ApiMaker::Deserializer < ApiMaker::ApplicationService
+  attr_reader :arg
+
+  def initialize(arg:)
+    @arg = arg
+  end
+
+  def perform
+    succeed! deserialize
+  end
+
+  def deserialize
+    if arg.is_a?(Array)
+      arg.map { |value| ApiMaker::Deserializer.execute!(arg: value) }
+    elsif arg.is_a?(Hash) || arg.is_a?(ActionController::Parameters)
+      if arg["api_maker_type"] == "resource"
+        "Resources::#{arg.fetch("name")}Resource".safe_constantize
+      elsif arg["api_maker_type"] == "datetime"
+        Time.zone.parse(arg.fetch("value"))
+      else
+        new_hash = arg.class.new
+        arg.each do |key, value|
+          deserialized_key = ApiMaker::Deserializer.execute!(arg: key)
+          deserialized_value = ApiMaker::Deserializer.execute!(arg: value)
+
+          new_hash[deserialized_key] = deserialized_value
+        end
+
+        new_hash
+      end
+    else
+      arg
+    end
+  end
+end

data/app/services/api_maker/destroy_command.rb

@@ -1,38 +1,32 @@
 class ApiMaker::DestroyCommand < 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 || {}
-      @serializer = serialized_resource(model)
+    @serializer = serialized_resource(model)
 
-      if command.model.destroy
-        success_response
-      else
-        failure_response
-      end
+    if command.model.destroy
+      success_response
+    else
+      failure_response
     end
+  end
 
-    ServicePattern::Response.new(success: true)
+  def errors_for_model
+    ActiveRecordBetterDependentErrorMessages::DestroyValidator.(model: model) if model.errors.full_messages.empty?
+    model.errors.full_messages
   end
 
   def failure_response
-    command.fail(
-      model: serializer.result,
+    fail!(
+      model: serialized_model(model),
       success: false,
-      errors: model.errors.full_messages
+      errors: errors_for_model
     )
   end
 
-  def serialized_resource(model)
-    ApiMaker::Serializer.new(ability: current_ability, args: api_maker_args, model: model)
-  end
-
   def success_response
-    command.result(
-      model: serializer.result,
+    succeed!(
+      model: serialized_model(model),
       success: true
     )
   end

data/app/services/api_maker/destroy_command_service.rb

@@ -1,15 +1,15 @@
 class ApiMaker::DestroyCommandService < ApiMaker::CommandService
-  def execute
+  def perform
     ApiMaker::DestroyCommand.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/generate_react_native_api_service.rb

@@ -1,10 +1,10 @@
 class ApiMaker::GenerateReactNativeApiService < ApiMaker::ApplicationService
-  def execute
+  def perform
     check_if_root_folder_defined
     create_root_folder
     create_model_files
 
-    ServicePattern::Response.new(success: true)
+    succeed!
   end
 
   def root_folder
@@ -21,20 +21,6 @@ class ApiMaker::GenerateReactNativeApiService < ApiMaker::ApplicationService
     Dir.mkdir(root_folder) unless Dir.exist?(root_folder)
   end
 
-  def create_model_files
-    model_generator_service.models.each do |model|
-      next if model_generator_service.ignore_model?(model)
-
-      model_content_response = ApiMaker::ModelContentGeneratorService.execute!(model: model)
-
-      if model_content_response.success?
-        File.open(model_file(model), "w") { |fp| fp.write(model_content_response.result) }
-      else
-        puts model_content_response.errors.join(". ")
-      end
-    end
-  end
-
   def model_generator_service
     @model_generator_service ||= ApiMaker::ModelsGeneratorService.new
   end
@@ -50,9 +36,7 @@ class ApiMaker::GenerateReactNativeApiService < ApiMaker::ApplicationService
 
   def copy_base_model
     files = %w[
-      api.js base-model.js cable-connection-pool.js cable-subscription.js cable-subscription-pool.js
-      collection.js commands-pool.js devise.js event-listener.jsx error-logger.js form-data-to-object.js logger.js
-      model-name.js models-response-reader.js result.js event-connection.jsx
+      devise.js event-connection.jsx
     ]
     path = File.join(__dir__, "..", "..", "..", "lib", "api_maker", "javascript")
 

data/app/services/api_maker/include_helpers.rb

@@ -0,0 +1,17 @@
+require_relative "../../api_maker/api_helpers/api_maker_helpers" # Sometimes this file isn't auto-loaded so it needs to be manually required
+
+class ApiMaker::IncludeHelpers < ApiMaker::ApplicationService
+  attr_reader :klass
+
+  def initialize(klass:)
+    @klass = klass
+  end
+
+  def perform
+    ::ApiHelpers.constants(false).each do |constant|
+      klass.include ApiHelpers.const_get(constant)
+    end
+
+    succeed!
+  end
+end

data/app/services/api_maker/index_command.rb

@@ -1,96 +1,16 @@
 class ApiMaker::IndexCommand < ApiMaker::BaseCommand
-  attr_reader :params
-
   def execute!
-    ApiMaker::Configuration.profile("IndexCommand execute") do
-      each_command do |command|
-        @params = command.args || {}
-
-        set_collection
-
-        if params[:count]
-          count = @query.count
-          count = count.length if count.is_a?(Hash)
-
-          command.result(count: count)
-        else
-          collection = collection_from_query(@query.fix)
-          response = collection.as_json
-          include_pagination_data(response, @query)
-
-          command.result(response)
-        end
-      end
-    end
-
-    ServicePattern::Response.new(success: true)
-  end
-
-  def filter_custom_accessible_by(collection)
-    return collection if params[:accessible_by].blank?
-
-    collection.accessible_by(current_ability, params[:accessible_by].to_sym)
-  end
+    ApiMaker::Configuration.profile(-> { "IndexCommand: #{model_class.name}" }) do
+      Rails.logger.debug { "API maker: IndexCommand execute: #{model_class.name} with Ransack: #{command.args&.dig(:q)&.permit!&.to_h}" }
 
-  def collection_from_query(collection)
-    ApiMaker::Configuration.profile("IndexCommand collection_from_query") do
-      select = parse_select(params[:select]&.permit!&.to_hash) if params[:select]
-
-      ApiMaker::CollectionSerializer.new(
+      result = ApiMaker::CollectionLoader.execute!(
         ability: current_ability,
-        args: api_maker_args,
+        api_maker_args: api_maker_args,
         collection: collection,
-        include_param: params[:include],
-        select: select
-      ).result
+        locals: locals,
+        params: command.args || {}
+      )
+      succeed!(result)
     end
   end
-
-  def include_pagination_data(response, collection)
-    return if params[:page].blank?
-
-    response[:meta] = {
-      currentPage: collection.current_page,
-      totalCount: collection.try(:total_count) || collection.try(:total_entries),
-      totalPages: collection.total_pages
-    }
-  end
-
-  def manage_through_relationship
-    return if params[:through].blank?
-
-    model_class = params[:through][:model].safe_constantize
-    through_model = model_class.accessible_by(current_ability).find(params[:through][:id])
-    association = ActiveRecord::Associations::Association.new(through_model, model_class.reflections.fetch(params[:through][:reflection]))
-
-    query_through = association.scope
-    query_through = query_through.accessible_by(current_ability)
-    query_through = filter_custom_accessible_by(query_through)
-    query_through
-  end
-
-  # This converts the list of attributes to a hash that contains the data needed for the serializer (so the serializer doesn't have to do it for each model)
-  def parse_select(select)
-    new_select = {}
-
-    select.each do |model_collection_name, attributes|
-      model_class = model_collection_name.underscore.singularize.camelize
-      resource = "Resources::#{model_class}Resource".safe_constantize
-      raise "Resource not found for: #{model_collection_name}" unless resource
-
-      new_attributes = resource._attributes.select { |key| attributes.include?(key.to_s) }
-      new_select[resource.model_class] = new_attributes
-    end
-
-    new_select
-  end
-
-  def set_collection
-    @query = manage_through_relationship || collection
-    @query = @query.distinct if params[:distinct]
-    @query = @query.ransack(params[:q]).result
-    @query = @query.limit(params[:limit]) if params[:limit].present?
-    @query = @query.page(params[:page]) if params[:page].present?
-    @query = filter_custom_accessible_by(@query)
-  end
 end

data/app/services/api_maker/index_command_service.rb

@@ -1,22 +1,22 @@
 class ApiMaker::IndexCommandService < ApiMaker::CommandService
-  def execute
+  def perform
     ApiMaker::IndexCommand.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
-    @collection ||= model_class.accessible_by(@ability)
+    @collection ||= model_class.accessible_by(ability)
   end
 
   def ids
-    @ids ||= @commands.values.map { |command| command.fetch("primary_key") }
+    @ids ||= commands.values.map { |command| command.fetch("primary_key") }
   end
 end

data/app/services/api_maker/js_method_namer_service.rb

@@ -3,7 +3,7 @@ class ApiMaker::JsMethodNamerService < ApiMaker::ApplicationService
     @name = name
   end
 
-  def execute
+  def perform
     camelized = @name.to_s.camelize
     new_name = "#{camelized[0..0].downcase}#{camelized[1..camelized.length]}"
     ServicePattern::Response.new(result: new_name)