carbonyte 0.1.0 → 0.2.0

data/config/routes.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
 
 Carbonyte::Engine.routes.draw do
+  get :health, controller: :application, via: :all
 end

data/lib/carbonyte.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'carbonyte/engine'
+require 'carbonyte/version'
 
 # Main Carbonyte module
 module Carbonyte

data/lib/carbonyte/engine.rb

@@ -1,8 +1,22 @@
 # frozen_string_literal: true
 
+require 'carbonyte/initializers'
+require 'interactor/rails'
+require 'jsonapi/serializer'
+require 'pundit'
+require 'rails/engine'
+
 module Carbonyte
   # Carbonyte Engine
   class Engine < ::Rails::Engine
     isolate_namespace Carbonyte
+
+    include Initializers::Lograge
+
+    initializer 'carbonyte.catch_404' do
+      config.after_initialize do |app|
+        app.routes.append { match '*path', to: 'carbonyte/application#route_not_found', via: :all }
+      end
+    end
   end
 end

data/lib/carbonyte/initializers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'carbonyte/initializers/lograge'
+
+module Carbonyte
+  # Module enclosing all initializers
+  module Initializers
+  end
+end

data/lib/carbonyte/initializers/lograge.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'lograge'
+
+module Carbonyte
+  module Initializers
+    # This initializer setups lograge and automatically logs exceptions
+    module Lograge
+      extend ActiveSupport::Concern
+
+      # Items to be removed from `params` hash
+      PARAMS_EXCEPTIONS = %w[controller action].freeze
+      # Log type, this allows to distinguish these logs from others
+      LOG_TYPE = 'SERVER_REQUEST'
+
+      included do
+        initializer 'carbonyte.lograge' do
+          Rails.application.config.tap do |config|
+            config.lograge.enabled = true
+            config.lograge.base_controller_class = 'ActionController::API'
+            config.lograge.formatter = ::Lograge::Formatters::Logstash.new
+
+            config.lograge.custom_options = lambda do |event|
+              custom_options(event)
+            end
+
+            config.lograge.custom_payload do |controller|
+              custom_payload(controller)
+            end
+          end
+        end
+      end
+
+      # Adds custom options to the Lograge event
+      def custom_options(event)
+        opts = {
+          type: LOG_TYPE,
+          params: event.payload[:params].except(*PARAMS_EXCEPTIONS),
+          correlation_id: RequestStore.store[:correlation_id],
+          environment: Rails.env,
+          pid: ::Process.pid
+        }
+        add_rescued_exception(opts, RequestStore.store[:rescued_exception])
+        opts
+      end
+
+      # Adds the rescued exception (if any) to the Lograge event
+      def add_rescued_exception(opts, exc)
+        return unless exc
+
+        opts[:rescued_exception] = {
+          name: exc.class.name,
+          message: exc.message,
+          backtrace: %('#{Array(exc.backtrace.first(10)).join("\n\t")}')
+        }
+      end
+
+      # Adds custom payload to the Lograge event
+      def custom_payload(controller)
+        payload = {
+          headers: parse_headers(controller.request.headers),
+          remote_ip: controller.remote_ip
+        }
+        payload[:user_id] = controller.current_user&.id if controller.respond_to?(:current_user)
+        payload
+      end
+
+      # Parses headers returning only those starting with "HTTP", but excluding cookies
+      def parse_headers(headers)
+        headers.to_h.select { |k, _v| k.start_with?('HTTP') and k != 'HTTP_COOKIE' }
+      end
+    end
+  end
+end

data/lib/carbonyte/version.rb

@@ -2,5 +2,5 @@
 
 module Carbonyte
   # Carbonyte version
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/api/health_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+RSpec.describe '/health', type: :request do
+  it 'returns the health of the application' do
+    get '/health'
+
+    expect(parsed_response).to have_key('correlation_id')
+    expect(parsed_response).to have_key('db_status')
+    expect(parsed_response).to have_key('environment')
+    expect(parsed_response).to have_key('pid')
+  end
+end

