api_maker 0.0.1

data/app/services/api_maker/update_command.rb

@@ -0,0 +1,43 @@
+class ApiMaker::UpdateCommand < ApiMaker::BaseCommand
+  attr_reader :command, :model, :params, :serializer
+
+  def execute!
+    each_command do |command|
+      @command = command
+      @model = command.model
+      @params = command.args || {}
+      @serializer = serialized_resource(model)
+
+      if command.model.update(sanitize_parameters)
+        success_response
+      else
+        failure_response
+      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)
+  end
+
+  def success_response
+    command.result(
+      model: serializer.result,
+      success: true
+    )
+  end
+end

data/app/services/api_maker/update_command_service.rb

@@ -0,0 +1,21 @@
+class ApiMaker::UpdateCommandService < ApiMaker::CommandService
+  def execute
+    ApiMaker::UpdateCommand.execute_in_thread!(
+      ability: ability,
+      args: args,
+      collection: collection,
+      commands: commands,
+      command_response: command_response,
+      controller: controller
+    )
+    ServicePattern::Response.new(success: true)
+  end
+
+  def collection
+    @collection ||= model_class.accessible_by(@ability, :update).where(model_class.primary_key => ids)
+  end
+
+  def ids
+    @commands.values.map { |command| command.fetch("primary_key") }
+  end
+end

data/app/services/api_maker/valid_command.rb

@@ -0,0 +1,35 @@
+class ApiMaker::ValidCommand < ApiMaker::BaseCommand
+  attr_reader :command, :model, :params, :serializer
+
+  def execute!
+    each_command do |command|
+      @command = command
+      @params = command.args || {}
+
+      if command.model_id.present?
+        model = resource_instance_class.find(command.model_id)
+      else
+        model = resource_instance_class.new
+      end
+
+      serializer = serialized_resource(model)
+      model.assign_attributes(sanitize_parameters(serializer))
+
+      command.result(valid: model.valid?, errors: model.errors.full_messages)
+    end
+
+    ServicePattern::Response.new(success: true)
+  end
+
+  def resource_instance_class
+    collection.klass
+  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)
+  end
+end

data/app/services/api_maker/valid_command_service.rb

@@ -0,0 +1,21 @@
+class ApiMaker::ValidCommandService < ApiMaker::CommandService
+  def execute
+    ApiMaker::ValidCommand.execute_in_thread!(
+      ability: ability,
+      args: args,
+      collection: collection,
+      commands: commands,
+      command_response: command_response,
+      controller: controller
+    )
+    ServicePattern::Response.new(success: true)
+  end
+
+  def collection
+    @collection ||= model_class.accessible_by(@ability, :valid).where(model_class.primary_key => ids)
+  end
+
+  def ids
+    @commands.values.map { |command| command.fetch("primary_key") }
+  end
+end

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

@@ -0,0 +1,15 @@
+<div class="api-maker-data"<%
+
+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
+
+  serializer = ApiMaker::Serializer.new(ability: current_ability, args: api_maker_args, model: model) if model
+
+  %> data-current-<%= scope[0].to_s.dasherize %>="<%= model ? serializer.to_json : null %>"<%
+end
+
+%>></div>

data/config/rails_best_practices.yml

@@ -0,0 +1,55 @@
+AddModelVirtualAttributeCheck: { }
+AlwaysAddDbIndexCheck: { }
+#CheckSaveReturnValueCheck: { }
+#CheckDestroyReturnValueCheck: { }
+DefaultScopeIsEvilCheck: { }
+DryBundlerInCapistranoCheck: { }
+#HashSyntaxCheck: { }
+IsolateSeedDataCheck: { }
+KeepFindersOnTheirOwnModelCheck: { }
+LawOfDemeterCheck: { }
+#LongLineCheck: { max_line_length: 80 }
+MoveCodeIntoControllerCheck: { }
+MoveCodeIntoHelperCheck: { array_count: 3 }
+MoveCodeIntoModelCheck: { use_count: 2 }
+MoveFinderToNamedScopeCheck: { }
+#MoveModelLogicIntoModelCheck: { use_count: 4 }
+NeedlessDeepNestingCheck: { nested_count: 2 }
+NotRescueExceptionCheck: { }
+NotUseDefaultRouteCheck: { }
+NotUseTimeAgoInWordsCheck: { }
+OveruseRouteCustomizationsCheck: { customize_count: 3 }
+ProtectMassAssignmentCheck: { }
+RemoveEmptyHelpersCheck: { }
+#RemoveTabCheck: { }
+RemoveTrailingWhitespaceCheck: { }
+RemoveUnusedMethodsInControllersCheck: {
+  except_methods: [
+    "ApiMaker::BaseController#current_ability",
+    "ApiMaker::CommandsController#create",
+    "ApiMaker::DeviseController#do_sign_in",
+    "ApiMaker::DeviseController#do_sign_out",
+    "ApiMaker::MemberActionsController#create",
+    "ApiMaker::ModelController#index",
+    "ApiMaker::ModelController#show",
+    "ApiMaker::ModelController#create",
+    "ApiMaker::ModelController#edit",
+    "ApiMaker::ModelController#validate"
+  ]
+}
+RemoveUnusedMethodsInHelpersCheck: { except_methods: [] }
+RemoveUnusedMethodsInModelsCheck: { except_methods: [] }
+ReplaceComplexCreationWithFactoryMethodCheck: { attribute_assignment_count: 2 }
+ReplaceInstanceVariableWithLocalVariableCheck: { }
+RestrictAutoGeneratedRoutesCheck: { }
+SimplifyRenderInControllersCheck: { }
+SimplifyRenderInViewsCheck: { }
+#UseBeforeFilterCheck: { customize_count: 2 }
+UseModelAssociationCheck: { }
+UseMultipartAlternativeAsContentTypeOfEmailCheck: { }
+#UseParenthesesInMethodDefCheck: { }
+UseObserverCheck: { }
+UseQueryAttributeCheck: { }
+UseSayWithTimeInMigrationsCheck: { }
+UseScopeAccessCheck: { }
+UseTurboSprocketsRails3Check: { }

