api_maker 0.0.1

data/Rakefile

@@ -0,0 +1,27 @@
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "ApiMaker"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+if Rails.env.development? || Rails.env.test?
+  require "best_practice_project"
+  BestPracticeProject.load_tasks
+end

data/app/channels/api_maker/subscriptions_channel.rb

@@ -0,0 +1,80 @@
+class ApiMaker::SubscriptionsChannel < ApplicationCable::Channel
+  def subscribed
+    params[:subscription_data].each do |model_name, subscription_types|
+      subscription_types["events"]&.each do |event_name, model_ids|
+        connect_event(model_name, model_ids, event_name)
+      end
+
+      connect_creates(model_name) if subscription_types.key?("creates")
+
+      if subscription_types.key?("updates")
+        model_ids = subscription_types.fetch("updates")
+        connect_updates(model_name, model_ids)
+      end
+
+      if subscription_types.key?("destroys")
+        model_ids = subscription_types.fetch("destroys")
+        connect_destroys(model_name, model_ids)
+      end
+    end
+  end
+
+private
+
+  def connect_creates(model_name)
+    model_class = model_for_resource_name(model_name)
+    channel_name = model_class.api_maker_broadcast_create_channel_name
+    stream_from(channel_name, coder: ActiveSupport::JSON) do |data|
+      # We need to look the model up to evaluate if the user has access
+      model = data.fetch("model_class_name").safe_constantize.accessible_by(current_ability, :create_events).find(data.fetch("model_id"))
+
+      # Transmit the data to JS if its allowed
+      transmit data if model
+    end
+  end
+
+  def connect_destroys(model_name, model_ids)
+    model_class = model_for_resource_name(model_name)
+    models = model_class.accessible_by(current_ability, :destroy_events).where(model_class.primary_key => model_ids)
+    models.each do |model|
+      channel_name = model.api_maker_broadcast_destroy_channel_name
+      stream_from(channel_name, coder: ActiveSupport::JSON) do |data|
+        transmit data
+      end
+    end
+  end
+
+  def connect_event(model_name, model_ids, event_name)
+    ability_name = "event_#{event_name}".to_sym
+    model_class = model_for_resource_name(model_name)
+    models = model_class.accessible_by(current_ability, ability_name).where(model_class.primary_key => model_ids)
+    models.each do |model|
+      channel_name = model.api_maker_event_channel_name(event_name)
+      stream_from(channel_name, coder: ActiveSupport::JSON) do |data|
+        transmit data
+      end
+    end
+  end
+
+  def connect_updates(model_name, model_ids)
+    model_class = model_for_resource_name(model_name)
+    models = model_class.accessible_by(current_ability, :update_events).where(model_class.primary_key => model_ids)
+    models.each do |model|
+      channel_name = model.api_maker_broadcast_update_channel_name
+      stream_from(channel_name, coder: ActiveSupport::JSON) do |data|
+        transmit data
+      end
+    end
+  end
+
+  def model_for_resource_name(resource_name)
+    resource_for_resource_name(resource_name).model_class
+  end
+
+  def resource_for_resource_name(resource_name)
+    resource = "Resources::#{resource_name}Resource".safe_constantize
+    raise "Cannot find resource by resource name: #{resource_name}" unless resource
+
+    resource
+  end
+end

data/app/controllers/api_maker/base_controller.rb

@@ -0,0 +1,32 @@
+class ApiMaker::BaseController < ApplicationController
+  protect_from_forgery with: :exception
+
+  before_action :set_locale
+
+  rescue_from Exception, with: :render_error
+
+private
+
+  def current_ability
+    @current_ability ||= ::ApiMaker::Ability.new(args: api_maker_args)
+  end
+
+  def render_error(error)
+    puts error.inspect
+    puts error.backtrace
+
+    logger.error error.inspect
+    logger.error error.backtrace.join("\n")
+
+    raise error
+  end
+
+  def set_locale
+    return if session[:locale].blank?
+
+    locale = session[:locale].to_s
+    locale_exists = I18n.available_locales.map(&:to_s).include?(locale)
+
+    I18n.locale = locale if locale_exists
+  end
+end

data/app/controllers/api_maker/commands_controller.rb