data/spec/controllers/concerns/rescuable_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe Carbonyte::Concerns::Rescuable, type: :controller do
+  class FakePolicy < Carbonyte::ApplicationPolicy
+    def index?
+      false
+    end
+  end
+
+  class FakeInteractor < Carbonyte::ApplicationInteractor
+    def call
+      context.fail!
+    end
+  end
+
+  controller(ApplicationController) do
+    def index
+      raise 'Something unpredictable happened.'
+    end
+
+    def record_not_found_error
+      User.find(-1)
+    end
+
+    def policy_not_authorized_error
+      authorize(User.new, 'index?', policy_class: FakePolicy)
+    end
+
+    def interactor_error
+      FakeInteractor.call!(error: 'Something went wrong.')
+    end
+
+    def record_invalid_error
+      User.create!
+    end
+  end
+
+  let(:errors) { parsed_response['errors'] }
+  let(:error) { errors.first }
+
+  it 'rescues all exceptions inheriting from StandardError' do
+    get :index
+    expect(errors.size).to eq(1)
+    expect(error['code']).to eq('RuntimeError')
+    expect(error['detail']).to eq('Something unpredictable happened.')
+    expect(error['title']).to eq('Internal Server Error')
+  end
+
+  it 'rescues ActiveRecord::RecordNotFound' do
+    routes.draw { get :record_not_found_error, to: 'anonymous#record_not_found_error' }
+    get :record_not_found_error
+    expect(errors.size).to eq(1)
+    expect(error['code']).to eq('ActiveRecord::RecordNotFound')
+    expect(error['detail']).to eq("Couldn't find User with 'id'=-1")
+    expect(error['source']['id']).to eq(-1)
+    expect(error['source']['model']).to eq('User')
+    expect(error['title']).to eq('Resource Not Found')
+  end
+
+  it 'rescues Pundit::NotAuthorizedError' do
+    routes.draw { get :policy_not_authorized_error, to: 'anonymous#policy_not_authorized_error' }
+    get :policy_not_authorized_error
+    expect(errors.size).to eq(1)
+    expect(error['code']).to eq('Pundit::NotAuthorizedError')
+    expect(error).to have_key('detail')
+    expect(error['source']['policy']).to eq('FakePolicy')
+    expect(error['title']).to eq('Not Authorized By Policy')
+  end
+
+  it 'rescues Interactor::Failure' do
+    routes.draw { get :interactor_error, to: 'anonymous#interactor_error' }
+    get :interactor_error
+    expect(errors.size).to eq(1)
+    expect(error['code']).to eq('Interactor::Failure')
+    expect(error['detail']).to eq('Something went wrong.')
+    expect(error['source']['interactor']).to eq('FakeInteractor')
+    expect(error['title']).to eq('Interactor Failure')
+  end
+
+  it 'rescues ActiveRecord::RecordInvalid' do
+    routes.draw { get :record_invalid_error, to: 'anonymous#record_invalid_error' }
+    get :record_invalid_error
+    expect(errors.size).to eq(1)
+    expect(error['code']).to eq('ActiveRecord::RecordInvalid')
+    expect(error['detail']).to eq('can\'t be blank')
+    expect(error['source']['pointer']).to eq('attributes/email')
+    expect(error['title']).to eq('Invalid Field')
+  end
+end