data/config/routes.rb

@@ -0,0 +1,7 @@
+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.rb

@@ -0,0 +1,36 @@
+require "api_maker/engine"
+
+require "active_record_query_fixer"
+require "ransack"
+require "service_pattern"
+
+require_relative "api_maker/action_controller_base_extensions"
+
+module ApiMaker
+  dir = "#{__dir__}/api_maker"
+
+  autoload :Ability, "#{dir}/ability"
+  autoload :AbilityLoader, "#{dir}/ability_loader"
+  autoload :BaseCommand, "#{dir}/base_command"
+  autoload :BaseResource, "#{dir}/base_resource"
+  autoload :CollectionSerializer, "#{dir}/collection_serializer"
+  autoload :CommandSpecHelper, "#{dir}/command_spec_helper"
+  autoload :Configuration, "#{dir}/configuration"
+  autoload :IndividualCommand, "#{dir}/individual_command"
+  autoload :Loader, "#{dir}/loader"
+  autoload :MemoryStorage, "#{dir}/memory_storage"
+  autoload :ModelExtensions, "#{dir}/model_extensions"
+  autoload :PermittedParamsArgument, "#{dir}/permitted_params_argument"
+  autoload :Preloader, "#{dir}/preloader"
+  autoload :PreloaderBelongsTo, "#{dir}/preloader_belongs_to"
+  autoload :PreloaderHasMany, "#{dir}/preloader_has_many"
+  autoload :PreloaderHasOne, "#{dir}/preloader_has_one"
+  autoload :PreloaderThrough, "#{dir}/preloader_through"
+  autoload :RelationshipIncluder, "#{dir}/relationship_includer"
+  autoload :ResourceRouting, "#{dir}/resource_routing"
+  autoload :ResultParser, "#{dir}/result_parser"
+  autoload :Serializer, "#{dir}/serializer"
+  autoload :SpecHelper, "#{dir}/spec_helper"
+end
+
+require_relative "api_maker/railtie"

data/lib/api_maker/ability.rb

@@ -0,0 +1,39 @@
+class ApiMaker::Ability
+  include CanCan::Ability
+
+  attr_reader :loader
+
+  def initialize(args: nil)
+    @args = args
+    @loader = ApiMaker::AbilityLoader.new(ability: self, args: args)
+  end
+
+  # Override methods from CanCan::Ability to first load abilities from the given resource
+  def can?(*args)
+    subject = args.second
+    load_abilities(subject)
+    super
+  end
+
+  def model_adapter(*args)
+    subject = args.first
+    load_abilities(subject)
+    super
+  end
+
+  def load_abilities(subject)
+    return unless active_record?(subject)
+
+    if subject.class == Class
+      loader.load_model_class(subject)
+    elsif subject.class != Class
+      loader.load_model_class(subject.class)
+    end
+  end
+
+  def active_record?(subject)
+    return subject < ActiveRecord::Base if subject.class == Class
+
+    subject.is_a?(ActiveRecord::Base)
+  end
+end

data/lib/api_maker/ability_loader.rb

@@ -0,0 +1,21 @@
+class ApiMaker::AbilityLoader
+  def initialize(ability:, args:)
+    @ability = ability
+    @args = args
+    @loaded_model_names = {}
+  end
+
+  def load_model_class(model_class)
+    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)
+
+    resource.new(ability: @ability, args: @args, model: nil).abilities
+    @loaded_model_names[resource.model_class_name] = true
+  end
+end

data/lib/api_maker/action_controller_base_extensions.rb

@@ -0,0 +1,5 @@
+ActionController::Base.__send__(:define_method, :api_maker_args) do
+  @api_maker_args ||= {}
+end
+
+ActionController::Base.helper_method(:api_maker_args)