@@ -0,0 +1,26 @@
+class ApiMaker::CommandsController < ApiMaker::BaseController
+  def create
+    command_response = ApiMaker::CommandResponse.new(controller: self)
+    controller = self
+
+    params[:pool].each do |command_type, command_type_data|
+      command_type_data.each do |resource_plural_name, command_model_data|
+        command_model_data.each do |command_name, command_data|
+          ApiMaker.const_get("#{command_type.camelize}CommandService").execute!(
+            ability: current_ability,
+            args: api_maker_args,
+            command_response: command_response,
+            commands: command_data,
+            command_name: command_name,
+            resource_name: resource_plural_name,
+            controller: controller
+          )
+        end
+      end
+    end
+
+    command_response.join_threads
+
+    render json: {responses: command_response.result}
+  end
+end

data/app/controllers/api_maker/devise_controller.rb

@@ -0,0 +1,60 @@
+class ApiMaker::DeviseController < ApiMaker::BaseController
+  include Devise::Controllers::Rememberable
+
+  before_action :check_model_exists, only: :do_sign_in
+  before_action :check_serializer_exists, only: :do_sign_in
+
+  def do_sign_in
+    if !model.active_for_authentication?
+      render json: {success: false, errors: [model.inactive_message]}
+    elsif model.valid_password?(params[:password])
+      sign_in(model, scope: scope)
+      remember_me(model) if params.dig(:args, :rememberMe)
+      render json: {success: true, model_data: serializer.result}
+    else
+      render json: {success: false, errors: [invalid_error_message]}
+    end
+  end
+
+  def do_sign_out
+    scope = params.dig(:args, :scope).presence || "user"
+    current_model = __send__("current_#{scope}")
+    sign_out current_model
+    render json: {success: true}
+  end
+
+private
+
+  def check_model_exists
+    error_msg = t("devise.failure.not_found_in_database", authentication_keys: model_class.authentication_keys.join(", "))
+    render json: {success: false, errors: [error_msg]} unless model
+  end
+
+  def check_serializer_exists
+    render json: {success: false, errors: ["Serializer doesn't exist for #{scope}"]} unless resource
+  end
+
+  def invalid_error_message
+    t("devise.failure.invalid", authentication_keys: model_class.authentication_keys.join(", "))
+  end
+
+  def model
+    @model ||= model_class.find_for_authentication(email: params[:username])
+  end
+
+  def model_class
+    @model_class ||= scope.camelize.safe_constantize
+  end
+
+  def scope
+    @scope ||= params.dig(:args, :scope).presence || "user"
+  end
+
+  def resource
+    @resource ||= ApiMaker::Serializer.resource_for(model.class)
+  end
+
+  def serializer
+    @serializer ||= ApiMaker::Serializer.new(ability: current_ability, args: api_maker_args, model: model)
+  end
+end

data/app/controllers/api_maker/session_statuses_controller.rb

@@ -0,0 +1,33 @@
+class ApiMaker::SessionStatusesController < ActionController::Base
+  skip_before_action :verify_authenticity_token, raise: false
+
+  def create
+    scopes = {}
+    result = {
+      devise: {
+        timeout_in: Devise.timeout_in.to_i
+      },
+      csrf_token: form_authenticity_token,
+      scopes: scopes
+    }
+
+    Devise.mappings.each do |scope|
+      klass = scope[1].class_name.safe_constantize
+      param_key = klass.model_name.param_key
+
+      model_method_name = "current_#{param_key}"
+      model = __send__(model_method_name)
+      model_pk = model&.__send__(klass.primary_key)
+
+      signed_in_method_name = "#{param_key}_signed_in?"
+      signed_in = __send__(signed_in_method_name)
+
+      scopes[param_key] = {
+        primary_key: model_pk,
+        signed_in: signed_in
+      }
+    end
+
+    render json: result
+  end
+end

data/app/services/api_maker/application_service.rb

@@ -0,0 +1,7 @@
+class ApiMaker::ApplicationService < ServicePattern::Service
+  def api_maker_json(object)
+    json = object.to_json
+    json.gsub!(/"\{\{(.+?)\}\}"/, "\\1")
+    json
+  end
+end

data/app/services/api_maker/collection_command_service.rb