data/spec/controllers/concerns/serializable_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+RSpec.describe Carbonyte::Concerns::Serializable, type: :controller do
+  class FakeSerializer < Carbonyte::ApplicationSerializer
+    attributes :name, :age
+  end
+
+  class AlternativeFakeSerializer < Carbonyte::ApplicationSerializer
+    set_type :fake
+    attributes :name
+  end
+
+  class Fake
+    attr_accessor :id, :name, :age
+  end
+
+  controller(ApplicationController) do
+    def fake
+      Fake.new.tap do |f|
+        f.id = 1
+        f.name = 'test'
+        f.age = 20
+      end
+    end
+
+    def inferred
+      serialize(fake)
+    end
+
+    def explicit
+      serialize(fake, serializer_class: AlternativeFakeSerializer, status: :created)
+    end
+
+    def list
+      serialize([fake, fake])
+    end
+  end
+
+  it 'infers the serializer type automatically when not specified' do
+    expect(FakeSerializer).to receive(:new).and_call_original
+    routes.draw { get :inferred, to: 'anonymous#inferred' }
+    get :inferred
+    expect(response.status).to eq(200)
+  end
+
+  it 'allows to customize the serializer type and status' do
+    expect(AlternativeFakeSerializer).to receive(:new).and_call_original
+    routes.draw { get :explicit, to: 'anonymous#explicit' }
+    get :explicit
+    expect(response.status).to eq(201)
+  end
+
+  it 'automatically passes include options to serializer' do
+    object_matcher = instance_of(Fake)
+    options_matcher = hash_including(include: %i[field1 field2])
+    expect(FakeSerializer).to receive(:new)
+      .with(object_matcher, options_matcher)
+      .and_call_original
+    routes.draw { get :inferred, to: 'anonymous#inferred' }
+    get :inferred, params: { include: 'field1,field2' }
+  end
+
+  it 'works with lists as well' do
+    expect(FakeSerializer).to receive(:new).and_call_original
+    routes.draw { get :list, to: 'anonymous#list' }
+    get :list
+    expect(response.status).to eq(200)
+  end
+end

data/spec/dummy/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative 'config/application'
+
+Rails.application.load_tasks

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ApplicationController < Carbonyte::ApplicationController
+  def current_user
+    User.first
+  end
+end

data/spec/dummy/app/models/application_record.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationRecord < Carbonyte::ApplicationRecord
+  self.abstract_class = true
+end

data/spec/dummy/app/models/user.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class User < ApplicationRecord
+  validates :email, presence: true
+end

data/spec/dummy/bin/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+APP_PATH = File.expand_path('../config/application', __dir__)
+require_relative '../config/boot'
+require 'rails/commands'

data/spec/dummy/bin/rake

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../config/boot'
+require 'rake'
+Rake.application.run

data/spec/dummy/bin/setup

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+
+# path to your application root.
+APP_ROOT = File.expand_path('..', __dir__)
+
+def system!(*args)
+  system(*args) || abort("\n== Command #{args} failed ==")
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to setup or update your development environment automatically.
+  # This script is idempotent, so that you can run it at anytime and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts '== Installing dependencies =='
+  system! 'gem install bundler --conservative'
+  system('bundle check') || system!('bundle install')
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?('config/database.yml')
+  #   FileUtils.cp 'config/database.yml.sample', 'config/database.yml'
+  # end
+
+  puts "\n== Preparing database =="
+  system! 'bin/rails db:prepare'
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! 'bin/rails log:clear tmp:clear'
+
+  puts "\n== Restarting application server =="
+  system! 'bin/rails restart'
+end

data/spec/dummy/config.ru

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# This file is used by Rack-based servers to start the application.
+
+require_relative 'config/environment'
+
+run Rails.application

data/spec/dummy/config/application.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'boot'
+
+require 'rails'
+# Pick the frameworks you want:
+require 'active_model/railtie'
+# require 'active_job/railtie'
+require 'active_record/railtie'
+require 'active_storage/engine'
+require 'action_controller/railtie'
+require 'action_mailer/railtie'
+# require 'action_view/railtie'
+# require 'action_cable/engine'
+# require 'sprockets/railtie'
+# require "rails/test_unit/railtie"
+
+Bundler.require(*Rails.groups)
+require 'carbonyte'
+
+module Dummy
+  class Application < Rails::Application
+    # Initialize configuration defaults for originally generated Rails version.
+    config.load_defaults 6.0
+
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration can go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded after loading
+    # the framework and any gems in your application.
+
+    config.api_only = true
+  end
+end

data/spec/dummy/config/boot.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../Gemfile', __dir__)
+
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+$LOAD_PATH.unshift File.expand_path('../../../lib', __dir__)

data/spec/dummy/config/database.yml

@@ -0,0 +1,25 @@
+# SQLite. Versions 3.8.0 and up are supported.
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+#
+default: &default
+  adapter: sqlite3
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  timeout: 5000
+
+development:
+  <<: *default
+  database: db/development.sqlite3
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: db/test.sqlite3
+
+production:
+  <<: *default
+  database: db/production.sqlite3