data/lib/api_maker/base_command.rb

@@ -0,0 +1,81 @@
+class ApiMaker::BaseCommand
+  attr_reader :api_maker_args, :commands, :command_response, :collection, :controller, :current_ability
+
+  # Returns true if the gem "goldiloader" is present in the app
+  def self.goldiloader?
+    @goldiloader = Gem::Specification.find_all_by_name("goldiloader").any? if @goldiloader.nil?
+    @goldiloader
+  end
+
+  def initialize(ability:, args:, collection:, commands:, command_response:, controller:)
+    @api_maker_args = args
+    @current_ability = ability
+    @collection = collection
+    @commands = commands
+    @command_response = command_response
+    @controller = controller
+
+    # Make it possible to do custom preloads (useful in threadded mode that doesnt support Goldiloader)
+    @collection = custom_collection(@collection) if respond_to?(:custom_collection)
+  end
+
+  def self.execute_in_thread!(**args)
+    args.fetch(:command_response).with_thread do
+      new(**args).execute!
+    end
+  end
+
+  def each_command(args = {}, &blk)
+    if args[:threadded]
+      # Goldiloader doesn't work with threads (loads all relationships for each thread)
+      @collection = @collection.auto_include(false) if ApiMaker::BaseCommand.goldiloader?
+
+      # Load relationship before commands so each command doesn't query on its own
+      @collection.load
+    end
+
+    @commands.each do |command_id, command_data|
+      if args[:threadded]
+        command_response.with_thread do
+          run_command(command_id, command_data, &blk)
+        end
+      else
+        run_command(command_id, command_data, &blk)
+      end
+    end
+  end
+
+  delegate :result_for_command, to: :command_response
+
+private
+
+  def run_command(command_id, command_data)
+    command = ApiMaker::IndividualCommand.new(
+      args: command_data[:args],
+      collection: @collection,
+      command: self,
+      id: command_id,
+      primary_key: command_data[:primary_key],
+      response: command_response
+    )
+
+    begin
+      yield command
+    rescue => e # rubocop:disable Style/RescueStandardError
+      command.error(success: false, errors: [command_error_message(e)])
+
+      Rails.logger.error e.message
+      Rails.logger.error e.backtrace.join("\n")
+
+      ApiMaker::Configuration.current.report_error(controller: controller, error: e)
+    end
+  end
+
+  def command_error_message(error)
+    if Rails.application.config.consider_all_requests_local
+      "#{error.class.name}: #{error.message}"
+    else
+      "Internal server error"
+    end
+  end
+end

data/lib/api_maker/base_resource.rb

@@ -0,0 +1,78 @@
+class ApiMaker::BaseResource
+  attr_reader :ability, :args, :model
+
+  delegate :can, to: :ability
+
+  CRUD = [:create, :read, :update, :destroy].freeze
+
+  def self.attributes(*attributes, **args)
+    attributes.each do |attribute|
+      ApiMaker::MemoryStorage.current.add(self, :attributes, attribute, args)
+    end
+  end
+
+  def self._attributes
+    ApiMaker::MemoryStorage.current.storage_for(self, :attributes)
+  end
+
+  def self.collection_commands(*list)
+    list.each do |collection_command|
+      ApiMaker::MemoryStorage.current.add(self, :collection_commands, collection_command)
+    end
+  end
+
+  def self.member_commands(*list)
+    list.each do |member_command|
+      ApiMaker::MemoryStorage.current.add(self, :member_commands, member_command)
+    end
+  end
+
+  def self.model_class=(klass)
+    # Set the name to avoid reloading issues with Rails
+    @model_class_name ||= klass.name
+    ApiMaker::MemoryStorage.current.model_class_for(resource: self, klass: klass)
+  end
+
+  def self.model_class
+    # Use the name to constantize to avoid reloading issues with Rails
+    model_class_name.constantize
+  end
+
+  def self.model_class_name
+    @model_class_name ||= name.gsub(/Resource$/, "").gsub(/^Resources::/, "")
+  end
+
+  def self.relationships(*relationships)
+    relationships.each do |relationship|
+      ApiMaker::MemoryStorage.current.add(self, :relationships, relationship)
+    end
+  end
+
+  def self._relationships
+    ApiMaker::MemoryStorage.current.storage_for(self, :relationships)
+  end
+
+  def self.collection_name
+    @collection_name ||= plural_name.underscore.dasherize
+  end
+
+  def self.default_select
+    _attributes.select do |_attribute_name, args|
+      !args.fetch(:args).key?(:selected_by_default) || args.fetch(:args).fetch(:selected_by_default)
+    end
+  end
+
+  def self.plural_name
+    @plural_name ||= short_name.pluralize
+  end
+
+  def self.short_name
+    @short_name ||= name.match(/\AResources::(.+)Resource\Z/)[1]
+  end
+
+  def initialize(ability: nil, args: {}, model:)
+    @ability = ability
+    @args = args
+    @model = model
+  end
+end