@@ -0,0 +1,24 @@
+class ApiMaker::CollectionCommandService < ApiMaker::CommandService
+  def execute
+    authorize!
+
+    constant.execute_in_thread!(
+      ability: ability,
+      args: args,
+      collection: nil,
+      commands: commands,
+      command_response: command_response,
+      controller: controller
+    )
+
+    ServicePattern::Response.new(success: true)
+  end
+
+  def authorize!
+    raise CanCan::AccessDenied, "No access to '#{@command_name}' on '#{model_class.name}'" unless @ability.can?(@command_name.to_sym, model_class)
+  end
+
+  def constant
+    @constant ||= "Commands::#{namespace}::#{@command_name.camelize}".constantize
+  end
+end

data/app/services/api_maker/command_response.rb

@@ -0,0 +1,67 @@
+class ApiMaker::CommandResponse
+  attr_reader :controller, :locale, :result
+
+  def initialize(controller:)
+    @controller = controller
+    @locale = I18n.locale
+    @mutex = Mutex.new
+    @result = {}
+    @threads = []
+  end
+
+  def error_for_command(id, data)
+    respond_to_command(id, data, :error)
+  end
+
+  def fail_for_command(id, data)
+    respond_to_command(id, data, :failed)
+  end
+
+  def result_for_command(id, data)
+    respond_to_command(id, data, :success)
+  end
+
+  def join_threads
+    ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+      @threads.each(&:join)
+    end
+  end
+
+  def respond_to_command(id, data, type)
+    @mutex.synchronize do
+      @result[id] = {type: type, data: data}
+    end
+  end
+
+  def threadding?
+    ApiMaker::Configuration.current.threadding
+  end
+
+  def with_thread(&blk)
+    if Rails.env.test? || !threadding?
+      yield
+    else
+      spawn_thread(&blk)
+    end
+  end
+
+private
+
+  def spawn_thread
+    @threads << Thread.new do
+      Rails.application.executor.wrap do
+        I18n.with_locale(locale) do
+          yield
+        end
+      end
+    rescue => e # rubocop:disable Style/RescueStandardError
+      puts e.inspect
+      puts e.backtrace
+
+      Rails.logger.error e.message
+      Rails.logger.error e.backtrace.join("\n")
+
+      ApiMaker::Configuration.current.report_error(controller: controller, error: e)
+    end
+  end
+end

data/app/services/api_maker/command_service.rb

@@ -0,0 +1,31 @@
+class ApiMaker::CommandService < ApiMaker::ApplicationService
+  attr_reader :ability, :args, :commands, :command_name, :command_response, :controller, :resource_name
+
+  def initialize(ability:, args:, commands:, command_name:, command_response:, controller:, resource_name:)
+    @ability = ability
+    @args = args
+    @command_name = command_name
+    @command_response = command_response
+    @commands = commands
+    @controller = controller
+    @resource_name = resource_name
+  end
+
+  def namespace
+    @namespace ||= resource_name.underscore.camelize
+  end
+
+  def resource
+    @resource ||= begin
+      resource_class_name = "Resources::#{resource_name.underscore.singularize.camelize}Resource"
+      resource = resource_class_name.safe_constantize
+      raise "Couldnt find resource from resource name: #{resource_class_name}" unless resource
+
+      resource
+    end
+  end
+
+  def model_class
+    @model_class ||= resource.model_class
+  end
+end

data/app/services/api_maker/create_command.rb

@@ -0,0 +1,62 @@
+class ApiMaker::CreateCommand < ApiMaker::BaseCommand
+  attr_reader :command, :model, :params, :serializer
+
+  def execute!
+    each_command do |command|
+      @command = command
+      @model = collection.klass.new
+      @params = command.args || {}
+      @serializer = serialized_resource(model)
+      @model.assign_attributes(sanitize_parameters)
+
+      if !current_ability.can?(:create, @model)
+        failure_response(["No access to create that resource"])
+      elsif @model.save
+        success_response
+      else
+        failure_response(model.errors.full_messages)
+      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
+
+  def resource_instance_class
+    @resource_instance_class ||= api_maker_resource_class.model_class
+  end
+
+  def resource_variable_name
+    @resource_variable_name ||= resource_instance_class_name.underscore.parameterize
+  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